From c32bf0c949e7ab4a99e5a98d07639812267c97ee Mon Sep 17 00:00:00 2001
From: Liang-Chi Hsieh <viirya@gmail.com>
Date: Wed, 13 Nov 2024 22:18:56 -0800
Subject: [PATCH 01/47] chore: Simplify CometShuffleMemoryAllocator to use
 Spark unified memory allocator (#1063)

---
 .../scala/org/apache/comet/CometConf.scala    |  19 +-
 docs/source/user-guide/configs.md             |   1 -
 .../comet/CometShuffleMemoryAllocator.java    | 182 ++++------------
 .../CometShuffleMemoryAllocatorTrait.java     |  41 ++++
 .../CometTestShuffleMemoryAllocator.java      | 194 ++++++++++++++++++
 .../sort/CometShuffleExternalSorter.java      |   3 +-
 .../shuffle/CometDiskBlockWriter.java         |  10 +-
 .../comet/execution/shuffle/SpillWriter.java  |   8 +-
 .../comet/CometSparkSessionExtensions.scala   |  16 +-
 .../exec/CometColumnarShuffleSuite.scala      |  10 +
 10 files changed, 336 insertions(+), 148 deletions(-)
 create mode 100644 spark/src/main/java/org/apache/spark/shuffle/comet/CometShuffleMemoryAllocatorTrait.java
 create mode 100644 spark/src/main/java/org/apache/spark/shuffle/comet/CometTestShuffleMemoryAllocator.java

diff --git a/common/src/main/scala/org/apache/comet/CometConf.scala b/common/src/main/scala/org/apache/comet/CometConf.scala
index 7450d27a6d..b602d7cf1c 100644
--- a/common/src/main/scala/org/apache/comet/CometConf.scala
+++ b/common/src/main/scala/org/apache/comet/CometConf.scala
@@ -322,8 +322,10 @@ object CometConf extends ShimCometConf {
 
   val COMET_COLUMNAR_SHUFFLE_MEMORY_SIZE: OptionalConfigEntry[Long] =
     conf("spark.comet.columnar.shuffle.memorySize")
+      .internal()
       .doc(
-        "The optional maximum size of the memory used for Comet columnar shuffle, in MiB. " +
+        "Test-only config. This is only used to test Comet shuffle with Spark tests. " +
+          "The optional maximum size of the memory used for Comet columnar shuffle, in MiB. " +
           "Note that this config is only used when `spark.comet.exec.shuffle.mode` is " +
           "`jvm`. Once allocated memory size reaches this config, the current batch will be " +
           "flushed to disk immediately. If this is not configured, Comet will use " +
@@ -335,8 +337,10 @@ object CometConf extends ShimCometConf {
 
   val COMET_COLUMNAR_SHUFFLE_MEMORY_FACTOR: ConfigEntry[Double] =
     conf("spark.comet.columnar.shuffle.memory.factor")
+      .internal()
       .doc(
-        "Fraction of Comet memory to be allocated per executor process for Comet shuffle. " +
+        "Test-only config. This is only used to test Comet shuffle with Spark tests. " +
+          "Fraction of Comet memory to be allocated per executor process for Comet shuffle. " +
           "Comet memory size is specified by `spark.comet.memoryOverhead` or " +
           "calculated by `spark.comet.memory.overhead.factor` * `spark.executor.memory`.")
       .doubleConf
@@ -345,6 +349,17 @@ object CometConf extends ShimCometConf {
         "Ensure that Comet shuffle memory overhead factor is a double greater than 0")
       .createWithDefault(1.0)
 
+  val COMET_COLUMNAR_SHUFFLE_UNIFIED_MEMORY_ALLOCATOR_IN_TEST: ConfigEntry[Boolean] =
+    conf("spark.comet.columnar.shuffle.unifiedMemoryAllocatorTest")
+      .doc("Whether to use Spark unified memory allocator for Comet columnar shuffle in tests." +
+        "If not configured, Comet will use a test-only memory allocator for Comet columnar " +
+        "shuffle when Spark test env detected. The test-ony allocator is proposed to run with " +
+        "Spark tests as these tests require on-heap memory configuration. " +
+        "By default, this config is false.")
+      .internal()
+      .booleanConf
+      .createWithDefault(false)
+
   val COMET_COLUMNAR_SHUFFLE_BATCH_SIZE: ConfigEntry[Int] =
     conf("spark.comet.columnar.shuffle.batch.size")
       .internal()
diff --git a/docs/source/user-guide/configs.md b/docs/source/user-guide/configs.md
index dc97e3c598..69da792223 100644
--- a/docs/source/user-guide/configs.md
+++ b/docs/source/user-guide/configs.md
@@ -29,7 +29,6 @@ Comet provides the following configuration settings.
 | spark.comet.columnar.shuffle.async.enabled | Whether to enable asynchronous shuffle for Arrow-based shuffle. | false |
 | spark.comet.columnar.shuffle.async.max.thread.num | Maximum number of threads on an executor used for Comet async columnar shuffle. This is the upper bound of total number of shuffle threads per executor. In other words, if the number of cores * the number of shuffle threads per task `spark.comet.columnar.shuffle.async.thread.num` is larger than this config. Comet will use this config as the number of shuffle threads per executor instead. | 100 |
 | spark.comet.columnar.shuffle.async.thread.num | Number of threads used for Comet async columnar shuffle per shuffle task. Note that more threads means more memory requirement to buffer shuffle data before flushing to disk. Also, more threads may not always improve performance, and should be set based on the number of cores available. | 3 |
-| spark.comet.columnar.shuffle.memory.factor | Fraction of Comet memory to be allocated per executor process for Comet shuffle. Comet memory size is specified by `spark.comet.memoryOverhead` or calculated by `spark.comet.memory.overhead.factor` * `spark.executor.memory`. | 1.0 |
 | spark.comet.convert.csv.enabled | When enabled, data from Spark (non-native) CSV v1 and v2 scans will be converted to Arrow format. Note that to enable native vectorized execution, both this config and 'spark.comet.exec.enabled' need to be enabled. | false |
 | spark.comet.convert.json.enabled | When enabled, data from Spark (non-native) JSON v1 and v2 scans will be converted to Arrow format. Note that to enable native vectorized execution, both this config and 'spark.comet.exec.enabled' need to be enabled. | false |
 | spark.comet.convert.parquet.enabled | When enabled, data from Spark (non-native) Parquet v1 and v2 scans will be converted to Arrow format. Note that to enable native vectorized execution, both this config and 'spark.comet.exec.enabled' need to be enabled. | false |
diff --git a/spark/src/main/java/org/apache/spark/shuffle/comet/CometShuffleMemoryAllocator.java b/spark/src/main/java/org/apache/spark/shuffle/comet/CometShuffleMemoryAllocator.java
index 2837fa369a..54e349c137 100644
--- a/spark/src/main/java/org/apache/spark/shuffle/comet/CometShuffleMemoryAllocator.java
+++ b/spark/src/main/java/org/apache/spark/shuffle/comet/CometShuffleMemoryAllocator.java
@@ -20,157 +20,75 @@
 package org.apache.spark.shuffle.comet;
 
 import java.io.IOException;
-import java.util.BitSet;
 
 import org.apache.spark.SparkConf;
 import org.apache.spark.memory.MemoryConsumer;
 import org.apache.spark.memory.MemoryMode;
-import org.apache.spark.memory.SparkOutOfMemoryError;
 import org.apache.spark.memory.TaskMemoryManager;
-import org.apache.spark.sql.internal.SQLConf;
-import org.apache.spark.unsafe.array.LongArray;
 import org.apache.spark.unsafe.memory.MemoryBlock;
-import org.apache.spark.unsafe.memory.UnsafeMemoryAllocator;
+import org.apache.spark.util.Utils;
 
-import org.apache.comet.CometSparkSessionExtensions$;
+import org.apache.comet.CometConf$;
 
 /**
  * A simple memory allocator used by `CometShuffleExternalSorter` to allocate memory blocks which
- * store serialized rows. We don't rely on Spark memory allocator because we need to allocate
- * off-heap memory no matter memory mode is on-heap or off-heap. This allocator is configured with
- * fixed size of memory, and it will throw `SparkOutOfMemoryError` if the memory is not enough.
- *
- * <p>Some methods are copied from `org.apache.spark.unsafe.memory.TaskMemoryManager` with
- * modifications. Most modifications are to remove the dependency on the configured memory mode.
+ * store serialized rows. This class is simply an implementation of `MemoryConsumer` that delegates
+ * memory allocation to the `TaskMemoryManager`. This requires that the `TaskMemoryManager` is
+ * configured with `MemoryMode.OFF_HEAP`, i.e. it is using off-heap memory.
  */
-public final class CometShuffleMemoryAllocator extends MemoryConsumer {
-  private final UnsafeMemoryAllocator allocator = new UnsafeMemoryAllocator();
-
-  private final long pageSize;
-  private final long totalMemory;
-  private long allocatedMemory = 0L;
-
-  /** The number of bits used to address the page table. */
-  private static final int PAGE_NUMBER_BITS = 13;
-
-  /** The number of entries in the page table. */
-  private static final int PAGE_TABLE_SIZE = 1 << PAGE_NUMBER_BITS;
-
-  private final MemoryBlock[] pageTable = new MemoryBlock[PAGE_TABLE_SIZE];
-  private final BitSet allocatedPages = new BitSet(PAGE_TABLE_SIZE);
+public final class CometShuffleMemoryAllocator extends CometShuffleMemoryAllocatorTrait {
+  private static CometShuffleMemoryAllocatorTrait INSTANCE;
 
-  private static final int OFFSET_BITS = 51;
-  private static final long MASK_LONG_LOWER_51_BITS = 0x7FFFFFFFFFFFFL;
-
-  private static CometShuffleMemoryAllocator INSTANCE;
-
-  public static synchronized CometShuffleMemoryAllocator getInstance(
+  /**
+   * Returns the singleton instance of `CometShuffleMemoryAllocator`. This method should be used
+   * instead of the constructor to ensure that only one instance of `CometShuffleMemoryAllocator` is
+   * created. For Spark tests, this returns `CometTestShuffleMemoryAllocator` which is a test-only
+   * allocator that should not be used in production.
+   */
+  public static CometShuffleMemoryAllocatorTrait getInstance(
       SparkConf conf, TaskMemoryManager taskMemoryManager, long pageSize) {
-    if (INSTANCE == null) {
-      INSTANCE = new CometShuffleMemoryAllocator(conf, taskMemoryManager, pageSize);
+    boolean isSparkTesting = Utils.isTesting();
+    boolean useUnifiedMemAllocator =
+        (boolean)
+            CometConf$.MODULE$.COMET_COLUMNAR_SHUFFLE_UNIFIED_MEMORY_ALLOCATOR_IN_TEST().get();
+
+    if (isSparkTesting && !useUnifiedMemAllocator) {
+      synchronized (CometShuffleMemoryAllocator.class) {
+        if (INSTANCE == null) {
+          // CometTestShuffleMemoryAllocator handles pages by itself so it can be a singleton.
+          INSTANCE = new CometTestShuffleMemoryAllocator(conf, taskMemoryManager, pageSize);
+        }
+      }
+      return INSTANCE;
+    } else {
+      if (taskMemoryManager.getTungstenMemoryMode() != MemoryMode.OFF_HEAP) {
+        throw new IllegalArgumentException(
+            "CometShuffleMemoryAllocator should be used with off-heap "
+                + "memory mode, but got "
+                + taskMemoryManager.getTungstenMemoryMode());
+      }
+
+      // CometShuffleMemoryAllocator stores pages in TaskMemoryManager which is not singleton,
+      // but one instance per task. So we need to create a new instance for each task.
+      return new CometShuffleMemoryAllocator(taskMemoryManager, pageSize);
     }
-
-    return INSTANCE;
   }
 
-  CometShuffleMemoryAllocator(SparkConf conf, TaskMemoryManager taskMemoryManager, long pageSize) {
+  CometShuffleMemoryAllocator(TaskMemoryManager taskMemoryManager, long pageSize) {
     super(taskMemoryManager, pageSize, MemoryMode.OFF_HEAP);
-    this.pageSize = pageSize;
-    this.totalMemory =
-        CometSparkSessionExtensions$.MODULE$.getCometShuffleMemorySize(conf, SQLConf.get());
-  }
-
-  public synchronized long acquireMemory(long size) {
-    if (allocatedMemory >= totalMemory) {
-      throw new SparkOutOfMemoryError(
-          "Unable to acquire "
-              + size
-              + " bytes of memory, current usage "
-              + "is "
-              + allocatedMemory
-              + " bytes and max memory is "
-              + totalMemory
-              + " bytes");
-    }
-    long allocationSize = Math.min(size, totalMemory - allocatedMemory);
-    allocatedMemory += allocationSize;
-    return allocationSize;
   }
 
   public long spill(long l, MemoryConsumer memoryConsumer) throws IOException {
+    // JVM shuffle writer does not support spilling for other memory consumers
     return 0;
   }
 
-  public synchronized LongArray allocateArray(long size) {
-    long required = size * 8L;
-    MemoryBlock page = allocate(required);
-    return new LongArray(page);
-  }
-
-  public synchronized void freeArray(LongArray array) {
-    if (array == null) {
-      return;
-    }
-    free(array.memoryBlock());
-  }
-
-  public synchronized MemoryBlock allocatePage(long required) {
-    long size = Math.max(pageSize, required);
-    return allocate(size);
-  }
-
-  private synchronized MemoryBlock allocate(long required) {
-    if (required > TaskMemoryManager.MAXIMUM_PAGE_SIZE_BYTES) {
-      throw new TooLargePageException(required);
-    }
-
-    long got = acquireMemory(required);
-
-    if (got < required) {
-      allocatedMemory -= got;
-
-      throw new SparkOutOfMemoryError(
-          "Unable to acquire "
-              + required
-              + " bytes of memory, got "
-              + got
-              + " bytes. Available: "
-              + (totalMemory - allocatedMemory));
-    }
-
-    int pageNumber = allocatedPages.nextClearBit(0);
-    if (pageNumber >= PAGE_TABLE_SIZE) {
-      allocatedMemory -= got;
-
-      throw new IllegalStateException(
-          "Have already allocated a maximum of " + PAGE_TABLE_SIZE + " pages");
-    }
-
-    MemoryBlock block = allocator.allocate(got);
-
-    block.pageNumber = pageNumber;
-    pageTable[pageNumber] = block;
-    allocatedPages.set(pageNumber);
-
-    return block;
+  public synchronized MemoryBlock allocate(long required) {
+    return this.allocatePage(required);
   }
 
   public synchronized void free(MemoryBlock block) {
-    if (block.pageNumber == MemoryBlock.FREED_IN_ALLOCATOR_PAGE_NUMBER) {
-      // Already freed block
-      return;
-    }
-    allocatedMemory -= block.size();
-
-    pageTable[block.pageNumber] = null;
-    allocatedPages.clear(block.pageNumber);
-    block.pageNumber = MemoryBlock.FREED_IN_TMM_PAGE_NUMBER;
-
-    allocator.free(block);
-  }
-
-  public synchronized long getAvailableMemory() {
-    return totalMemory - allocatedMemory;
+    this.freePage(block);
   }
 
   /**
@@ -178,21 +96,11 @@ public synchronized long getAvailableMemory() {
    * method assumes that the page number is valid.
    */
   public long getOffsetInPage(long pagePlusOffsetAddress) {
-    long offsetInPage = decodeOffset(pagePlusOffsetAddress);
-    int pageNumber = TaskMemoryManager.decodePageNumber(pagePlusOffsetAddress);
-    assert (pageNumber >= 0 && pageNumber < PAGE_TABLE_SIZE);
-    MemoryBlock page = pageTable[pageNumber];
-    assert (page != null);
-    return page.getBaseOffset() + offsetInPage;
-  }
-
-  public long decodeOffset(long pagePlusOffsetAddress) {
-    return pagePlusOffsetAddress & MASK_LONG_LOWER_51_BITS;
+    return taskMemoryManager.getOffsetInPage(pagePlusOffsetAddress);
   }
 
   public long encodePageNumberAndOffset(int pageNumber, long offsetInPage) {
-    assert (pageNumber >= 0);
-    return ((long) pageNumber) << OFFSET_BITS | offsetInPage & MASK_LONG_LOWER_51_BITS;
+    return TaskMemoryManager.encodePageNumberAndOffset(pageNumber, offsetInPage);
   }
 
   public long encodePageNumberAndOffset(MemoryBlock page, long offsetInPage) {
diff --git a/spark/src/main/java/org/apache/spark/shuffle/comet/CometShuffleMemoryAllocatorTrait.java b/spark/src/main/java/org/apache/spark/shuffle/comet/CometShuffleMemoryAllocatorTrait.java
new file mode 100644
index 0000000000..6831396b3a
--- /dev/null
+++ b/spark/src/main/java/org/apache/spark/shuffle/comet/CometShuffleMemoryAllocatorTrait.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.spark.shuffle.comet;
+
+import org.apache.spark.memory.MemoryConsumer;
+import org.apache.spark.memory.MemoryMode;
+import org.apache.spark.memory.TaskMemoryManager;
+import org.apache.spark.unsafe.memory.MemoryBlock;
+
+/** The base class for Comet JVM shuffle memory allocators. */
+public abstract class CometShuffleMemoryAllocatorTrait extends MemoryConsumer {
+  protected CometShuffleMemoryAllocatorTrait(
+      TaskMemoryManager taskMemoryManager, long pageSize, MemoryMode mode) {
+    super(taskMemoryManager, pageSize, mode);
+  }
+
+  public abstract MemoryBlock allocate(long required);
+
+  public abstract void free(MemoryBlock block);
+
+  public abstract long getOffsetInPage(long pagePlusOffsetAddress);
+
+  public abstract long encodePageNumberAndOffset(MemoryBlock page, long offsetInPage);
+}
diff --git a/spark/src/main/java/org/apache/spark/shuffle/comet/CometTestShuffleMemoryAllocator.java b/spark/src/main/java/org/apache/spark/shuffle/comet/CometTestShuffleMemoryAllocator.java
new file mode 100644
index 0000000000..084e82b2b6
--- /dev/null
+++ b/spark/src/main/java/org/apache/spark/shuffle/comet/CometTestShuffleMemoryAllocator.java
@@ -0,0 +1,194 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.spark.shuffle.comet;
+
+import java.io.IOException;
+import java.util.BitSet;
+
+import org.apache.spark.SparkConf;
+import org.apache.spark.memory.MemoryConsumer;
+import org.apache.spark.memory.MemoryMode;
+import org.apache.spark.memory.SparkOutOfMemoryError;
+import org.apache.spark.memory.TaskMemoryManager;
+import org.apache.spark.sql.internal.SQLConf;
+import org.apache.spark.unsafe.array.LongArray;
+import org.apache.spark.unsafe.memory.MemoryBlock;
+import org.apache.spark.unsafe.memory.UnsafeMemoryAllocator;
+
+import org.apache.comet.CometSparkSessionExtensions$;
+
+/**
+ * A simple memory allocator used by `CometShuffleExternalSorter` to allocate memory blocks which
+ * store serialized rows. We don't rely on Spark memory allocator because we need to allocate
+ * off-heap memory no matter memory mode is on-heap or off-heap. This allocator is configured with
+ * fixed size of memory, and it will throw `SparkOutOfMemoryError` if the memory is not enough.
+ *
+ * <p>Some methods are copied from `org.apache.spark.unsafe.memory.TaskMemoryManager` with
+ * modifications. Most modifications are to remove the dependency on the configured memory mode.
+ *
+ * <p>This allocator is test-only and should not be used in production. It is used to test Comet JVM
+ * shuffle and execution with Spark tests which basically require on-heap memory configuration.
+ * Thus, this allocator is used to allocate separate off-heap memory allocation for Comet JVM
+ * shuffle and execution apart from Spark's on-heap memory configuration.
+ */
+public final class CometTestShuffleMemoryAllocator extends CometShuffleMemoryAllocatorTrait {
+  private final UnsafeMemoryAllocator allocator = new UnsafeMemoryAllocator();
+
+  private final long pageSize;
+  private final long totalMemory;
+  private long allocatedMemory = 0L;
+
+  /** The number of bits used to address the page table. */
+  private static final int PAGE_NUMBER_BITS = 13;
+
+  /** The number of entries in the page table. */
+  private static final int PAGE_TABLE_SIZE = 1 << PAGE_NUMBER_BITS;
+
+  private final MemoryBlock[] pageTable = new MemoryBlock[PAGE_TABLE_SIZE];
+  private final BitSet allocatedPages = new BitSet(PAGE_TABLE_SIZE);
+
+  private static final int OFFSET_BITS = 51;
+  private static final long MASK_LONG_LOWER_51_BITS = 0x7FFFFFFFFFFFFL;
+
+  private static CometTestShuffleMemoryAllocator INSTANCE;
+
+  CometTestShuffleMemoryAllocator(
+      SparkConf conf, TaskMemoryManager taskMemoryManager, long pageSize) {
+    super(taskMemoryManager, pageSize, MemoryMode.OFF_HEAP);
+    this.pageSize = pageSize;
+    this.totalMemory =
+        CometSparkSessionExtensions$.MODULE$.getCometShuffleMemorySize(conf, SQLConf.get());
+  }
+
+  private synchronized long _acquireMemory(long size) {
+    if (allocatedMemory >= totalMemory) {
+      throw new SparkOutOfMemoryError(
+          "Unable to acquire "
+              + size
+              + " bytes of memory, current usage "
+              + "is "
+              + allocatedMemory
+              + " bytes and max memory is "
+              + totalMemory
+              + " bytes");
+    }
+    long allocationSize = Math.min(size, totalMemory - allocatedMemory);
+    allocatedMemory += allocationSize;
+    return allocationSize;
+  }
+
+  public long spill(long l, MemoryConsumer memoryConsumer) throws IOException {
+    return 0;
+  }
+
+  public synchronized LongArray allocateArray(long size) {
+    long required = size * 8L;
+    MemoryBlock page = allocateMemoryBlock(required);
+    return new LongArray(page);
+  }
+
+  public synchronized void freeArray(LongArray array) {
+    if (array == null) {
+      return;
+    }
+    free(array.memoryBlock());
+  }
+
+  public synchronized MemoryBlock allocate(long required) {
+    long size = Math.max(pageSize, required);
+    return allocateMemoryBlock(size);
+  }
+
+  private synchronized MemoryBlock allocateMemoryBlock(long required) {
+    if (required > TaskMemoryManager.MAXIMUM_PAGE_SIZE_BYTES) {
+      throw new TooLargePageException(required);
+    }
+
+    long got = _acquireMemory(required);
+
+    if (got < required) {
+      allocatedMemory -= got;
+
+      throw new SparkOutOfMemoryError(
+          "Unable to acquire "
+              + required
+              + " bytes of memory, got "
+              + got
+              + " bytes. Available: "
+              + (totalMemory - allocatedMemory));
+    }
+
+    int pageNumber = allocatedPages.nextClearBit(0);
+    if (pageNumber >= PAGE_TABLE_SIZE) {
+      allocatedMemory -= got;
+
+      throw new IllegalStateException(
+          "Have already allocated a maximum of " + PAGE_TABLE_SIZE + " pages");
+    }
+
+    MemoryBlock block = allocator.allocate(got);
+
+    block.pageNumber = pageNumber;
+    pageTable[pageNumber] = block;
+    allocatedPages.set(pageNumber);
+
+    return block;
+  }
+
+  public synchronized void free(MemoryBlock block) {
+    if (block.pageNumber == MemoryBlock.FREED_IN_ALLOCATOR_PAGE_NUMBER) {
+      // Already freed block
+      return;
+    }
+    allocatedMemory -= block.size();
+
+    pageTable[block.pageNumber] = null;
+    allocatedPages.clear(block.pageNumber);
+    block.pageNumber = MemoryBlock.FREED_IN_TMM_PAGE_NUMBER;
+
+    allocator.free(block);
+  }
+
+  /**
+   * Returns the offset in the page for the given page plus base offset address. Note that this
+   * method assumes that the page number is valid.
+   */
+  public long getOffsetInPage(long pagePlusOffsetAddress) {
+    long offsetInPage = decodeOffset(pagePlusOffsetAddress);
+    int pageNumber = TaskMemoryManager.decodePageNumber(pagePlusOffsetAddress);
+    assert (pageNumber >= 0 && pageNumber < PAGE_TABLE_SIZE);
+    MemoryBlock page = pageTable[pageNumber];
+    assert (page != null);
+    return page.getBaseOffset() + offsetInPage;
+  }
+
+  public long decodeOffset(long pagePlusOffsetAddress) {
+    return pagePlusOffsetAddress & MASK_LONG_LOWER_51_BITS;
+  }
+
+  public long encodePageNumberAndOffset(int pageNumber, long offsetInPage) {
+    assert (pageNumber >= 0);
+    return ((long) pageNumber) << OFFSET_BITS | offsetInPage & MASK_LONG_LOWER_51_BITS;
+  }
+
+  public long encodePageNumberAndOffset(MemoryBlock page, long offsetInPage) {
+    return encodePageNumberAndOffset(page.pageNumber, offsetInPage - page.getBaseOffset());
+  }
+}
diff --git a/spark/src/main/java/org/apache/spark/shuffle/sort/CometShuffleExternalSorter.java b/spark/src/main/java/org/apache/spark/shuffle/sort/CometShuffleExternalSorter.java
index ed3e2be669..cc44955705 100644
--- a/spark/src/main/java/org/apache/spark/shuffle/sort/CometShuffleExternalSorter.java
+++ b/spark/src/main/java/org/apache/spark/shuffle/sort/CometShuffleExternalSorter.java
@@ -38,6 +38,7 @@
 import org.apache.spark.shuffle.ShuffleWriteMetricsReporter;
 import org.apache.spark.shuffle.comet.CometShuffleChecksumSupport;
 import org.apache.spark.shuffle.comet.CometShuffleMemoryAllocator;
+import org.apache.spark.shuffle.comet.CometShuffleMemoryAllocatorTrait;
 import org.apache.spark.shuffle.comet.TooLargePageException;
 import org.apache.spark.sql.comet.execution.shuffle.CometUnsafeShuffleWriter;
 import org.apache.spark.sql.comet.execution.shuffle.ShuffleThreadPool;
@@ -110,7 +111,7 @@ public final class CometShuffleExternalSorter implements CometShuffleChecksumSup
   // The memory allocator for this sorter. It is used to allocate/free memory pages for this sorter.
   // Because we need to allocate off-heap memory regardless of configured Spark memory mode
   // (on-heap/off-heap), we need a separate memory allocator.
-  private final CometShuffleMemoryAllocator allocator;
+  private final CometShuffleMemoryAllocatorTrait allocator;
 
   /** Whether to write shuffle spilling file in async mode */
   private final boolean isAsync;
diff --git a/spark/src/main/java/org/apache/spark/sql/comet/execution/shuffle/CometDiskBlockWriter.java b/spark/src/main/java/org/apache/spark/sql/comet/execution/shuffle/CometDiskBlockWriter.java
index f793874d79..dcb9d99d37 100644
--- a/spark/src/main/java/org/apache/spark/sql/comet/execution/shuffle/CometDiskBlockWriter.java
+++ b/spark/src/main/java/org/apache/spark/sql/comet/execution/shuffle/CometDiskBlockWriter.java
@@ -41,6 +41,7 @@
 import org.apache.spark.serializer.SerializerInstance;
 import org.apache.spark.shuffle.ShuffleWriteMetricsReporter;
 import org.apache.spark.shuffle.comet.CometShuffleMemoryAllocator;
+import org.apache.spark.shuffle.comet.CometShuffleMemoryAllocatorTrait;
 import org.apache.spark.shuffle.sort.RowPartition;
 import org.apache.spark.sql.catalyst.expressions.UnsafeRow;
 import org.apache.spark.sql.types.StructType;
@@ -87,7 +88,7 @@ public final class CometDiskBlockWriter {
   static final int MAXIMUM_PAGE_SIZE_BYTES = 1 << 27;
 
   /** The Comet allocator used to allocate pages. */
-  private final CometShuffleMemoryAllocator allocator;
+  private final CometShuffleMemoryAllocatorTrait allocator;
 
   /** The serializer used to write rows to memory page. */
   private final SerializerInstance serializer;
@@ -435,12 +436,17 @@ public int compare(CometDiskBlockWriter lhs, CometDiskBlockWriter rhs) {
               }
             });
 
+        long totalFreed = 0;
         for (CometDiskBlockWriter writer : currentWriters) {
           // Force to spill the writer in a synchronous way, otherwise, we may not be able to
           // acquire enough memory.
+          long used = writer.getActiveMemoryUsage();
+
           writer.doSpill(true);
 
-          if (allocator.getAvailableMemory() >= required) {
+          totalFreed += used;
+
+          if (totalFreed >= required) {
             break;
           }
         }
diff --git a/spark/src/main/java/org/apache/spark/sql/comet/execution/shuffle/SpillWriter.java b/spark/src/main/java/org/apache/spark/sql/comet/execution/shuffle/SpillWriter.java
index cc8c04fdd4..3dc86b05bb 100644
--- a/spark/src/main/java/org/apache/spark/sql/comet/execution/shuffle/SpillWriter.java
+++ b/spark/src/main/java/org/apache/spark/sql/comet/execution/shuffle/SpillWriter.java
@@ -31,7 +31,7 @@
 
 import org.apache.spark.memory.SparkOutOfMemoryError;
 import org.apache.spark.shuffle.ShuffleWriteMetricsReporter;
-import org.apache.spark.shuffle.comet.CometShuffleMemoryAllocator;
+import org.apache.spark.shuffle.comet.CometShuffleMemoryAllocatorTrait;
 import org.apache.spark.shuffle.sort.RowPartition;
 import org.apache.spark.sql.types.StructType;
 import org.apache.spark.unsafe.memory.MemoryBlock;
@@ -62,7 +62,7 @@ public abstract class SpillWriter {
   // The memory allocator for this sorter. It is used to allocate/free memory pages for this sorter.
   // Because we need to allocate off-heap memory regardless of configured Spark memory mode
   // (on-heap/off-heap), we need a separate memory allocator.
-  protected CometShuffleMemoryAllocator allocator;
+  protected CometShuffleMemoryAllocatorTrait allocator;
 
   protected Native nativeLib;
 
@@ -134,7 +134,7 @@ public boolean acquireNewPageIfNecessary(int required) {
         || pageCursor + required > currentPage.getBaseOffset() + currentPage.size()) {
       // TODO: try to find space in previous pages
       try {
-        currentPage = allocator.allocatePage(required);
+        currentPage = allocator.allocate(required);
       } catch (SparkOutOfMemoryError error) {
         try {
           // Cannot allocate enough memory, spill
@@ -155,7 +155,7 @@ public boolean acquireNewPageIfNecessary(int required) {
   public void initialCurrentPage(int required) {
     assert (currentPage == null);
     try {
-      currentPage = allocator.allocatePage(required);
+      currentPage = allocator.allocate(required);
     } catch (SparkOutOfMemoryError e) {
       logger.error("Unable to acquire {} bytes of memory", required);
       throw e;
diff --git a/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala b/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
index 952ef39e90..6a5c0efea7 100644
--- a/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
+++ b/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
@@ -1162,8 +1162,22 @@ object CometSparkSessionExtensions extends Logging {
     }
   }
 
+  private[comet] def isOffHeapEnabled(conf: SQLConf): Boolean =
+    conf.contains("spark.memory.offHeap.enabled") &&
+      conf.getConfString("spark.memory.offHeap.enabled").toBoolean
+
+  // Copied from org.apache.spark.util.Utils which is private to Spark.
+  private[comet] def isTesting: Boolean = {
+    System.getenv("SPARK_TESTING") != null || System.getProperty("spark.testing") != null
+  }
+
+  // Check whether Comet shuffle is enabled:
+  // 1. `COMET_EXEC_SHUFFLE_ENABLED` is true
+  // 2. `spark.shuffle.manager` is set to `CometShuffleManager`
+  // 3. Off-heap memory is enabled || Spark/Comet unit testing
   private[comet] def isCometShuffleEnabled(conf: SQLConf): Boolean =
-    COMET_EXEC_SHUFFLE_ENABLED.get(conf) && isCometShuffleManagerEnabled(conf)
+    COMET_EXEC_SHUFFLE_ENABLED.get(conf) && isCometShuffleManagerEnabled(conf) &&
+      (isOffHeapEnabled(conf) || isTesting)
 
   private[comet] def getCometShuffleNotEnabledReason(conf: SQLConf): Option[String] = {
     if (!COMET_EXEC_SHUFFLE_ENABLED.get(conf)) {
diff --git a/spark/src/test/scala/org/apache/comet/exec/CometColumnarShuffleSuite.scala b/spark/src/test/scala/org/apache/comet/exec/CometColumnarShuffleSuite.scala
index ecc056ddda..a2c2f66517 100644
--- a/spark/src/test/scala/org/apache/comet/exec/CometColumnarShuffleSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/exec/CometColumnarShuffleSuite.scala
@@ -40,6 +40,7 @@ import org.apache.comet.CometConf
 abstract class CometColumnarShuffleSuite extends CometTestBase with AdaptiveSparkPlanHelper {
   protected val adaptiveExecutionEnabled: Boolean
   protected val numElementsForceSpillThreshold: Int = 10
+  protected val useUnifiedMemoryAllocator: Boolean = true
 
   override protected def sparkConf: SparkConf = {
     val conf = super.sparkConf
@@ -57,6 +58,8 @@ abstract class CometColumnarShuffleSuite extends CometTestBase with AdaptiveSpar
         CometConf.COMET_COLUMNAR_SHUFFLE_SPILL_THRESHOLD.key -> numElementsForceSpillThreshold.toString,
         CometConf.COMET_EXEC_ENABLED.key -> "false",
         CometConf.COMET_SHUFFLE_MODE.key -> "jvm",
+        CometConf.COMET_COLUMNAR_SHUFFLE_UNIFIED_MEMORY_ALLOCATOR_IN_TEST.key ->
+          useUnifiedMemoryAllocator.toString,
         CometConf.COMET_EXEC_SHUFFLE_ENABLED.key -> "true",
         CometConf.COMET_COLUMNAR_SHUFFLE_MEMORY_SIZE.key -> "1536m") {
         testFun
@@ -968,6 +971,13 @@ abstract class CometColumnarShuffleSuite extends CometTestBase with AdaptiveSpar
   }
 }
 
+class CometTestMemoryAllocatorShuffleSuite extends CometColumnarShuffleSuite {
+  override protected val asyncShuffleEnable: Boolean = false
+  override protected val adaptiveExecutionEnabled: Boolean = true
+  // Explicitly test with `CometTestShuffleMemoryAllocator`
+  override protected val useUnifiedMemoryAllocator: Boolean = false
+}
+
 class CometAsyncShuffleSuite extends CometColumnarShuffleSuite {
   override protected val asyncShuffleEnable: Boolean = true
 

From f3da8449b90cfb7d7497db43a8ee57cc0d9c0a54 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <raz.luvaton@flarion.io>
Date: Thu, 14 Nov 2024 18:10:13 +0200
Subject: [PATCH 02/47] docs: Update benchmarking.md (#1085)

---
 docs/source/contributor-guide/benchmarking.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/contributor-guide/benchmarking.md b/docs/source/contributor-guide/benchmarking.md
index 8c8d53e677..08aa10abc5 100644
--- a/docs/source/contributor-guide/benchmarking.md
+++ b/docs/source/contributor-guide/benchmarking.md
@@ -22,7 +22,7 @@ under the License.
 To track progress on performance, we regularly run benchmarks derived from TPC-H and TPC-DS. Data generation and 
 benchmarking documentation and scripts are available in the [DataFusion Benchmarks](https://github.com/apache/datafusion-benchmarks) GitHub repository.
 
-We also have many micro benchmarks that can be run from an IDE located [here]()https://github.com/apache/datafusion-comet/tree/main/spark/src/test/scala/org/apache/spark/sql/benchmark). 
+We also have many micro benchmarks that can be run from an IDE located [here](https://github.com/apache/datafusion-comet/tree/main/spark/src/test/scala/org/apache/spark/sql/benchmark). 
 
 Here are example commands for running the benchmarks against a Spark cluster. This command will need to be 
 adapted based on the Spark environment and location of data files.

From 2c832b4a56eafa3dacbe3ef31d99adabccb803bf Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 14 Nov 2024 12:55:57 -0700
Subject: [PATCH 03/47] feat: Require offHeap memory to be enabled (always use
 unified memory) (#1062)

* Require offHeap memory

* remove unused import

* use off heap memory in stability tests

* reorder imports
---
 docs/source/user-guide/tuning.md              | 32 ++-----------------
 native/core/src/execution/jni_api.rs          | 24 ++------------
 .../org/apache/comet/CometExecIterator.scala  | 11 +------
 .../comet/CometSparkSessionExtensions.scala   |  7 ++++
 .../sql/comet/CometPlanStabilitySuite.scala   |  3 ++
 5 files changed, 16 insertions(+), 61 deletions(-)

diff --git a/docs/source/user-guide/tuning.md b/docs/source/user-guide/tuning.md
index 30ada4c9b1..b1838ca801 100644
--- a/docs/source/user-guide/tuning.md
+++ b/docs/source/user-guide/tuning.md
@@ -23,40 +23,12 @@ Comet provides some tuning options to help you get the best performance from you
 
 ## Memory Tuning
 
-Comet provides two options for memory management:
-
-- **Unified Memory Management** shares an off-heap memory pool between Spark and Comet. This is the recommended option.
-- **Native Memory Management** leverages DataFusion's memory management for the native plans and allocates memory independently of Spark.
-
-### Unified Memory Management
-
-This option is automatically enabled when `spark.memory.offHeap.enabled=true`.
+Comet shares an off-heap memory pool between Spark and Comet. This requires setting `spark.memory.offHeap.enabled=true`. 
+If this setting is not enabled, Comet will not accelerate queries and will fall back to Spark.
 
 Each executor will have a single memory pool which will be shared by all native plans being executed within that
 process, and by Spark itself. The size of the pool is specified by `spark.memory.offHeap.size`.
 
-### Native Memory Management
-
-This option is automatically enabled when `spark.memory.offHeap.enabled=false`.
-
-Each native plan has a dedicated memory pool.
-
-By default, the size of each pool is `spark.comet.memory.overhead.factor * spark.executor.memory`. The default value
-for `spark.comet.memory.overhead.factor` is `0.2`.
-
-It is important to take executor concurrency into account. The maximum number of concurrent plans in an executor can
-be calculated with `spark.executor.cores / spark.task.cpus`.
-
-For example, if the executor can execute 4 plans concurrently, then the total amount of memory allocated will be
-`4 * spark.comet.memory.overhead.factor * spark.executor.memory`.
-
-It is also possible to set `spark.comet.memoryOverhead` to the desired size for each pool, rather than calculating
-it based on `spark.comet.memory.overhead.factor`.
-
-If both `spark.comet.memoryOverhead` and `spark.comet.memory.overhead.factor` are set, the former will be used.
-
-Comet will allocate at least `spark.comet.memory.overhead.min` memory per pool.
-
 ### Determining How Much Memory to Allocate
 
 Generally, increasing memory overhead will improve query performance, especially for queries containing joins and
diff --git a/native/core/src/execution/jni_api.rs b/native/core/src/execution/jni_api.rs
index d7e8ccaba1..47d87fe1af 100644
--- a/native/core/src/execution/jni_api.rs
+++ b/native/core/src/execution/jni_api.rs
@@ -202,27 +202,9 @@ fn prepare_datafusion_session_context(
 
     let mut rt_config = RuntimeConfig::new().with_disk_manager(DiskManagerConfig::NewOs);
 
-    // Check if we are using unified memory manager integrated with Spark. Default to false if not
-    // set.
-    let use_unified_memory_manager = parse_bool(conf, "use_unified_memory_manager")?;
-
-    if use_unified_memory_manager {
-        // Set Comet memory pool for native
-        let memory_pool = CometMemoryPool::new(comet_task_memory_manager);
-        rt_config = rt_config.with_memory_pool(Arc::new(memory_pool));
-    } else {
-        // Use the memory pool from DF
-        if conf.contains_key("memory_limit") {
-            let memory_limit = conf.get("memory_limit").unwrap().parse::<usize>()?;
-            let memory_fraction = conf
-                .get("memory_fraction")
-                .ok_or(CometError::Internal(
-                    "Config 'memory_fraction' is not specified from Comet JVM side".to_string(),
-                ))?
-                .parse::<f64>()?;
-            rt_config = rt_config.with_memory_limit(memory_limit, memory_fraction)
-        }
-    }
+    // Set Comet memory pool for native
+    let memory_pool = CometMemoryPool::new(comet_task_memory_manager);
+    rt_config = rt_config.with_memory_pool(Arc::new(memory_pool));
 
     // Get Datafusion configuration from Spark Execution context
     // can be configured in Comet Spark JVM using Spark --conf parameters
diff --git a/spark/src/main/scala/org/apache/comet/CometExecIterator.scala b/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
index 07dd80c39e..b1f22726a6 100644
--- a/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
+++ b/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
@@ -23,7 +23,7 @@ import org.apache.spark._
 import org.apache.spark.sql.comet.CometMetricNode
 import org.apache.spark.sql.vectorized._
 
-import org.apache.comet.CometConf.{COMET_BATCH_SIZE, COMET_BLOCKING_THREADS, COMET_DEBUG_ENABLED, COMET_EXEC_MEMORY_FRACTION, COMET_EXPLAIN_NATIVE_ENABLED, COMET_WORKER_THREADS}
+import org.apache.comet.CometConf.{COMET_BATCH_SIZE, COMET_BLOCKING_THREADS, COMET_DEBUG_ENABLED, COMET_EXPLAIN_NATIVE_ENABLED, COMET_WORKER_THREADS}
 import org.apache.comet.vector.NativeUtil
 
 /**
@@ -75,15 +75,6 @@ class CometExecIterator(
     val result = new java.util.HashMap[String, String]()
     val conf = SparkEnv.get.conf
 
-    val maxMemory = CometSparkSessionExtensions.getCometMemoryOverhead(conf)
-    // Only enable unified memory manager when off-heap mode is enabled. Otherwise,
-    // we'll use the built-in memory pool from DF, and initializes with `memory_limit`
-    // and `memory_fraction` below.
-    result.put(
-      "use_unified_memory_manager",
-      String.valueOf(conf.get("spark.memory.offHeap.enabled", "false")))
-    result.put("memory_limit", String.valueOf(maxMemory))
-    result.put("memory_fraction", String.valueOf(COMET_EXEC_MEMORY_FRACTION.get()))
     result.put("batch_size", String.valueOf(COMET_BATCH_SIZE.get()))
     result.put("debug_native", String.valueOf(COMET_DEBUG_ENABLED.get()))
     result.put("explain_native", String.valueOf(COMET_EXPLAIN_NATIVE_ENABLED.get()))
diff --git a/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala b/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
index 6a5c0efea7..1c4ffcf3e5 100644
--- a/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
+++ b/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
@@ -915,6 +915,13 @@ class CometSparkSessionExtensions
     }
 
     override def apply(plan: SparkPlan): SparkPlan = {
+
+      // Comet required off-heap memory to be enabled
+      if ("true" != conf.getConfString("spark.memory.offHeap.enabled", "false")) {
+        logInfo("Comet extension disabled because spark.memory.offHeap.enabled=false")
+        return plan
+      }
+
       // DataFusion doesn't have ANSI mode. For now we just disable CometExec if ANSI mode is
       // enabled.
       if (isANSIEnabled(conf)) {
diff --git a/spark/src/test/scala/org/apache/spark/sql/comet/CometPlanStabilitySuite.scala b/spark/src/test/scala/org/apache/spark/sql/comet/CometPlanStabilitySuite.scala
index a553e61c78..16a7e5338d 100644
--- a/spark/src/test/scala/org/apache/spark/sql/comet/CometPlanStabilitySuite.scala
+++ b/spark/src/test/scala/org/apache/spark/sql/comet/CometPlanStabilitySuite.scala
@@ -26,6 +26,7 @@ import scala.collection.mutable
 
 import org.apache.commons.io.FileUtils
 import org.apache.spark.SparkContext
+import org.apache.spark.internal.config.{MEMORY_OFFHEAP_ENABLED, MEMORY_OFFHEAP_SIZE}
 import org.apache.spark.sql.TPCDSBase
 import org.apache.spark.sql.catalyst.expressions.AttributeSet
 import org.apache.spark.sql.catalyst.util.resourceToString
@@ -286,6 +287,8 @@ trait CometPlanStabilitySuite extends DisableAdaptiveExecutionSuite with TPCDSBa
     conf.set(
       "spark.shuffle.manager",
       "org.apache.spark.sql.comet.execution.shuffle.CometShuffleManager")
+    conf.set(MEMORY_OFFHEAP_ENABLED.key, "true")
+    conf.set(MEMORY_OFFHEAP_SIZE.key, "2g")
     conf.set(CometConf.COMET_ENABLED.key, "true")
     conf.set(CometConf.COMET_EXEC_ENABLED.key, "true")
     conf.set(CometConf.COMET_MEMORY_OVERHEAD.key, "1g")

From 7cec28588345c2d240119e0500e2cacc1fd8a788 Mon Sep 17 00:00:00 2001
From: Liang-Chi Hsieh <viirya@gmail.com>
Date: Thu, 14 Nov 2024 16:47:57 -0800
Subject: [PATCH 04/47] test: Restore one test in CometExecSuite by adding
 COMET_SHUFFLE_MODE config (#1087)

---
 .../apache/comet/exec/CometExecSuite.scala    | 22 ++++++++++---------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala b/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala
index 99007d0c91..d262e83f65 100644
--- a/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala
@@ -119,17 +119,19 @@ class CometExecSuite extends CometTestBase {
   }
 
   test("ShuffleQueryStageExec could be direct child node of CometBroadcastExchangeExec") {
-    val table = "src"
-    withTable(table) {
-      withView("lv_noalias") {
-        sql(s"CREATE TABLE $table (key INT, value STRING) USING PARQUET")
-        sql(s"INSERT INTO $table VALUES(238, 'val_238')")
+    withSQLConf(CometConf.COMET_SHUFFLE_MODE.key -> "jvm") {
+      val table = "src"
+      withTable(table) {
+        withView("lv_noalias") {
+          sql(s"CREATE TABLE $table (key INT, value STRING) USING PARQUET")
+          sql(s"INSERT INTO $table VALUES(238, 'val_238')")
 
-        sql(
-          "CREATE VIEW lv_noalias AS SELECT myTab.* FROM src " +
-            "LATERAL VIEW explode(map('key1', 100, 'key2', 200)) myTab LIMIT 2")
-        val df = sql("SELECT * FROM lv_noalias a JOIN lv_noalias b ON a.key=b.key");
-        checkSparkAnswer(df)
+          sql(
+            "CREATE VIEW lv_noalias AS SELECT myTab.* FROM src " +
+              "LATERAL VIEW explode(map('key1', 100, 'key2', 200)) myTab LIMIT 2")
+          val df = sql("SELECT * FROM lv_noalias a JOIN lv_noalias b ON a.key=b.key");
+          checkSparkAnswer(df)
+        }
       }
     }
   }

From 10ef62ab49777fc5c8db11847745280614a6557c Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Fri, 15 Nov 2024 10:16:41 -0700
Subject: [PATCH 05/47] Add changelog for 0.4.0 (#1089)

---
 dev/changelog/0.4.0.md | 108 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 dev/changelog/0.4.0.md

diff --git a/dev/changelog/0.4.0.md b/dev/changelog/0.4.0.md
new file mode 100644
index 0000000000..69aa5c30b8
--- /dev/null
+++ b/dev/changelog/0.4.0.md
@@ -0,0 +1,108 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# DataFusion Comet 0.4.0 Changelog
+
+This release consists of 51 commits from 10 contributors. See credits at the end of this changelog for more information.
+
+**Fixed bugs:**
+
+- fix: Use the number of rows from underlying arrays instead of logical row count from RecordBatch [#972](https://github.com/apache/datafusion-comet/pull/972) (viirya)
+- fix: The spilled_bytes metric of CometSortExec should be size instead of time [#984](https://github.com/apache/datafusion-comet/pull/984) (Kontinuation)
+- fix: Properly handle Java exceptions without error messages; fix loading of comet native library from java.library.path [#982](https://github.com/apache/datafusion-comet/pull/982) (Kontinuation)
+- fix: Fallback to Spark if scan has meta columns [#997](https://github.com/apache/datafusion-comet/pull/997) (viirya)
+- fix: Fallback to Spark if named_struct contains duplicate field names [#1016](https://github.com/apache/datafusion-comet/pull/1016) (viirya)
+- fix: Make comet-git-info.properties optional [#1027](https://github.com/apache/datafusion-comet/pull/1027) (andygrove)
+- fix: TopK operator should return correct results on dictionary column with nulls [#1033](https://github.com/apache/datafusion-comet/pull/1033) (viirya)
+- fix: need default value for getSizeAsMb(EXECUTOR_MEMORY.key) [#1046](https://github.com/apache/datafusion-comet/pull/1046) (neyama)
+
+**Performance related:**
+
+- perf: Remove one redundant CopyExec for SMJ [#962](https://github.com/apache/datafusion-comet/pull/962) (andygrove)
+- perf: Add experimental feature to replace SortMergeJoin with ShuffledHashJoin [#1007](https://github.com/apache/datafusion-comet/pull/1007) (andygrove)
+- perf: Cache jstrings during metrics collection [#1029](https://github.com/apache/datafusion-comet/pull/1029) (mbutrovich)
+
+**Implemented enhancements:**
+
+- feat: Support `GetArrayStructFields` expression [#993](https://github.com/apache/datafusion-comet/pull/993) (Kimahriman)
+- feat: Implement bloom_filter_agg [#987](https://github.com/apache/datafusion-comet/pull/987) (mbutrovich)
+- feat: Support more types with BloomFilterAgg [#1039](https://github.com/apache/datafusion-comet/pull/1039) (mbutrovich)
+- feat: Implement CAST from struct to string [#1066](https://github.com/apache/datafusion-comet/pull/1066) (andygrove)
+- feat: Use official DataFusion 43 release [#1070](https://github.com/apache/datafusion-comet/pull/1070) (andygrove)
+- feat: Implement CAST between struct types [#1074](https://github.com/apache/datafusion-comet/pull/1074) (andygrove)
+- feat: support array_append [#1072](https://github.com/apache/datafusion-comet/pull/1072) (NoeB)
+- feat: Require offHeap memory to be enabled (always use unified memory) [#1062](https://github.com/apache/datafusion-comet/pull/1062) (andygrove)
+
+**Documentation updates:**
+
+- doc: add documentation interlinks [#975](https://github.com/apache/datafusion-comet/pull/975) (comphead)
+- docs: Add IntelliJ documentation for generated source code [#985](https://github.com/apache/datafusion-comet/pull/985) (mbutrovich)
+- docs: Update tuning guide [#995](https://github.com/apache/datafusion-comet/pull/995) (andygrove)
+- docs: Various documentation improvements [#1005](https://github.com/apache/datafusion-comet/pull/1005) (andygrove)
+- docs: clarify that Maven central only has jars for Linux [#1009](https://github.com/apache/datafusion-comet/pull/1009) (andygrove)
+- doc: fix K8s links and doc [#1058](https://github.com/apache/datafusion-comet/pull/1058) (comphead)
+- docs: Update benchmarking.md [#1085](https://github.com/apache/datafusion-comet/pull/1085) (rluvaton-flarion)
+
+**Other:**
+
+- chore: Generate changelog for 0.3.0 release [#964](https://github.com/apache/datafusion-comet/pull/964) (andygrove)
+- chore: fix publish-to-maven script [#966](https://github.com/apache/datafusion-comet/pull/966) (andygrove)
+- chore: Update benchmarks results based on 0.3.0-rc1 [#969](https://github.com/apache/datafusion-comet/pull/969) (andygrove)
+- chore: update rem expression guide [#976](https://github.com/apache/datafusion-comet/pull/976) (kazuyukitanimura)
+- chore: Enable additional CreateArray tests [#928](https://github.com/apache/datafusion-comet/pull/928) (Kimahriman)
+- chore: fix compatibility guide [#978](https://github.com/apache/datafusion-comet/pull/978) (kazuyukitanimura)
+- chore: Update for 0.3.0 release, prepare for 0.4.0 development [#970](https://github.com/apache/datafusion-comet/pull/970) (andygrove)
+- chore: Don't transform the HashAggregate to CometHashAggregate if Comet shuffle is disabled [#991](https://github.com/apache/datafusion-comet/pull/991) (viirya)
+- chore: Make parquet reader options Comet options instead of Hadoop options [#968](https://github.com/apache/datafusion-comet/pull/968) (parthchandra)
+- chore: remove legacy comet-spark-shell [#1013](https://github.com/apache/datafusion-comet/pull/1013) (andygrove)
+- chore: Reserve memory for native shuffle writer per partition [#988](https://github.com/apache/datafusion-comet/pull/988) (viirya)
+- chore: Bump arrow-rs to 53.1.0 and datafusion [#1001](https://github.com/apache/datafusion-comet/pull/1001) (kazuyukitanimura)
+- chore: Revert "chore: Reserve memory for native shuffle writer per partition (#988)" [#1020](https://github.com/apache/datafusion-comet/pull/1020) (viirya)
+- minor: Remove hard-coded version number from Dockerfile [#1025](https://github.com/apache/datafusion-comet/pull/1025) (andygrove)
+- chore: Reserve memory for native shuffle writer per partition [#1022](https://github.com/apache/datafusion-comet/pull/1022) (viirya)
+- chore: Improve error handling when native lib fails to load [#1000](https://github.com/apache/datafusion-comet/pull/1000) (andygrove)
+- chore: Use twox-hash 2.0 xxhash64 oneshot api instead of custom implementation [#1041](https://github.com/apache/datafusion-comet/pull/1041) (NoeB)
+- chore: Refactor Arrow Array and Schema allocation in ColumnReader and MetadataColumnReader [#1047](https://github.com/apache/datafusion-comet/pull/1047) (viirya)
+- minor: Refactor binary expr serde to reduce code duplication [#1053](https://github.com/apache/datafusion-comet/pull/1053) (andygrove)
+- chore: Upgrade to DataFusion 43.0.0-rc1 [#1057](https://github.com/apache/datafusion-comet/pull/1057) (andygrove)
+- chore: Refactor UnaryExpr and MathExpr in protobuf [#1056](https://github.com/apache/datafusion-comet/pull/1056) (andygrove)
+- minor: use defaults instead of hard-coding values [#1060](https://github.com/apache/datafusion-comet/pull/1060) (andygrove)
+- minor: refactor UnaryExpr handling to make code more concise [#1065](https://github.com/apache/datafusion-comet/pull/1065) (andygrove)
+- chore: Refactor binary and math expression serde code [#1069](https://github.com/apache/datafusion-comet/pull/1069) (andygrove)
+- chore: Simplify CometShuffleMemoryAllocator to use Spark unified memory allocator [#1063](https://github.com/apache/datafusion-comet/pull/1063) (viirya)
+- test: Restore one test in CometExecSuite by adding COMET_SHUFFLE_MODE config [#1087](https://github.com/apache/datafusion-comet/pull/1087) (viirya)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+    19	Andy Grove
+    13	Matt Butrovich
+     8	Liang-Chi Hsieh
+     3	KAZUYUKI TANIMURA
+     2	Adam Binford
+     2	Kristin Cowalcijk
+     1	NoeB
+     1	Oleks V
+     1	Parth Chandra
+     1	neyama
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.

From 0c9a403ffaaee7247015edcd3472d2a6e86254dc Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Fri, 15 Nov 2024 11:56:56 -0700
Subject: [PATCH 06/47] chore: Prepare for 0.5.0 development (#1090)

* Update version number for build

* update docs
---
 .../actions/setup-spark-builder/action.yaml   |  2 +-
 .github/workflows/spark_sql_test.yml          |  2 +-
 .github/workflows/spark_sql_test_ansi.yml     |  2 +-
 benchmarks/README.md                          |  2 +-
 common/pom.xml                                |  2 +-
 dev/diffs/3.4.3.diff                          |  2 +-
 dev/diffs/3.5.1.diff                          |  2 +-
 dev/diffs/4.0.0-preview1.diff                 |  2 +-
 docs/source/contributor-guide/debugging.md    |  2 +-
 docs/source/user-guide/installation.md        |  4 +-
 fuzz-testing/README.md                        |  6 +-
 fuzz-testing/pom.xml                          |  2 +-
 native/Cargo.lock                             | 70 +++++++++----------
 native/Cargo.toml                             |  6 +-
 pom.xml                                       |  2 +-
 spark-integration/pom.xml                     |  2 +-
 spark/pom.xml                                 |  2 +-
 17 files changed, 56 insertions(+), 56 deletions(-)

diff --git a/.github/actions/setup-spark-builder/action.yaml b/.github/actions/setup-spark-builder/action.yaml
index ebe8e0dc37..1bd37d6b17 100644
--- a/.github/actions/setup-spark-builder/action.yaml
+++ b/.github/actions/setup-spark-builder/action.yaml
@@ -29,7 +29,7 @@ inputs:
   comet-version:
     description: 'The Comet version to use for Spark'
     required: true
-    default: '0.4.0-SNAPSHOT'
+    default: '0.5.0-SNAPSHOT'
 runs:
   using: "composite"
   steps:
diff --git a/.github/workflows/spark_sql_test.yml b/.github/workflows/spark_sql_test.yml
index 05c095b2f5..477e3a1ab9 100644
--- a/.github/workflows/spark_sql_test.yml
+++ b/.github/workflows/spark_sql_test.yml
@@ -71,7 +71,7 @@ jobs:
         with:
           spark-version: ${{ matrix.spark-version.full }}
           spark-short-version: ${{ matrix.spark-version.short }}
-          comet-version: '0.4.0-SNAPSHOT' # TODO: get this from pom.xml
+          comet-version: '0.5.0-SNAPSHOT' # TODO: get this from pom.xml
       - name: Run Spark tests
         run: |
           cd apache-spark
diff --git a/.github/workflows/spark_sql_test_ansi.yml b/.github/workflows/spark_sql_test_ansi.yml
index 06a5b2c8e7..e1d8388fb1 100644
--- a/.github/workflows/spark_sql_test_ansi.yml
+++ b/.github/workflows/spark_sql_test_ansi.yml
@@ -69,7 +69,7 @@ jobs:
         with:
           spark-version: ${{ matrix.spark-version.full }}
           spark-short-version: ${{ matrix.spark-version.short }}
-          comet-version: '0.4.0-SNAPSHOT' # TODO: get this from pom.xml
+          comet-version: '0.5.0-SNAPSHOT' # TODO: get this from pom.xml
       - name: Run Spark tests
         run: |
           cd apache-spark
diff --git a/benchmarks/README.md b/benchmarks/README.md
index 1042762d99..97877a3447 100644
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@@ -62,7 +62,7 @@ docker push localhost:32000/apache/datafusion-comet-tpcbench:latest
 export SPARK_MASTER=k8s://https://127.0.0.1:16443
 export COMET_DOCKER_IMAGE=localhost:32000/apache/datafusion-comet-tpcbench:latest
 # Location of Comet JAR within the Docker image
-export COMET_JAR=/opt/spark/jars/comet-spark-spark3.4_2.12-0.2.0-SNAPSHOT.jar
+export COMET_JAR=/opt/spark/jars/comet-spark-spark3.4_2.12-0.5.0-SNAPSHOT.jar
 
 $SPARK_HOME/bin/spark-submit \
     --master $SPARK_MASTER \
diff --git a/common/pom.xml b/common/pom.xml
index cda873abbc..91109edf5d 100644
--- a/common/pom.xml
+++ b/common/pom.xml
@@ -26,7 +26,7 @@ under the License.
   <parent>
     <groupId>org.apache.datafusion</groupId>
     <artifactId>comet-parent-spark${spark.version.short}_${scala.binary.version}</artifactId>
-    <version>0.4.0-SNAPSHOT</version>
+    <version>0.5.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
 
diff --git a/dev/diffs/3.4.3.diff b/dev/diffs/3.4.3.diff
index 6ac55f95c9..12f739848c 100644
--- a/dev/diffs/3.4.3.diff
+++ b/dev/diffs/3.4.3.diff
@@ -7,7 +7,7 @@ index d3544881af1..bf0e2b53c70 100644
      <ivy.version>2.5.1</ivy.version>
      <oro.version>2.0.8</oro.version>
 +    <spark.version.short>3.4</spark.version.short>
-+    <comet.version>0.4.0-SNAPSHOT</comet.version>
++    <comet.version>0.5.0-SNAPSHOT</comet.version>
      <!--
      If you changes codahale.metrics.version, you also need to change
      the link to metrics.dropwizard.io in docs/monitoring.md.
diff --git a/dev/diffs/3.5.1.diff b/dev/diffs/3.5.1.diff
index cef200fc5f..64d6681bcb 100644
--- a/dev/diffs/3.5.1.diff
+++ b/dev/diffs/3.5.1.diff
@@ -7,7 +7,7 @@ index 0f504dbee85..f6019da888a 100644
      <ivy.version>2.5.1</ivy.version>
      <oro.version>2.0.8</oro.version>
 +    <spark.version.short>3.5</spark.version.short>
-+    <comet.version>0.4.0-SNAPSHOT</comet.version>
++    <comet.version>0.5.0-SNAPSHOT</comet.version>
      <!--
      If you changes codahale.metrics.version, you also need to change
      the link to metrics.dropwizard.io in docs/monitoring.md.
diff --git a/dev/diffs/4.0.0-preview1.diff b/dev/diffs/4.0.0-preview1.diff
index f29dba920d..335aa01d1e 100644
--- a/dev/diffs/4.0.0-preview1.diff
+++ b/dev/diffs/4.0.0-preview1.diff
@@ -7,7 +7,7 @@ index a4b1b2c3c9f..db50bdb0d3b 100644
      <ivy.version>2.5.2</ivy.version>
      <oro.version>2.0.8</oro.version>
 +    <spark.version.short>4.0</spark.version.short>
-+    <comet.version>0.4.0-SNAPSHOT</comet.version>
++    <comet.version>0.5.0-SNAPSHOT</comet.version>
      <!--
      If you change codahale.metrics.version, you also need to change
      the link to metrics.dropwizard.io in docs/monitoring.md.
diff --git a/docs/source/contributor-guide/debugging.md b/docs/source/contributor-guide/debugging.md
index 2694802d8d..47d1f04c87 100644
--- a/docs/source/contributor-guide/debugging.md
+++ b/docs/source/contributor-guide/debugging.md
@@ -130,7 +130,7 @@ Then build the Comet as [described](https://github.com/apache/arrow-datafusion-c
 Start Comet with `RUST_BACKTRACE=1`
 
 ```console
-RUST_BACKTRACE=1 $SPARK_HOME/spark-shell --jars spark/target/comet-spark-spark3.4_2.12-0.3.0-SNAPSHOT.jar --conf spark.plugins=org.apache.spark.CometPlugin --conf spark.comet.enabled=true --conf spark.comet.exec.enabled=true
+RUST_BACKTRACE=1 $SPARK_HOME/spark-shell --jars spark/target/comet-spark-spark3.4_2.12-0.5.0-SNAPSHOT.jar --conf spark.plugins=org.apache.spark.CometPlugin --conf spark.comet.enabled=true --conf spark.comet.exec.enabled=true
 ```
 
 Get the expanded exception details
diff --git a/docs/source/user-guide/installation.md b/docs/source/user-guide/installation.md
index d583631335..e2a946758c 100644
--- a/docs/source/user-guide/installation.md
+++ b/docs/source/user-guide/installation.md
@@ -74,7 +74,7 @@ See the [Comet Kubernetes Guide](kubernetes.md) guide.
 Make sure `SPARK_HOME` points to the same Spark version as Comet was built for.
 
 ```console
-export COMET_JAR=spark/target/comet-spark-spark3.4_2.12-0.3.0-SNAPSHOT.jar
+export COMET_JAR=spark/target/comet-spark-spark3.4_2.12-0.5.0-SNAPSHOT.jar
 
 $SPARK_HOME/bin/spark-shell \
     --jars $COMET_JAR \
@@ -130,7 +130,7 @@ explicitly contain Comet otherwise Spark may use a different class-loader for th
 components which will then fail at runtime. For example:
 
 ```
---driver-class-path spark/target/comet-spark-spark3.4_2.12-0.3.0-SNAPSHOT.jar
+--driver-class-path spark/target/comet-spark-spark3.4_2.12-0.5.0-SNAPSHOT.jar
 ```
 
 Some cluster managers may require additional configuration, see <https://spark.apache.org/docs/latest/cluster-overview.html>
diff --git a/fuzz-testing/README.md b/fuzz-testing/README.md
index aa312d0b72..f958d8d950 100644
--- a/fuzz-testing/README.md
+++ b/fuzz-testing/README.md
@@ -59,7 +59,7 @@ Set appropriate values for `SPARK_HOME`, `SPARK_MASTER`, and `COMET_JAR` environ
 $SPARK_HOME/bin/spark-submit \
     --master $SPARK_MASTER \
     --class org.apache.comet.fuzz.Main \
-    target/comet-fuzz-spark3.4_2.12-0.1.0-SNAPSHOT-jar-with-dependencies.jar \
+    target/comet-fuzz-spark3.4_2.12-0.5.0-SNAPSHOT-jar-with-dependencies.jar \
     data --num-files=2 --num-rows=200 --num-columns=100
 ```
 
@@ -75,7 +75,7 @@ Generate random queries that are based on the available test files.
 $SPARK_HOME/bin/spark-submit \
     --master $SPARK_MASTER \
     --class org.apache.comet.fuzz.Main \
-    target/comet-fuzz-spark3.4_2.12-0.1.0-SNAPSHOT-jar-with-dependencies.jar \
+    target/comet-fuzz-spark3.4_2.12-0.5.0-SNAPSHOT-jar-with-dependencies.jar \
     queries --num-files=2 --num-queries=500
 ```
 
@@ -97,7 +97,7 @@ $SPARK_HOME/bin/spark-submit \
     --conf spark.driver.extraClassPath=$COMET_JAR \
     --conf spark.executor.extraClassPath=$COMET_JAR \
     --class org.apache.comet.fuzz.Main \
-    target/comet-fuzz-spark3.4_2.12-0.1.0-SNAPSHOT-jar-with-dependencies.jar \
+    target/comet-fuzz-spark3.4_2.12-0.5.0-SNAPSHOT-jar-with-dependencies.jar \
     run --num-files=2 --filename=queries.sql
 ```
 
diff --git a/fuzz-testing/pom.xml b/fuzz-testing/pom.xml
index 11f57700dd..a8175d3d62 100644
--- a/fuzz-testing/pom.xml
+++ b/fuzz-testing/pom.xml
@@ -25,7 +25,7 @@ under the License.
     <parent>
         <groupId>org.apache.datafusion</groupId>
         <artifactId>comet-parent-spark${spark.version.short}_${scala.binary.version}</artifactId>
-        <version>0.4.0-SNAPSHOT</version>
+        <version>0.5.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
diff --git a/native/Cargo.lock b/native/Cargo.lock
index 3649128fd9..a7f8359d87 100644
--- a/native/Cargo.lock
+++ b/native/Cargo.lock
@@ -57,9 +57,9 @@ dependencies = [
 
 [[package]]
 name = "allocator-api2"
-version = "0.2.18"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
+checksum = "45862d1c77f2228b9e10bc609d5bc203d86ebc9b87ad8d5d5167a6c9abf739d9"
 
 [[package]]
 name = "android-tzdata"
@@ -481,9 +481,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.1.37"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40545c26d092346d8a8dab71ee48e7685a7a9cba76e634790c215b41a4a7b4cf"
+checksum = "fd9de9f2205d5ef3fd67e685b0df337994ddd4495e2a28d185500d0e1edfea47"
 dependencies = [
  "jobserver",
  "libc",
@@ -586,18 +586,18 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.20"
+version = "4.5.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97f376d85a664d5837dbae44bf546e6477a679ff6610010f17276f686d867e8"
+checksum = "fb3b4b9e5a7c7514dfa52869339ee98b3156b0bfb4e8a77c4ff4babb64b1604f"
 dependencies = [
  "clap_builder",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.5.20"
+version = "4.5.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19bc80abd44e4bed93ca373a0704ccbd1b710dc5749406201bb018272808dc54"
+checksum = "b17a95aa67cc7b5ebd32aa5370189aa0d79069ef1c64ce893bd30fb24bff20ec"
 dependencies = [
  "anstyle",
  "clap_lex",
@@ -605,9 +605,9 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
+checksum = "afb84c814227b90d6895e01398aee0d8033c00e7466aca416fb6a8e0eb19d8a7"
 
 [[package]]
 name = "combine"
@@ -621,9 +621,9 @@ dependencies = [
 
 [[package]]
 name = "comfy-table"
-version = "7.1.1"
+version = "7.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b34115915337defe99b2aff5c2ce6771e5fbc4079f4b506301f5cf394c8452f7"
+checksum = "24f165e7b643266ea80cb858aed492ad9280e3e05ce24d4a99d7d7b889b6a4d9"
 dependencies = [
  "strum",
  "strum_macros",
@@ -673,9 +673,9 @@ dependencies = [
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.14"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+checksum = "0ca741a962e1b0bff6d724a1a0958b686406e853bb14061f218562e1896f95e6"
 dependencies = [
  "libc",
 ]
@@ -770,9 +770,9 @@ dependencies = [
 
 [[package]]
 name = "csv"
-version = "1.3.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
+checksum = "acdc4883a9c96732e4733212c01447ebd805833b7275a73ca3ee080fd77afdaf"
 dependencies = [
  "csv-core",
  "itoa",
@@ -869,7 +869,7 @@ dependencies = [
 
 [[package]]
 name = "datafusion-comet"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "ahash",
  "arrow",
@@ -921,7 +921,7 @@ dependencies = [
 
 [[package]]
 name = "datafusion-comet-proto"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "prost 0.12.6",
  "prost-build",
@@ -929,7 +929,7 @@ dependencies = [
 
 [[package]]
 name = "datafusion-comet-spark-expr"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "arrow",
  "arrow-array",
@@ -1387,9 +1387,9 @@ dependencies = [
 
 [[package]]
 name = "flate2"
-version = "1.0.34"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1b589b4dc103969ad3cf85c950899926ec64300a1a46d76c03a6072957036f0"
+checksum = "c936bfdafb507ebbf50b8074c54fa31c5be9a1e7e5f467dd659697041407d07c"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
@@ -2682,9 +2682,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.8"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -2723,9 +2723,9 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.39"
+version = "0.38.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "375116bee2be9ed569afe2154ea6a99dfdffd257f533f187498c2a8f5feaf4ee"
+checksum = "99e4ea3e1cdc4b559b8e5650f9c8e5998e3e5c1343b4eaf034565f32318d63c0"
 dependencies = [
  "bitflags 2.6.0",
  "errno",
@@ -2775,9 +2775,9 @@ checksum = "a3f0bf26fd526d2a95683cd0f87bf103b8539e2ca1ef48ce002d67aad59aa0b4"
 
 [[package]]
 name = "serde"
-version = "1.0.214"
+version = "1.0.215"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
+checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f"
 dependencies = [
  "serde_derive",
 ]
@@ -2794,9 +2794,9 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.214"
+version = "1.0.215"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
+checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3037,18 +3037,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.68"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02dd99dc800bbb97186339685293e1cc5d9df1f8fae2d0aecd9ff1c77efea892"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.68"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7c61ec9a6f64d2793d8a45faba21efbe3ced62a886d44c36a009b2b519b4c7e"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3207,9 +3207,9 @@ checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.14"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
 
 [[package]]
 name = "unsafe-any-ors"
diff --git a/native/Cargo.toml b/native/Cargo.toml
index 8f6f515adc..85c46a6d02 100644
--- a/native/Cargo.toml
+++ b/native/Cargo.toml
@@ -20,7 +20,7 @@ members = ["core", "spark-expr", "proto"]
 resolver = "2"
 
 [workspace.package]
-version = "0.4.0"
+version = "0.5.0"
 homepage = "https://datafusion.apache.org/comet"
 repository = "https://github.com/apache/datafusion-comet"
 authors = ["Apache DataFusion <dev@datafusion.apache.org>"]
@@ -47,8 +47,8 @@ datafusion-expr = { version = "43.0.0", default-features = false }
 datafusion-execution = { version = "43.0.0", default-features = false }
 datafusion-physical-plan = { version = "43.0.0", default-features = false }
 datafusion-physical-expr = { version = "43.0.0", default-features = false }
-datafusion-comet-spark-expr = { path = "spark-expr", version = "0.4.0" }
-datafusion-comet-proto = { path = "proto", version = "0.4.0" }
+datafusion-comet-spark-expr = { path = "spark-expr", version = "0.5.0" }
+datafusion-comet-proto = { path = "proto", version = "0.5.0" }
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 chrono-tz = { version = "0.8" }
 num = "0.4"
diff --git a/pom.xml b/pom.xml
index ed0a8afb2f..cdc44a5ca3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -30,7 +30,7 @@ under the License.
   </parent>
   <groupId>org.apache.datafusion</groupId>
   <artifactId>comet-parent-spark${spark.version.short}_${scala.binary.version}</artifactId>
-  <version>0.4.0-SNAPSHOT</version>
+  <version>0.5.0-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Comet Project Parent POM</name>
 
diff --git a/spark-integration/pom.xml b/spark-integration/pom.xml
index a9e1619a1a..a260301da8 100644
--- a/spark-integration/pom.xml
+++ b/spark-integration/pom.xml
@@ -26,7 +26,7 @@ under the License.
     <parent>
         <groupId>org.apache.datafusion</groupId>
         <artifactId>comet-parent-spark${spark.version.short}_${scala.binary.version}</artifactId>
-        <version>0.4.0-SNAPSHOT</version>
+        <version>0.5.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
diff --git a/spark/pom.xml b/spark/pom.xml
index d1bf0fa2f8..ad7590dbc4 100644
--- a/spark/pom.xml
+++ b/spark/pom.xml
@@ -26,7 +26,7 @@ under the License.
   <parent>
     <groupId>org.apache.datafusion</groupId>
     <artifactId>comet-parent-spark${spark.version.short}_${scala.binary.version}</artifactId>
-    <version>0.4.0-SNAPSHOT</version>
+    <version>0.5.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
 

From 406ffeff7754c87c42d0c84f0f404b31784f2ec7 Mon Sep 17 00:00:00 2001
From: Parth Chandra <parthc@apache.org>
Date: Fri, 15 Nov 2024 12:11:06 -0800
Subject: [PATCH 07/47] build: Skip installation of spark-integration  and fuzz
 testing modules (#1091)

---
 fuzz-testing/pom.xml      | 7 +++++++
 spark-integration/pom.xml | 7 +++++++
 2 files changed, 14 insertions(+)

diff --git a/fuzz-testing/pom.xml b/fuzz-testing/pom.xml
index a8175d3d62..2184e54eea 100644
--- a/fuzz-testing/pom.xml
+++ b/fuzz-testing/pom.xml
@@ -100,6 +100,13 @@ under the License.
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-install-plugin</artifactId>
+                <configuration>
+                    <skip>true</skip>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 </project>
diff --git a/spark-integration/pom.xml b/spark-integration/pom.xml
index a260301da8..84c09c1c97 100644
--- a/spark-integration/pom.xml
+++ b/spark-integration/pom.xml
@@ -100,6 +100,13 @@ under the License.
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-install-plugin</artifactId>
+                <configuration>
+                    <skip>true</skip>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 

From bfd7054c02950219561428463d3926afaf8edbba Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Fri, 15 Nov 2024 16:59:32 -0700
Subject: [PATCH 08/47] Add hint for finding the GPG key to use when publishing
 to maven (#1093)

---
 dev/release/README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dev/release/README.md b/dev/release/README.md
index fdf1065c0d..cd972aa1c3 100644
--- a/dev/release/README.md
+++ b/dev/release/README.md
@@ -172,6 +172,8 @@ Set up your development environment from here: https://infra.apache.org/publishi
 The script `publish-to-maven.sh` will publish the artifacts created by the `build-release-comet.sh` script.
 The artifacts will be signed using the gpg key of the release manager and uploaded to the maven staging repository.
 
+Note that installed GPG keys can be listed with `gpg --list-keys`. The gpg key is a 40 character hex string.
+
 Note: This script needs `xmllint` to be installed. On MacOS xmllint is available by default.
 
 On Ubuntu `apt-get install -y libxml2-utils`

From 59da6ce7512360a2f0f687cd02892edd11bfe242 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Mon, 18 Nov 2024 16:46:43 -0700
Subject: [PATCH 09/47] docs: Update documentation for 0.4.0 release (#1096)

* update TPC-H results

* update Maven links

* update benchmarking guide and add TPC-DS results

* include q72
---
 README.md                                     |  10 +-
 .../0.4.0/tpcds_allqueries.png                | Bin 0 -> 28503 bytes
 .../0.4.0/tpcds_queries_compare.png           | Bin 0 -> 43094 bytes
 .../0.4.0/tpcds_queries_speedup_abs.png       | Bin 0 -> 64166 bytes
 .../0.4.0/tpcds_queries_speedup_rel.png       | Bin 0 -> 90369 bytes
 .../0.4.0/tpch_allqueries.png                 | Bin 0 -> 29251 bytes
 .../0.4.0/tpch_queries_compare.png            | Bin 0 -> 34357 bytes
 .../0.4.0/tpch_queries_speedup_abs.png        | Bin 0 -> 37579 bytes
 .../0.4.0/tpch_queries_speedup_rel.png        | Bin 0 -> 48051 bytes
 .../0.3.0/datafusion-python-tpch.json         |  73 --
 .../benchmark-results/0.4.0/comet-tpcds.json  | 755 ++++++++++++++++++
 .../benchmark-results/0.4.0/comet-tpch.json   | 219 +++++
 .../benchmark-results/0.4.0/spark-tpcds.json  | 742 +++++++++++++++++
 .../benchmark-results/0.4.0/spark-tpch.json   | 203 +++++
 .../datafusion-python-tpch.json               |   0
 .../benchmark-results/tpc-ds.md               |  14 +-
 .../benchmark-results/tpc-h.md                |  13 +-
 docs/source/contributor-guide/benchmarking.md |   4 +-
 docs/source/user-guide/installation.md        |  12 +-
 19 files changed, 1945 insertions(+), 100 deletions(-)
 create mode 100644 docs/source/_static/images/benchmark-results/0.4.0/tpcds_allqueries.png
 create mode 100644 docs/source/_static/images/benchmark-results/0.4.0/tpcds_queries_compare.png
 create mode 100644 docs/source/_static/images/benchmark-results/0.4.0/tpcds_queries_speedup_abs.png
 create mode 100644 docs/source/_static/images/benchmark-results/0.4.0/tpcds_queries_speedup_rel.png
 create mode 100644 docs/source/_static/images/benchmark-results/0.4.0/tpch_allqueries.png
 create mode 100644 docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_compare.png
 create mode 100644 docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_speedup_abs.png
 create mode 100644 docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_speedup_rel.png
 delete mode 100644 docs/source/contributor-guide/benchmark-results/0.3.0/datafusion-python-tpch.json
 create mode 100644 docs/source/contributor-guide/benchmark-results/0.4.0/comet-tpcds.json
 create mode 100644 docs/source/contributor-guide/benchmark-results/0.4.0/comet-tpch.json
 create mode 100644 docs/source/contributor-guide/benchmark-results/0.4.0/spark-tpcds.json
 create mode 100644 docs/source/contributor-guide/benchmark-results/0.4.0/spark-tpch.json
 rename docs/source/contributor-guide/benchmark-results/{0.2.0 => datafusion-40.1.0}/datafusion-python-tpch.json (100%)

diff --git a/README.md b/README.md
index 1a6281a993..caad63924f 100644
--- a/README.md
+++ b/README.md
@@ -46,7 +46,7 @@ The following chart shows the time it takes to run the 22 TPC-H queries against
 using a single executor with 8 cores. See the [Comet Benchmarking Guide](https://datafusion.apache.org/comet/contributor-guide/benchmarking.html)
 for details of the environment used for these benchmarks.
 
-When using Comet, the overall run time is reduced from 616 seconds to 374 seconds, a 1.6x speedup, with query 1
+When using Comet, the overall run time is reduced from 615 seconds to 364 seconds, a 1.7x speedup, with query 1
 running 9x faster than Spark.
 
 Running the same queries with DataFusion standalone (without Spark) using the same number of cores results in a 3.6x 
@@ -55,21 +55,21 @@ speedup compared to Spark.
 Comet is not yet achieving full DataFusion speeds in all cases, but with future work we aim to provide a 2x-4x speedup 
 for a broader set of queries.
 
-![](docs/source/_static/images/benchmark-results/0.3.0/tpch_allqueries.png)
+![](docs/source/_static/images/benchmark-results/0.4.0/tpch_allqueries.png)
 
 Here is a breakdown showing relative performance of Spark, Comet, and DataFusion for each TPC-H query.
 
-![](docs/source/_static/images/benchmark-results/0.3.0/tpch_queries_compare.png)
+![](docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_compare.png)
 
 The following charts shows how much Comet currently accelerates each query from the benchmark.
 
 ### Relative speedup
 
-![](docs/source/_static/images/benchmark-results/0.3.0/tpch_queries_speedup_rel.png)
+![](docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_speedup_rel.png)
 
 ### Absolute speedup
 
-![](docs/source/_static/images/benchmark-results/0.3.0/tpch_queries_speedup_abs.png)
+![](docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_speedup_abs.png)
 
 These benchmarks can be reproduced in any environment using the documentation in the 
 [Comet Benchmarking Guide](https://datafusion.apache.org/comet/contributor-guide/benchmarking.html). We encourage 
diff --git a/docs/source/_static/images/benchmark-results/0.4.0/tpcds_allqueries.png b/docs/source/_static/images/benchmark-results/0.4.0/tpcds_allqueries.png
new file mode 100644
index 0000000000000000000000000000000000000000..b1c9e3c90a871b9befcfd35bca84b075601a356c
GIT binary patch
literal 28503
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

literal 0
HcmV?d00001

diff --git a/docs/source/_static/images/benchmark-results/0.4.0/tpcds_queries_compare.png b/docs/source/_static/images/benchmark-results/0.4.0/tpcds_queries_compare.png
new file mode 100644
index 0000000000000000000000000000000000000000..e367fe4cc7d10faf6b7a21eabe19ddbb9eede0cb
GIT binary patch
literal 43094
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

literal 0
HcmV?d00001

diff --git a/docs/source/_static/images/benchmark-results/0.4.0/tpcds_queries_speedup_abs.png b/docs/source/_static/images/benchmark-results/0.4.0/tpcds_queries_speedup_abs.png
new file mode 100644
index 0000000000000000000000000000000000000000..d719bdbb19c4e410c67578a11b460a4b3ebf232f
GIT binary patch
literal 64166
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
E0eV7O`2YX_

literal 0
HcmV?d00001

diff --git a/docs/source/_static/images/benchmark-results/0.4.0/tpcds_queries_speedup_rel.png b/docs/source/_static/images/benchmark-results/0.4.0/tpcds_queries_speedup_rel.png
new file mode 100644
index 0000000000000000000000000000000000000000..afbea75ac03b553ad543183cb2ba073fac685b3e
GIT binary patch
literal 90369
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

literal 0
HcmV?d00001

diff --git a/docs/source/_static/images/benchmark-results/0.4.0/tpch_allqueries.png b/docs/source/_static/images/benchmark-results/0.4.0/tpch_allqueries.png
new file mode 100644
index 0000000000000000000000000000000000000000..24a3698bba6a61408dd6489df3cd86e9e1d8a8c5
GIT binary patch
literal 29251
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
F_h0{H@Y(<X

literal 0
HcmV?d00001

diff --git a/docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_compare.png b/docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_compare.png
new file mode 100644
index 0000000000000000000000000000000000000000..8d3223a9f2d479f957911a92742b4ac92a26d2b8
GIT binary patch
literal 34357
zcmeFa2UJz*)-6bBnMKPoVF0y61p}A>iAGdJf)XW)fJ#Q9WYhx71d1ps3I-$x$w@$^
z5EKx}IVedu1SMyBF64Nv+xPGB{?YwL_js=vqe{fXK6`&*t-0o$>pNFur4O;rUOt<J
zg@sk(@PXqjEYqr3Sf(h?oQ|KIkLKjWAA%O*$`*1ar!B0t%ye0#v@A>wO)L!cPOY}m
zH8a;UG2X!=$g_R(>a!LWrshJtyhcA>z++-|hIfth)N)*8mg(UW<}57pwdlWJ0(S@K
zv9P#2l{m0h{`|wXY8z$w#_{oQrK^Q!CcHTO^z&6oUH#>H9ajw=+|zYDURd-ypV#)F
zoGs>h`8l!2k7h3k+q@(GsFZm&-=_Gv83#Vf@7epRZe;9hroH!`X(C$#^D-@S70i8y
ztC}71=F0LKcW7^$oBkW_V&W@-dtM(8^DoYozg!Sz{$>4Y(;1WBzxwsp4(5;VIlp3O
ze!uXygsGF?pPVwqn)&0Sd+O#*e(yYMX4Nl~-*5f@FaE#eu*|N0<1$A#QrTi;;M<fG
z=|X?0;uyWcDJj!W#?@!KXP=5Z`{|8K(YZO-+})K*!_^gn<+)F6ULxfyroKYJ*fZl)
z{@WWX!bWZTJHlo!-dGkU&BAh$hZfVx^iz=yt&!*I4;rxD?&VSpz4!jkrhr2nHV20L
z+Ozqs^!0=NrM&&8vo6o7tW*sT4-Zy}4aVR6)*f=JdJ$KXVwYW5*qszRfB8<XT5}m0
z86|yv{nWhiw&=W`wDD0H+{mqrQ;EhOz3<-jU#e+;?81c$X6EK{m!`AE7*{8)9LE0?
zZY<~XNKQ_kGG)q6ovh!~lPtJ1Q}grlm+w4#GgvWfqqVhlVsdiG!5ho3{`J>K-n5ZZ
zh1P9lk^G&$mo8m;@5%ja9=p(4-0q+wyKIaRuBV;prm%0{#T3c>mcoGIG$*HNGiGGx
z=1Se!s8I0rQ@UkGm7txMt4P-DThScS($c}okxy;=+JbhEj}+E4-f!wH)hz95%r>uf
zDtn=&5`Fr{A8Xgfp8s|#R<F>%?kYB;xa+f&IoNRG*`G768Ts(4#2jXngk_g#q}W=j
zr`n(JC`z%jjx{KiUbbwR(D|>An{w_yQwUMi!#xJ8C&zKNbf%3fdh;8_*!3G*e)+gp
zM&#R{BBG*}17EcqhFSt_J5%~SeS9>y%tzwWFV8oqh|yC?G<!Za#Nd_i@b&erh&PGY
zdue)*^dq4}4ucO51uIhQ;ycpD$5u>tO|k1QiPFv9Y4Jr?A?UdHoTWVS$yV(#TItjI
z^oz18Olngd^z)y(1S>^^$JaWlI*s;v)!27Sv5VTuhbV?cE$gl{Nh{WN7hQko(4pQh
z`TP58>>^gKTxs#;;~Iy-Mz04u&bU2&_Dmtwe$dd;&enG0jvaCvWPFN-JJTYt!VH=}
zJSyqWGn5e<^y6?EIhUA_uqbOFAudccUcV~gTx)f5yuH1Bn_}j3Nv}oAmj^dA=&-Kb
zCA)X;-ikD*w9_9R2C=T-Kil6?ZDxAX;bWLi*3C6Z<72~?jqew?mq#DMxcDfBs|8J+
zF^_BO){ixf)iI@-PU`B(Rtk7y^WyQ#s~lwmq#yN+bmys7V(A2Dd+}zMmnS+0|H{JB
zcaS2c;Yg>`c(hHb!>|?Zibpk>lVP>mvb88uu;zu<e$kPy>GX_Ex!xOE^k2QS?$p?#
z8h7;5r%(L#NAGRji^Ui9ZbxF|m4zGhu>^w^Lhkz5G%YI*R*+nBO+3?$z0gb3F=(il
z!N^#uS@idnh30%USR<CD>elaGzup_GUz~J0?UAr`YoW~U;uR(@wOCKl%2SEe*K5eS
zRgq*F65A=so8tHTx+7=n-`?oz>hj=J2$bDBI@DWO5o=JKWN9E#5UHKnGf?jyVn5iW
zlIEC#9iVNV%Pr@Bwy&*RaQZzOj+TPwVR^#V9ien({AJpbgr%Dlk7it5yy<4-v4Oei
zve?*FRaIsV9|UUcpDo-V{RI=RfCU=XzE1LP(ZIL*Sf_EvYU^5uX~&GiIX7&`PESua
zE=^l3+VgRLYej4bXG>6k&v86BAGWN+z^BVsuV2sUPZ%7uUp(#1hllU_B)80%F(WZ4
zsUl!C3yUn5^7bh#EJsUU+L%iy#S7f>V;8nM+xY%YYh}Di+zWLNH8r)KCU27^`Zpq8
zc3su5Yv;@L-K}ZY-%*^+n-+?d-ty`4s*)F4=`l9lryaU;1u#p};g_C1e*9Q1EK5Dk
z@ID^Re{6JEwNg!8y*S=P)2K2|3QN<IbKSaiC!ES}Esm2^O1D9Tau^$IE{O}03)m<q
zc;eWxW94tGB+M)<if*pizi81Si}WGHq0r_L)uTtRBd}Pccdu)~I4I;k;A`yY2*=C>
zVxOx->0IeOFKw5ggxSHXKHlA;Dxc=)fCmmfm2p)i=IpV!Z%%`aOZoH)4j3C7Z&Zy7
zrKb`X7jM+p9Ege8d1Kj*gLgJ5-Mx10+Qo|(cbYXEe*XM<qrS1QRhukgLqmJ}76d-}
z_1&XAw|fU(Uz*X_)a36YYFF_vUN?KmV$3IR>cG?3Eo;{7-G6zWf~@RKjG}y^nXc6R
z?c(?E-{)^Wefo6kBkP)c-2WCOC8fckp<pR*ek>#}KSpP)QKa%tt2SlK#{%0=E=xHj
zUcY`_vSm+{Mzqt|;Gu=<kIFtja;M?*=ch;+U!Hquyzi^fNl`K=2|bo#+uP98bb7Q=
z#TcV2;W08gYE%&|mX<h6X+FD<A7c8u(o!WnHuj)OoMugXb+QuX<Bpe?7vfy;Q}Jtt
zs_S(fI0TF;{4PwL@jfq4MmPIzEQe;S{v8h6FKcYhpAS6$?X!MuYKr4<yMXt$&!0c{
z6v@d18J0(xojZ5z{&wA>Ah`{4opN8(=kHc#eEs(A81}uz*Sgn+qgX7@vAs8L-73q&
z!!vu{yprfVF@w=fPrIA*7=z8er8F8?2R1e~LAWW3JbJN5%AJ-R5El=!>2B)k?!Jvl
z(Ju;oB52;EBiw208<93PB#CW%_wwb-BO@cBm2o51nmrhnK<mz$^0yyaQs*TO`kahZ
z_I&s-bpGy<k3*KX3kM3u9en1de+)el9Xh(MG2ybE^!6P)_#B2TibGGxA(eLZ_m?{V
zGS%YKn`z#Th|<TEmG2$#;@Kh~Ab^AwBI7Go%D#eyWzl9uLV$(XF-JY*k=P}al%kGc
z(zd17I*mKXHIE}0JP@&oDhWODY{?cC<w{=lB+mKs=K}z!Cz$RHQ;97=L@GvjL!6VC
zFY@(O?p>Z1eHP_deFg8|)IC~DBY0a{`L`ns3z^nAV|%PB4pGYU_l=H@)-MeYLrzht
zOdai0RR~u*!Mc2Bmbqwip0Ae$U!9<3tLOTo_f}(VSu#p;{WbG^M3E)eFLOOt{jCN!
z$GU9$0mP$X^E}ajq9Xaxu58|lNbSo$=RaRz_zY*Ratbsk4Mz-!u<dPqK5fnt8qZ+W
z_;CG_Q0^A}du5>~cHk+*4<3A<p1yyT{nx$WaRKjga*8nPp$N=@PUB<28YxNhR_=O?
z<lK^VYpp<)?;xdt$~Ys1cw=?iW%IBEemmFQlpCy>mP(m#*248)T$XCc0x0!j0c}DY
zz%wcyKK$2P_f@<SM<gVU-Ci$c(OSgK%C>b6qEul?nCjwX%Yq66WDJIST1psw?UhQD
zTk$TvJ%ut1U#GEr<cwH{;XXrOcLpNvHMf<5Pmu=?0IEfg>0XM6h~R8#3Ggk!%>{<5
zC+q+H*8&=f^->S~F3p(V8WNEjwTuCD(pr;}Jbf<PW5>}U$_t6%`#qKm7;i=}745Gw
zw`GLI%f}g>ppksA>)cZz#Q2*xZ!&zw5huSqxy<2l`}Xaj{>}*6vt^OmDv_sLdLxe0
zE~3bdgi?S(YHVom!%7drm;qeK#YK40F2t6NNF55s71pVbX5T@S<KDdasGR@NV@Hl$
zB@6=urq@}MQsS-ddigQ~_@S`w^(BQT`=&h-G(QLgB!`g6E%5iq*l=fYoRO+RsPZvD
zvEs&TuilR2&S0%{*NW&f?!C(+BO_@le*gXVB7ifOKmYuK-K>Hbe*F0HhPJj)05Lga
z?$T%OV!?HFCo?iL4QgK6=ok21aU37DE{t;;?997}y%~5q_kk@^Pve&_fe43Z>t0=W
zpOYhh;J}}`iGmKPJesMY*biLm*B{*PI``PglaH71YJ{$G99UD!*VJeC28o#_F9ai9
zqIp*lJ1cV=&~j+TwWW-A8+<1K(P-Be0h$e$IZIoS@CqnNu(OBV-*HACBLT4H+kmm$
zapprHHb7TzZ*kzUXASlB&j899n30@*1}d|oCjl1K4&lDeg^la{<>toExeVET#|Ix#
zgTFH}mf=lzVt~Z<dwc_IU~|=Ca~J9QYt6d^(@$@tiVH%Nc=s1ru3E5QfxyZDOxfFy
zPxgo9#T!@a%Lg6LxT!NRG_?HMk}cccd-0kWmc4krb#6Kvzu~=ae=n422r7BNXRuuA
z!Op~{NG#AZ2IKAVwR0ujRwbIVrf<Ct9Jbu!`YNZ9ZK}10Ryh>SoH-M}z4iBn3t1%&
z0#ilzCYye`c&@MQ1Y_;Gbs4sXIrp{+rn-uWiM?$t4vD@|>?d*Cz;Ve~m|TGLL1f5?
z$_*PgzQ3t+;Lst}O5BgHQ7XW|Hsq!23)UV~uADxf!%%ti5^Y*Vapuh*mH}+!@SnzR
zGpxCcabJPG`WE+T)OugoI(*H$0Ss{X3G>sZ{f|9AvUu(0%{f^)IWchoetv97RtEuD
zLyZ8k4`OM~b#ij52e9V<<Bvb)0=?EZ`#Qz--QTKp5$H{8rJ&j0O+t9tcHo55fB*eA
zjq>i1ub0-mW81EC*o|-5+i{022gSv88EfCM?KpkCcM$OGR=ef)x#?x`CcbOloyTMw
zRbZprV45iFR7TZ=JQUkt^X>JFRcsg$e%~}~nPp1hYKfl`Z>$jDzq*vy_~EW|Z~RAV
zJEbs~tY^-gsmGoyi7P8peun&Z5Q`wp=!9=3HrBH7k#6_cQLIT<cX#*v2+iHz6KkWU
zrlzD1p@z-lx<JkOwI;l;_!@c~OTyJFzjk-;`0z;hj8P>r*eC3hp0@JBijwFvGU*tb
zrs%ut7_kykQheLDZ;w(h%*e=K+wC}F$;f)=%DMt8;NrA7*Q3wm(Pn&$n(qbz2HTQr
z87kRnY2!Mx=FHi#Q8Dyvp;cI3X-`WbtHfIjr?HWwv^4)lrEtT;QI2^ZmOoR9&?pbL
z-ch?yL`1}FWw(mi(0$KdmC<CXgqC63$BWgzw28(vB10K{P*1Uql^RykbkIHg{#y$8
zp1$<E+gVuZ{3%GMrl!uGIa3zV(z2~=8zC6ffwy{`R1YoU)fn-QXl!i_#ujTF$hv{M
zZbj-SLhxCqUL7DPBBJ)oFTV@{^z)tjeBcI$sLHu>=Ss{G8tv0}kLO)OC}~buE^MG#
z8|s~ZdbC@`A=>RsN~({KPx%m^QH4C-x+D`>I;wZ@^EF<Sr9xrq$%;URRO`M;PdDoG
z@Cr9}IazhmGMRI5VBibjKtbN_ar^YtafN3GSt+oVG~+5jI}gT2x@8P1u{jnmU#=gW
zX8+D(UGcL+?kn8VELx5$L};k5S+iyc<x-e?Xc#ZQVVP;Jd4GFl0AA91WrNShMDym*
z=Jgvkgos~TGW0ETRha7QUAuNsai3(-;!zQ26jC02X4CfV1*iFj3Z6^$e%wDl=)jfV
z`D0@Y%a3Cx(C@5McW~Og<l5Wo%WjAHhZ=3n`3l4%;o&-em2siislR7R6kxuMDo{Kx
zUb4hWuJk1%Jeja7u?3nAy?5}!aQEF~%GfPQ9X2O4GaZI{jwPBk8oKGGtjBw(BwK}1
z-oZ{%arfeuJ4p3woMHK?(TaBkv~ca_gsR3%&zd!ha#^mOe5mp^zOx@+4cVMCH@^)~
z!Eao3&nSETj)!6nDkwSR5DgTfbR-Ohk>Q>JF`lSR&dE8tMKe_mm?!5O@2V(`6-$>c
zW%MagL2cdf5Fk<^Oob0M;f7kvzLvs6w0h>wm8bee^@UDxSEtcM#IWA}TBi_++v|tA
z^LF34ckk>DMQPuN&eUOP-S?i69SeCSIyyS|E6p2=bM0lgxFo%J?!?E(Bj@VM$yFy=
zHnz0rg>f4=4Va{jDq>f2_Xz#MvgbqDaje{`7?c`}{6nkmU=&f(%157;^1ivtfZ=&<
zDevjz3sp|w0R&aQdc+1KSoEIu23E<j4zufPI|h`_=d6ly9=Wauu~>x>di?oS1nJYF
znYFc=XYzb<`}xMfR&2=}eIq9)7nV6bnrG0PE9BFA?K*Bzmmy$MBclHD{IPG}z6sV0
zC?+M1zD_fF08p<)6+f^<Nk?^Z_jW#sf@{2~fryA2y^K;NpctwiMUfTs%U*n9%^Nj2
zzfoe{5ziO1w#hu)_2lEnkA|bz+V<(++&M&paT%3(*}({8Hnn~=39RQ*zG2Sw>w~e_
zJi?6yZpEIl1+d&{+w;Y+p1_DeXd^-!CLv~)%A7Z-j~nXhZnj&_ojLO+;+gcrU0Q`4
zD_7dfl@24M7d_cO!`tW_rgAecFE3)HG%YdEKxQHWjHO#klLfzFncwm7@TgZ502Wn3
z0+99*(W?$V{9Y^|v|nVC{b)pJ=Q7~?2itY89=y)B2GL*i>#M1)AD>)8MXlF8x+yJ6
zW7r^97g_0uv~&qFou{X#MRlq8P@3J893N3tFih{WvR-gxSB$OOt>MtCK>HX$k1%)`
z9=Nh<&gTGM$AWv?v}24a`Jemwl|A&ncaO`&#DvlPP)u`!^g~&UYV_z+?ug1|qm>hj
z=#V>y!l_eFQ6!j&_$bIBu`S}@2tQZ<Ru4c+zal1xHqHj0^M5F*8verKd~q*v62>ZE
zrovZTJky?GU-#-4@8WF1K_bvl@s!6jo>s6lM(y$8w9{vxiV&<%{^6iA?azH08{XX(
zSiEmk3FQ#LYLH=jfQ;{5P6LM%0`58b<0iGCj>sMx<@~QZj`o%sjz;wbe#pMDLKGF)
z<GoWI@G}eyN}5CAd3VC6J71o^ssxxW1mn%X%K6w<9^DIAO2kd6Xn$?Uwej50ygitS
zj?`h}l+nIQL5{Q<Dcxwrh_r8SSMY~0#@o}JbYEDtt4JvI7mHz=N)0@?e?JHtn#c`7
zHwDli1|?mZr7A6BovV9KXAVVFRTcHv64~P9G;X*l64*@Z2D`ALYP@mE={gPBF=0%$
z{kP8<g43JF=iR<Mk3HCpU08pxtC48AgYFz**xfBa)E^!CtCe23H0LuS(!%qf9irmt
z0aE{wyPLUzoLSk0c2=_5b$<rRN^Q!!2viz`06TlutbEWOVUHiL78Dj{;NJ>Csz#~z
zpWdxmI{aXuzyH4XppUF9%C^Sl<^aURU77VK(pJ7u-b`pU&ZIV+U?)~sYhi$UjV)t~
zQEjSdW|}Rij%n^h;V(*{`z`R382a+e-Iy)mvWrWjt=+wmuU%bHC-$!T?YGDG?y-#`
zJe7QHtF81ptYk99c1K9-c!*VdMa2uPOV|O17sn6<mE9$klsbikgiw&F^9yX1l94Gz
zk!x5%WZ-<UfjuC5a{A_68W}*I<{YiPq0>zzle=i&Jr29JZO;P&LJ&NtVgQ*LrrO+~
zghA{@7S%Dx3u;f>s1WQoI^0iL$EL<@9b@_x4GoRNA(5O%!b$-4g<!J4L~v3$r0Fyo
zn|t1iM?LA2G7+i>T^3^_g9hPdc`6FNH*cOS9IFNY6niNP9O@?UgR~`jTZ_Zm5wMON
zJ}iqjj!-?L0aV{SFy}&O*tRIKOM>r)=G=Mc_|7u}MF^s@ko|yZoHpj$<I<&c*7Ty#
z{;Iq@UZqYOFcLeF!fvo_+eg=JuZZm}Q8j5nrI7R~vGjItg{A=ywmKE+ptl+t8!fTp
zJwVR*qgK$vee$;>FY!CIpYq4lac$WmRcqgUBUdx30R#kYm;plZjusogZ~a3JFK|6N
z!?riW9i>L>u045aFSFHrP5>iFKFA|=e9Vr|uxzVR+WGT!7iRRlnmYgN=fAHID};#n
zL}vG>JpQv-BM+K*?3yU#nLQWgu(B$E*y#aWJc}_XcMAvzAU?v&!cxIH`|cJaj?+}j
zqHa9JdP*hUI1H(zwfu~4G1hbJnLG|eaT$<|hul`?gEffJFAg@Wyij!=wdBUNYxfg3
z8oLG01Kgtj@$m(|Uwiuc6mi*JWT_Uw%92!EkHTONmZD1KLARCM;Fo%lJTWij;rG23
ze@0bbN|o+!znzSJzV`?Jl?Ra7T~%Iw0u=I1EjItQ9V?eC@dtIH2R50XPt$<!OB$e=
z6d0HSARFKIGC;pO4<Fj+nq%#R9J#ZxC0C#}=iIQ5lZh}@PfIn<?*%BgZF%lRq+hGI
zNoqcELi*)#M&4jCZX1RE`RA_&bt^eIc+$6;jWC=;`-`))C2{j{9m77l;5o}byc?SK
z-YGo`8%4syU&hzC&?mMl9`$$m+oWY6+ZB+N<A&GTcfH%-VNtE{2?zm^EON<aW!iGy
z+9x6;B2Q%$Ath2E<aheCVAZM!R3oV04)UjceJ=qr=H<(mJwuF$=7I8D+dR4B$3s>3
z>C)^2*!$Gqm9<guKf0_qTwN7m>q+i#A7YO_7Gz2P2T;9;*d+i+G2k~0>qmxT2Rr-!
z#Qir7cnO?-r=l>{$ymRB{YHG1YU4H1K;aZpVz;2mYO>S2i$No~;E0S&e4N8@d%TcM
zm!DJ`mf+W~U$eITEr1AF?Ro3g6HpmC!hHav$_A(w_r>*ZV=Rq3ZQsGdvS;kY8;U?z
zv8RJDJ+0s*gsj>EQ4wb$GGO-<BfABI(qLeAHh&eO7yw{s0Ia!O$Rd!`7`r}0+VUV?
zE&x#ap!RtL$ToHQTv-s(B!{ROb$+XN->ot=51^d*)QFV62Yw;Legei-$_2$n8XOKi
z$3Wk-=G@;Atd<xhHu7~p`))^(%BzKd2(8!(@<@@y0$>s}iQJ$W!Ij@uL|_PLKP6dr
zhGVS<;f9l-M(DD+LV$?XdH1{Eu3drP1It@AFmOPG_?J`K+I&u9_QZOjxQsoK4-_F|
zR1wqS`pE%H5exe<il6tuSu^Hy6yctVQyuK&j2{YveRb%`KZN(WgA#Q!$TNqpuV(-b
zJ^bLi+o@V1kQ5EE@ey;;?wlPIn3wY#2425D7tHTrl!S@2XzO#=KM&Drnz73Mahy?Q
zFmV&03@kwXw}9TDU&4BdIh8Scnd=iVhoLM8QszxLx4s8e`)@8jb{&GTK=Dw>h>q>S
ztOSDBCDEi6+Xz|-`!3Tx*wKaG>N6FREcEycN{-TfozA)U1oZ<^yP!XckWN7`?f_AD
z*rNyhhCx@uJ6ja5C_Y3-QHTlQVdHFy!c>(!dH~!Qs2IFJ8qwOY>r7Dsw_AWe1F!>$
zd`4a=BFYMtW@S}ro$XsU_7H+I>8`ARGcA0>^gf6=t!0tVFm$1ap#~`8h8k|m6a_16
zVptt6-LCz1E<(p)u#d;a$3_>gTp0==V*u<_qWSh^UxfjJ-J|7v`V&-ee*Q5qb#f{y
z5B#Mc*`_C+x3STK#AS<ptPmj0E;=?)51K^*!HJY0%%(n=DLm3&pxmE;cn(4>O>92O
z%;y6G=jrt&-<I&G1qS%o9-;fJPPR7IkPbmHy&oY=;q2MKp}zJI)QAjJNmKyf2@Tr&
zvF{CNGj}cn9x8>77>oMNs60v>l|F$?Foh9xN#x$gL_Y!?l$~yjFUPZNL7k5x_89ib
zM~b(g!?KaRGL53ms65JjC@3dt*H;9TP61?##!F>nyz(Kj(Vjwz0RW26@E|RK(}WsA
zonmjU<E>ptYk<H!s*$)UQ>S7S?bGx09Cu=l=#4<c#F*5I#Tr+uK++Vl?FqcgqaJKs
zV{?f3SDHcW1;(vI93WEeSbX~|o&sSFbYRrj@2F?WE`X*oWe3IdHg@dx8X=*In>sIn
z>Jpc4LO?nXz2ycXd+pbro}CXLJ-UHV!G;QfAA{?@!lxDl71W{n2bt@ZO^{T?0dbv(
z^7{rXqEb0FHf&N4q_OkVsZ-#Vu4BKH@3QIA;W^#wgc?;FWWcu5Ic(mkUc8$86l2z|
zUj54S+_`O#G##~p90c8xA^OxKSnPzh!>XyNx%Q7g-W)!1<b7l(s4Fdz;kM|5SWT>;
zq0@77b7#()wT)CcZKNlG&{EvmOjcGt?A~reZ2`T4h6lbbPTm40KKTjfw4Z@Oa|PRf
zEa>>UdT_!-eT6wZefo5+#6b&-nAk9gYzGmD&0iW5NmbF;QEecCI$`2>z{6?-+u<R0
z;N@y+RhD_cWdi<3@1H6PJyA%{aKw{K3tO#}O~Ck})Q!?82#U`D#7YM5@M_k4DGBqA
zbR4x!-#WJ*GR-#5WtxZsxi;IjZF7ZGk{_-vY)}bS>_%4B;b&%z?_E(lAH&9<7z&bY
z*NTc(S9D@Px7D1lXI;z5`M0T+6~DcM!wp2B<;m8aaeWdJ65FuA4bI!yt-z%Ok}Mgg
z9}1eU&&;d+bJoJ^$sI}ArlzJZY*vA`I(2=8z=xUh=J7v#`0zSF@mlZ<hoz)q1;<r7
z0gB%KwP5YsYZ<3jik$!I8qxS<|78Ln%OM-MB7Pi8wYRAUoDl$jY;ryvF9%JcFVdB@
zmI$p+t*!bXRCC!xZDXW-vHaPzw6t7-fIf9}81FPF$ti>ODdiiQSC3rwu-+2P$jLul
zT$Z7LaSaIxq3L-BZQw25aBh0S&?v0{nr9GCb5W2zgC1U<>Q>{>ufD&4FRdh6$HC;r
z)vHl@Smd2I5G9sFjG7qJNbN)Qpat@*#*l!nLrq%_WH2$Ck*CBb)|I5>4lL8-a&k97
zS+apD*ajqdovs14KfABjEKJDE)`4>wrZL4h%_Md3Z9=n;-CQibXZu`czxCvnyACCz
zVaRT8NfieQn)K@GYA*Gpm~U0)dCNkSB0&DG;5U5HG7R9l%(~jr>(l4Yr*;~aeJq1z
zK*~X8m&KQxv@~fc-_+@8EoLNj=eC?VUSiPOsbbgLs_V(CDONd1fbSR-4tg1v#><3r
z{ngeh;L6yEB*=;(D(?XKax7d;Fdft%afLz_Urvsyp)?tO!RC6!dJQzCglTN9Pf($>
zLU))@3jD*zdqGMBBehqZ?^v=8HiBGl0U1L3O}R?PzCtRBpa>6vqmSo#Rtpxe+p68+
z06P`Qo|W%m0YK`BUNNRH4FE*z<a{_xOfw^uHxD5X5o1GW3F<wPJcEGX?y-UW7)Aw>
zQL@&$e?gdfVV#)u8u-!3$5+@|8jw{HG}O$>b}nviiQ)dvQYh2y>PK#Av$=vrI$M33
zjAZc}`p8CQ%?VYHA+;HZUW%bn>CpgL;KhrrsL866YWc3-{rFLq=sw~T?CoDR<@rYV
z`Ekmb7+-tY-PQH^^o>#ocot1L%j~=m44tP;*abS2!AMgIChH7HZf=MPP|@X3%0i(v
z>g+OQN0umr<)Wv?uJhfg$Uw-C4|Y4H_P&k5ow1yp-}VU={=}E_tg`g~Z0qVX&17GT
zQVA$<Bc>8qD<%88qs#dbW(cD|YUaFop%Sh(Gpo*J{&nL9$-ODr-!Hsp!MUymi91_V
zOKNoM`1jSh2_Hnw3=!vGYh$Bsv;Oy2o#aI<m_2)TRFk;#3A##F#lg4P+1Hp>GehCI
zg^_y~wDF*t0Gv=nRKUVVd|W35=Yy-3@-S`%X;lGR;+D6!H*!@FURM!0d3}}_;&t<q
zy}`$jRs@Bl6$CBOGf3pYFcOqjoB>JkV4JpU(}zbPsA&m?A_^QqgwbyNevd3)oi@Ks
z^I9;~3L3|Z!Qo*8lx!t&U%#3rCMHsq=b^<0j;RQdh)f=m9thWsot+UR&j82d6<eZW
z#>9mE{r7=5&+kK+aOu{<Cy!rT7H;c63MnFNgKZKBtVhx>c+00?JybntJtidV0s<?r
zbps55`{*$Mg8B|q8A(aPBfU1D>|RU5NrJC3g@XrODP(qTm;H5@pkR=4<f%TMsn)Bf
zSeI3!h5*;(ck||NB+`Skq`Dh*;Tnmn*RI{>#A8)HZ0_td5xsjG{DmF}mT5}6CN9hM
zJFFRMY7ZfewW-g(`rE2itET<>tEsm9qK$N6<kJaeR`TxVV_+R(k?=un$OAEguTo0Q
zym9?{5w>zz-fa&Lco}pKzMHt}<C*VfSB{R1G<0-Gzp}l&WA1)#Zf+s-rt6$RNAGX9
z3ZH5HJ6(Ma@5{%ieon-@CJuKbTYmm~7IY&C;KAd2_BeBLi;2}Vt<b^F0R`cZdrn<V
z4c>s`k7K{P6NiaQb8QE>h_V*s`U5M6Qv%Y@EnnYNmD!I!?kY=WS-ozZ_`G>>t1@7a
z;KpkASOg^K?939TnO0*fg8fa_hqGtTJ}IG1&BAi^Zm4J_f@izhtg8<~^L`y3dbTz4
z4ZBq-Vz|`9UB{5}<!BU;Q;Ciu4u%su@a&h5Pi)&`OXZ;$K}R>}`I1lEFa(%(RgsAc
zbNya+aQb-0nJIlRQ6}3VaPryqoFyj`?wE8!Qv9&ei!086xB^M02-te(=FP_>fC7-1
zSz7*BvGM-!#|5JbeIVwLlp^_y@g_s=smYtLi&2z@ld%Tz64?44xj(=%sSZQ`y0L1v
z1~dw+{9@#y2-t|2yU2M&*sd?s$D!{8ydl!$Uw|lrQq*y%WrLm9-DfCkf`Ie!K%SGv
zk+UB$uIn0GN8l-;@Cu3mcqQ4m_Lr&C1CKvH0=M05h|fZnt$wH`?r)v*xDJCjF%B&8
zk7hqpT+-U>CS&XyFou#G^=2tyMO3aE#l$oir4gl2BxVP`2`MNnG+H9qbQgR#U8+>W
zP6~;02*ux`1q+_QT44aCLqNm{14bJZ^teeGYSg6G{AZU@RR+*2;F!{{PKrhSmN>|L
zRb;}}KsVyT1q%xhSqX9{fYT0OqY2JhN5_v6sKM@Q8Ba;>#daj`AmT4}>2~i(4f}86
z$SMke&*b3)A82HL`y=d8G#^8Cm*!)E+2^*~5P1)f;4tznQ;>uA*wa60e6e9<kY|*j
zobEKO+hbJoa?rI~9R?I=YauX2?GWH~Cm|g<Ed+TzST4Ygrtp!7&GAfkM4CZo(FIIr
zu1i*7p&axil~nu0f`WqZN^4ql^XHdh7@+>lrz(VufV~j?GGbAuj{=t1Hb1ha+JO9h
z{Mxv;RYQ=UdK$enn-U&nd#sZr7a`p<hVW2$({C$Qgus4woU~lyG?X^P2O%@uO-{B8
ze>)bB`Vi(K?p?c-0my8`R&g0J{lt6LP(cL$XfHfe?=v$G!DLrNE;CKX!F3b5FOgL-
z<d*}TK<*}6Y>BW;O`FEWq62l8f@Pmvr0NjSM}vypT(*{$7L;4JNVBenwSzws#qM)h
z2=p;ED2~!u4It?xS5;R}7~jC$fI)c8H@w{S2@Io*`)7Q}L1etEFD=(cv~uX$6*5Oc
zaT%<bJ>%!wo-=>GlA&Q}>R{6fPyz=blgmF6vW&s_c{@IN@}%5n+|FhAjIV<~z}d#t
ztM_0AY#Z+=En2ux+gutHTO)(v9p(yRPmhe8SdFYo!DsIC8$AGl^bF`!g$#R$ml5T7
z-r8coW0*YdheVEtfo!NqwvOP3KM9)?jud0;)!gn~d$iUv4cl$6ii@%MVhg_HKZ~_w
zDE4+#t7^Z!{;qcrXhseiN)g~YQ8#oU4aY%UaIlp<-Joy2jUc?rVE3rJIC)`idR8&t
z)G1RI{r>w?>^x-@zlFf(7O<JD93F!^1)85X^m76;*hi8ci1Y!NBK3YDVB=tDM{tLP
z;u%|zF^9m{n<=b4Df46M7sx`OT(@CEWeic%mEHJlNsl<=>R{qJvD6eX5fmsN?K<~I
zX=w<^Eg<j5G&ZR3KA5M#M&@CW>+t0aI0g{J1}Le(IQym!cL>9V)ClEhTWRUGx%*wU
zs!Y@D9&?$-SbxvDEUz9lz+_+xR;4&VW)&?Hf;QNg&tbj8Zj$DA0IUp#@h1pLX9$&K
zta-CEx&A!phBE&C`wN*QNBe6d5DJ@Y7N3XNFqVw0z;JGEZiu(GZliP~V3HZwM_#BV
z$mf#s_01eeTu(O22d<W=NHh;1hb1-(RL+j$BxAls8S81m_k|apJWk?f$Po)#%#VDV
zC_jp5Nr4B=1{X~R+4V9$o8id<I_HrwpW1fe6?=k<0$c2MrBTF9%~y9OVySagS5J>T
zY|T53Dt3}p3qgm(K3p@vOT+e^e`mtE`W|Rs`f#a`CL=c3un=yM{T@A-WCJWvvO6Pq
z6oHZ=4I3IouAC^Ixe$i3$CP9MF^D0H>V=G2NRC?=YPiApV!so)hvcN&j>P{Io?!--
zN@8js2F?PeVn|nqlag{jfEgnD8PQ{7V`D^zVkK<cy*o`Lcg~9$*KSp^K5$l5JAT~b
zWl9S4QZ8t7c3#@Ezc(Gcdc?!WrvT9mj=H-j$znz0$MX#DUL0^TL3oC7=m@F+eup;U
z*Rf(N3fk{4d~)`r%VeX2vG8WGsVC=G?Ogml@362eoFFIZZ(JA4W-U+X{qcAF+yAp2
z56<lH*yzC;NI3#K3BbsYR2fj1eLPa+6$gShFSbTa13~B(9*qPp2ujw8sUHv+IS(Dm
zR8wcb*qgt9z9=W^ylK;>=>f_nrp}X9UfHfb`AjF1B5PdiQ~nmQgwG-Y1R)pDTM9^&
zBtlcLFo&IpJ_vpUb(rigi}k}{KMsb$^}$X(5B%scanH!^<d6b1wX8N@2zwOh%h<E|
z`@qnbwtE9oVpWD<uRnk}hDax(5fRU^F$K(zypqylj<;;q^m!|}FfEvpjj%@$9}c9%
z2UUftp$cA9F^Hrd*fHQF!A}Tyn+h4M8-gc99u=dFtu3umAi9s(9bipY@7}!|h%3Ko
z2;vEGiHNM5usZlmYSd7ad2w!0OOS<`r4acJO$s`Z$_UbLRyKe8Alw-UxI%oUJk0S_
zNPq>*2lHw&uv`ROs_o}18{h=DO-}`r6A6$Jd-C-Z@<)PCOK_dLjIjBzYx5MBE6g&5
z>j23Vh+~TvELbytzPn+jgS|bc1OgSN<TmKq2)rR>6H@(q%e39gdv*hUL4|ydl+U;=
zBbGlh*iFPQQO?M{x53vuRno8#2mE~D(+$dv*lNhEcdR;V!T@#x!JrE{jlCoxjf5xg
zu0<dOEfJy(OLL;24O7wJzXfJFg#P3XgWnb}eoh`XN(Z@;q?81KGBvZZic9?PDgCk~
z7<RQAzbu;0tWa2H=i}+uq;EwMFspVX)P-b91qnzPi2_I?<S!US!9#BNb?U55OCe)G
z)1jUSSS9bzTO}4sz6R8)<UyeaLXHmvDN+%od(En&DhN7$Rz`-n2k9*n`YDJ;pc`IP
z%z{EfNS<{`d~Y){-qqID`sacl2RbbkX+~-TFYC!~QnUF`W>v;*{1m(YgVm!@Z8!(A
zig)eV`y(IDzNN*M*lPW?ZZEdSiF7N8;A78RA;Q3vyVsyj11`bEyc$&%WO4vXxD6aB
zRf!^zbE2vTO-jyIZw71=Cy<r1`(K)^MIB1c5&*COB;h4rVp;5dv`fuC2JI2+>}c|~
zV31F_=GQVjv{fNab7C7yQhc2-nS_S68=7rey?S*et4w`;eMI8+F$^0Sph4t?V0<K!
zlJ?bZor^Ib=|&$m!|;gPmUFo_{wUSC4q#`>1A-IAf!WV66C0CL0&A)C-R%vQD7+bw
z@ZqXsXW)qsrbcLjrUvEm4oo)UZ=8)MkGhHn*&453zrMl^wxD1nqska;|BeR&`+DKX
z#AFk9%cv)01ZIK$0>ez*gVI5uLJA$;43K9x+I3|8e#Ax>Lx>L8q9n!i!Z!E?lSLR4
zYJe7Nh$@P6=-H~Gwmly~a>XFE_O_MF0X!1)>T+m@B)W0uPI;24FdUX61Lvr7hWZ<j
zqSwI=%!g1<sh;Rta;EPpK?)C`Eff}CQvmXhyyF<N>?B)t4~WXeh*c7hYcC;s>2`x~
zx{XLm-=|z@Bc<i3_#6fs%_j(C^5>&sGZ`Y617gJ4fv=y?z2kiGM^oFPD3l=juoKhr
zhQH$p_G1vj7&SbAURaA8+)7F`_|+$b&=C|Vyo-Sf_D+gJzY_?D0Q>`EvP+>C_<{iy
zyJW>JcvnLZBIv?kN_*k-Y}i$DX}(w>=J`uXe@!9&qwDDbL1NwAjm^VmU%YVP?SSRj
zeJ0+c4Jj!pv9LLaA379*3TOGYQ-6|uq_?wn_o@gMS<}r2jXMiisy_dVih$L;Jb9&@
z{J(>SldFP)g08x`5!V80yIp<W)td|le&fuCGsUNF`oG=OS9kXen`?^Xo(1XOOWlb?
z<*a%a8-|k`y#9wfj|1Ng9o2C-==`ScY$vEe`f?s26AbNKaA6YEm<2xSQOHG6=vJPd
zi^%H>4TN5kBKd~>Pi9<>k3lIf5#`$9OddJq-7EHJt(nBiueRiZ7z5P+YkeX1L>r!y
zWy6LIigD>Y%+^IyRWzTmt=Ytq{MkR~`;D-${G$)@#q+r=EU%10-vr)4oUu0>o)SL6
z#TYw<GBG&|HBr7uhLthvRHTmGfddB)dw|GArg(x%_#KKg)VNpO-Q&%RC*R^E=r5~&
zWC{jcjwPAkB{?PB#fAboCrSpGr%6S@YT@SRSA-!k^2~Qeg@xrNt6f5R2NsZ#kBpDV
z2}Gmg5C}Z)-3uJ-Zl+oou_Td`d*j9<6e-{r?}bO8?3vEw`)0W=?%+C(d`I$p5Zo$J
z%A2W;3zX7RY)zHnKmYtQP%Y66=)cl3^9UFyz_Q%$R0|8s?AaHDuX>_--Gss!*7dub
z6mX!>lMQtg-586PF14<XgtwfN+)8V?xB{JnA@fXp#d+>sumdV-tWl*Rm?HsEMbz13
z4s`JG^gQrof~|}X0x{4OT>I@^`<#T|f#t8iVi$i4#=Hl3oQ%yeap0x6L`5m=@rP6)
zwgM)YR)3>P1+0*4BXcpa;_YrNSiE>0AVjRmxKju#gse@Nd}4hntbk5|^tpEKEaK3e
z{FOa!%Aef+SObEH<htSzua)fMo!TuR^<a3>N2J&YX$i1p=lQQEU0hvTFU;V0p`9`L
za5SIdZ-`WZ$`5nHhRR5A+0=VQ>;{IB0(qW~(dCVkWlCMe%&KFYFny}HYBikCK}{EZ
zI=28M_Uy!slh@1=ouHQ|{`S9pm+pn{t&cPqS3Ul*NaC0OAaq#%_v}=5LznkWKa{pD
z)cuFt;fZPtmDnak0nmoGIT1m(X}|q~J*0&GRPqoItp%flRrpF8QDdXU2g7m{(&}$l
zE;U^To9U49r+LX_!KZS9HjPT`k+ku#Wb&Hb;X3x_e~eP6ix4l5KC?xO7wa0$0Sh~p
zti?u@r3OeIY76p+Ih+3n5$?!(wjiD6q@1QZ!q)(=A|f4;Fo<L_6dd7hw5WCHZ^3iK
zbGRdYfw6`fpl8$#%Mo?<0`VHSQO7R?7H?*Q`=UieGJ`<Ut9ExlHDcRWeumjR=-~(I
zUBV+REiKmurD=(_;C+-uC_}^C(cyQ|dm_*yH3@TE5N_i^XrL;Byne)_p!`uva~$1i
z-BIPeTwwe5<5#X+DaiyllL}`0{s=5lYfUd#-+@&bK7<!~A+T9NjOLVpZQR2TRGPOK
zDlEJy@a-)Kum6a%ZQ&@h;YWKRRe5XeA$h2r5=thIm%~Z|7^mvKVcj}C0M^;8tXqmy
zm@!3#s=}@ChY@{di#nqiC02V?q8y2K(1}DPJOEKZ*z{HyL<C{}sY?y`Z800$gwZ1Y
z{N#NPjL)pnvPL*dOC4(61S5?;`oHPL$W}xw8u;R#$ah0yKuZcP3d~Y=adENRoylzR
zYJ839p<AS<px5}*gUl_khQqu76Uow33X|`1)9z=PikXvHSpNUx1pd3HENm5rRFon)
zIj$_pf0!OhMHlW7pzh<Sd(e5s3ELg@9zyydT?le*yZRrKuP2$O;T?Hbh;{@lAm)~A
z+{FB%^D>{@MM&#kK>sM=a=ke_^1i^R+sCtP@(QzE5TIX$>5|k2rW5#K(~Qe)X%QsV
zPLN&1?Gor9fa9XRp83W?^u_=iX2qT0$qHaCo|CYA@*lZ`V0!m|2RZ;5nA#QXye4xs
zi;LSU_CbD<i9y^I6u(HpQxR2;P!oeg1%{U}cfSh|#301B?bQ(AJp9OfDI}x<hi3tr
zddY`WnJC13JGEasvf>fuR44W)6}A+0h@S@G@#WQpsaD}kO?CFt3&LGguu@b+r%Q}&
zuRbcMBOVlbp)-~LbX5w^@!@3J0XrZE(=_VGq9|QSi2~3;D7{ZLw@%){W77o*Yir5s
zgtDUrV?i`#<LA$RND%BLqU|3qt@pQRui#TvjnGJGlbtnrjWW739e6_$JA~25J|%QA
zhOt~-LPHIsv7rx)5Q>oEy1sq8#kr1?Gpo8<-O<sJN#3$_aM8IT@pr#`Im^(7y_60Q
zn8zU!NR6!EFsRzYG(Q7rUzRM-96Wg%JSYZaXClXSs1b39c)OnWn<C00(Qq^I#br;g
zBljO7^1BircnJpv2GrblpsGX5rS~CpL-w9WmpIy~s5A#B1SUyDrhYQ2?9p0{l}+Rn
zxsOm{h8n?dLanwTz^_euq3{K_PGD;MH8c|pJsED#qB<wa1&hA;x#ZHqrpbuOa=Okx
zC@Y>iK+#i#9!(!uP&g&1C+f|cH)NS@(A$irE`UxQ1DT^oi}3j50VD#-13B$EaH0WZ
zFI$*#jUAc0iBL#`H^eVuiP;6s4v?Xk6a9uH{@QRb5OGOJL!G*B|9<i}qc)MIr@)_v
ziaD2mK=2jJ6I-1Bxb%u$APm1gIJ-Q0=h=^Ys0$RM48C5E`WWVm_S}TqUg;-1-aIfo
zyoraWBdOm1`E&5KxkJ!8xoi0*x6rE_zhSM>(uJ-8P^>{3B#4aMZ`7%%RF7m@GSrFI
zPj^zJiMB_z;^pnFn#%A-jzo>?)!98cjH`JQ^fq?2CpP;OQn3z$BIaI_&Tz<Gn}&)G
zcd9T7N`XX0TiYb4%!WgM!-t*FJe-E)vT@tC{2{Vtr5a4$obw8Bie2qQ#FO?6YT&+5
z2gn)=^k|6=Hr%FOUCdMrOiV79FH3q55e484Sgv8c5-mG80OFnsdYC7^)aKA$MU{f#
zO>H?xRxh&2kq8Hs2Rr2%Hf#_m(JsIU2n|G6-r0QOIIQT)Mb5v#93^T^Vshs{T(;=m
zG+BG_`bXi;muu6v8tXr#9&MQWlrS5_XrdxJg2M&8sPUGXFUYiqX0Bp5Yp{yGpoZD0
z{at5<O9Rk#Z7o>====$cS@4Nye>|6=TQmQnad=lE?5h4%8FZ;{ntY-~J86Nz-o#<k
zuwcSAGVu@MQ}Cc$V1lawhMV}>b8By%o3|DEDA~pAl|AHPg<;e%CjZfN!zWt&5b(&2
z4R^&cP^lC5IemICPV7KGa-_A*<cnnkXI9-Z0mWYmNr2p>h#MrI5*b2r6+BC2$=_ve
zaO?7h+?VW!sjCf<7s5$V1=LMpcqxJ)Y0*I!qja7LeL3$tSm$OhDIswyEzK#;3e_6e
z$&&*A#G`m!oiv*Evf|;Tp{_m97bS7<P8z_&00<PTtvhis9QZJRBF^3p66Yd##bJ+W
z1?;)Q*<PEbiOzTG-gp%9{hhf^YNwc&^G2Rzu*mArR>0<Z4qr(tq~#LOOq>!lsnFBt
z#DRYcy9qcJMl;P3#*4|fZF3XF=%5fU0F@mT%d7li5BirQ_lr;d`^nuD_0amv&B@8B
zYDb*7b%&a;JTo@;?Z+TMSf}g|6+1jML?O&7a3=HemyyJlKtJ$x9O70ThB)B&>eZf~
zemz}E?v@D%xkA7#;_W8l6YY*0D+P~ZwZ1U7WDZaQ%_Hy2uNUF04FChU5yiAe1G*gP
zl$=|)ZvA_XgRuc8eJqE64k>^OdK7hg!64Ab!#a7%+3a=+_5O%FEr^c6kn&KB>kt9N
z+|2tjXInQ^LeQuEVN~{FFSQe(ivmD`7&#Oa`%F@L@1{s%I1>3vguO<8pA$EcX%k%F
z85o2#xK&V4kUUV3+)Mg0IqZ(Y&=&V^v#yH%Kst*6vtALSgu6ti)C)N#)I7N=6p4c*
z$xy>Qv#}8y<A;;mu+EJ}-ws{uREsb`={`jppwuHF(k`NZdJ~|LL4M0tdCER?ZURCX
z+8KhN6iAUafN9a`?3x^u$Fg+iiXn<yC;_0w>^RyK=$Hmr+Rj3yrg2Ki{;>%%W?NS+
z0%wvk(v|)5vRaH~17K|c`*le(7=q(qK6}w%{ROhRRVaw5iLcqKu<_gJXaTS_oGm~q
z%f;*yz^?`%g|n^_tNKtp8L9VtIwiTRK@}ELoHMaTf|UOv*jiF>$PXz%_?0t1t#x{Y
zCNRjL-y{l%+<*=w>4D}ZJ@r8*60)96F^mcTNDLv=YY*uYeCQ5|0;*f!RTWnH0miP;
z^MHMS50aW3<)k>ns4n3_G6}*+*-x;Eri&6IhSw;r4{S>L6DBZxfzoiT3=E%hVs=js
zK~*r;^#;7Y1h9!D5`#X-!*n<Rv=KfiBKty_cieUvF?<75{RuMyY#S6K6abVLv9WPM
zW+R=FU>#5?9Y;jf&nxF&euBEwFxq}VXf%2d{huK*=|exKV|1wZA3^{FnSVkm#WhGj
z?c-U>oGMoQ@^dh3MBjp7*6PGjbQ52X4^Q|OzyIaGf6Q6}H#u3x$NF~@IR*X9!w<#+
zS~ynWKh_Ch!*<|$vi86#6$1+sICcrLv-QGx{_j|r+&0h#i-G!i!2%fA!F`XGARl{o
zVPtE-HMqcvD(*gb5d7C)Gb!=G2?6^FY>p$jp7ST4%b!XSN<Y9UA4)pFr-5U%zcC0n
zLB}g3!Nh7<arr;tG%tH~W`LbNk=o$3a2ok`D6Wsr;6T#0;poI*lhua~{g@yoe7-ZG
z47f=ZF(-5u2ka?&SO^s;BBXMez%K`OMSCb-zSREEUKY6@F$p$E@&oij@M53=D!2PQ
zWK%i}hDe6ORGgZno@kcgFUrYz03NVH%&oC4$K+F<oPNk|sk3S+dGOGDNasJmc7{i$
zgLVjVuyTm(lF_DfwrHa{;<OXPOdKx*fo3!GT5l^fk|Knvo9Dn!#kiri4p@y_hL5>z
zH7G-Y4<|zh84bt)WzkZwj+A^1y3O)tsunsDo2iW)hXFlMtc5dwr*YM;!ne#I!_bmk
zR<#pN0`yBD5%SE-c+{)6L)O?qrPE4wb~@04R7_wZ6o8(fMZgqCSO3KaPZnyT(v?56
z9NlV6fYq>M6LJc2GSzrwl_0L34g$*TZ!5nYa*kRg;Jz)35$!FKqvl7dEUEcXP*4v^
z3oFKplNJd4=Sb!$O$kUZIBw@%edy%iu6ClNg(j<F1gK(k92ZAuYA(69PO~0O`f31P
zQF<`A$OavM9@<W?g13emyHV|u{*G%FPn|DfTG%~#IhGwXnsl-ZsqOG=XkE}GH<X#F
zsqFdl2{1ztctGF6(g8~*!i}dpAlEdSuryX{n^Yy_HzfkWlR9@I`t;(g-pPyCojzA6
z-%zP)lJcA~D&-(+ZssDfrl3Z276yxSBUqJCnd_L3Aahy;|JbG!&cgsmAp(19IE`9@
zA8Q`|Ay1eJQwc<}8A2PWMg~7($g2+Mhl5Mt=>a&ZOlDq?>vy{Q+Z$v`U|^;C81kDm
zT)F(rJ(_SEDo0ls=H9~(OSdd$h3gumK>&F>&uNo4Zv`l6Ux{|2A1uQ}RWexOC$Z4Z
zi#fF7({b+&FfAMdXNX?x$1r;}COLGXHrN-;#Jz23QnfjrY-L2{3Jzg{#pQ0sDG0gc
zLy?y!y&KNL6e&4Tti!QX;>1iLYT|WnBHWs(FQL=<ql~1}$ohDg|9W-q4BCY<(yCdL
zH}vWem;&a_Eu^PxgywcLAfVZDc<!?8em8@e5n*^OMwJ>*0ZWpb&Rxsc$K+t@+$dO-
zL%jt9*{04EG!`vu`{X7Pt-QI9hk1>wD*?>!Yq9;?Ps-8DZG1kRSt}<L!WG;_XPW%{
zx}RC>$?u(4tYAFKcDyo86%Q!R_D^N5%Lo?`I`{ccrX8Eb`44!62K!(y2!ZTG?xMS!
zPdr6DvGZaAO)G*rC{KJ5fX<NLAy2gbAzJQwpoq4j)QYp#n;b0JFYs#1k<~8u-nRV+
zjpQz;vjEY5DobTyjZHKAy7gw!6AUtb$$I(}>w9mu&P9wAhf#0)-2Kq%KO(p+25`+2
z8_ua|WJa?KYfUqy${{<^iH_TK-=D=6Oak9RnmyX)B&bP{T7PlGo1GVv*qBC?j}<m7
z1Imjm5DYo#v8MIWXGT4Ku`)Qo&l07Mup;wUT+;Jvrqz`Y3rZypwl7W-AYB~6$whhb
z<dc@oK=|T?Zz><4>W-(U&X4W%_%Q7>*sQtv_=;<oHO53yWq%E4Lc%xN1LIa%@}kL0
zy%6rhFOXw`1Y>e^k{Hgx!NH%IHqs?2tiW75F4zHsO*pUz7W4n>0`4_OM*=qy64d)k
zO%aGco}3wP-@<z(`EzQg7))mapx2i`38o!^@dz+LDQ?pfq&NV0Me>1(J2kw~`$0GD
z?~7qmSxi+aKhqgcM1S;k)<$6MoTyxd%93(~+nrxnPP+X=aKRN`h2f;w!8o)>Q5gF0
z;RApB;*Ihj;jn9y|JShEA<CkM{SK;%uu*vXj>Co8F1vs^?DHwgp+l79fZjw9)4)+X
z(UFB{@WIh#a;-SC)1GaI_D{!@(cx$~&x=lzpjI<FF#(;3fB$P`Jvjy5APnu9<gwSV
zZCQuH`Y6_nFU)kIP%Lre8*gbn7UdyY!cg<js{I^AC4$v^TM-z|knz!F=83+}#W+9#
z)YQd$zfaz9!-`GV5lEB0IAOHY|1B4Md~{j7K5Oe-I*X8;KxFU$2Sr(hPS1pnyAima
zx)q`0=2MMOuzB)=bxlO~A>LY4*P}Hlr+60(d@(j+I87!OcZhAOR34>Eouyk&L><7~
zdvOBG1i`upER)QE4)Br1%m}`oq8H5~e_jN%Tp)IszO$>VMN2OXr|IhG5CcYza`YXN
zy=aqCcp$t6C1N-hhT2VmWhVMg=*}Kz(W(auUZYwGLa&!X18R$`Lgg9rR>CMB2x%LK
zlmwCY4!Q=BvrH5N4P^|y2FV@w^z`%~dq#`Npj}Q*YVv_^F8#G*s{(-HPQb@e9Ee$n
zLfgzi0}GYBC+pU)*T(~s_KI4-LN4|w`T)R5BnNF{Vad7^S(Di2rToHj;$m&@Ut??c
z)dR7Vm6eG+sz;du$%~8;<ZSCm>DNf<{viA_<CK}12}@30lJ>!$C?}18$tsm4@hw%U
zaA0e9S8bh34aYDq$pi74=(nLB1WpdZ#m&sj=u|r_4ju_oXQ1bhkF1)`nt}ptCingJ
z(1v78lZ#_F47;mNMP|X%i3uzPEV#osN46ClR7TYec5@Lt*OZjWr&m)`L&wt5Q8@VN
zdsvv^hsC6E2^^hfYF;+wdmO(<r1stW_x0ZIBGwLe6;wQWHg<LlpxJz^K5BuLC;<6N
z85ki3H&17(p;?;0v0`#EPJ$1viXpli`xhOV?@Qqz$V=-uhY|>duOzC?_oV}qFP3E^
zhHo7RAKD=3DudXs@btheQsbd~0ju`$Fqh(Nc7&ocsEC!YR_Ihj4pG}cELsmg@+%?C
zhog)P0EGWS-bPpyD9#HjF~JI*U}3}WIC7rO#y~SFjw{Tw3PqftUR?6OARnbmD@;z?
zo=*s0K6GXe(0=xkI7w<6q0S$0hI&Ylw3yg8PNqNSH<=tAS<wU=fZIw%G*F(So%<|a
z_ftBcA}JK$TF7x^fX^KjAi8KHzRqT{8Gj)3*(?D-#ND4jqAPd9=<30EuV3hYgMA~j
zVj0$&Z{1LiwlV5|Ce8!{M?Oz2wh6aXo=+Ge^cIzvtePJNgeUYUXs1#nT!$hau5j-3
zt(+1lO%R_75Vdd;qM)$SkMsu9!Qk&`W`RMe1-XktB4-d9Hp!{*Xw#27S&eMVjrId{
z(V28IiTGC?n9<4EW%*zGJn&r=$>=#`|3BHFSYByBqMjUs|MyQbC!L7CX3M!8+hktc
zIndBIO^xQ-Sm58CMs)lPtmjHdsB}UMs60Btk>BAznvUc$CN2x_5Ia<CV|2;WdDhr>
zXxbJcv<6F{qM2D#Y#yC+3u<?ZdXhX)#Bs3WIQ{EXCKDpRT0-6<#Rv_fZhLr1$yJ4B
za$<}ra-(C8&P{kAV8SDD_3G8*a30`XN-H`YsgG*~i|N$1TN7Ix==Tk~xHL{H;tbMx
z=i%W8o|Sy#2>s7vWg!3H`v55U>gErzL(pSX&ZLzeKmIM@*<m_|6Er8CD@rPZ$D*Z6
zH=wA6`Kzp_x4&Nr{m^`wlmmXq_?ssSfLH8*km5&h9wJF4REmE$AyMzOJCNi9*)@|R
z)o@+3>X^=4ByF%yVUFM&sLQc}1L}KEj|HgjvQRV7?@D|2yyD9=hkAeQn&jTQ%m}6!
z3e_K;3-~-+aK2^%8R>COo_9Th*d3VQN+L8(jD&wA50x^eYl$pK^O6Z!BKY?Zjz{B8
zi9<Pze>j78J#a)X4gduSuLPr4BajOY=iLN1CC*lLeiSlU1UZM0c0X~%12OOZqHuvs
zc(qX7Nx`X01P!!e=vz2vqitU}6T61rfF<n=+gsM*grp?66i*<JD6S!j`s#y!$A1a@
z|4nO>@q^hcE_$KXJj3gj7*0;dR^$n0;q(u||D@zH7H7_&e>dE*)Ri2dlB{i$KtF$7
z>I9T_R%KCrKRIdtbpO1fGyYf-92!nv`{RnyReH^$nLpQ9{~!HK17;L3JrlfDUpIV+
z-M1>$c@xHIE6SArI9xx>$rCn2=3xB8!}!C!`_D1@VS8n9o;BG};H-KG(Z{5$8PUgO
zLR6OR`MF2p`}bVGCZ1Tv6DdTsU&0;G#LRd7uX-q6adfaiBr*E_0H(q}S~OVxnS0R0
zST*adZF7|7sn;cVvFWByX-{zRn}_}x0=a&tO-V8ytc36|QU_e_x%90)=tK&J<CFUJ
zKz&;Fd^t9}XwJml8P_OxuGq~|w*)2dA8X)UA$<}s;7<KF)Ghkpyr{jws;vy}{`oF0
zE~xopZ*H1oKb#+en7H~U(YXjsf*j~&1&S!$6!G#Y5RQZgKs+ZHJi;O9AULmemq~R9
zq9D2Y5;Q!hjvzwZ{Mf}XS?@uPPj0dyn0(|&6jNo}vzI(G5HL4L0QSV|_2YjW+3!H*
zQP;P_uhXV2KKp2LtUC-LvQ_?@iSpi>cmbZ}-b|FtvS=F^r&~+WN+Ci1Q#}MNT<{7w
zNz^`uO!87z7G}f-G_3+3?*S<qABV6zX)pShw)WKt0*Lq<RB1gpRzukr$cXx~2y9Tu
z29$4&E!B_%yr%|RR1TZaJPxKQPBVYvmREa!4<qMFr||sB(gqkM{s!kNQ0FD1J2a&f
zXAC??L$&^Y(fisMumhJdt<269)k$zdtmT?Q7E1Iz$-8Q)btj;J1lr;QXxkUc9DOrj
z$?wCJklSEu;5%U}t^4psO74H+PWs8lG~rrwRs)N3P3+1v&B+LTbLwR5>H4=Aw`dyH
z|K#-k6OS;1+@fC$kNwILFZOdFV}4(C<X;<ye7=(xf}45r`$anyIZ^N*`W`S&@>~?h
zORAoHzu&qga#}_2)p~`+5*>a~0@!tS`rc#VT)EiE2rncB7^CL=^iO9>840>S+EA@G
zI+oABM+F)4Es3IJa&rF@tgGL<{az{l8%{!zIEOhH5Z8bH)S8KGP!;^I0irwQ{3&qB
z{SSo5pC<Od{c$(-cefjqY^KjtfDTOurJ*}UuhV04!1nxpLD+bWuS4H`s{G*9Jd2u+
zj-A3uss1QK%aV6az7kkIte(UTI1eX|riUwt;ue@>YGJbTVlqr-=!o27>=zJV09x$o
z_3JTlbZ`|S5Ug3MZq0s7Psp}y$2@Rqfc%S$B~No=Jk@$7qu3Hxe3Xv35!9W)-n6=0
zmm@xXrC+5s{lS?UXWo(3%$;U@*`{iq`Astc_e!mK$MbzM+qcfR;=5STx}n=sGd^9!
z__E+(d!y#6TX}NFZr_=|>>y9`{05JVIyo2BJ%E)RNemuhj?hh8(g&FkrIQp+B|j8r
zK6%d5;?wuPKX8J}Lv%jlwqvcACEP&vi4Vi6G^A+`iNKFZRVHYEII3VD`h-w=9KDY?
zvXgtFhw!!uZsp$o{By!N^;Y*TS=i-V5?sXoU;K=2IX+Y5UV2zANK71bip<i-GcA4@
z%H-dPX`<r;a2SEV=yx?l(5D{GEW~PW{#C1dFK&#?!f_r+TO7~V%<DcmPaGpcV^h$+
zZGMxiMb&@)84YkX2VNe}gS24h<y`rjfK<ko*D$L9D;9%j2r~j#Nn~Q~5(<Cxb&@yK
zG;@nK9O+ct;=cgAj?Rat^G4-lM0L>x^8E`THr|cYa%gtNK%&8LyHc+{#PholcTyxb
z6@az?=XTGql2N6PN!@z+DMpHBv!(Ce40A4_|Kevf`Nr-xTW7EcM&d~8vSg-JfyLPJ
zzisJ!#r_$#7<p)Plb;{dUKyWPv#zlm1W6Ax)>g34bh09jpQ3IbaGw>)F(S)^twQ(h
z+t={v(-Zn|3|iSZ*FGitef$|8n}evCk)Y$Pxot|4txYDJWhiOd)D?Z$Mb66tk-tEB
z(1_oKwy6o>sgGw<>DVxbjwqdIgcA=oph>vk@!m@$V3TiUa+~4ux2XpnP1jf+X4ck9
zxT*zEhMkwCdg9>Vf6_wjKP|OmO}w8@CxE~_L!=Jw4h;-08qGJV&T^1<fDW{WIfvef
zwBhYKf1xO8mouGb)~zuYN8ur<df@C6^nDZu$!);#Z-HO0rMSHuvG&zs)31yRgEV*-
zrx%>%t2u1k^pQ+{yM=KU)%`cTeap>;#SHPGB*Y(L5RvzbP_d!mEzuO0Sdm+gtXVp8
zA{FP14KEs9m1x6DpL&6F)Tp%`)HP{?sRN&{;Zj0oJKWK@+JfV}Zo%I~mqP9MNB0ii
z`0?G=@Kn%8_rNv<W8pC%14{^$!U{&4;?3{DaLR#?QNZUZWrKzj%g{Jv+;k4jUsTWF
z)Nq1pbi^juUusv6G^;BCHmzC%i63I+S{%!rQS-b(6`uz{E%bmE28fSCaBtFQ7tx33
z^zm$wA)_X|1+8FCsQnOq*pERpF(z!PTk^=rj3!j|iCw*}7INP+ED+UIzV=;LQY7Es
zrn6bmM@RA`yluT$kY~Z^(2*O~dWn6VrQ>kqP~$vC8g{OBbrqkvtHji>lS*)aJ$;md
zKF<H3UTSizV*zb))uO)IiEdC-a&$7mM#xrldJPmmJ1=V~EEjUNgegbv!(l|lSQ?9P
z)&l$?i%#7s_3{?<^Yfc%V#RTlvm>KkCgzL4zPK1K0Y@nZ*I5W1F9$I(1YRu{wU*e%
zrj$VV;&6x<=_te|;ua7_(5%Px_mK!*-tlSyv|*pve0N{qMw2mo$_>Y2%SYqqM)+n1
zK0f?v_0x+>4+Ql_X}Ecrmm~+aOB5}6`CL~+r7$;Ez2d!!LEbqdQ4M`1)mYEmsO_R5
z_nXuuwp*uY>My>PGe?hWw#J?{gZN~+t!XoLR;T66?XiEDF1UTiyojZmZ}aSH9S0q=
zE4AMIIV+>&CWO^wt|#V=EiZ7oD4p{NafuEq03#8Aj}ywu&NjCye$;yw-mWXLBgIOZ
z3g{W8voe+jY*Dv~%Yc~X3CjVVjLxc~Gb3Rrq)&=kx_*myGzZS9mPd*)<o5=ae*$u0
z)9&4x^uY$R=gd)m80Xj3kq0}@5jt_44kUocfwMBz$r9~-e5q2+yuraiK;=?k?kdk1
z!^W0#IFJTuSRY&qopZ30=y=d}&uXu+aHO*YE-|i3(4r$iz=%pgqQDAtYk?!-zL2GU
zWF~0jio@IC|1^`7KJ&ivSr!hWxWS3yd|B!AE&IiV(b&l*aT>KiIID_lm&Go$`@$go
zWDrYR3hhz%p}AFd)m)3_puS|lc5{P+XC7M8$1K>iMP^p5D7bPpbv^d$Q7kX@6;Uf6
z_MV52DMxdx%j=X=0JQMa$P31YRg<EG{QUiwOEh6!TZoK-FnVho?;T%bo4t0&_{Wrz
z__j7fG*fBAhtrtQj)-v31JmR_XSs6n!Op70!o%C)j}0rzc^-7VfB7nho?G8~d->3C
zduQR$p^eYdk;1QYnnV70KTCafi0w)ti!3@>OfA9m^<m(i(4d|+@z5`_B`Tk1D_VT1
zN{qI_qE=ftz_GF3l8&3}Mz~Rwt~;)r{~DdZ|3`P{;a26DZE>QBPNKmlI+hr~Ym^xk
zWW<n&6fsew0zv5(5MyC10R$<c5x7Q&nTQgJfC6FzX-8CufS@22ssw3bIfw>DnnxKy
zL;}ojV<va*{Sz*aK2pxXbH49=_q+DqYpt!zKDq6Ny?~zc;AfeI*az%G9Z_6d?5T`6
za>R{0dk3n`u<^?NKK^u>O)75Vz-T`N+hTllnJb)DC+qymot0v<1vk3n{clHvpYx!@
z@{RD3&CQ3~O^AI_->9atpa>;YC2>2EkU_ZdVe9x6CZGNOWl?eQfil+@i7r(si<rJM
z(1W3-C43_1n2!4~K2vmctD*AZSdbX3wY_NH;!=lLw*yeT=qI7f7G0i=gF{4gWkjk%
zorF@XIPsv7!EjJ?k_ir4KIUpkYtH;bsOEUHJx`ppYOi5y1?@`0suc!KGYdB0A0#HM
zZ2h`J*;#2u%G{kR!@lqJ-OVMTN|QwYQ90c|zQ?6rl=-`M4I-r0dah(dg&5@UrtQ9b
zG%_G{v$sEMZ3-cs7Q>i$-RK%k_xl%<xJ2S>!IjIHvGI<g34^T^!DE#7*e)q?ab2!8
z84#HEaME_{b@}xRVGa_lbtbwst1{=o7w+q+?-xa{aN8ks)SwQD?2q2u+4>7{SUMyY
zwO%?#-uU#=bE@V<N7J0h`MVTf6dR(r&Y!)fsxk{X^4F)|5xse#8||Pl-d$-xs>(0W
zoyUle5@Hw4&}MogoH|av<9}{ByJVWZRcK6%2FuX?ixtPBJiD$<xZIl)(3>rbQx<7M
zhC-oh3srBL&+Z)ywvStDxoTA`?!lKnob44i%r@fmMNP58XuuPTMfL885wjp&_{_Uo
z8J=*}rT?{K6}Fiu_cny+Yx(cq;lCX>nW2p^Z$6_zjT&D8ZqPr4?y3<G;b+_O3v0sY
z<BIa~@*B~!%4HMWi2Ahj_BWsX7!%W0@TmXHi8HNvy-z(FX<*NQoT6vh?Bu^)ne9`G
zlVic6ncSIz+S=NS^sU^@ox;*36#WUqL8#KvT)aax1f!v3l`Wb{#MC<69jrQ^%jt22
zK`as5RMa63!=*}{xn}Iz&hbxECn<FrE)|fiTT<}!XTpolM9;+zzRR+<9B=RHniXbA
zeZ+aYcaFX3pR8gwaOORE<)mkFr7l?=cc0IIH8bU1igHLI(uYhd(N4%K{a&4-p?;Vp
zFnc*#{@G{&y6NP3fK1AeJ~`h!;kD`>D}N@JCj5sCZwH^O?VZX0*tgF|(Ex?Wl`c(q
zOke-<3Vi3P-hTV-L)2cPV6H{M$2&yyCmNzS(5lHlRN3`}$$T5xF%~Ab2v(eW={8>d
zKh*TZsf?~%n)&i{Rb{0m-Ja!8eb&z(l03Rr!+g*&8vukvd<qY~O5x0+1IX65ziuD5
z@bl0Ao0DQ)NQGH{_Y%hfU0Z)+Yz{5NfF3fq7<x~gI5FRI_m4TVTeo0{FD4q&tXUZQ
z;`|~G9!l(*f%E{+3wR(Z$p9w?2zYM1UuoF7)LZXo;I$N4!v-vPxZ+|~g#X&Z*Eh{<
zDgux4N=^YW{FSqtN~;<s^uG%3dvUaX13QQOjOXM?TNFO~SmW%w&M`hr7ptJt?7`-=
zA{dIVfmp`E*)18@aNuytu9lmhr{xyXF7Ie{>0cp^u%fElYZFmcqK<o^4Jo3iW~7%4
z+7y|uMc>o36QVZ$X>Fl;=8@>T$!_gew;Hh(SJ0tedUVcC20*6r)>cMj8aQ}QSy6a&
zd&^X@#t-W#b?LKV1=d2Z#W+)U^SsC_Ew#REDB<1-Z`EOecS*9kNcq#!(^2_;hT>rZ
zd{r@D2f1N{<mS^hQqlBv<~?@!G%<M#?C+_UIyUU_L=G#x3woE!HwIe$Q>h--X-XV7
zSbbSd#xMaK!XrLP)H9499yBeX>HU08*`F{!qWzd<Y_kV`lxQ8L!44_nF%(0VeYUZ~
z1t8QEvP4>MaQh>0*Td5Hq}i_zN61j8oQAqc>VHtO=flnQ@;m6oRXV_fK&ts`G7E76
z0z0~!cUEC!GX-t{?!kV32j43#Ev*s;8+2|#!q#jRgY_kU6s7?OyQkkpuU0t!B1zy-
z6*4Igkb{7FdZTKC*>XSvt&{L0N1WSU68V3go=_3w-TT@{ppayJJdROL4XQ<>X|<RN
z*%%Nb&Ld)t2dpcoJ6GaHIK(u~5!1M}(<9?#hEjY&`Pmf}tCNxy4cyBg;x?u4x2WV<
z;e>Q53R%YHd!!nWzv~?^=wV>NNvfGr_7n?cpk$M3+vt&?OBx*Oncs)vL+E^vHy&DV
z_Fvw!70X0yo^@Zo5;tJjGVO^zIYw<inm=xB7wb;&0SfDA7)QVS?cm&+tCuwshe$7o
z+<48CpK=HSq~*;8cB36*wHA2%0g|0ex1i>jGpWV2x7y8m*|H|Xz%;hr3{3H4Fev-d
z_uJjU!8(*Eh!DPxZ6gCpG6W)}rKM>YUsg3Lz9S0}Te#}#>NSDSpg^*byf@z3kyPZn
zEZaK?f13x^wVzD+MIn114@z?lQ+z$&FZ>`x<#52wn#+6VsjsweG1`N-uywuNP@P+u
zj9(Oc8y35tQW84a=E-2hh{ow<<s0|uh4Q)R^2JFD2WgAI==ijZJ^Ei3jEg+o;Lx!R
zYNv(bahL!_%BagVFYGS4J7$5Y)4BaCD~{8-qXFaBYUJLTAukaI)a0Bxcl-GX;3IEU
zpkHc(gU4Ph9N!r-WD_@8oV7_q72j`P;?P#^^YpI$ojZ4ATwX&4WD$Hu&)%-M8>`G8
zwX8;rOXR!<ZBo#A6jpywEqSoj)WLRxMYW0zl(+=YhXQ<T;`U!3bCp9ymiTKdF|>=@
z3+6EAYVH0%Zn<^x*s-~J-DMsFc?8lR6s{EziL~o_I}Ncx_A7{dbnz<r<fmI3Err>_
z-<w2GahQW@GKC^ZS@ScmTN4cpv#v$!LvIEB_*YLI8PmzD_}eO(d4k0>0K*mvy%2DP
z))Ls?=WZ3~=)dY7I$Ctchs1#$$1#}S1Ge6f=i720m@SP}udJJ>M5l=G)@hcuKz<Gu
zApw&z+e0dZu-$?ltcn$k4#H$sLSBl=y*2a-)9yW$&L@m-16ceJa&Nnh4LHAMCrMl^
z=U)Q;TMh(TI3qWo1#}t9#U`XAjntehgAB5_wV!Axs*^mCGk{;TrTBWOqRHCeoAR=<
z8cFV17tIh<!&I?Dj#Dqts(*-7_!hNsk~W>3x>V86NrhZE{FrY!ZVJ%Zp=|AS;e19j
zxkB5B{n?7Rxt1|s3T~8a0^YnW1w6?Pr&Z*;rcY%veBydT<_uEFF&2)CZ~%!E&dr*N
z7VAgi`3_TYPH%^8<hsnXc>)9xs)_uN=wyxKhtSf%mtsU^e=1n!l!~&#H^-Tiy@IC$
z2n`}HF3DUIsK@t3W`|?5NFyNf4QN5o7LWp`%pbbg2-C>5JL)cMEo`5#3)=*01y<p5
zNkTc$gxpUBpzy_xlHqSXU*>KSXreaEIWM5j<mK(P1)!wrGcNT^#JNYFebw{xgJ97~
zN!JR&LdvL~!jcwiZ_i_ubEuOxtD4l;`;ZrY!aO~F3>5?=A%eS1gSP0TUeu<L7e^B&
zytuaa)OcIpP^Hpo)JGp}Zu8AST&)lH%$3ulksGMm?`+8_&I$3Ao!voPT_QG8Ia!Ws
zq-Rj%2@_4G^nHWJs2itO-Pr1P|7xn|l(m|Xk?)Su(sCC^8KHsWA={djb@tC&Zav&L
z>;4Qf$(fj62ui!yQEAag4y$$Kf=TO2&P9J3%w-UdSHl{;!2rJ-G&hp%f<OGk_2BD6
zoJ`ZIPB!g26Tg#jRN3a<MMXt3AW0ig5-p%aV!+ts5RKWDGRRH4`*e%-_zTZZBo!zF
zgNa5_wB4g2P}>5RN1?1|;eUnudU*5Fb@XioW60%299qMFlco4B+;r8phwoHT_95xe
zjBLzIz6w?=ql^9(6rFZVnqgh)Lm58fW!l$~V0M^-;zw-TD$H{t^TwWICFtmshK$p{
z!ty8-)W#l)qEY0Sq%Mi+y{?tyX_o@-kJBFX^PLdSD*Ll)cG-wCQI7g<M~7ag`8d}u
zSj+plM$Pe|nkEZ<nyg0~+g-n5=Adb`h?K#n>A&nl-~9MLK93*zpxLl{<Zs1HwK1#z
zO~_RXdIu!%`}ZIG0l()rAG(+S-SAOU8#d#AdJuz#|K2-2t2X%mK76h|U_^BNDwQbr
z=Z157@$d5)BwtlHcO^lgVu<ZDm`*Hkd(Lu;+&*Y;1~By^zn#uQj~RVE@Zz@pARdN9
zW;<H!b6!0dOzFZLtItXnh7i}GTf|r9`UV8#PA+!O6k<_jt}sxRI_nR-Sd$_SF<j14
zMBxDbmUu-TC1^@We1z?=$<bw}z<gtRawuiJuFdOv{OVU64+Uj`2E=P&?AQdc2lwnB
zwZ!B&6oJi9{H5y;;MWc}iMPZMOa_h;k%EHMq?E~Q7f&S?svnTwS^z=pLDk|7hq`}d
z-z904nP?7Nw9E6TPA(9k3DV5d#F?=<e}Pv9*p%6B>q9(WJCTjG)aT`a1yUd(KD~cw
zrJO!NZw=O1m}ViDA)FKSx9}4`M;x)Ch@OZ3CQ~NJ0v!RN8Vm1*QlepVRf_T(C~gV^
zma5`~&}TyBTKcJf&Hzn3C<h#|F2vf>(lV(_02_Em2G&(Q5$+`iOeaTMscZUTJdwhX
z_ast!qkL>GlY<9-R9l-_{iGYduDJOEdt`h@SRC#c0$f)xIFQ^ZksXIbRS4~2lYwI=
zuGC2%tR-kbo%`VH7|r~EGY?;l5TO@9(gr-g7dN$A)5%1P=Xmht;c`DNZe5n=JZhcS
z-OH(PnUsrU88d_dy)?zr(aeDXcpH~VCEae;oAo+E9BjDXGPi=E<k~8+_#?7W2`5`N
zAKp0Zz4tT%b2(Jyb|G{=xJ@gkPW37sG3DXIRHlxDFQ&|%ec{?p7E4&1*v(-=U5zYS
z7>B~_mf2THvf6`MLf*WgiMzi04uOT)rS8UPIhW48$a0|_qT`^r$>P+m(~NSVuHzZV
z3a1jFc{J0beicZ<j!*)VJizM|H@TH~D{@*gK~;Aa?Qcx0L}DSTCvL?!aj<>x*WkUU
zgjJ`t4p5rCvnNA*Z;2SqEN343BT+~MY`xv(ff18soemqLOUw%Xi4ozwFEjI|`yQ_(
z)(L<YSL4NtD{#zW0FXi&094ig;up*E5$Gm5UXj_dExwdl2jY>;;>JsGiOiXW{3MA1
zFk2ehT_z(;Wsx2EZA&g<{|;EAG53TFL2@-A=V6n_6H-XK!{VS;Cu6nuy5>wk{DDae
zTS5bWJxSEpC~ttB#XFk%@yB1ttZYlm5CIy9VC|d!?#GRV4{Rsso<gSlLL_vpBFAyb
z%N43K)eBL(;)urXmN+1T(N_GnBaf6B=6pPg7pj&SCFbU3(Fts;WJ<}Z{nA8!pfzxn
z)$HdY3WT=WfoDTe>0TE*>C&2f@Sj2OIQ-f-AIsh>>VYr*SG;}myX5<;-x~6JYx)1p
c!(W-@dhJ_!ZO{2$d5en|Sj|uUV)d?n0iOj)O8@`>

literal 0
HcmV?d00001

diff --git a/docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_speedup_abs.png b/docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_speedup_abs.png
new file mode 100644
index 0000000000000000000000000000000000000000..f8b3eeaea666ebe8cb2f7cb9888827182c946628
GIT binary patch
literal 37579
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

literal 0
HcmV?d00001

diff --git a/docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_speedup_rel.png b/docs/source/_static/images/benchmark-results/0.4.0/tpch_queries_speedup_rel.png
new file mode 100644
index 0000000000000000000000000000000000000000..d95b41503764aafa92e36a121a7a7f1b778b6b93
GIT binary patch
literal 48051
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

literal 0
HcmV?d00001

diff --git a/docs/source/contributor-guide/benchmark-results/0.3.0/datafusion-python-tpch.json b/docs/source/contributor-guide/benchmark-results/0.3.0/datafusion-python-tpch.json
deleted file mode 100644
index 8f6ca23a29..0000000000
--- a/docs/source/contributor-guide/benchmark-results/0.3.0/datafusion-python-tpch.json
+++ /dev/null
@@ -1,73 +0,0 @@
-{
-    "engine": "datafusion-python",
-    "datafusion-version": "40.1.0",
-    "benchmark": "tpch",
-    "data_path": "/mnt/bigdata/tpch/sf100",
-    "query_path": "../../tpch/queries/",
-    "1": [
-        5.120208740234375
-    ],
-    "2": [
-        3.7675418853759766
-    ],
-    "3": [
-        5.07387113571167
-    ],
-    "4": [
-        1.9587907791137695
-    ],
-    "5": [
-        8.816755771636963
-    ],
-    "6": [
-        1.0937256813049316
-    ],
-    "7": [
-        17.575931549072266
-    ],
-    "8": [
-        8.337157964706421
-    ],
-    "9": [
-        17.257150411605835
-    ],
-    "10": [
-        7.945651292800903
-    ],
-    "11": [
-        2.7080790996551514
-    ],
-    "12": [
-        1.7468397617340088
-    ],
-    "13": [
-        5.695569276809692
-    ],
-    "14": [
-        2.0220673084259033
-    ],
-    "15": [
-        4.112257719039917
-    ],
-    "16": [
-        1.9162819385528564
-    ],
-    "17": [
-        21.812944650650024
-    ],
-    "18": [
-        23.510076999664307
-    ],
-    "19": [
-        2.842766761779785
-    ],
-    "20": [
-        7.717615842819214
-    ],
-    "21": [
-        19.96519947052002
-    ],
-    "22": [
-        1.0273211002349854
-    ]
-}
\ No newline at end of file
diff --git a/docs/source/contributor-guide/benchmark-results/0.4.0/comet-tpcds.json b/docs/source/contributor-guide/benchmark-results/0.4.0/comet-tpcds.json
new file mode 100644
index 0000000000..ecd632e840
--- /dev/null
+++ b/docs/source/contributor-guide/benchmark-results/0.4.0/comet-tpcds.json
@@ -0,0 +1,755 @@
+{
+    "engine": "datafusion-comet",
+    "benchmark": "tpcds",
+    "data_path": "/mnt/bigdata/tpcds/sf100/",
+    "query_path": "/tpcds",
+    "spark_conf": {
+        "spark.executor.instances": "4",
+        "spark.comet.cast.allowIncompatible": "true",
+        "spark.kubernetes.memoryOverheadFactor": "0.4",
+        "spark.app.initial.jar.urls": "file:/opt/spark/jars/comet-spark-spark3.4_2.12-0.4.0-SNAPSHOT.jar",
+        "spark.kubernetes.authenticate.driver.serviceAccountName": "spark",
+        "spark.kubernetes.executor.container.image": "woody:5000/spark-tpcbench:comet",
+        "spark.kubernetes.driver.volumes.hostPath.data.mount.path": "/mnt/bigdata",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.options.claimName": "benchmark-results-pvc",
+        "spark.comet.exec.shuffle.enabled": "true",
+        "spark.memory.offHeap.enabled": "true",
+        "spark.memory.offHeap.size": "32g",
+        "spark.executor.memoryOverhead": "2457M",
+        "spark.master": "k8s://https://kube1:6443",
+        "spark.app.startTime": "1731962698535",
+        "spark.app.id": "spark-41930409e7b1448a837ed5c0d9130620",
+        "spark.kubernetes.executor.podNamePrefix": "comet-benchmark-derived-from-tpcds-31aa739341057c91",
+        "spark.serializer.objectStreamReset": "100",
+        "spark.executor.memory": "8g",
+        "spark.submit.deployMode": "client",
+        "spark.kubernetes.driver.volumes.hostPath.data.options.path": "/mnt/bigdata",
+        "spark.driver.host": "tpcbench-py-26286b934105723b-driver-svc.default.svc",
+        "spark.eventLog.enabled": "false",
+        "spark.kubernetes.container.image.pullPolicy": "Always",
+        "spark.kubernetes.submitInDriver": "true",
+        "spark.comet.exec.replaceSortMergeJoin": "false",
+        "spark.driver.bindAddress": "10.42.1.9",
+        "spark.sql.warehouse.dir": "file:/opt/spark/work-dir/spark-warehouse",
+        "spark.driver.extraJavaOptions": "-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false",
+        "spark.jars": "local:/opt/spark/jars/comet-spark-spark3.4_2.12-0.4.0-SNAPSHOT.jar",
+        "spark.shuffle.manager": "org.apache.spark.sql.comet.execution.shuffle.CometShuffleManager",
+        "spark.driver.blockManager.port": "7079",
+        "spark.repl.local.jars": "local:///opt/spark/jars/comet-spark-spark3.4_2.12-0.4.0-SNAPSHOT.jar",
+        "spark.app.submitTime": "1731962698320",
+        "spark.driver.extraClassPath": "local:///opt/spark/jars/comet-spark-spark3.4_2.12-0.4.0-SNAPSHOT.jar",
+        "spark.executor.id": "driver",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.mount.readOnly": "false",
+        "spark.comet.exec.shuffle.mode": "auto",
+        "spark.driver.memory": "8G",
+        "spark.plugins": "org.apache.spark.CometPlugin",
+        "spark.driver.port": "7078",
+        "spark.sql.extensions": "org.apache.comet.CometSparkSessionExtensions",
+        "spark.kubernetes.driver.pod.name": "tpcbench-py-26286b934105723b-driver",
+        "spark.kubernetes.driver.volumes.hostPath.data.options.readOnly": "false",
+        "spark.kubernetes.resource.type": "python",
+        "spark.kubernetes.executor.volumes.hostPath.data.mount.path": "/mnt/bigdata",
+        "spark.kubernetes.driver.container.image": "woody:5000/spark-tpcbench:comet",
+        "spark.executor.cores": "6",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.mount.path": "/mnt/benchmark-results",
+        "spark.rdd.compress": "True",
+        "spark.kubernetes.executor.volumes.hostPath.data.options.path": "/mnt/bigdata",
+        "spark.executor.extraJavaOptions": "-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false",
+        "spark.submit.pyFiles": "",
+        "spark.executor.extraClassPath": "local:///opt/spark/jars/comet-spark-spark3.4_2.12-0.4.0-SNAPSHOT.jar",
+        "spark.app.name": "comet benchmark derived from tpcds"
+    },
+    "1": [
+        3.613295316696167,
+        0.9363176822662354,
+        0.8858673572540283,
+        0.9213356971740723,
+        0.9260072708129883
+    ],
+    "2": [
+        2.1988301277160645,
+        1.2930514812469482,
+        1.2836058139801025,
+        1.3122997283935547,
+        1.310011863708496
+    ],
+    "3": [
+        1.1296944618225098,
+        0.8390710353851318,
+        0.863898754119873,
+        0.8277552127838135,
+        0.8591916561126709
+    ],
+    "4": [
+        23.46227192878723,
+        23.30874729156494,
+        22.632073640823364,
+        23.021177530288696,
+        23.210322380065918
+    ],
+    "5": [
+        4.248774290084839,
+        3.8154327869415283,
+        3.7951250076293945,
+        3.841792583465576,
+        3.830977201461792
+    ],
+    "6": [
+        1.2654953002929688,
+        1.0582756996154785,
+        1.0062625408172607,
+        0.9889535903930664,
+        1.0066215991973877
+    ],
+    "7": [
+        1.9927458763122559,
+        1.7910470962524414,
+        1.7864744663238525,
+        1.8166968822479248,
+        1.8165059089660645
+    ],
+    "8": [
+        1.39858078956604,
+        1.1697239875793457,
+        1.181609869003296,
+        1.1592917442321777,
+        1.2115702629089355
+    ],
+    "9": [
+        3.8118808269500732,
+        3.5978047847747803,
+        3.6009204387664795,
+        3.6475167274475098,
+        3.720515489578247
+    ],
+    "10": [
+        1.6375336647033691,
+        1.253730058670044,
+        1.2790555953979492,
+        1.2641334533691406,
+        1.2304799556732178
+    ],
+    "11": [
+        8.888672590255737,
+        8.726006031036377,
+        8.779715061187744,
+        8.728724002838135,
+        8.738395929336548
+    ],
+    "12": [
+        1.209524393081665,
+        1.1902368068695068,
+        1.2197084426879883,
+        1.214184045791626,
+        1.0896027088165283
+    ],
+    "13": [
+        2.334285259246826,
+        2.3459174633026123,
+        2.376317262649536,
+        2.3597984313964844,
+        2.399404287338257
+    ],
+    "14": [
+        22.216265201568604,
+        21.80620813369751,
+        22.18099617958069,
+        22.004033088684082,
+        22.437575578689575
+    ],
+    "15": [
+        2.6664204597473145,
+        2.5816941261291504,
+        2.6421005725860596,
+        2.655304193496704,
+        2.6851134300231934
+    ],
+    "16": [
+        7.677209854125977,
+        7.403982400894165,
+        7.679336309432983,
+        7.390750169754028,
+        7.398985385894775
+    ],
+    "17": [
+        2.4100611209869385,
+        2.4173429012298584,
+        2.3482720851898193,
+        2.3698456287384033,
+        2.4305622577667236
+    ],
+    "18": [
+        2.439337730407715,
+        2.5373470783233643,
+        2.4983959197998047,
+        2.529120922088623,
+        2.538098096847534
+    ],
+    "19": [
+        2.5696511268615723,
+        2.5729575157165527,
+        2.5877132415771484,
+        2.5895493030548096,
+        2.584230899810791
+    ],
+    "20": [
+        1.7106993198394775,
+        1.6393051147460938,
+        1.5836944580078125,
+        1.624565839767456,
+        1.6353082656860352
+    ],
+    "21": [
+        1.096069097518921,
+        1.0144309997558594,
+        1.0689029693603516,
+        1.1604490280151367,
+        1.0859742164611816
+    ],
+    "22": [
+        8.084425210952759,
+        8.307284593582153,
+        8.248545169830322,
+        8.41027283668518,
+        8.130585432052612
+    ],
+    "23": [
+        31.006169080734253,
+        31.809021949768066,
+        31.491374731063843,
+        31.673828125,
+        32.41964364051819
+    ],
+    "24": [
+        13.210773944854736,
+        12.064785242080688,
+        12.284985542297363,
+        12.34001111984253,
+        13.093876361846924
+    ],
+    "25": [
+        2.7884602546691895,
+        2.611072301864624,
+        2.6468446254730225,
+        2.5781397819519043,
+        2.732714891433716
+    ],
+    "26": [
+        1.1039531230926514,
+        1.038722276687622,
+        1.0986864566802979,
+        0.9996967315673828,
+        1.0384690761566162
+    ],
+    "27": [
+        1.8319566249847412,
+        1.8125741481781006,
+        1.7781953811645508,
+        1.7830994129180908,
+        1.8019931316375732
+    ],
+    "28": [
+        4.2303125858306885,
+        4.181443214416504,
+        4.171067953109741,
+        4.197100639343262,
+        4.169423341751099
+    ],
+    "29": [
+        3.66855525970459,
+        3.7532052993774414,
+        3.566790819168091,
+        3.7179572582244873,
+        3.686014175415039
+    ],
+    "30": [
+        1.117868185043335,
+        1.2058172225952148,
+        1.0498886108398438,
+        1.1140456199645996,
+        1.1328985691070557
+    ],
+    "31": [
+        4.85772180557251,
+        4.797250270843506,
+        4.839718818664551,
+        4.840039014816284,
+        4.837655782699585
+    ],
+    "32": [
+        1.3921968936920166,
+        1.3323743343353271,
+        1.4425835609436035,
+        1.348841667175293,
+        1.3850789070129395
+    ],
+    "33": [
+        2.293806314468384,
+        2.253751754760742,
+        2.240044593811035,
+        2.2648448944091797,
+        2.2620596885681152
+    ],
+    "34": [
+        1.3108677864074707,
+        1.2720186710357666,
+        1.3723440170288086,
+        1.2785835266113281,
+        1.26865816116333
+    ],
+    "35": [
+        2.447936773300171,
+        2.445019483566284,
+        2.438453197479248,
+        2.401923179626465,
+        2.5346932411193848
+    ],
+    "36": [
+        2.4888269901275635,
+        2.191847085952759,
+        2.1506924629211426,
+        2.1331875324249268,
+        2.2247748374938965
+    ],
+    "37": [
+        1.82137131690979,
+        1.7718479633331299,
+        1.762279748916626,
+        1.805389165878296,
+        1.8042621612548828
+    ],
+    "38": [
+        2.4564521312713623,
+        2.7351372241973877,
+        2.2422144412994385,
+        2.271132707595825,
+        2.6268062591552734
+    ],
+    "39": [
+        15.272886514663696,
+        16.56870722770691,
+        15.184351682662964,
+        17.65111756324768,
+        16.851532697677612
+    ],
+    "40": [
+        4.618505954742432,
+        4.582245826721191,
+        4.805966854095459,
+        4.843486547470093,
+        4.6164655685424805
+    ],
+    "41": [
+        0.15246796607971191,
+        0.12736821174621582,
+        0.123199462890625,
+        0.13370347023010254,
+        0.13098549842834473
+    ],
+    "42": [
+        0.8077573776245117,
+        0.7788431644439697,
+        0.755042314529419,
+        0.7611534595489502,
+        0.7864503860473633
+    ],
+    "43": [
+        1.0223720073699951,
+        1.0028953552246094,
+        1.0250427722930908,
+        1.0194573402404785,
+        1.076014518737793
+    ],
+    "44": [
+        1.1571755409240723,
+        1.1396656036376953,
+        1.1511790752410889,
+        1.1235918998718262,
+        1.1504936218261719
+    ],
+    "45": [
+        1.8097100257873535,
+        1.8120465278625488,
+        1.8139166831970215,
+        1.7709436416625977,
+        1.7835633754730225
+    ],
+    "46": [
+        2.4002232551574707,
+        2.2962591648101807,
+        2.38244366645813,
+        2.4457669258117676,
+        2.4249236583709717
+    ],
+    "47": [
+        5.617861032485962,
+        5.408482551574707,
+        5.431608438491821,
+        5.449252128601074,
+        5.623114109039307
+    ],
+    "48": [
+        1.638838768005371,
+        1.68455171585083,
+        1.6805500984191895,
+        1.6506848335266113,
+        1.642219066619873
+    ],
+    "49": [
+        4.706164598464966,
+        4.6550188064575195,
+        4.703380346298218,
+        4.4827210903167725,
+        4.653671503067017
+    ],
+    "50": [
+        6.328258275985718,
+        6.51447057723999,
+        6.318875789642334,
+        6.525310277938843,
+        6.306564569473267
+    ],
+    "51": [
+        7.000143051147461,
+        6.798591613769531,
+        6.729523658752441,
+        6.572738170623779,
+        6.712196111679077
+    ],
+    "52": [
+        0.919975757598877,
+        0.8573052883148193,
+        0.8529157638549805,
+        0.8662893772125244,
+        0.8644464015960693
+    ],
+    "53": [
+        1.268928050994873,
+        1.1189360618591309,
+        1.155031442642212,
+        1.151642084121704,
+        1.1593868732452393
+    ],
+    "54": [
+        2.8306691646575928,
+        2.8038384914398193,
+        2.8667569160461426,
+        2.8659167289733887,
+        2.8607115745544434
+    ],
+    "55": [
+        0.9192891120910645,
+        0.8829891681671143,
+        0.9207160472869873,
+        0.9063892364501953,
+        0.9118208885192871
+    ],
+    "56": [
+        2.098660469055176,
+        2.0563149452209473,
+        2.0371997356414795,
+        2.0526468753814697,
+        2.052966594696045
+    ],
+    "57": [
+        3.1710643768310547,
+        3.102032423019409,
+        3.1820738315582275,
+        3.2220702171325684,
+        3.1981401443481445
+    ],
+    "58": [
+        4.2822654247283936,
+        4.219950199127197,
+        4.260200023651123,
+        4.203465700149536,
+        4.235920667648315
+    ],
+    "59": [
+        2.8434674739837646,
+        2.8698465824127197,
+        2.958869218826294,
+        2.9485886096954346,
+        2.944758176803589
+    ],
+    "60": [
+        2.0825767517089844,
+        2.0261218547821045,
+        2.093472957611084,
+        2.028120756149292,
+        2.0296173095703125
+    ],
+    "61": [
+        4.164551496505737,
+        4.247161149978638,
+        4.208996057510376,
+        4.154303073883057,
+        4.216529369354248
+    ],
+    "62": [
+        0.6185667514801025,
+        0.6253015995025635,
+        0.6186847686767578,
+        0.6257288455963135,
+        0.6202499866485596
+    ],
+    "63": [
+        1.088174819946289,
+        1.0861599445343018,
+        1.045111894607544,
+        1.0676589012145996,
+        1.0662899017333984
+    ],
+    "64": [
+        11.732340097427368,
+        11.538040399551392,
+        11.864402532577515,
+        11.667150020599365,
+        11.87758994102478
+    ],
+    "65": [
+        6.239193439483643,
+        6.3904407024383545,
+        6.047687768936157,
+        6.067760467529297,
+        6.426549196243286
+    ],
+    "66": [
+        2.0485336780548096,
+        2.0909292697906494,
+        2.0843634605407715,
+        2.114530324935913,
+        2.2097740173339844
+    ],
+    "67": [
+        23.676459312438965,
+        24.08505654335022,
+        24.311410903930664,
+        23.65312933921814,
+        23.644501447677612
+    ],
+    "68": [
+        2.6239256858825684,
+        2.68916654586792,
+        2.713677406311035,
+        2.735755443572998,
+        2.6569156646728516
+    ],
+    "69": [
+        1.3641211986541748,
+        1.3893208503723145,
+        1.4258897304534912,
+        1.406707763671875,
+        1.4287145137786865
+    ],
+    "70": [
+        2.3978335857391357,
+        2.388171911239624,
+        2.311910629272461,
+        2.323887825012207,
+        2.357830286026001
+    ],
+    "71": [
+        2.148318290710449,
+        2.0978829860687256,
+        2.1367037296295166,
+        2.1240034103393555,
+        2.096367359161377
+    ],
+    "72": [
+        55.71474242210388,
+        55.65497851371765,
+        55.09920024871826,
+        54.11650276184082,
+        56.20997095108032
+    ],
+    "73": [
+        0.981971025466919,
+        1.0062155723571777,
+        0.9884769916534424,
+        1.0174438953399658,
+        0.9753994941711426
+    ],
+    "74": [
+        6.0974955558776855,
+        6.090858697891235,
+        6.104249477386475,
+        6.180070161819458,
+        6.250415325164795
+    ],
+    "75": [
+        7.970996618270874,
+        7.890105485916138,
+        7.769358396530151,
+        7.92317795753479,
+        7.910406589508057
+    ],
+    "76": [
+        1.833014726638794,
+        1.8315975666046143,
+        1.8497719764709473,
+        1.8833909034729004,
+        1.8657946586608887
+    ],
+    "77": [
+        2.430835008621216,
+        2.378892660140991,
+        2.253649950027466,
+        2.3566322326660156,
+        2.381143093109131
+    ],
+    "78": [
+        13.936902523040771,
+        14.407816886901855,
+        14.292723894119263,
+        14.425165891647339,
+        14.25799822807312
+    ],
+    "79": [
+        1.7828254699707031,
+        1.8427963256835938,
+        1.8661816120147705,
+        1.9232194423675537,
+        1.905480146408081
+    ],
+    "80": [
+        10.53323483467102,
+        10.418278694152832,
+        10.549378871917725,
+        10.663471698760986,
+        10.687374830245972
+    ],
+    "81": [
+        1.3656373023986816,
+        1.3399004936218262,
+        1.3288192749023438,
+        1.4544517993927002,
+        1.3790254592895508
+    ],
+    "82": [
+        3.3641715049743652,
+        3.279186964035034,
+        3.213341236114502,
+        3.3441648483276367,
+        3.389477014541626
+    ],
+    "83": [
+        0.7808544635772705,
+        0.7731945514678955,
+        0.8409247398376465,
+        0.9210186004638672,
+        0.8299705982208252
+    ],
+    "84": [
+        0.7040410041809082,
+        0.7207241058349609,
+        0.7018799781799316,
+        0.8818099498748779,
+        0.6937227249145508
+    ],
+    "85": [
+        1.421285629272461,
+        1.4219837188720703,
+        1.5009398460388184,
+        1.5087964534759521,
+        1.4539406299591064
+    ],
+    "86": [
+        0.7153642177581787,
+        0.653031587600708,
+        0.6546626091003418,
+        0.7315728664398193,
+        0.6839661598205566
+    ],
+    "87": [
+        2.6152150630950928,
+        2.4368674755096436,
+        2.447220802307129,
+        2.4948906898498535,
+        2.4271810054779053
+    ],
+    "88": [
+        3.7563509941101074,
+        3.7107393741607666,
+        3.740159511566162,
+        3.9487733840942383,
+        3.7908895015716553
+    ],
+    "89": [
+        1.3733341693878174,
+        1.3950858116149902,
+        1.3895792961120605,
+        1.434366226196289,
+        1.4087369441986084
+    ],
+    "90": [
+        0.32382941246032715,
+        0.3856828212738037,
+        0.31131482124328613,
+        0.3739144802093506,
+        0.3414499759674072
+    ],
+    "91": [
+        0.4922313690185547,
+        0.4702589511871338,
+        0.4913055896759033,
+        0.547508955001831,
+        0.47322750091552734
+    ],
+    "92": [
+        0.5397188663482666,
+        0.5313537120819092,
+        0.5446431636810303,
+        0.5584907531738281,
+        0.5503730773925781
+    ],
+    "93": [
+        7.6846864223480225,
+        7.392237186431885,
+        7.6069016456604,
+        7.612182378768921,
+        7.472257614135742
+    ],
+    "94": [
+        4.253883123397827,
+        4.180011034011841,
+        4.123626470565796,
+        4.342567205429077,
+        4.465695381164551
+    ],
+    "95": [
+        14.060906887054443,
+        14.277164697647095,
+        14.19387698173523,
+        14.002771854400635,
+        15.193023920059204
+    ],
+    "96": [
+        0.526421070098877,
+        0.5006999969482422,
+        0.5214729309082031,
+        0.5473310947418213,
+        0.517216682434082
+    ],
+    "97": [
+        3.6567018032073975,
+        3.5691311359405518,
+        3.5199546813964844,
+        3.6811041831970215,
+        3.667187213897705
+    ],
+    "98": [
+        3.188143253326416,
+        3.1263539791107178,
+        3.1795992851257324,
+        3.23490834236145,
+        3.170579671859741
+    ],
+    "99": [
+        1.0296411514282227,
+        1.0101523399353027,
+        1.0162627696990967,
+        1.0697321891784668,
+        1.0347280502319336
+    ]
+}
\ No newline at end of file
diff --git a/docs/source/contributor-guide/benchmark-results/0.4.0/comet-tpch.json b/docs/source/contributor-guide/benchmark-results/0.4.0/comet-tpch.json
new file mode 100644
index 0000000000..25404f8722
--- /dev/null
+++ b/docs/source/contributor-guide/benchmark-results/0.4.0/comet-tpch.json
@@ -0,0 +1,219 @@
+{
+    "engine": "datafusion-comet",
+    "benchmark": "tpch",
+    "data_path": "/mnt/bigdata/tpch/sf100/",
+    "query_path": "/tpch",
+    "spark_conf": {
+        "spark.comet.cast.allowIncompatible": "true",
+        "spark.kubernetes.memoryOverheadFactor": "0.4",
+        "spark.kubernetes.driver.volumes.hostPath.data.mount.path": "/mnt/bigdata",
+        "spark.driver.host": "tpcbench-py-a08b54934067a8b3-driver-svc.default.svc",
+        "spark.memory.offHeap.size": "32g",
+        "spark.master": "k8s://https://kube1:6443",
+        "spark.kubernetes.driver.volumes.hostPath.data.options.path": "/mnt/bigdata",
+        "spark.comet.exec.all.enabled": "true",
+        "spark.driver.bindAddress": "10.42.0.10",
+        "spark.eventLog.enabled": "false",
+        "spark.kubernetes.container.image.pullPolicy": "Always",
+        "spark.kubernetes.submitInDriver": "true",
+        "spark.app.submitTime": "1731952357631",
+        "spark.sql.warehouse.dir": "file:/opt/spark/work-dir/spark-warehouse",
+        "spark.driver.extraJavaOptions": "-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false",
+        "spark.jars": "local:/opt/spark/jars/comet-spark-spark3.4_2.12-0.4.0-SNAPSHOT.jar",
+        "spark.shuffle.manager": "org.apache.spark.sql.comet.execution.shuffle.CometShuffleManager",
+        "spark.comet.exec.enabled": "true",
+        "spark.executor.id": "driver",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.mount.readOnly": "false",
+        "spark.comet.exec.shuffle.mode": "auto",
+        "spark.driver.memory": "8G",
+        "spark.driver.port": "7078",
+        "spark.sql.extensions": "org.apache.comet.CometSparkSessionExtensions",
+        "spark.kubernetes.driver.volumes.hostPath.data.options.readOnly": "false",
+        "spark.kubernetes.executor.podNamePrefix": "comet-benchmark-derived-from-tpch-42d900934067b351",
+        "spark.kubernetes.executor.volumes.hostPath.data.mount.path": "/mnt/bigdata",
+        "spark.kubernetes.driver.container.image": "woody:5000/spark-tpcbench:comet",
+        "spark.executor.instances": "1",
+        "spark.kubernetes.driver.pod.name": "tpcbench-py-a08b54934067a8b3-driver",
+        "spark.executor.extraClassPath": "local:///opt/spark/jars/comet-spark-spark3.4_2.12-0.4.0-SNAPSHOT.jar",
+        "spark.comet.explain.native.enabled": "false",
+        "spark.executor.memoryOverhead": "4914M",
+        "spark.app.initial.jar.urls": "file:/opt/spark/jars/comet-spark-spark3.4_2.12-0.4.0-SNAPSHOT.jar",
+        "spark.kubernetes.authenticate.driver.serviceAccountName": "spark",
+        "spark.kubernetes.executor.container.image": "woody:5000/spark-tpcbench:comet",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.options.claimName": "benchmark-results-pvc",
+        "spark.comet.exec.replaceSortMergeJoin": "true",
+        "spark.comet.exec.shuffle.enabled": "true",
+        "spark.memory.offHeap.enabled": "true",
+        "spark.app.name": "comet benchmark derived from tpch",
+        "spark.executor.memory": "16G",
+        "spark.serializer.objectStreamReset": "100",
+        "spark.submit.deployMode": "client",
+        "spark.app.id": "spark-71d7e005c63b4f7a9a54d11eaa5d99d4",
+        "spark.executor.cores": "8",
+        "spark.driver.blockManager.port": "7079",
+        "spark.repl.local.jars": "local:///opt/spark/jars/comet-spark-spark3.4_2.12-0.4.0-SNAPSHOT.jar",
+        "spark.driver.extraClassPath": "local:///opt/spark/jars/comet-spark-spark3.4_2.12-0.4.0-SNAPSHOT.jar",
+        "spark.plugins": "org.apache.spark.CometPlugin",
+        "spark.app.startTime": "1731952357848",
+        "spark.kubernetes.resource.type": "python",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.mount.path": "/mnt/benchmark-results",
+        "spark.rdd.compress": "True",
+        "spark.kubernetes.executor.volumes.hostPath.data.options.path": "/mnt/bigdata",
+        "spark.executor.extraJavaOptions": "-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false",
+        "spark.submit.pyFiles": ""
+    },
+    "1": [
+        12.675217866897583,
+        10.69823956489563,
+        10.959712743759155,
+        11.049235582351685,
+        11.25637674331665
+    ],
+    "2": [
+        7.2883970737457275,
+        6.955080509185791,
+        6.996195316314697,
+        7.001482725143433,
+        6.981860399246216
+    ],
+    "3": [
+        17.389552116394043,
+        17.815346479415894,
+        18.098077297210693,
+        18.250796794891357,
+        18.289159297943115
+    ],
+    "4": [
+        9.9054114818573,
+        9.76110053062439,
+        9.778793573379517,
+        9.659870386123657,
+        9.890227794647217
+    ],
+    "5": [
+        29.422667026519775,
+        29.41081738471985,
+        29.542785167694092,
+        29.379701375961304,
+        30.072590589523315
+    ],
+    "6": [
+        2.591843843460083,
+        2.5433740615844727,
+        2.486654758453369,
+        2.5132291316986084,
+        2.507908821105957
+    ],
+    "7": [
+        17.24040937423706,
+        17.355087280273438,
+        17.514805555343628,
+        17.43350887298584,
+        17.35370373725891
+    ],
+    "8": [
+        29.68608021736145,
+        29.521278858184814,
+        29.879571437835693,
+        29.99302840232849,
+        30.18179965019226
+    ],
+    "9": [
+        44.744760274887085,
+        45.07009744644165,
+        45.67892384529114,
+        45.49783205986023,
+        46.2200129032135
+    ],
+    "10": [
+        16.815892696380615,
+        16.816420078277588,
+        16.754045486450195,
+        16.916579008102417,
+        16.823299169540405
+    ],
+    "11": [
+        5.107349395751953,
+        4.9230499267578125,
+        4.9613683223724365,
+        4.954375743865967,
+        4.949444770812988
+    ],
+    "12": [
+        5.476846694946289,
+        5.373950719833374,
+        5.399810791015625,
+        5.373565196990967,
+        5.389242172241211
+    ],
+    "13": [
+        11.168701410293579,
+        11.108731031417847,
+        11.159045219421387,
+        10.97795581817627,
+        11.064870119094849
+    ],
+    "14": [
+        5.262895584106445,
+        5.161571502685547,
+        5.15362286567688,
+        5.113251209259033,
+        5.200662136077881
+    ],
+    "15": [
+        9.296111345291138,
+        9.049000263214111,
+        8.952059745788574,
+        9.111369371414185,
+        9.09269094467163
+    ],
+    "16": [
+        6.102790832519531,
+        5.706904411315918,
+        5.573681831359863,
+        5.436795473098755,
+        5.416778802871704
+    ],
+    "17": [
+        34.57182478904724,
+        34.73775792121887,
+        34.8440580368042,
+        35.2716920375824,
+        35.55662488937378
+    ],
+    "18": [
+        32.07862377166748,
+        31.731548070907593,
+        31.748567819595337,
+        31.76587414741516,
+        31.907649993896484
+    ],
+    "19": [
+        6.052667140960693,
+        5.940260887145996,
+        5.960237264633179,
+        6.020690441131592,
+        6.060962677001953
+    ],
+    "20": [
+        10.794468641281128,
+        10.485475778579712,
+        10.518470525741577,
+        10.661662101745605,
+        10.678892850875854
+    ],
+    "21": [
+        47.43690896034241,
+        46.92784881591797,
+        46.689401626586914,
+        52.07501554489136,
+        53.362786054611206
+    ],
+    "22": [
+        4.79883337020874,
+        4.179429054260254,
+        4.191235303878784,
+        4.875058889389038,
+        5.055111885070801
+    ]
+}
\ No newline at end of file
diff --git a/docs/source/contributor-guide/benchmark-results/0.4.0/spark-tpcds.json b/docs/source/contributor-guide/benchmark-results/0.4.0/spark-tpcds.json
new file mode 100644
index 0000000000..69da376274
--- /dev/null
+++ b/docs/source/contributor-guide/benchmark-results/0.4.0/spark-tpcds.json
@@ -0,0 +1,742 @@
+{
+    "engine": "datafusion-comet",
+    "benchmark": "tpcds",
+    "data_path": "/mnt/bigdata/tpcds/sf100/",
+    "query_path": "/tpcds",
+    "spark_conf": {
+        "spark.executor.instances": "4",
+        "spark.kubernetes.memoryOverheadFactor": "0.4",
+        "spark.kubernetes.driver.pod.name": "tpcbench-py-630faa934132c6a0-driver",
+        "spark.kubernetes.authenticate.driver.serviceAccountName": "spark",
+        "spark.kubernetes.driver.volumes.hostPath.data.mount.path": "/mnt/bigdata",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.options.claimName": "benchmark-results-pvc",
+        "spark.kubernetes.executor.podNamePrefix": "spark-benchmark-derived-from-tpcds-e2f7c6934132d1e7",
+        "spark.memory.offHeap.enabled": "true",
+        "spark.memory.offHeap.size": "32g",
+        "spark.master": "k8s://https://kube1:6443",
+        "spark.driver.bindAddress": "10.42.1.12",
+        "spark.app.id": "spark-70c8317ee1414dd18a7f648dd9213dc3",
+        "spark.kubernetes.executor.container.image": "apache/spark:3.4.2",
+        "spark.kubernetes.driver.container.image": "woody:5000/spark-tpcbench:spark",
+        "spark.app.startTime": "1731965669512",
+        "spark.serializer.objectStreamReset": "100",
+        "spark.executor.memory": "8g",
+        "spark.submit.deployMode": "client",
+        "spark.kubernetes.driver.volumes.hostPath.data.options.path": "/mnt/bigdata",
+        "spark.eventLog.enabled": "false",
+        "spark.kubernetes.container.image.pullPolicy": "Always",
+        "spark.kubernetes.submitInDriver": "true",
+        "spark.sql.warehouse.dir": "file:/opt/spark/work-dir/spark-warehouse",
+        "spark.driver.extraJavaOptions": "-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false",
+        "spark.app.submitTime": "1731965669258",
+        "spark.driver.blockManager.port": "7079",
+        "spark.driver.host": "tpcbench-py-630faa934132c6a0-driver-svc.default.svc",
+        "spark.executor.id": "driver",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.mount.readOnly": "false",
+        "spark.driver.memory": "8G",
+        "spark.driver.port": "7078",
+        "spark.kubernetes.driver.volumes.hostPath.data.options.readOnly": "false",
+        "spark.kubernetes.resource.type": "python",
+        "spark.kubernetes.executor.volumes.hostPath.data.mount.path": "/mnt/bigdata",
+        "spark.executor.cores": "6",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.mount.path": "/mnt/benchmark-results",
+        "spark.rdd.compress": "True",
+        "spark.kubernetes.executor.volumes.hostPath.data.options.path": "/mnt/bigdata",
+        "spark.executor.extraJavaOptions": "-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false",
+        "spark.submit.pyFiles": "",
+        "spark.app.name": "spark benchmark derived from tpcds"
+    },
+    "1": [
+        4.101798057556152,
+        1.6628072261810303,
+        1.6944208145141602,
+        1.5850894451141357,
+        1.6819756031036377
+    ],
+    "2": [
+        2.505007743835449,
+        1.4451699256896973,
+        1.4508037567138672,
+        1.4211256504058838,
+        1.4528944492340088
+    ],
+    "3": [
+        1.0310730934143066,
+        0.78733229637146,
+        0.8511149883270264,
+        0.7833230495452881,
+        0.8547565937042236
+    ],
+    "4": [
+        30.011910915374756,
+        29.12224292755127,
+        28.913774251937866,
+        28.686842441558838,
+        29.61912488937378
+    ],
+    "5": [
+        6.010044097900391,
+        5.845148086547852,
+        6.015597820281982,
+        5.935771703720093,
+        5.921597957611084
+    ],
+    "6": [
+        1.7483971118927002,
+        1.4204390048980713,
+        1.3826384544372559,
+        1.4277729988098145,
+        1.426151990890503
+    ],
+    "7": [
+        2.1159181594848633,
+        1.8394184112548828,
+        1.7851722240447998,
+        1.9111988544464111,
+        1.8159196376800537
+    ],
+    "8": [
+        1.8837699890136719,
+        1.8838860988616943,
+        1.7019884586334229,
+        1.7169978618621826,
+        1.7927045822143555
+    ],
+    "9": [
+        3.0422322750091553,
+        2.8414883613586426,
+        2.9845988750457764,
+        2.8628768920898438,
+        2.875807523727417
+    ],
+    "10": [
+        1.9554328918457031,
+        1.746701955795288,
+        1.7458853721618652,
+        1.6303400993347168,
+        1.6505646705627441
+    ],
+    "11": [
+        10.3078453540802,
+        9.928950548171997,
+        10.273672103881836,
+        9.962933778762817,
+        9.891152143478394
+    ],
+    "12": [
+        1.1306350231170654,
+        0.966578483581543,
+        1.0629677772521973,
+        0.9184162616729736,
+        0.8431236743927002
+    ],
+    "13": [
+        2.5771689414978027,
+        2.2377328872680664,
+        2.2578840255737305,
+        2.2780606746673584,
+        2.208707332611084
+    ],
+    "14": [
+        31.266183137893677,
+        29.093640327453613,
+        29.287079572677612,
+        29.792733430862427,
+        29.16390872001648
+    ],
+    "15": [
+        2.7301526069641113,
+        2.42869234085083,
+        2.4819107055664062,
+        2.494722604751587,
+        2.5909152030944824
+    ],
+    "16": [
+        8.37593412399292,
+        8.275684833526611,
+        8.2781822681427,
+        8.58998966217041,
+        8.340266942977905
+    ],
+    "17": [
+        3.3585970401763916,
+        3.002685546875,
+        2.973276138305664,
+        2.8865857124328613,
+        2.9933559894561768
+    ],
+    "18": [
+        2.930973529815674,
+        2.7753474712371826,
+        2.721234083175659,
+        2.608856678009033,
+        2.630030870437622
+    ],
+    "19": [
+        2.173407793045044,
+        1.8570218086242676,
+        1.9925012588500977,
+        1.915762186050415,
+        1.8977746963500977
+    ],
+    "20": [
+        1.1954548358917236,
+        0.9028189182281494,
+        0.9437844753265381,
+        0.8968183994293213,
+        0.8379025459289551
+    ],
+    "21": [
+        1.4207208156585693,
+        1.4522266387939453,
+        1.318542718887329,
+        1.3398542404174805,
+        1.2218236923217773
+    ],
+    "22": [
+        14.03326940536499,
+        14.454235315322876,
+        13.709498643875122,
+        14.177965641021729,
+        13.597661256790161
+    ],
+    "23": [
+        57.87645149230957,
+        56.65002155303955,
+        57.25854849815369,
+        56.565542221069336,
+        56.94704866409302
+    ],
+    "24": [
+        12.221173524856567,
+        10.913657665252686,
+        10.763681888580322,
+        12.460498809814453,
+        10.905694246292114
+    ],
+    "25": [
+        3.1492040157318115,
+        2.946575880050659,
+        2.888327121734619,
+        3.002459764480591,
+        3.161397933959961
+    ],
+    "26": [
+        1.3824872970581055,
+        1.3174099922180176,
+        1.4262938499450684,
+        1.411545991897583,
+        1.3012707233428955
+    ],
+    "27": [
+        1.6621944904327393,
+        1.7461235523223877,
+        1.6490883827209473,
+        1.6821620464324951,
+        1.668259859085083
+    ],
+    "28": [
+        4.79725980758667,
+        4.714123010635376,
+        4.665875196456909,
+        5.1792051792144775,
+        4.8896565437316895
+    ],
+    "29": [
+        4.536823749542236,
+        4.077563047409058,
+        4.396845817565918,
+        4.073688268661499,
+        4.367259502410889
+    ],
+    "30": [
+        1.7702891826629639,
+        1.8158881664276123,
+        1.6796913146972656,
+        1.9046649932861328,
+        1.8696742057800293
+    ],
+    "31": [
+        4.611050367355347,
+        4.022041320800781,
+        4.182346343994141,
+        4.287677764892578,
+        4.402425050735474
+    ],
+    "32": [
+        1.1875083446502686,
+        1.101001501083374,
+        1.261136531829834,
+        1.2711787223815918,
+        1.1264948844909668
+    ],
+    "33": [
+        1.9605779647827148,
+        2.101670980453491,
+        1.995006799697876,
+        2.0540874004364014,
+        1.9772546291351318
+    ],
+    "34": [
+        1.1797206401824951,
+        1.037219762802124,
+        1.116685152053833,
+        1.3116002082824707,
+        1.1500279903411865
+    ],
+    "35": [
+        2.6695785522460938,
+        2.653355121612549,
+        2.738192081451416,
+        2.6304309368133545,
+        2.7922165393829346
+    ],
+    "36": [
+        1.4320690631866455,
+        1.3371284008026123,
+        1.399195909500122,
+        1.3704102039337158,
+        1.3641293048858643
+    ],
+    "37": [
+        2.7905285358428955,
+        2.6404833793640137,
+        2.481349229812622,
+        2.54872989654541,
+        2.605477809906006
+    ],
+    "38": [
+        3.9898948669433594,
+        4.339789867401123,
+        4.0293896198272705,
+        3.894653081893921,
+        4.017303943634033
+    ],
+    "39": [
+        6.200651168823242,
+        5.982529163360596,
+        6.708714723587036,
+        6.462383508682251,
+        6.6200456619262695
+    ],
+    "40": [
+        5.8705267906188965,
+        6.351257085800171,
+        6.25710129737854,
+        6.0561816692352295,
+        6.249178171157837
+    ],
+    "41": [
+        0.24708271026611328,
+        0.2163989543914795,
+        0.21043944358825684,
+        0.19862890243530273,
+        0.20019888877868652
+    ],
+    "42": [
+        0.878232479095459,
+        0.8881511688232422,
+        0.9662492275238037,
+        0.925433874130249,
+        0.9298341274261475
+    ],
+    "43": [
+        0.9265544414520264,
+        0.8833436965942383,
+        0.9058196544647217,
+        0.9031116962432861,
+        0.8841662406921387
+    ],
+    "44": [
+        0.5191357135772705,
+        0.48758602142333984,
+        0.5332913398742676,
+        0.5114614963531494,
+        0.4971604347229004
+    ],
+    "45": [
+        1.7107188701629639,
+        1.6529803276062012,
+        1.6080644130706787,
+        1.671886920928955,
+        1.6790966987609863
+    ],
+    "46": [
+        2.0748560428619385,
+        1.9469430446624756,
+        2.0227723121643066,
+        2.011340379714966,
+        1.9434280395507812
+    ],
+    "47": [
+        3.5550601482391357,
+        3.700406312942505,
+        3.5939836502075195,
+        3.6490423679351807,
+        3.4499003887176514
+    ],
+    "48": [
+        3.7200522422790527,
+        3.7572500705718994,
+        3.7702255249023438,
+        3.7124366760253906,
+        3.730222463607788
+    ],
+    "49": [
+        5.228905200958252,
+        4.625717878341675,
+        4.951889276504517,
+        4.957994222640991,
+        5.071847438812256
+    ],
+    "50": [
+        9.543980360031128,
+        9.599350452423096,
+        9.469555377960205,
+        9.601779699325562,
+        9.497092962265015
+    ],
+    "51": [
+        11.083372354507446,
+        9.904197931289673,
+        10.511804342269897,
+        10.427511930465698,
+        11.04982876777649
+    ],
+    "52": [
+        1.1101248264312744,
+        1.0503735542297363,
+        1.034118413925171,
+        0.858811616897583,
+        1.0684659481048584
+    ],
+    "53": [
+        1.2383568286895752,
+        1.2415111064910889,
+        1.2688398361206055,
+        1.2551381587982178,
+        1.2679004669189453
+    ],
+    "54": [
+        2.482556104660034,
+        2.4029476642608643,
+        2.4188714027404785,
+        2.504854440689087,
+        2.386593818664551
+    ],
+    "55": [
+        1.0882360935211182,
+        1.1614463329315186,
+        1.0238258838653564,
+        1.2537846565246582,
+        1.060547113418579
+    ],
+    "56": [
+        1.7780375480651855,
+        1.8225603103637695,
+        1.851440668106079,
+        1.7312126159667969,
+        1.8368158340454102
+    ],
+    "57": [
+        2.49904203414917,
+        2.4126837253570557,
+        2.4750289916992188,
+        2.433041572570801,
+        2.3518331050872803
+    ],
+    "58": [
+        2.17509388923645,
+        2.3151907920837402,
+        2.259735345840454,
+        2.428464651107788,
+        2.1495883464813232
+    ],
+    "59": [
+        2.7380449771881104,
+        2.754039764404297,
+        2.6889383792877197,
+        2.604966878890991,
+        2.636704921722412
+    ],
+    "60": [
+        1.7363862991333008,
+        1.6587703227996826,
+        1.5419552326202393,
+        1.4795036315917969,
+        1.6812565326690674
+    ],
+    "61": [
+        2.4846465587615967,
+        2.387451410293579,
+        2.4108707904815674,
+        2.388557195663452,
+        2.3161416053771973
+    ],
+    "62": [
+        0.8136637210845947,
+        0.7371957302093506,
+        0.7617106437683105,
+        0.7683372497558594,
+        0.7747564315795898
+    ],
+    "63": [
+        1.1109309196472168,
+        1.1343533992767334,
+        1.2317695617675781,
+        1.133389949798584,
+        1.1092209815979004
+    ],
+    "64": [
+        14.743201732635498,
+        15.078812599182129,
+        14.671916007995605,
+        15.006304025650024,
+        15.00887680053711
+    ],
+    "65": [
+        7.251803636550903,
+        7.2695631980896,
+        7.238022804260254,
+        7.301697254180908,
+        7.161722421646118
+    ],
+    "66": [
+        1.9731743335723877,
+        1.9496684074401855,
+        1.9994518756866455,
+        1.8531701564788818,
+        1.930753231048584
+    ],
+    "67": [
+        49.6675705909729,
+        48.19621968269348,
+        50.70038366317749,
+        47.88284492492676,
+        48.761271715164185
+    ],
+    "68": [
+        2.0306437015533447,
+        1.9414896965026855,
+        1.9469645023345947,
+        1.9012255668640137,
+        1.9914145469665527
+    ],
+    "69": [
+        1.7471072673797607,
+        1.536611795425415,
+        1.6588964462280273,
+        1.6081433296203613,
+        1.6223390102386475
+    ],
+    "70": [
+        1.945021629333496,
+        1.8145639896392822,
+        1.812164545059204,
+        1.849292278289795,
+        1.8018312454223633
+    ],
+    "71": [
+        1.9524719715118408,
+        1.9845960140228271,
+        1.9457154273986816,
+        1.923093557357788,
+        1.951244592666626
+    ],
+    "72": [
+        12.546458959579468,
+        11.85893964767456,
+        12.32059645652771,
+        11.475525379180908,
+        11.872873306274414
+    ],
+    "73": [
+        1.0386018753051758,
+        1.0372083187103271,
+        1.0216479301452637,
+        0.9761593341827393,
+        0.933098316192627
+    ],
+    "74": [
+        9.800452470779419,
+        10.76702070236206,
+        11.209776163101196,
+        9.91211724281311,
+        10.263824701309204
+    ],
+    "75": [
+        8.530277013778687,
+        8.607342958450317,
+        8.445864200592041,
+        8.522737741470337,
+        8.499200582504272
+    ],
+    "76": [
+        1.8576176166534424,
+        2.0158095359802246,
+        1.891855239868164,
+        1.8044593334197998,
+        1.8446557521820068
+    ],
+    "77": [
+        2.266920566558838,
+        2.314894676208496,
+        2.4184823036193848,
+        2.4789552688598633,
+        2.355562925338745
+    ],
+    "78": [
+        22.44752526283264,
+        23.02877902984619,
+        22.419431447982788,
+        22.97319006919861,
+        22.363235473632812
+    ],
+    "79": [
+        1.6027934551239014,
+        1.4661269187927246,
+        1.4280049800872803,
+        1.4568893909454346,
+        1.4736254215240479
+    ],
+    "80": [
+        16.729133129119873,
+        16.709152698516846,
+        16.817840099334717,
+        17.630494117736816,
+        17.207946300506592
+    ],
+    "81": [
+        2.1778812408447266,
+        2.3530967235565186,
+        2.1917331218719482,
+        2.0935323238372803,
+        2.1222338676452637
+    ],
+    "82": [
+        6.663294792175293,
+        7.8879075050354,
+        7.217211961746216,
+        6.868515968322754,
+        6.5749123096466064
+    ],
+    "83": [
+        1.5960721969604492,
+        1.5132818222045898,
+        1.4365019798278809,
+        1.44840407371521,
+        1.477241039276123
+    ],
+    "84": [
+        1.163783073425293,
+        1.1479411125183105,
+        1.1228821277618408,
+        1.2401597499847412,
+        1.1172442436218262
+    ],
+    "85": [
+        3.2570650577545166,
+        2.7596423625946045,
+        3.081651449203491,
+        3.0925028324127197,
+        3.0603017807006836
+    ],
+    "86": [
+        0.7725980281829834,
+        0.7427737712860107,
+        0.7912232875823975,
+        0.7065935134887695,
+        0.7383038997650146
+    ],
+    "87": [
+        4.294668912887573,
+        4.660226345062256,
+        4.278197765350342,
+        4.472849130630493,
+        3.904066562652588
+    ],
+    "88": [
+        3.554309606552124,
+        3.6045660972595215,
+        3.5492982864379883,
+        3.3328254222869873,
+        3.5090348720550537
+    ],
+    "89": [
+        1.3484902381896973,
+        1.276850700378418,
+        1.3466012477874756,
+        1.2572429180145264,
+        1.4886093139648438
+    ],
+    "90": [
+        0.46999287605285645,
+        0.529099702835083,
+        0.578873872756958,
+        0.47667670249938965,
+        0.48769092559814453
+    ],
+    "91": [
+        0.7944860458374023,
+        0.8916025161743164,
+        0.832402229309082,
+        0.7235825061798096,
+        0.65761399269104
+    ],
+    "92": [
+        0.9741818904876709,
+        0.9964475631713867,
+        0.992856502532959,
+        0.9798798561096191,
+        0.9271073341369629
+    ],
+    "93": [
+        14.810303688049316,
+        14.715499639511108,
+        14.565584897994995,
+        14.738952398300171,
+        14.814255237579346
+    ],
+    "94": [
+        5.665013790130615,
+        5.276642084121704,
+        5.49097204208374,
+        5.194403886795044,
+        5.2361180782318115
+    ],
+    "95": [
+        13.44327449798584,
+        13.04519772529602,
+        13.047563791275024,
+        13.274654865264893,
+        13.301786184310913
+    ],
+    "96": [
+        0.5319077968597412,
+        0.5078849792480469,
+        0.5532786846160889,
+        0.49875950813293457,
+        0.529167890548706
+    ],
+    "97": [
+        7.3789963722229,
+        7.497219800949097,
+        7.451964855194092,
+        7.59662938117981,
+        7.404102802276611
+    ],
+    "98": [
+        1.5613372325897217,
+        1.698850154876709,
+        1.6474971771240234,
+        1.6323800086975098,
+        1.5777685642242432
+    ],
+    "99": [
+        1.1006407737731934,
+        1.109886884689331,
+        1.0147747993469238,
+        2.1191627979278564,
+        1.0859904289245605
+    ]
+}
\ No newline at end of file
diff --git a/docs/source/contributor-guide/benchmark-results/0.4.0/spark-tpch.json b/docs/source/contributor-guide/benchmark-results/0.4.0/spark-tpch.json
new file mode 100644
index 0000000000..f0a080aa95
--- /dev/null
+++ b/docs/source/contributor-guide/benchmark-results/0.4.0/spark-tpch.json
@@ -0,0 +1,203 @@
+{
+    "engine": "datafusion-comet",
+    "benchmark": "tpch",
+    "data_path": "/mnt/bigdata/tpch/sf100/",
+    "query_path": "/tpch",
+    "spark_conf": {
+        "spark.kubernetes.executor.podNamePrefix": "spark-benchmark-derived-from-tpch-91eee2934092023f",
+        "spark.kubernetes.memoryOverheadFactor": "0.4",
+        "spark.kubernetes.authenticate.driver.serviceAccountName": "spark",
+        "spark.kubernetes.driver.volumes.hostPath.data.mount.path": "/mnt/bigdata",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.options.claimName": "benchmark-results-pvc",
+        "spark.memory.offHeap.enabled": "true",
+        "spark.app.startTime": "1731955130576",
+        "spark.app.id": "spark-35db63a6dc9b42c79428c048244d508f",
+        "spark.master": "k8s://https://kube1:6443",
+        "spark.memory.offHeap.size": "48g",
+        "spark.kubernetes.driver.pod.name": "tpcbench-py-bca54a934091f6cd-driver",
+        "spark.kubernetes.executor.container.image": "apache/spark:3.4.2",
+        "spark.kubernetes.driver.container.image": "woody:5000/spark-tpcbench:spark",
+        "spark.executor.memory": "16G",
+        "spark.serializer.objectStreamReset": "100",
+        "spark.submit.deployMode": "client",
+        "spark.driver.host": "tpcbench-py-bca54a934091f6cd-driver-svc.default.svc",
+        "spark.kubernetes.driver.volumes.hostPath.data.options.path": "/mnt/bigdata",
+        "spark.eventLog.enabled": "false",
+        "spark.kubernetes.container.image.pullPolicy": "Always",
+        "spark.executor.cores": "8",
+        "spark.kubernetes.submitInDriver": "true",
+        "spark.sql.warehouse.dir": "file:/opt/spark/work-dir/spark-warehouse",
+        "spark.driver.extraJavaOptions": "-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false",
+        "spark.driver.blockManager.port": "7079",
+        "spark.driver.bindAddress": "10.42.0.12",
+        "spark.executor.id": "driver",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.mount.readOnly": "false",
+        "spark.driver.memory": "8G",
+        "spark.driver.port": "7078",
+        "spark.kubernetes.driver.volumes.hostPath.data.options.readOnly": "false",
+        "spark.kubernetes.resource.type": "python",
+        "spark.kubernetes.executor.volumes.hostPath.data.mount.path": "/mnt/bigdata",
+        "spark.kubernetes.driver.volumes.persistentVolumeClaim.benchmark-results-pv.mount.path": "/mnt/benchmark-results",
+        "spark.rdd.compress": "True",
+        "spark.app.name": "spark benchmark derived from tpch",
+        "spark.kubernetes.executor.volumes.hostPath.data.options.path": "/mnt/bigdata",
+        "spark.executor.extraJavaOptions": "-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false",
+        "spark.executor.instances": "1",
+        "spark.app.submitTime": "1731955130325",
+        "spark.submit.pyFiles": ""
+    },
+    "1": [
+        76.3459792137146,
+        77.43206644058228,
+        77.43688368797302,
+        77.57843589782715,
+        77.36109328269958
+    ],
+    "2": [
+        11.60047721862793,
+        12.094002485275269,
+        11.385731935501099,
+        11.742280006408691,
+        10.831515073776245
+    ],
+    "3": [
+        23.393443822860718,
+        23.679790496826172,
+        23.2339928150177,
+        23.296000957489014,
+        23.57963228225708
+    ],
+    "4": [
+        17.686111450195312,
+        17.663344860076904,
+        17.97491693496704,
+        17.99352526664734,
+        17.13844132423401
+    ],
+    "5": [
+        47.576931953430176,
+        47.90366792678833,
+        47.885528802871704,
+        47.82782196998596,
+        47.35511922836304
+    ],
+    "6": [
+        3.1415493488311768,
+        3.0869905948638916,
+        3.0410678386688232,
+        3.0086350440979004,
+        3.006296157836914
+    ],
+    "7": [
+        20.144665241241455,
+        20.645880699157715,
+        20.30326247215271,
+        20.52312994003296,
+        20.44648313522339
+    ],
+    "8": [
+        31.149712800979614,
+        31.346466541290283,
+        31.87547278404236,
+        31.968525409698486,
+        31.624362230300903
+    ],
+    "9": [
+        70.20270848274231,
+        73.088698387146,
+        71.15446996688843,
+        70.36094760894775,
+        71.0561454296112
+    ],
+    "10": [
+        19.035035133361816,
+        19.235825538635254,
+        19.032540559768677,
+        18.992990732192993,
+        18.960989236831665
+    ],
+    "11": [
+        12.353803873062134,
+        12.383912324905396,
+        12.390283346176147,
+        12.384623289108276,
+        12.608469009399414
+    ],
+    "12": [
+        12.46756649017334,
+        12.692992210388184,
+        13.037216424942017,
+        14.199844360351562,
+        12.41795563697815
+    ],
+    "13": [
+        21.14127492904663,
+        21.24750590324402,
+        21.330607652664185,
+        21.19257688522339,
+        21.117241144180298
+    ],
+    "14": [
+        5.365051031112671,
+        5.244381904602051,
+        5.224266290664673,
+        5.279320478439331,
+        5.351390600204468
+    ],
+    "15": [
+        14.187044382095337,
+        14.210954904556274,
+        14.301335096359253,
+        14.133733034133911,
+        14.062178373336792
+    ],
+    "16": [
+        6.709480047225952,
+        6.949545383453369,
+        6.819269180297852,
+        6.797849178314209,
+        7.115732192993164
+    ],
+    "17": [
+        59.576388120651245,
+        60.451228857040405,
+        60.65900158882141,
+        60.63210201263428,
+        60.68089413642883
+    ],
+    "18": [
+        69.60278511047363,
+        70.1350531578064,
+        69.89858436584473,
+        70.29715323448181,
+        69.83147168159485
+    ],
+    "19": [
+        6.37906551361084,
+        6.309690952301025,
+        6.3234429359436035,
+        6.329152345657349,
+        6.348209381103516
+    ],
+    "20": [
+        9.532709121704102,
+        9.26326322555542,
+        9.232454776763916,
+        9.317341089248657,
+        9.209791898727417
+    ],
+    "21": [
+        65.31082701683044,
+        65.26856255531311,
+        64.04693102836609,
+        64.84621214866638,
+        64.52755498886108
+    ],
+    "22": [
+        8.907754182815552,
+        8.766010046005249,
+        8.830661535263062,
+        8.698703527450562,
+        8.652528524398804
+    ]
+}
\ No newline at end of file
diff --git a/docs/source/contributor-guide/benchmark-results/0.2.0/datafusion-python-tpch.json b/docs/source/contributor-guide/benchmark-results/datafusion-40.1.0/datafusion-python-tpch.json
similarity index 100%
rename from docs/source/contributor-guide/benchmark-results/0.2.0/datafusion-python-tpch.json
rename to docs/source/contributor-guide/benchmark-results/datafusion-40.1.0/datafusion-python-tpch.json
diff --git a/docs/source/contributor-guide/benchmark-results/tpc-ds.md b/docs/source/contributor-guide/benchmark-results/tpc-ds.md
index 5575fef021..3fa70eb862 100644
--- a/docs/source/contributor-guide/benchmark-results/tpc-ds.md
+++ b/docs/source/contributor-guide/benchmark-results/tpc-ds.md
@@ -19,27 +19,27 @@ under the License.
 
 # Apache DataFusion Comet: Benchmarks Derived From TPC-DS
 
-The following benchmarks were performed on a Linux workstation with PCIe 5, AMD 7950X CPU (16 cores), 128 GB RAM, and
+The following benchmarks were performed on a two node Kubernetes cluster with
 data stored locally in Parquet format on NVMe storage. Performance characteristics will vary in different environments 
 and we encourage you to run these benchmarks in your own environments.
 
 The tracking issue for improving TPC-DS performance is [#858](https://github.com/apache/datafusion-comet/issues/858).
 
-![](../../_static/images/benchmark-results/0.3.0/tpcds_allqueries.png)
+![](../../_static/images/benchmark-results/0.4.0/tpcds_allqueries.png)
 
 Here is a breakdown showing relative performance of Spark and Comet for each query.
 
-![](../../_static/images/benchmark-results/0.3.0/tpcds_queries_compare.png)
+![](../../_static/images/benchmark-results/0.4.0/tpcds_queries_compare.png)
 
 The following chart shows how much Comet currently accelerates each query from the benchmark in relative terms.
 
-![](../../_static/images/benchmark-results/0.3.0/tpcds_queries_speedup_rel.png)
+![](../../_static/images/benchmark-results/0.4.0/tpcds_queries_speedup_rel.png)
 
 The following chart shows how much Comet currently accelerates each query from the benchmark in absolute terms.
 
-![](../../_static/images/benchmark-results/0.3.0/tpcds_queries_speedup_abs.png)
+![](../../_static/images/benchmark-results/0.4.0/tpcds_queries_speedup_abs.png)
 
 The raw results of these benchmarks in JSON format is available here:
 
-- [Spark](0.3.0/spark-tpcds.json)
-- [Comet](0.3.0/comet-tpcds.json)
+- [Spark](0.4.0/spark-tpcds.json)
+- [Comet](0.4.0/comet-tpcds.json)
diff --git a/docs/source/contributor-guide/benchmark-results/tpc-h.md b/docs/source/contributor-guide/benchmark-results/tpc-h.md
index 22cab0b453..2285489356 100644
--- a/docs/source/contributor-guide/benchmark-results/tpc-h.md
+++ b/docs/source/contributor-guide/benchmark-results/tpc-h.md
@@ -25,22 +25,21 @@ and we encourage you to run these benchmarks in your own environments.
 
 The tracking issue for improving TPC-H performance is [#391](https://github.com/apache/datafusion-comet/issues/391).
 
-![](../../_static/images/benchmark-results/0.3.0/tpch_allqueries.png)
+![](../../_static/images/benchmark-results/0.4.0/tpch_allqueries.png)
 
 Here is a breakdown showing relative performance of Spark, Comet, and DataFusion for each query.
 
-![](../../_static/images/benchmark-results/0.3.0/tpch_queries_compare.png)
+![](../../_static/images/benchmark-results/0.4.0/tpch_queries_compare.png)
 
 The following chart shows how much Comet currently accelerates each query from the benchmark in relative terms.
 
-![](../../_static/images/benchmark-results/0.3.0/tpch_queries_speedup_rel.png)
+![](../../_static/images/benchmark-results/0.4.0/tpch_queries_speedup_rel.png)
 
 The following chart shows how much Comet currently accelerates each query from the benchmark in absolute terms.
 
-![](../../_static/images/benchmark-results/0.3.0/tpch_queries_speedup_abs.png)
+![](../../_static/images/benchmark-results/0.4.0/tpch_queries_speedup_abs.png)
 
 The raw results of these benchmarks in JSON format is available here:
 
-- [Spark](0.3.0/spark-tpch.json)
-- [Comet](0.3.0/comet-tpch.json)
-- [DataFusion](0.3.0/datafusion-python-tpch.json)
\ No newline at end of file
+- [Spark](0.4.0/spark-tpch.json)
+- [Comet](0.4.0/comet-tpch.json)
diff --git a/docs/source/contributor-guide/benchmarking.md b/docs/source/contributor-guide/benchmarking.md
index 08aa10abc5..bd280f47fd 100644
--- a/docs/source/contributor-guide/benchmarking.md
+++ b/docs/source/contributor-guide/benchmarking.md
@@ -54,11 +54,11 @@ $SPARK_HOME/bin/spark-submit \
     --master $SPARK_MASTER \
     --conf spark.driver.memory=8G \
     --conf spark.executor.instances=1 \
-    --conf spark.executor.memory=32G \
+    --conf spark.executor.memory=16G \
     --conf spark.executor.cores=8 \
     --conf spark.cores.max=8 \
     --conf spark.memory.offHeap.enabled=true \
-    --conf spark.memory.offHeap.size=10g \
+    --conf spark.memory.offHeap.size=32g \
     --jars $COMET_JAR \
     --conf spark.driver.extraClassPath=$COMET_JAR \
     --conf spark.executor.extraClassPath=$COMET_JAR \
diff --git a/docs/source/user-guide/installation.md b/docs/source/user-guide/installation.md
index e2a946758c..22d482e475 100644
--- a/docs/source/user-guide/installation.md
+++ b/docs/source/user-guide/installation.md
@@ -51,12 +51,12 @@ is currently necessary to build from source.
 
 Here are the direct links for downloading the Comet jar file.
 
-- [Comet plugin for Spark 3.3 / Scala 2.12](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.3_2.12/0.3.0/comet-spark-spark3.3_2.12-0.3.0.jar)
-- [Comet plugin for Spark 3.3 / Scala 2.13](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.3_2.13/0.3.0/comet-spark-spark3.3_2.13-0.3.0.jar)
-- [Comet plugin for Spark 3.4 / Scala 2.12](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.4_2.12/0.3.0/comet-spark-spark3.4_2.12-0.3.0.jar)
-- [Comet plugin for Spark 3.4 / Scala 2.13](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.4_2.13/0.3.0/comet-spark-spark3.4_2.13-0.3.0.jar)
-- [Comet plugin for Spark 3.5 / Scala 2.12](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.5_2.12/0.3.0/comet-spark-spark3.5_2.12-0.3.0.jar)
-- [Comet plugin for Spark 3.5 / Scala 2.13](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.5_2.13/0.3.0/comet-spark-spark3.5_2.13-0.3.0.jar)
+- [Comet plugin for Spark 3.3 / Scala 2.12](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.3_2.12/0.4.0/comet-spark-spark3.3_2.12-0.4.0.jar)
+- [Comet plugin for Spark 3.3 / Scala 2.13](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.3_2.13/0.4.0/comet-spark-spark3.3_2.13-0.4.0.jar)
+- [Comet plugin for Spark 3.4 / Scala 2.12](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.4_2.12/0.4.0/comet-spark-spark3.4_2.12-0.4.0.jar)
+- [Comet plugin for Spark 3.4 / Scala 2.13](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.4_2.13/0.4.0/comet-spark-spark3.4_2.13-0.4.0.jar)
+- [Comet plugin for Spark 3.5 / Scala 2.12](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.5_2.12/0.4.0/comet-spark-spark3.5_2.12-0.4.0.jar)
+- [Comet plugin for Spark 3.5 / Scala 2.13](https://repo1.maven.org/maven2/org/apache/datafusion/comet-spark-spark3.5_2.13/0.4.0/comet-spark-spark3.5_2.13-0.4.0.jar)
 
 ## Building from source
 

From ca3a5290754c795b28e826aff95fe25f492bcbf3 Mon Sep 17 00:00:00 2001
From: KAZUYUKI TANIMURA <ktanimura@apple.com>
Date: Mon, 18 Nov 2024 19:01:18 -0800
Subject: [PATCH 10/47] fix: Unsigned type related bugs (#1095)

## Which issue does this PR close?

Closes https://github.com/apache/datafusion-comet/issues/1067

## Rationale for this change

Bug fix. A few expressions were failing some unsigned type related tests

## What changes are included in this PR?

 - For `u8`/`u16`, switched to use `generate_cast_to_signed!` in order to copy full i16/i32 width instead of padding zeros in the higher bits
 - `u64` becomes `Decimal(20, 0)` but there was a bug in `round()`  (`>` vs `>=`)

## How are these changes tested?

Put back tests for unsigned types
---
 native/core/src/parquet/read/values.rs             |  9 +++++----
 native/spark-expr/src/scalar_funcs.rs              |  2 +-
 .../scala/org/apache/comet/CometCastSuite.scala    |  5 +----
 .../org/apache/comet/CometExpressionSuite.scala    | 14 ++++----------
 .../comet/exec/CometColumnarShuffleSuite.scala     |  4 ++++
 .../apache/comet/parquet/ParquetReadSuite.scala    |  4 ++--
 6 files changed, 17 insertions(+), 21 deletions(-)

diff --git a/native/core/src/parquet/read/values.rs b/native/core/src/parquet/read/values.rs
index 324f6106dc..b439e29e6a 100644
--- a/native/core/src/parquet/read/values.rs
+++ b/native/core/src/parquet/read/values.rs
@@ -476,7 +476,7 @@ make_int_variant_impl!(Int32ToDoubleType, copy_i32_to_f64, 8);
 make_int_variant_impl!(FloatToDoubleType, copy_f32_to_f64, 8);
 
 // unsigned type require double the width and zeroes are written for the second half
-// perhaps because they are implemented as the next size up signed type?
+// because they are implemented as the next size up signed type
 make_int_variant_impl!(UInt8Type, copy_i32_to_u8, 2);
 make_int_variant_impl!(UInt16Type, copy_i32_to_u16, 4);
 make_int_variant_impl!(UInt32Type, copy_i32_to_u32, 8);
@@ -586,8 +586,6 @@ macro_rules! generate_cast_to_unsigned {
     };
 }
 
-generate_cast_to_unsigned!(copy_i32_to_u8, i32, u8, 0_u8);
-generate_cast_to_unsigned!(copy_i32_to_u16, i32, u16, 0_u16);
 generate_cast_to_unsigned!(copy_i32_to_u32, i32, u32, 0_u32);
 
 macro_rules! generate_cast_to_signed {
@@ -624,6 +622,9 @@ generate_cast_to_signed!(copy_i64_to_i64, i64, i64);
 generate_cast_to_signed!(copy_i64_to_i128, i64, i128);
 generate_cast_to_signed!(copy_u64_to_u128, u64, u128);
 generate_cast_to_signed!(copy_f32_to_f64, f32, f64);
+// even for u8/u16, need to copy full i16/i32 width for Spark compatibility
+generate_cast_to_signed!(copy_i32_to_u8, i32, i16);
+generate_cast_to_signed!(copy_i32_to_u16, i32, i32);
 
 // Shared implementation for variants of Binary type
 macro_rules! make_plain_binary_impl {
@@ -1096,7 +1097,7 @@ mod test {
         let source =
             hex::decode("8a000000dbffffff1800000034ffffff300000001d000000abffffff37fffffff1000000")
                 .unwrap();
-        let expected = hex::decode("8a00db001800340030001d00ab003700f100").unwrap();
+        let expected = hex::decode("8a00dbff180034ff30001d00abff37fff100").unwrap();
         let num = source.len() / 4;
         let mut dest: Vec<u8> = vec![b' '; num * 2];
         copy_i32_to_u8(source.as_bytes(), dest.as_mut_slice(), num);
diff --git a/native/spark-expr/src/scalar_funcs.rs b/native/spark-expr/src/scalar_funcs.rs
index 5cc3f3dd7e..2961f038dc 100644
--- a/native/spark-expr/src/scalar_funcs.rs
+++ b/native/spark-expr/src/scalar_funcs.rs
@@ -354,7 +354,7 @@ pub fn spark_round(
             DataType::Int32 if *point < 0 => round_integer_array!(array, point, Int32Array, i32),
             DataType::Int16 if *point < 0 => round_integer_array!(array, point, Int16Array, i16),
             DataType::Int8 if *point < 0 => round_integer_array!(array, point, Int8Array, i8),
-            DataType::Decimal128(_, scale) if *scale > 0 => {
+            DataType::Decimal128(_, scale) if *scale >= 0 => {
                 let f = decimal_round_f(scale, point);
                 let (precision, scale) = get_precision_scale(data_type);
                 make_decimal_array(array, precision, scale, &f)
diff --git a/spark/src/test/scala/org/apache/comet/CometCastSuite.scala b/spark/src/test/scala/org/apache/comet/CometCastSuite.scala
index db9a870dc0..01583077df 100644
--- a/spark/src/test/scala/org/apache/comet/CometCastSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/CometCastSuite.scala
@@ -861,10 +861,7 @@ class CometCastSuite extends CometTestBase with AdaptiveSparkPlanHelper {
           // primitives
           checkSparkAnswerAndOperator(
             "SELECT CAST(struct(_1, _2, _3, _4, _5, _6, _7, _8) as string) FROM tbl")
-          // TODO: enable tests for unsigned ints (_9, _10, _11, _12) once
-          //  https://github.com/apache/datafusion-comet/issues/1067 is resolved
-          // checkSparkAnswerAndOperator(
-          //   "SELECT CAST(struct(_9, _10, _11, _12) as string) FROM tbl")
+          checkSparkAnswerAndOperator("SELECT CAST(struct(_9, _10, _11, _12) as string) FROM tbl")
           // decimals
           // TODO add _16 when https://github.com/apache/datafusion-comet/issues/1068 is resolved
           checkSparkAnswerAndOperator("SELECT CAST(struct(_15, _17) as string) FROM tbl")
diff --git a/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala b/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
index 5079f1910a..6a106fda72 100644
--- a/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
@@ -119,10 +119,7 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
         val path = new Path(dir.toURI.toString, "test.parquet")
         makeParquetFileAllTypes(path, dictionaryEnabled = dictionaryEnabled, 10000)
         withParquetTable(path.toString, "tbl") {
-          // TODO: enable test for unsigned ints
-          checkSparkAnswerAndOperator(
-            "select _1, _2, _3, _4, _5, _6, _7, _8, _13, _14, _15, _16, _17, " +
-              "_18, _19, _20 FROM tbl WHERE _2 > 100")
+          checkSparkAnswerAndOperator("select * FROM tbl WHERE _2 > 100")
         }
       }
     }
@@ -1115,7 +1112,7 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
         val path = new Path(dir.toURI.toString, "test.parquet")
         makeParquetFileAllTypes(path, dictionaryEnabled = dictionaryEnabled, 100)
         withParquetTable(path.toString, "tbl") {
-          Seq(2, 3, 4, 5, 6, 7, 15, 16, 17).foreach { col =>
+          Seq(2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 15, 16, 17).foreach { col =>
             checkSparkAnswerAndOperator(s"SELECT abs(_${col}) FROM tbl")
           }
         }
@@ -1239,9 +1236,8 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
         withParquetTable(path.toString, "tbl") {
           for (s <- Seq(-5, -1, 0, 1, 5, -1000, 1000, -323, -308, 308, -15, 15, -16, 16, null)) {
             // array tests
-            // TODO: enable test for unsigned ints (_9, _10, _11, _12)
             // TODO: enable test for floats (_6, _7, _8, _13)
-            for (c <- Seq(2, 3, 4, 5, 15, 16, 17)) {
+            for (c <- Seq(2, 3, 4, 5, 9, 10, 11, 12, 15, 16, 17)) {
               checkSparkAnswerAndOperator(s"select _${c}, round(_${c}, ${s}) FROM tbl")
             }
             // scalar tests
@@ -1452,9 +1448,8 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
         makeParquetFileAllTypes(path, dictionaryEnabled = dictionaryEnabled, 10000)
 
         withParquetTable(path.toString, "tbl") {
-          // _9 and _10 (uint8 and uint16) not supported
           checkSparkAnswerAndOperator(
-            "SELECT hex(_1), hex(_2), hex(_3), hex(_4), hex(_5), hex(_6), hex(_7), hex(_8), hex(_11), hex(_12), hex(_13), hex(_14), hex(_15), hex(_16), hex(_17), hex(_18), hex(_19), hex(_20) FROM tbl")
+            "SELECT hex(_1), hex(_2), hex(_3), hex(_4), hex(_5), hex(_6), hex(_7), hex(_8), hex(_9), hex(_10), hex(_11), hex(_12), hex(_13), hex(_14), hex(_15), hex(_16), hex(_17), hex(_18), hex(_19), hex(_20) FROM tbl")
         }
       }
     }
@@ -2334,7 +2329,6 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
         checkSparkAnswerAndOperator(
           spark.sql("SELECT array_append((CASE WHEN _2 =_3 THEN array(_4) END), _4) FROM t1"));
       }
-
     }
   }
 }
diff --git a/spark/src/test/scala/org/apache/comet/exec/CometColumnarShuffleSuite.scala b/spark/src/test/scala/org/apache/comet/exec/CometColumnarShuffleSuite.scala
index a2c2f66517..6130e4cd58 100644
--- a/spark/src/test/scala/org/apache/comet/exec/CometColumnarShuffleSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/exec/CometColumnarShuffleSuite.scala
@@ -750,6 +750,10 @@ abstract class CometColumnarShuffleSuite extends CometTestBase with AdaptiveSpar
           $"_6",
           $"_7",
           $"_8",
+          $"_9",
+          $"_10",
+          $"_11",
+          $"_12",
           $"_13",
           $"_14",
           $"_15",
diff --git a/spark/src/test/scala/org/apache/comet/parquet/ParquetReadSuite.scala b/spark/src/test/scala/org/apache/comet/parquet/ParquetReadSuite.scala
index 5ddf62c85f..d2e71b0b66 100644
--- a/spark/src/test/scala/org/apache/comet/parquet/ParquetReadSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/parquet/ParquetReadSuite.scala
@@ -434,8 +434,8 @@ abstract class ParquetReadSuite extends CometTestBase {
                   i.toFloat,
                   i.toDouble,
                   i.toString * 48,
-                  java.lang.Byte.toUnsignedInt((-i).toByte),
-                  java.lang.Short.toUnsignedInt((-i).toShort),
+                  (-i).toByte,
+                  (-i).toShort,
                   java.lang.Integer.toUnsignedLong(-i),
                   new BigDecimal(UnsignedLong.fromLongBits((-i).toLong).bigIntegerValue()),
                   i.toString,

From b64c13df9580b7342082167623e0aa03435c2de5 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Tue, 19 Nov 2024 17:41:31 -0700
Subject: [PATCH 11/47] chore: Include first ScanExec batch in metrics (#1105)

* include first batch in ScanExec metrics

* record row count metric

* fix regression
---
 native/core/src/execution/operators/scan.rs | 50 ++++++++++++++++-----
 1 file changed, 40 insertions(+), 10 deletions(-)

diff --git a/native/core/src/execution/operators/scan.rs b/native/core/src/execution/operators/scan.rs
index 7d75f7f1cd..b2546f839d 100644
--- a/native/core/src/execution/operators/scan.rs
+++ b/native/core/src/execution/operators/scan.rs
@@ -65,6 +65,8 @@ pub struct ScanExec {
     pub input_source_description: String,
     /// The data types of columns of the input batch. Converted from Spark schema.
     pub data_types: Vec<DataType>,
+    /// Schema of first batch
+    pub schema: SchemaRef,
     /// The input batch of input data. Used to determine the schema of the input data.
     /// It is also used in unit test to mock the input data from JVM.
     pub batch: Arc<Mutex<Option<InputBatch>>>,
@@ -72,6 +74,7 @@ pub struct ScanExec {
     cache: PlanProperties,
     /// Metrics collector
     metrics: ExecutionPlanMetricsSet,
+    baseline_metrics: BaselineMetrics,
 }
 
 impl ScanExec {
@@ -81,6 +84,9 @@ impl ScanExec {
         input_source_description: &str,
         data_types: Vec<DataType>,
     ) -> Result<Self, CometError> {
+        let metrics_set = ExecutionPlanMetricsSet::default();
+        let baseline_metrics = BaselineMetrics::new(&metrics_set, 0);
+
         // Scan's schema is determined by the input batch, so we need to set it before execution.
         // Note that we determine if arrays are dictionary-encoded based on the
         // first batch. The array may be dictionary-encoded in some batches and not others, and
@@ -88,7 +94,12 @@ impl ScanExec {
         // may end up either unpacking dictionary arrays or dictionary-encoding arrays.
         // Dictionary-encoded primitive arrays are always unpacked.
         let first_batch = if let Some(input_source) = input_source.as_ref() {
-            ScanExec::get_next(exec_context_id, input_source.as_obj(), data_types.len())?
+            let mut timer = baseline_metrics.elapsed_compute().timer();
+            let batch =
+                ScanExec::get_next(exec_context_id, input_source.as_obj(), data_types.len())?;
+            timer.stop();
+            baseline_metrics.record_output(batch.num_rows());
+            batch
         } else {
             InputBatch::EOF
         };
@@ -96,7 +107,7 @@ impl ScanExec {
         let schema = scan_schema(&first_batch, &data_types);
 
         let cache = PlanProperties::new(
-            EquivalenceProperties::new(schema),
+            EquivalenceProperties::new(Arc::clone(&schema)),
             // The partitioning is not important because we are not using DataFusion's
             // query planner or optimizer
             Partitioning::UnknownPartitioning(1),
@@ -110,7 +121,9 @@ impl ScanExec {
             data_types,
             batch: Arc::new(Mutex::new(Some(first_batch))),
             cache,
-            metrics: ExecutionPlanMetricsSet::default(),
+            metrics: metrics_set,
+            baseline_metrics,
+            schema,
         })
     }
 
@@ -276,11 +289,15 @@ impl ExecutionPlan for ScanExec {
     }
 
     fn schema(&self) -> SchemaRef {
-        // `unwrap` is safe because `schema` is only called during converting
-        // Spark plan to DataFusion plan. At the moment, `batch` is not EOF.
-        let binding = self.batch.try_lock().unwrap();
-        let input_batch = binding.as_ref().unwrap();
-        scan_schema(input_batch, &self.data_types)
+        if self.exec_context_id == TEST_EXEC_CONTEXT_ID {
+            // `unwrap` is safe because `schema` is only called during converting
+            // Spark plan to DataFusion plan. At the moment, `batch` is not EOF.
+            let binding = self.batch.try_lock().unwrap();
+            let input_batch = binding.as_ref().unwrap();
+            scan_schema(input_batch, &self.data_types)
+        } else {
+            Arc::clone(&self.schema)
+        }
     }
 
     fn children(&self) -> Vec<&Arc<dyn ExecutionPlan>> {
@@ -303,6 +320,7 @@ impl ExecutionPlan for ScanExec {
             self.clone(),
             self.schema(),
             partition,
+            self.baseline_metrics.clone(),
         )))
     }
 
@@ -352,8 +370,12 @@ struct ScanStream<'a> {
 }
 
 impl<'a> ScanStream<'a> {
-    pub fn new(scan: ScanExec, schema: SchemaRef, partition: usize) -> Self {
-        let baseline_metrics = BaselineMetrics::new(&scan.metrics, partition);
+    pub fn new(
+        scan: ScanExec,
+        schema: SchemaRef,
+        partition: usize,
+        baseline_metrics: BaselineMetrics,
+    ) -> Self {
         let cast_time = MetricBuilder::new(&scan.metrics).subset_time("cast_time", partition);
         Self {
             scan,
@@ -465,4 +487,12 @@ impl InputBatch {
 
         InputBatch::Batch(columns, num_rows)
     }
+
+    /// Get the number of rows in this batch
+    fn num_rows(&self) -> usize {
+        match self {
+            Self::EOF => 0,
+            Self::Batch(_, num_rows) => *num_rows,
+        }
+    }
 }

From 19dd58d41b8e63ab7cf05480165a78375745cb35 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Wed, 20 Nov 2024 14:45:37 -0700
Subject: [PATCH 12/47] chore: Improve CometScan metrics (#1100)

* Add native metrics for plan creation

* make messages consistent

* Include get_next_batch cost in metrics

* formatting

* fix double count of rows
---
 native/core/src/execution/jni_api.rs          | 22 ++++++++++++++++--
 native/core/src/execution/operators/scan.rs   | 23 ++++++++++---------
 .../org/apache/comet/CometExecIterator.scala  |  3 ++-
 .../main/scala/org/apache/comet/Native.scala  | 11 ++++++++-
 4 files changed, 44 insertions(+), 15 deletions(-)

diff --git a/native/core/src/execution/jni_api.rs b/native/core/src/execution/jni_api.rs
index 47d87fe1af..448f383c6b 100644
--- a/native/core/src/execution/jni_api.rs
+++ b/native/core/src/execution/jni_api.rs
@@ -37,6 +37,7 @@ use jni::{
     sys::{jbyteArray, jint, jlong, jlongArray},
     JNIEnv,
 };
+use std::time::{Duration, Instant};
 use std::{collections::HashMap, sync::Arc, task::Poll};
 
 use super::{serde, utils::SparkArrowConvert, CometMemoryPool};
@@ -81,6 +82,8 @@ struct ExecutionContext {
     pub runtime: Runtime,
     /// Native metrics
     pub metrics: Arc<GlobalRef>,
+    /// The time it took to create the native plan and configure the context
+    pub plan_creation_time: Duration,
     /// DataFusion SessionContext
     pub session_ctx: Arc<SessionContext>,
     /// Whether to enable additional debugging checks & messages
@@ -109,6 +112,8 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
         // Init JVM classes
         JVMClasses::init(&mut env);
 
+        let start = Instant::now();
+
         let array = unsafe { JPrimitiveArray::from_raw(serialized_query) };
         let bytes = env.convert_byte_array(array)?;
 
@@ -167,6 +172,8 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
         // dictionaries will be dropped as well.
         let session = prepare_datafusion_session_context(&configs, task_memory_manager)?;
 
+        let plan_creation_time = start.elapsed();
+
         let exec_context = Box::new(ExecutionContext {
             id,
             spark_plan,
@@ -177,6 +184,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
             conf: configs,
             runtime,
             metrics,
+            plan_creation_time,
             session_ctx: Arc::new(session),
             debug_native,
             explain_native,
@@ -321,6 +329,8 @@ fn pull_input_batches(exec_context: &mut ExecutionContext) -> Result<(), CometEr
 pub unsafe extern "system" fn Java_org_apache_comet_Native_executePlan(
     e: JNIEnv,
     _class: JClass,
+    stage_id: jint,
+    partition: jint,
     exec_context: jlong,
     array_addrs: jlongArray,
     schema_addrs: jlongArray,
@@ -335,20 +345,23 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_executePlan(
         // Because we don't know if input arrays are dictionary-encoded when we create
         // query plan, we need to defer stream initialization to first time execution.
         if exec_context.root_op.is_none() {
+            let start = Instant::now();
             let planner = PhysicalPlanner::new(Arc::clone(&exec_context.session_ctx))
                 .with_exec_id(exec_context_id);
             let (scans, root_op) = planner.create_plan(
                 &exec_context.spark_plan,
                 &mut exec_context.input_sources.clone(),
             )?;
+            let physical_plan_time = start.elapsed();
 
+            exec_context.plan_creation_time += physical_plan_time;
             exec_context.root_op = Some(Arc::clone(&root_op));
             exec_context.scans = scans;
 
             if exec_context.explain_native {
                 let formatted_plan_str =
                     DisplayableExecutionPlan::new(root_op.as_ref()).indent(true);
-                info!("Comet native query plan:\n {formatted_plan_str:}");
+                info!("Comet native query plan:\n{formatted_plan_str:}");
             }
 
             let task_ctx = exec_context.session_ctx.task_ctx();
@@ -388,7 +401,12 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_executePlan(
                         if let Some(plan) = &exec_context.root_op {
                             let formatted_plan_str =
                                 DisplayableExecutionPlan::with_metrics(plan.as_ref()).indent(true);
-                            info!("Comet native query plan with metrics:\n{formatted_plan_str:}");
+                            info!(
+                                "Comet native query plan with metrics:\
+                            \n[Stage {} Partition {}] plan creation (including CometScans fetching first batches) took {:?}:\
+                            \n{formatted_plan_str:}",
+                                stage_id, partition, exec_context.plan_creation_time
+                            );
                         }
                     }
 
diff --git a/native/core/src/execution/operators/scan.rs b/native/core/src/execution/operators/scan.rs
index b2546f839d..a9bd954e99 100644
--- a/native/core/src/execution/operators/scan.rs
+++ b/native/core/src/execution/operators/scan.rs
@@ -15,16 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use futures::Stream;
-use itertools::Itertools;
-use std::rc::Rc;
-use std::{
-    any::Any,
-    pin::Pin,
-    sync::{Arc, Mutex},
-    task::{Context, Poll},
-};
-
 use crate::{
     errors::CometError,
     execution::{
@@ -48,9 +38,18 @@ use datafusion::{
     physical_plan::{ExecutionPlan, *},
 };
 use datafusion_common::{arrow_datafusion_err, DataFusionError, Result as DataFusionResult};
+use futures::Stream;
+use itertools::Itertools;
 use jni::objects::JValueGen;
 use jni::objects::{GlobalRef, JObject};
 use jni::sys::jsize;
+use std::rc::Rc;
+use std::{
+    any::Any,
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::{Context, Poll},
+};
 
 /// ScanExec reads batches of data from Spark via JNI. The source of the scan could be a file
 /// scan or the result of reading a broadcast or shuffle exchange.
@@ -98,7 +97,6 @@ impl ScanExec {
             let batch =
                 ScanExec::get_next(exec_context_id, input_source.as_obj(), data_types.len())?;
             timer.stop();
-            baseline_metrics.record_output(batch.num_rows());
             batch
         } else {
             InputBatch::EOF
@@ -162,6 +160,7 @@ impl ScanExec {
             // This is a unit test. We don't need to call JNI.
             return Ok(());
         }
+        let mut timer = self.baseline_metrics.elapsed_compute().timer();
 
         let mut current_batch = self.batch.try_lock().unwrap();
         if current_batch.is_none() {
@@ -173,6 +172,8 @@ impl ScanExec {
             *current_batch = Some(next_batch);
         }
 
+        timer.stop();
+
         Ok(())
     }
 
diff --git a/spark/src/main/scala/org/apache/comet/CometExecIterator.scala b/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
index b1f22726a6..8a349bd37e 100644
--- a/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
+++ b/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
@@ -95,7 +95,8 @@ class CometExecIterator(
     nativeUtil.getNextBatch(
       numOutputCols,
       (arrayAddrs, schemaAddrs) => {
-        nativeLib.executePlan(plan, arrayAddrs, schemaAddrs)
+        val ctx = TaskContext.get()
+        nativeLib.executePlan(ctx.stageId(), ctx.partitionId(), plan, arrayAddrs, schemaAddrs)
       })
   }
 
diff --git a/spark/src/main/scala/org/apache/comet/Native.scala b/spark/src/main/scala/org/apache/comet/Native.scala
index 03a9dea0c6..52063419df 100644
--- a/spark/src/main/scala/org/apache/comet/Native.scala
+++ b/spark/src/main/scala/org/apache/comet/Native.scala
@@ -56,6 +56,10 @@ class Native extends NativeBase {
   /**
    * Execute a native query plan based on given input Arrow arrays.
    *
+   * @param stage
+   *   the stage ID, for informational purposes
+   * @param partition
+   *   the partition ID, for informational purposes
    * @param plan
    *   the address to native query plan.
    * @param arrayAddrs
@@ -65,7 +69,12 @@ class Native extends NativeBase {
    * @return
    *   the number of rows, if -1, it means end of the output.
    */
-  @native def executePlan(plan: Long, arrayAddrs: Array[Long], schemaAddrs: Array[Long]): Long
+  @native def executePlan(
+      stage: Int,
+      partition: Int,
+      plan: Long,
+      arrayAddrs: Array[Long],
+      schemaAddrs: Array[Long]): Long
 
   /**
    * Release and drop the native query plan object and context object.

From e602305473f48591422de1767d3d5eeac4fb9fbd Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 21 Nov 2024 15:47:58 -0700
Subject: [PATCH 13/47] chore: Add custom metric for native shuffle fetching
 batches from JVM (#1108)

---
 docs/source/user-guide/tuning.md              | 18 +++++++++----
 .../execution/datafusion/shuffle_writer.rs    | 26 ++++++++++++++-----
 native/core/src/execution/operators/scan.rs   |  5 +++-
 .../shuffle/CometShuffleExchangeExec.scala    | 12 ++++++++-
 4 files changed, 48 insertions(+), 13 deletions(-)

diff --git a/docs/source/user-guide/tuning.md b/docs/source/user-guide/tuning.md
index b1838ca801..e0d7c1bc93 100644
--- a/docs/source/user-guide/tuning.md
+++ b/docs/source/user-guide/tuning.md
@@ -23,7 +23,7 @@ Comet provides some tuning options to help you get the best performance from you
 
 ## Memory Tuning
 
-Comet shares an off-heap memory pool between Spark and Comet. This requires setting `spark.memory.offHeap.enabled=true`. 
+Comet shares an off-heap memory pool between Spark and Comet. This requires setting `spark.memory.offHeap.enabled=true`.
 If this setting is not enabled, Comet will not accelerate queries and will fall back to Spark.
 
 Each executor will have a single memory pool which will be shared by all native plans being executed within that
@@ -105,8 +105,16 @@ then any shuffle operations that cannot be supported in this mode will fall back
 
 ## Metrics
 
-Comet metrics are not directly comparable to Spark metrics in some cases.
+Some Comet metrics are not directly comparable to Spark metrics in some cases:
 
-`CometScanExec` uses nanoseconds for total scan time. Spark also measures scan time in nanoseconds but converts to
-milliseconds _per batch_ which can result in a large loss of precision. In one case we saw total scan time
-of 41 seconds reported as 23 seconds for example.
+- `CometScanExec` uses nanoseconds for total scan time. Spark also measures scan time in nanoseconds but converts to
+  milliseconds _per batch_ which can result in a large loss of precision, making it difficult to compare scan times
+  between Spark and Comet.
+
+Comet also adds some custom metrics:
+
+### ShuffleWriterExec
+
+| Metric           | Description                                                                                                                                                                       |
+| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `jvm_fetch_time` | Measure the time it takes for `ShuffleWriterExec` to fetch batches from the JVM. Note that this does not include the execution time of the query that produced the input batches. |
diff --git a/native/core/src/execution/datafusion/shuffle_writer.rs b/native/core/src/execution/datafusion/shuffle_writer.rs
index 7587ff06dc..c79eeeb4a0 100644
--- a/native/core/src/execution/datafusion/shuffle_writer.rs
+++ b/native/core/src/execution/datafusion/shuffle_writer.rs
@@ -139,6 +139,7 @@ impl ExecutionPlan for ShuffleWriterExec {
     ) -> Result<SendableRecordBatchStream> {
         let input = self.input.execute(partition, Arc::clone(&context))?;
         let metrics = ShuffleRepartitionerMetrics::new(&self.metrics, 0);
+        let jvm_fetch_time = MetricBuilder::new(&self.metrics).subset_time("jvm_fetch_time", 0);
 
         Ok(Box::pin(RecordBatchStreamAdapter::new(
             self.schema(),
@@ -151,6 +152,7 @@ impl ExecutionPlan for ShuffleWriterExec {
                     self.partitioning.clone(),
                     metrics,
                     context,
+                    jvm_fetch_time,
                 )
                 .map_err(|e| ArrowError::ExternalError(Box::new(e))),
             )
@@ -1083,6 +1085,7 @@ impl Debug for ShuffleRepartitioner {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 async fn external_shuffle(
     mut input: SendableRecordBatchStream,
     partition_id: usize,
@@ -1091,6 +1094,7 @@ async fn external_shuffle(
     partitioning: Partitioning,
     metrics: ShuffleRepartitionerMetrics,
     context: Arc<TaskContext>,
+    jvm_fetch_time: Time,
 ) -> Result<SendableRecordBatchStream> {
     let schema = input.schema();
     let mut repartitioner = ShuffleRepartitioner::new(
@@ -1104,13 +1108,23 @@ async fn external_shuffle(
         context.session_config().batch_size(),
     );
 
-    while let Some(batch) = input.next().await {
-        // Block on the repartitioner to insert the batch and shuffle the rows
-        // into the corresponding partition buffer.
-        // Otherwise, pull the next batch from the input stream might overwrite the
-        // current batch in the repartitioner.
-        block_on(repartitioner.insert_batch(batch?))?;
+    loop {
+        let mut timer = jvm_fetch_time.timer();
+        let b = input.next().await;
+        timer.stop();
+
+        match b {
+            Some(batch_result) => {
+                // Block on the repartitioner to insert the batch and shuffle the rows
+                // into the corresponding partition buffer.
+                // Otherwise, pull the next batch from the input stream might overwrite the
+                // current batch in the repartitioner.
+                block_on(repartitioner.insert_batch(batch_result?))?;
+            }
+            _ => break,
+        }
     }
+
     repartitioner.shuffle_write().await
 }
 
diff --git a/native/core/src/execution/operators/scan.rs b/native/core/src/execution/operators/scan.rs
index a9bd954e99..2cb8a84d94 100644
--- a/native/core/src/execution/operators/scan.rs
+++ b/native/core/src/execution/operators/scan.rs
@@ -52,7 +52,9 @@ use std::{
 };
 
 /// ScanExec reads batches of data from Spark via JNI. The source of the scan could be a file
-/// scan or the result of reading a broadcast or shuffle exchange.
+/// scan or the result of reading a broadcast or shuffle exchange. ScanExec isn't invoked
+/// until the data is already available in the JVM. When CometExecIterator invokes
+/// Native.executePlan, it passes in the memory addresses of the input batches.
 #[derive(Debug, Clone)]
 pub struct ScanExec {
     /// The ID of the execution context that owns this subquery. We use this ID to retrieve the JVM
@@ -73,6 +75,7 @@ pub struct ScanExec {
     cache: PlanProperties,
     /// Metrics collector
     metrics: ExecutionPlanMetricsSet,
+    /// Baseline metrics
     baseline_metrics: BaselineMetrics,
 }
 
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
index 6430a7899f..4c3f994f9e 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
@@ -77,6 +77,9 @@ case class CometShuffleExchangeExec(
     SQLShuffleReadMetricsReporter.createShuffleReadMetrics(sparkContext)
   override lazy val metrics: Map[String, SQLMetric] = Map(
     "dataSize" -> SQLMetrics.createSizeMetric(sparkContext, "data size"),
+    "jvm_fetch_time" -> SQLMetrics.createNanoTimingMetric(
+      sparkContext,
+      "time fetching batches from JVM"),
     "numPartitions" -> SQLMetrics.createMetric(
       sparkContext,
       "number of partitions")) ++ readMetrics ++ writeMetrics
@@ -480,7 +483,14 @@ class CometShuffleWriteProcessor(
       "output_rows" -> metrics(SQLShuffleWriteMetricsReporter.SHUFFLE_RECORDS_WRITTEN),
       "data_size" -> metrics("dataSize"),
       "elapsed_compute" -> metrics(SQLShuffleWriteMetricsReporter.SHUFFLE_WRITE_TIME))
-    val nativeMetrics = CometMetricNode(nativeSQLMetrics)
+
+    val nativeMetrics = if (metrics.contains("jvm_fetch_time")) {
+      CometMetricNode(
+        nativeSQLMetrics ++ Map("jvm_fetch_time" ->
+          metrics("jvm_fetch_time")))
+    } else {
+      CometMetricNode(nativeSQLMetrics)
+    }
 
     // Getting rid of the fake partitionId
     val newInputs = inputs.asInstanceOf[Iterator[_ <: Product2[Any, Any]]].map(_._2)

From 9990b349a63006d28111b2fa52ad56b115855b34 Mon Sep 17 00:00:00 2001
From: Sem <ssinchenko@apache.org>
Date: Fri, 22 Nov 2024 14:25:01 +0100
Subject: [PATCH 14/47] feat: support array_insert (#1073)

* Part of the implementation of array_insert

* Missing methods

* Working version

* Reformat code

* Fix code-style

* Add comments about spark's implementation.

* Implement negative indices

+ fix tests for spark < 3.4

* Fix code-style

* Fix scalastyle

* Fix tests for spark < 3.4

* Fixes & tests

- added test for the negative index
- added test for the legacy spark mode

* Use assume(isSpark34Plus) in tests

* Test else-branch & improve coverage

* Update native/spark-expr/src/list.rs

Co-authored-by: Andy Grove <agrove@apache.org>

* Fix fallback test

In one case there is a zero in index and test fails due to spark error

* Adjust the behaviour for the NULL case to Spark

* Move the logic of type checking to the method

* Fix code-style

---------

Co-authored-by: Andy Grove <agrove@apache.org>
---
 .../core/src/execution/datafusion/planner.rs  |  20 +-
 native/proto/src/proto/expr.proto             |   9 +
 native/spark-expr/src/lib.rs                  |   2 +-
 native/spark-expr/src/list.rs                 | 424 +++++++++++++++++-
 .../apache/comet/serde/QueryPlanSerde.scala   |  29 ++
 .../apache/comet/CometExpressionSuite.scala   |  65 ++-
 6 files changed, 537 insertions(+), 12 deletions(-)

diff --git a/native/core/src/execution/datafusion/planner.rs b/native/core/src/execution/datafusion/planner.rs
index d80e22f1bf..73541b0a4e 100644
--- a/native/core/src/execution/datafusion/planner.rs
+++ b/native/core/src/execution/datafusion/planner.rs
@@ -98,8 +98,8 @@ use datafusion_comet_proto::{
     spark_partitioning::{partitioning::PartitioningStruct, Partitioning as SparkPartitioning},
 };
 use datafusion_comet_spark_expr::{
-    Cast, CreateNamedStruct, DateTruncExpr, GetArrayStructFields, GetStructField, HourExpr, IfExpr,
-    ListExtract, MinuteExpr, RLike, SecondExpr, TimestampTruncExpr, ToJson,
+    ArrayInsert, Cast, CreateNamedStruct, DateTruncExpr, GetArrayStructFields, GetStructField,
+    HourExpr, IfExpr, ListExtract, MinuteExpr, RLike, SecondExpr, TimestampTruncExpr, ToJson,
 };
 use datafusion_common::scalar::ScalarStructBuilder;
 use datafusion_common::{
@@ -720,6 +720,22 @@ impl PhysicalPlanner {
                 )?;
                 Ok(Arc::new(case_expr))
             }
+            ExprStruct::ArrayInsert(expr) => {
+                let src_array_expr = self.create_expr(
+                    expr.src_array_expr.as_ref().unwrap(),
+                    Arc::clone(&input_schema),
+                )?;
+                let pos_expr =
+                    self.create_expr(expr.pos_expr.as_ref().unwrap(), Arc::clone(&input_schema))?;
+                let item_expr =
+                    self.create_expr(expr.item_expr.as_ref().unwrap(), Arc::clone(&input_schema))?;
+                Ok(Arc::new(ArrayInsert::new(
+                    src_array_expr,
+                    pos_expr,
+                    item_expr,
+                    expr.legacy_negative_index,
+                )))
+            }
             expr => Err(ExecutionError::GeneralError(format!(
                 "Not implemented: {:?}",
                 expr
diff --git a/native/proto/src/proto/expr.proto b/native/proto/src/proto/expr.proto
index 220f5e521f..7a8ea78d57 100644
--- a/native/proto/src/proto/expr.proto
+++ b/native/proto/src/proto/expr.proto
@@ -83,6 +83,7 @@ message Expr {
     ListExtract list_extract = 56;
     GetArrayStructFields get_array_struct_fields = 57;
     BinaryExpr array_append = 58;
+    ArrayInsert array_insert = 59;
   }
 }
 
@@ -403,6 +404,14 @@ enum NullOrdering {
   NullsLast = 1;
 }
 
+// Array functions
+message ArrayInsert {
+  Expr src_array_expr = 1;
+  Expr pos_expr = 2;
+  Expr item_expr = 3;
+  bool legacy_negative_index = 4;
+}
+
 message DataType {
   enum DataTypeId {
     BOOL = 0;
diff --git a/native/spark-expr/src/lib.rs b/native/spark-expr/src/lib.rs
index 614b48f2b8..3ec2e886b5 100644
--- a/native/spark-expr/src/lib.rs
+++ b/native/spark-expr/src/lib.rs
@@ -37,7 +37,7 @@ pub mod utils;
 pub use cast::{spark_cast, Cast};
 pub use error::{SparkError, SparkResult};
 pub use if_expr::IfExpr;
-pub use list::{GetArrayStructFields, ListExtract};
+pub use list::{ArrayInsert, GetArrayStructFields, ListExtract};
 pub use regexp::RLike;
 pub use structs::{CreateNamedStruct, GetStructField};
 pub use temporal::{DateTruncExpr, HourExpr, MinuteExpr, SecondExpr, TimestampTruncExpr};
diff --git a/native/spark-expr/src/list.rs b/native/spark-expr/src/list.rs
index a376198db7..7dc17b5688 100644
--- a/native/spark-expr/src/list.rs
+++ b/native/spark-expr/src/list.rs
@@ -15,9 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::{array::MutableArrayData, datatypes::ArrowNativeType, record_batch::RecordBatch};
-use arrow_array::{Array, GenericListArray, Int32Array, OffsetSizeTrait, StructArray};
-use arrow_schema::{DataType, FieldRef, Schema};
+use arrow::{
+    array::{as_primitive_array, Capacities, MutableArrayData},
+    buffer::{NullBuffer, OffsetBuffer},
+    datatypes::ArrowNativeType,
+    record_batch::RecordBatch,
+};
+use arrow_array::{
+    make_array, Array, ArrayRef, GenericListArray, Int32Array, OffsetSizeTrait, StructArray,
+};
+use arrow_schema::{DataType, Field, FieldRef, Schema};
 use datafusion::logical_expr::ColumnarValue;
 use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{
@@ -27,10 +34,16 @@ use datafusion_common::{
 use datafusion_physical_expr::PhysicalExpr;
 use std::{
     any::Any,
-    fmt::{Display, Formatter},
+    fmt::{Debug, Display, Formatter},
     hash::{Hash, Hasher},
     sync::Arc,
 };
+
+// 2147483632 == java.lang.Integer.MAX_VALUE - 15
+// It is a value of ByteArrayUtils.MAX_ROUNDED_ARRAY_LENGTH
+// https://github.com/apache/spark/blob/master/common/utils/src/main/java/org/apache/spark/unsafe/array/ByteArrayUtils.java
+const MAX_ROUNDED_ARRAY_LENGTH: usize = 2147483632;
+
 #[derive(Debug, Hash)]
 pub struct ListExtract {
     child: Arc<dyn PhysicalExpr>,
@@ -413,14 +426,297 @@ impl PartialEq<dyn Any> for GetArrayStructFields {
     }
 }
 
+#[derive(Debug, Hash)]
+pub struct ArrayInsert {
+    src_array_expr: Arc<dyn PhysicalExpr>,
+    pos_expr: Arc<dyn PhysicalExpr>,
+    item_expr: Arc<dyn PhysicalExpr>,
+    legacy_negative_index: bool,
+}
+
+impl ArrayInsert {
+    pub fn new(
+        src_array_expr: Arc<dyn PhysicalExpr>,
+        pos_expr: Arc<dyn PhysicalExpr>,
+        item_expr: Arc<dyn PhysicalExpr>,
+        legacy_negative_index: bool,
+    ) -> Self {
+        Self {
+            src_array_expr,
+            pos_expr,
+            item_expr,
+            legacy_negative_index,
+        }
+    }
+
+    pub fn array_type(&self, data_type: &DataType) -> DataFusionResult<DataType> {
+        match data_type {
+            DataType::List(field) => Ok(DataType::List(Arc::clone(field))),
+            DataType::LargeList(field) => Ok(DataType::LargeList(Arc::clone(field))),
+            data_type => Err(DataFusionError::Internal(format!(
+                "Unexpected src array type in ArrayInsert: {:?}",
+                data_type
+            ))),
+        }
+    }
+}
+
+impl PhysicalExpr for ArrayInsert {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn data_type(&self, input_schema: &Schema) -> DataFusionResult<DataType> {
+        self.array_type(&self.src_array_expr.data_type(input_schema)?)
+    }
+
+    fn nullable(&self, input_schema: &Schema) -> DataFusionResult<bool> {
+        self.src_array_expr.nullable(input_schema)
+    }
+
+    fn evaluate(&self, batch: &RecordBatch) -> DataFusionResult<ColumnarValue> {
+        let pos_value = self
+            .pos_expr
+            .evaluate(batch)?
+            .into_array(batch.num_rows())?;
+
+        // Spark supports only IntegerType (Int32):
+        // https://github.com/apache/spark/blob/branch-3.5/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/collectionOperations.scala#L4737
+        if !matches!(pos_value.data_type(), DataType::Int32) {
+            return Err(DataFusionError::Internal(format!(
+                "Unexpected index data type in ArrayInsert: {:?}, expected type is Int32",
+                pos_value.data_type()
+            )));
+        }
+
+        // Check that src array is actually an array and get it's value type
+        let src_value = self
+            .src_array_expr
+            .evaluate(batch)?
+            .into_array(batch.num_rows())?;
+
+        let src_element_type = match self.array_type(src_value.data_type())? {
+            DataType::List(field) => &field.data_type().clone(),
+            DataType::LargeList(field) => &field.data_type().clone(),
+            _ => unreachable!(),
+        };
+
+        // Check that inserted value has the same type as an array
+        let item_value = self
+            .item_expr
+            .evaluate(batch)?
+            .into_array(batch.num_rows())?;
+        if item_value.data_type() != src_element_type {
+            return Err(DataFusionError::Internal(format!(
+                "Type mismatch in ArrayInsert: array type is {:?} but item type is {:?}",
+                src_element_type,
+                item_value.data_type()
+            )));
+        }
+
+        match src_value.data_type() {
+            DataType::List(_) => {
+                let list_array = as_list_array(&src_value)?;
+                array_insert(
+                    list_array,
+                    &item_value,
+                    &pos_value,
+                    self.legacy_negative_index,
+                )
+            }
+            DataType::LargeList(_) => {
+                let list_array = as_large_list_array(&src_value)?;
+                array_insert(
+                    list_array,
+                    &item_value,
+                    &pos_value,
+                    self.legacy_negative_index,
+                )
+            }
+            _ => unreachable!(), // This case is checked already
+        }
+    }
+
+    fn children(&self) -> Vec<&Arc<dyn PhysicalExpr>> {
+        vec![&self.src_array_expr, &self.pos_expr, &self.item_expr]
+    }
+
+    fn with_new_children(
+        self: Arc<Self>,
+        children: Vec<Arc<dyn PhysicalExpr>>,
+    ) -> DataFusionResult<Arc<dyn PhysicalExpr>> {
+        match children.len() {
+            3 => Ok(Arc::new(ArrayInsert::new(
+                Arc::clone(&children[0]),
+                Arc::clone(&children[1]),
+                Arc::clone(&children[2]),
+                self.legacy_negative_index,
+            ))),
+            _ => internal_err!("ArrayInsert should have exactly three childrens"),
+        }
+    }
+
+    fn dyn_hash(&self, _state: &mut dyn Hasher) {
+        let mut s = _state;
+        self.src_array_expr.hash(&mut s);
+        self.pos_expr.hash(&mut s);
+        self.item_expr.hash(&mut s);
+        self.legacy_negative_index.hash(&mut s);
+        self.hash(&mut s);
+    }
+}
+
+fn array_insert<O: OffsetSizeTrait>(
+    list_array: &GenericListArray<O>,
+    items_array: &ArrayRef,
+    pos_array: &ArrayRef,
+    legacy_mode: bool,
+) -> DataFusionResult<ColumnarValue> {
+    // The code is based on the implementation of the array_append from the Apache DataFusion
+    // https://github.com/apache/datafusion/blob/main/datafusion/functions-nested/src/concat.rs#L513
+    //
+    // This code is also based on the implementation of the array_insert from the Apache Spark
+    // https://github.com/apache/spark/blob/branch-3.5/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/collectionOperations.scala#L4713
+
+    let values = list_array.values();
+    let offsets = list_array.offsets();
+    let values_data = values.to_data();
+    let item_data = items_array.to_data();
+    let new_capacity = Capacities::Array(values_data.len() + item_data.len());
+
+    let mut mutable_values =
+        MutableArrayData::with_capacities(vec![&values_data, &item_data], true, new_capacity);
+
+    let mut new_offsets = vec![O::usize_as(0)];
+    let mut new_nulls = Vec::<bool>::with_capacity(list_array.len());
+
+    let pos_data: &Int32Array = as_primitive_array(&pos_array); // Spark supports only i32 for positions
+
+    for (row_index, offset_window) in offsets.windows(2).enumerate() {
+        let pos = pos_data.values()[row_index];
+        let start = offset_window[0].as_usize();
+        let end = offset_window[1].as_usize();
+        let is_item_null = items_array.is_null(row_index);
+
+        if list_array.is_null(row_index) {
+            // In Spark if value of the array is NULL than nothing happens
+            mutable_values.extend_nulls(1);
+            new_offsets.push(new_offsets[row_index] + O::one());
+            new_nulls.push(false);
+            continue;
+        }
+
+        if pos == 0 {
+            return Err(DataFusionError::Internal(
+                "Position for array_insert should be greter or less than zero".to_string(),
+            ));
+        }
+
+        if (pos > 0) || ((-pos).as_usize() < (end - start + 1)) {
+            let corrected_pos = if pos > 0 {
+                (pos - 1).as_usize()
+            } else {
+                end - start - (-pos).as_usize() + if legacy_mode { 0 } else { 1 }
+            };
+            let new_array_len = std::cmp::max(end - start + 1, corrected_pos);
+            if new_array_len > MAX_ROUNDED_ARRAY_LENGTH {
+                return Err(DataFusionError::Internal(format!(
+                    "Max array length in Spark is {:?}, but got {:?}",
+                    MAX_ROUNDED_ARRAY_LENGTH, new_array_len
+                )));
+            }
+
+            if (start + corrected_pos) <= end {
+                mutable_values.extend(0, start, start + corrected_pos);
+                mutable_values.extend(1, row_index, row_index + 1);
+                mutable_values.extend(0, start + corrected_pos, end);
+                new_offsets.push(new_offsets[row_index] + O::usize_as(new_array_len));
+            } else {
+                mutable_values.extend(0, start, end);
+                mutable_values.extend_nulls(new_array_len - (end - start));
+                mutable_values.extend(1, row_index, row_index + 1);
+                // In that case spark actualy makes array longer than expected;
+                // For example, if pos is equal to 5, len is eq to 3, than resulted len will be 5
+                new_offsets.push(new_offsets[row_index] + O::usize_as(new_array_len) + O::one());
+            }
+        } else {
+            // This comment is takes from the Apache Spark source code as is:
+            // special case- if the new position is negative but larger than the current array size
+            // place the new item at start of array, place the current array contents at the end
+            // and fill the newly created array elements inbetween with a null
+            let base_offset = if legacy_mode { 1 } else { 0 };
+            let new_array_len = (-pos + base_offset).as_usize();
+            if new_array_len > MAX_ROUNDED_ARRAY_LENGTH {
+                return Err(DataFusionError::Internal(format!(
+                    "Max array length in Spark is {:?}, but got {:?}",
+                    MAX_ROUNDED_ARRAY_LENGTH, new_array_len
+                )));
+            }
+            mutable_values.extend(1, row_index, row_index + 1);
+            mutable_values.extend_nulls(new_array_len - (end - start + 1));
+            mutable_values.extend(0, start, end);
+            new_offsets.push(new_offsets[row_index] + O::usize_as(new_array_len));
+        }
+        if is_item_null {
+            if (start == end) || (values.is_null(row_index)) {
+                new_nulls.push(false)
+            } else {
+                new_nulls.push(true)
+            }
+        } else {
+            new_nulls.push(true)
+        }
+    }
+
+    let data = make_array(mutable_values.freeze());
+    let data_type = match list_array.data_type() {
+        DataType::List(field) => field.data_type(),
+        DataType::LargeList(field) => field.data_type(),
+        _ => unreachable!(),
+    };
+    let new_array = GenericListArray::<O>::try_new(
+        Arc::new(Field::new("item", data_type.clone(), true)),
+        OffsetBuffer::new(new_offsets.into()),
+        data,
+        Some(NullBuffer::new(new_nulls.into())),
+    )?;
+
+    Ok(ColumnarValue::Array(Arc::new(new_array)))
+}
+
+impl Display for ArrayInsert {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "ArrayInsert [array: {:?}, pos: {:?}, item: {:?}]",
+            self.src_array_expr, self.pos_expr, self.item_expr
+        )
+    }
+}
+
+impl PartialEq<dyn Any> for ArrayInsert {
+    fn eq(&self, other: &dyn Any) -> bool {
+        down_cast_any_ref(other)
+            .downcast_ref::<Self>()
+            .map(|x| {
+                self.src_array_expr.eq(&x.src_array_expr)
+                    && self.pos_expr.eq(&x.pos_expr)
+                    && self.item_expr.eq(&x.item_expr)
+                    && self.legacy_negative_index.eq(&x.legacy_negative_index)
+            })
+            .unwrap_or(false)
+    }
+}
+
 #[cfg(test)]
 mod test {
-    use crate::list::{list_extract, zero_based_index};
+    use crate::list::{array_insert, list_extract, zero_based_index};
 
     use arrow::datatypes::Int32Type;
-    use arrow_array::{Array, Int32Array, ListArray};
+    use arrow_array::{Array, ArrayRef, Int32Array, ListArray};
     use datafusion_common::{Result, ScalarValue};
     use datafusion_expr::ColumnarValue;
+    use std::sync::Arc;
 
     #[test]
     fn test_list_extract_default_value() -> Result<()> {
@@ -458,4 +754,120 @@ mod test {
         );
         Ok(())
     }
+
+    #[test]
+    fn test_array_insert() -> Result<()> {
+        // Test inserting an item into a list array
+        // Inputs and expected values are taken from the Spark results
+        let list = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
+            Some(vec![Some(1), Some(2), Some(3)]),
+            Some(vec![Some(4), Some(5)]),
+            Some(vec![None]),
+            Some(vec![Some(1), Some(2), Some(3)]),
+            Some(vec![Some(1), Some(2), Some(3)]),
+            None,
+        ]);
+
+        let positions = Int32Array::from(vec![2, 1, 1, 5, 6, 1]);
+        let items = Int32Array::from(vec![
+            Some(10),
+            Some(20),
+            Some(30),
+            Some(100),
+            Some(100),
+            Some(40),
+        ]);
+
+        let ColumnarValue::Array(result) = array_insert(
+            &list,
+            &(Arc::new(items) as ArrayRef),
+            &(Arc::new(positions) as ArrayRef),
+            false,
+        )?
+        else {
+            unreachable!()
+        };
+
+        let expected = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
+            Some(vec![Some(1), Some(10), Some(2), Some(3)]),
+            Some(vec![Some(20), Some(4), Some(5)]),
+            Some(vec![Some(30), None]),
+            Some(vec![Some(1), Some(2), Some(3), None, Some(100)]),
+            Some(vec![Some(1), Some(2), Some(3), None, None, Some(100)]),
+            None,
+        ]);
+
+        assert_eq!(&result.to_data(), &expected.to_data());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_array_insert_negative_index() -> Result<()> {
+        // Test insert with negative index
+        // Inputs and expected values are taken from the Spark results
+        let list = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
+            Some(vec![Some(1), Some(2), Some(3)]),
+            Some(vec![Some(4), Some(5)]),
+            Some(vec![Some(1)]),
+            None,
+        ]);
+
+        let positions = Int32Array::from(vec![-2, -1, -3, -1]);
+        let items = Int32Array::from(vec![Some(10), Some(20), Some(100), Some(30)]);
+
+        let ColumnarValue::Array(result) = array_insert(
+            &list,
+            &(Arc::new(items) as ArrayRef),
+            &(Arc::new(positions) as ArrayRef),
+            false,
+        )?
+        else {
+            unreachable!()
+        };
+
+        let expected = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
+            Some(vec![Some(1), Some(2), Some(10), Some(3)]),
+            Some(vec![Some(4), Some(5), Some(20)]),
+            Some(vec![Some(100), None, Some(1)]),
+            None,
+        ]);
+
+        assert_eq!(&result.to_data(), &expected.to_data());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_array_insert_legacy_mode() -> Result<()> {
+        // Test the so-called "legacy" mode exisiting in the Spark
+        let list = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
+            Some(vec![Some(1), Some(2), Some(3)]),
+            Some(vec![Some(4), Some(5)]),
+            None,
+        ]);
+
+        let positions = Int32Array::from(vec![-1, -1, -1]);
+        let items = Int32Array::from(vec![Some(10), Some(20), Some(30)]);
+
+        let ColumnarValue::Array(result) = array_insert(
+            &list,
+            &(Arc::new(items) as ArrayRef),
+            &(Arc::new(positions) as ArrayRef),
+            true,
+        )?
+        else {
+            unreachable!()
+        };
+
+        let expected = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
+            Some(vec![Some(1), Some(2), Some(10), Some(3)]),
+            Some(vec![Some(4), Some(20), Some(5)]),
+            None,
+        ]);
+
+        assert_eq!(&result.to_data(), &expected.to_data());
+
+        Ok(())
+    }
 }
diff --git a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
index 4a130ad0db..f7d5fc91a0 100644
--- a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
+++ b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
@@ -2192,6 +2192,35 @@ object QueryPlanSerde extends Logging with ShimQueryPlanSerde with CometExprShim
             None
           }
 
+        case expr if expr.prettyName == "array_insert" =>
+          val srcExprProto = exprToProto(expr.children(0), inputs, binding)
+          val posExprProto = exprToProto(expr.children(1), inputs, binding)
+          val itemExprProto = exprToProto(expr.children(2), inputs, binding)
+          val legacyNegativeIndex =
+            SQLConf.get.getConfString("spark.sql.legacy.negativeIndexInArrayInsert").toBoolean
+          if (srcExprProto.isDefined && posExprProto.isDefined && itemExprProto.isDefined) {
+            val arrayInsertBuilder = ExprOuterClass.ArrayInsert
+              .newBuilder()
+              .setSrcArrayExpr(srcExprProto.get)
+              .setPosExpr(posExprProto.get)
+              .setItemExpr(itemExprProto.get)
+              .setLegacyNegativeIndex(legacyNegativeIndex)
+
+            Some(
+              ExprOuterClass.Expr
+                .newBuilder()
+                .setArrayInsert(arrayInsertBuilder)
+                .build())
+          } else {
+            withInfo(
+              expr,
+              "unsupported arguments for ArrayInsert",
+              expr.children(0),
+              expr.children(1),
+              expr.children(2))
+            None
+          }
+
         case ElementAt(child, ordinal, defaultValue, failOnError)
             if child.dataType.isInstanceOf[ArrayType] =>
           val childExpr = exprToProto(child, inputs, binding)
diff --git a/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala b/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
index 6a106fda72..35f374bf0f 100644
--- a/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
@@ -36,7 +36,7 @@ import org.apache.spark.sql.internal.SQLConf
 import org.apache.spark.sql.internal.SQLConf.SESSION_LOCAL_TIMEZONE
 import org.apache.spark.sql.types.{Decimal, DecimalType}
 
-import org.apache.comet.CometSparkSessionExtensions.{isSpark33Plus, isSpark34Plus, isSpark40Plus}
+import org.apache.comet.CometSparkSessionExtensions.{isSpark33Plus, isSpark34Plus, isSpark35Plus, isSpark40Plus}
 
 class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
   import testImplicits._
@@ -2310,8 +2310,7 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
   }
 
   test("array_append") {
-    // array append has been added in Spark 3.4 and in Spark 4.0 it gets written to ArrayInsert
-    assume(isSpark34Plus && !isSpark40Plus)
+    assume(isSpark34Plus)
     Seq(true, false).foreach { dictionaryEnabled =>
       withTempDir { dir =>
         val path = new Path(dir.toURI.toString, "test.parquet")
@@ -2331,4 +2330,64 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
       }
     }
   }
+
+  test("array_prepend") {
+    assume(isSpark35Plus) // in Spark 3.5 array_prepend is implemented via array_insert
+    Seq(true, false).foreach { dictionaryEnabled =>
+      withTempDir { dir =>
+        val path = new Path(dir.toURI.toString, "test.parquet")
+        makeParquetFileAllTypes(path, dictionaryEnabled = dictionaryEnabled, 10000)
+        spark.read.parquet(path.toString).createOrReplaceTempView("t1");
+        checkSparkAnswerAndOperator(spark.sql("Select array_prepend(array(_1),false) from t1"))
+        checkSparkAnswerAndOperator(
+          spark.sql("SELECT array_prepend(array(_2, _3, _4), 4) FROM t1"))
+        checkSparkAnswerAndOperator(
+          spark.sql("SELECT array_prepend(array(_2, _3, _4), null) FROM t1"));
+        checkSparkAnswerAndOperator(
+          spark.sql("SELECT array_prepend(array(_6, _7), CAST(6.5 AS DOUBLE)) FROM t1"));
+        checkSparkAnswerAndOperator(spark.sql("SELECT array_prepend(array(_8), 'test') FROM t1"));
+        checkSparkAnswerAndOperator(spark.sql("SELECT array_prepend(array(_19), _19) FROM t1"));
+        checkSparkAnswerAndOperator(
+          spark.sql("SELECT array_prepend((CASE WHEN _2 =_3 THEN array(_4) END), _4) FROM t1"));
+      }
+    }
+  }
+
+  test("ArrayInsert") {
+    assume(isSpark34Plus)
+    Seq(true, false).foreach(dictionaryEnabled =>
+      withTempDir { dir =>
+        val path = new Path(dir.toURI.toString, "test.parquet")
+        makeParquetFileAllTypes(path, dictionaryEnabled, 10000)
+        val df = spark.read
+          .parquet(path.toString)
+          .withColumn("arr", array(col("_4"), lit(null), col("_4")))
+          .withColumn("arrInsertResult", expr("array_insert(arr, 1, 1)"))
+          .withColumn("arrInsertNegativeIndexResult", expr("array_insert(arr, -1, 1)"))
+          .withColumn("arrPosGreaterThanSize", expr("array_insert(arr, 8, 1)"))
+          .withColumn("arrNegPosGreaterThanSize", expr("array_insert(arr, -8, 1)"))
+          .withColumn("arrInsertNone", expr("array_insert(arr, 1, null)"))
+        checkSparkAnswerAndOperator(df.select("arrInsertResult"))
+        checkSparkAnswerAndOperator(df.select("arrInsertNegativeIndexResult"))
+        checkSparkAnswerAndOperator(df.select("arrPosGreaterThanSize"))
+        checkSparkAnswerAndOperator(df.select("arrNegPosGreaterThanSize"))
+        checkSparkAnswerAndOperator(df.select("arrInsertNone"))
+      })
+  }
+
+  test("ArrayInsertUnsupportedArgs") {
+    // This test checks that the else branch in ArrayInsert
+    // mapping to the comet is valid and fallback to spark is working fine.
+    assume(isSpark34Plus)
+    withTempDir { dir =>
+      val path = new Path(dir.toURI.toString, "test.parquet")
+      makeParquetFileAllTypes(path, dictionaryEnabled = false, 10000)
+      val df = spark.read
+        .parquet(path.toString)
+        .withColumn("arr", array(col("_4"), lit(null), col("_4")))
+        .withColumn("idx", udf((_: Int) => 1).apply(col("_4")))
+        .withColumn("arrUnsupportedArgs", expr("array_insert(arr, idx, 1)"))
+      checkSparkAnswer(df.select("arrUnsupportedArgs"))
+    }
+  }
 }

From 500895dfa3319e2da276218068d27372f26ea931 Mon Sep 17 00:00:00 2001
From: Himadri Pal <mehimu@gmail.com>
Date: Fri, 22 Nov 2024 05:52:45 -0800
Subject: [PATCH 15/47] feat: enable decimal to decimal cast of different
 precision and scale (#1086)

* enable decimal to decimal cast of different precision and scale

* add more test cases for negative scale and higher precision

* add check for compatibility for decimal to decimal

* fix code style

* Update spark/src/main/scala/org/apache/comet/expressions/CometCast.scala

Co-authored-by: Andy Grove <agrove@apache.org>

* fix the nit in comment

---------

Co-authored-by: himadripal <hpal@apple.com>
Co-authored-by: Andy Grove <agrove@apache.org>
---
 .../apache/comet/expressions/CometCast.scala  | 10 +++++--
 .../org/apache/comet/CometCastSuite.scala     | 28 +++++++++++++++++++
 .../org/apache/spark/sql/CometTestBase.scala  |  6 ++--
 3 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/spark/src/main/scala/org/apache/comet/expressions/CometCast.scala b/spark/src/main/scala/org/apache/comet/expressions/CometCast.scala
index 11d6d049f7..859cb13bea 100644
--- a/spark/src/main/scala/org/apache/comet/expressions/CometCast.scala
+++ b/spark/src/main/scala/org/apache/comet/expressions/CometCast.scala
@@ -70,9 +70,13 @@ object CometCast {
           case _ =>
             Unsupported
         }
-      case (_: DecimalType, _: DecimalType) =>
-        // https://github.com/apache/datafusion-comet/issues/375
-        Incompatible()
+      case (from: DecimalType, to: DecimalType) =>
+        if (to.precision < from.precision) {
+          // https://github.com/apache/datafusion/issues/13492
+          Incompatible(Some("Casting to smaller precision is not supported"))
+        } else {
+          Compatible()
+        }
       case (DataTypes.StringType, _) =>
         canCastFromString(toType, timeZoneId, evalMode)
       case (_, DataTypes.StringType) =>
diff --git a/spark/src/test/scala/org/apache/comet/CometCastSuite.scala b/spark/src/test/scala/org/apache/comet/CometCastSuite.scala
index 01583077df..f8c1a8b095 100644
--- a/spark/src/test/scala/org/apache/comet/CometCastSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/CometCastSuite.scala
@@ -892,6 +892,34 @@ class CometCastSuite extends CometTestBase with AdaptiveSparkPlanHelper {
     }
   }
 
+  test("cast between decimals with different precision and scale") {
+    // cast between default Decimal(38, 18) to Decimal(6,2)
+    val values = Seq(BigDecimal("12345.6789"), BigDecimal("9876.5432"), BigDecimal("123.4567"))
+    val df = withNulls(values)
+      .toDF("b")
+      .withColumn("a", col("b").cast(DecimalType(6, 2)))
+    checkSparkAnswer(df)
+  }
+
+  test("cast between decimals with higher precision than source") {
+    // cast between Decimal(10, 2) to Decimal(10,4)
+    castTest(generateDecimalsPrecision10Scale2(), DataTypes.createDecimalType(10, 4))
+  }
+
+  test("cast between decimals with negative precision") {
+    // cast to negative scale
+    checkSparkMaybeThrows(
+      spark.sql("select a, cast(a as DECIMAL(10,-4)) from t order by a")) match {
+      case (expected, actual) =>
+        assert(expected.contains("PARSE_SYNTAX_ERROR") === actual.contains("PARSE_SYNTAX_ERROR"))
+    }
+  }
+
+  test("cast between decimals with zero precision") {
+    // cast between Decimal(10, 2) to Decimal(10,0)
+    castTest(generateDecimalsPrecision10Scale2(), DataTypes.createDecimalType(10, 0))
+  }
+
   private def generateFloats(): DataFrame = {
     withNulls(gen.generateFloats(dataSize)).toDF("a")
   }
diff --git a/spark/src/test/scala/org/apache/spark/sql/CometTestBase.scala b/spark/src/test/scala/org/apache/spark/sql/CometTestBase.scala
index 1709cce61c..213ec7efee 100644
--- a/spark/src/test/scala/org/apache/spark/sql/CometTestBase.scala
+++ b/spark/src/test/scala/org/apache/spark/sql/CometTestBase.scala
@@ -231,11 +231,9 @@ abstract class CometTestBase
       df: => DataFrame): (Option[Throwable], Option[Throwable]) = {
     var expected: Option[Throwable] = None
     withSQLConf(CometConf.COMET_ENABLED.key -> "false") {
-      val dfSpark = Dataset.ofRows(spark, df.logicalPlan)
-      expected = Try(dfSpark.collect()).failed.toOption
+      expected = Try(Dataset.ofRows(spark, df.logicalPlan).collect()).failed.toOption
     }
-    val dfComet = Dataset.ofRows(spark, df.logicalPlan)
-    val actual = Try(dfComet.collect()).failed.toOption
+    val actual = Try(Dataset.ofRows(spark, df.logicalPlan).collect()).failed.toOption
     (expected, actual)
   }
 

From 7b1a2904d083dd5b0c9f13fa2aed1aaaf4bd0051 Mon Sep 17 00:00:00 2001
From: gstvg <28798827+gstvg@users.noreply.github.com>
Date: Sat, 23 Nov 2024 23:41:49 -0300
Subject: [PATCH 16/47] docs: fix readme FGPA/FPGA typo (#1117)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index caad63924f..1f77aa3767 100644
--- a/README.md
+++ b/README.md
@@ -80,7 +80,7 @@ Results for our benchmark derived from TPC-DS are available in the [benchmarking
 ## Use Commodity Hardware
 
 Comet leverages commodity hardware, eliminating the need for costly hardware upgrades or
-specialized hardware accelerators, such as GPUs or FGPA. By maximizing the utilization of commodity hardware, Comet 
+specialized hardware accelerators, such as GPUs or FPGA. By maximizing the utilization of commodity hardware, Comet 
 ensures cost-effectiveness and scalability for your Spark deployments.
 
 ## Spark Compatibility

From 5400fd7c372d2f97ba607457f7d1098e36e2a6e8 Mon Sep 17 00:00:00 2001
From: Liang-Chi Hsieh <viirya@gmail.com>
Date: Sun, 24 Nov 2024 23:13:25 -0800
Subject: [PATCH 17/47] fix: Use RDD partition index (#1112)

* fix: Use RDD partition index

* fix

* fix

* fix
---
 .../org/apache/comet/CometExecIterator.scala  | 12 +++++--
 .../spark/sql/comet/CometExecUtils.scala      |  5 +--
 .../CometTakeOrderedAndProjectExec.scala      |  7 ++--
 .../spark/sql/comet/ZippedPartitionsRDD.scala | 11 ++++--
 .../shuffle/CometShuffleExchangeExec.scala    | 10 ++++--
 .../apache/spark/sql/comet/operators.scala    | 36 +++++++++++++++----
 .../org/apache/comet/CometNativeSuite.scala   |  4 ++-
 7 files changed, 64 insertions(+), 21 deletions(-)

diff --git a/spark/src/main/scala/org/apache/comet/CometExecIterator.scala b/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
index 8a349bd37e..bff3e79256 100644
--- a/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
+++ b/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
@@ -39,13 +39,19 @@ import org.apache.comet.vector.NativeUtil
  *   The input iterators producing sequence of batches of Arrow Arrays.
  * @param protobufQueryPlan
  *   The serialized bytes of Spark execution plan.
+ * @param numParts
+ *   The number of partitions.
+ * @param partitionIndex
+ *   The index of the partition.
  */
 class CometExecIterator(
     val id: Long,
     inputs: Seq[Iterator[ColumnarBatch]],
     numOutputCols: Int,
     protobufQueryPlan: Array[Byte],
-    nativeMetrics: CometMetricNode)
+    nativeMetrics: CometMetricNode,
+    numParts: Int,
+    partitionIndex: Int)
     extends Iterator[ColumnarBatch] {
 
   private val nativeLib = new Native()
@@ -92,11 +98,13 @@ class CometExecIterator(
   }
 
   def getNextBatch(): Option[ColumnarBatch] = {
+    assert(partitionIndex >= 0 && partitionIndex < numParts)
+
     nativeUtil.getNextBatch(
       numOutputCols,
       (arrayAddrs, schemaAddrs) => {
         val ctx = TaskContext.get()
-        nativeLib.executePlan(ctx.stageId(), ctx.partitionId(), plan, arrayAddrs, schemaAddrs)
+        nativeLib.executePlan(ctx.stageId(), partitionIndex, plan, arrayAddrs, schemaAddrs)
       })
   }
 
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/CometExecUtils.scala b/spark/src/main/scala/org/apache/spark/sql/comet/CometExecUtils.scala
index 8cc03856c2..9698dc98b8 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/CometExecUtils.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/CometExecUtils.scala
@@ -51,9 +51,10 @@ object CometExecUtils {
       childPlan: RDD[ColumnarBatch],
       outputAttribute: Seq[Attribute],
       limit: Int): RDD[ColumnarBatch] = {
-    childPlan.mapPartitionsInternal { iter =>
+    val numParts = childPlan.getNumPartitions
+    childPlan.mapPartitionsWithIndexInternal { case (idx, iter) =>
       val limitOp = CometExecUtils.getLimitNativePlan(outputAttribute, limit).get
-      CometExec.getCometIterator(Seq(iter), outputAttribute.length, limitOp)
+      CometExec.getCometIterator(Seq(iter), outputAttribute.length, limitOp, numParts, idx)
     }
   }
 
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/CometTakeOrderedAndProjectExec.scala b/spark/src/main/scala/org/apache/spark/sql/comet/CometTakeOrderedAndProjectExec.scala
index 6220c809da..5582f4d687 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/CometTakeOrderedAndProjectExec.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/CometTakeOrderedAndProjectExec.scala
@@ -77,12 +77,13 @@ case class CometTakeOrderedAndProjectExec(
         val localTopK = if (orderingSatisfies) {
           CometExecUtils.getNativeLimitRDD(childRDD, child.output, limit)
         } else {
-          childRDD.mapPartitionsInternal { iter =>
+          val numParts = childRDD.getNumPartitions
+          childRDD.mapPartitionsWithIndexInternal { case (idx, iter) =>
             val topK =
               CometExecUtils
                 .getTopKNativePlan(child.output, sortOrder, child, limit)
                 .get
-            CometExec.getCometIterator(Seq(iter), child.output.length, topK)
+            CometExec.getCometIterator(Seq(iter), child.output.length, topK, numParts, idx)
           }
         }
 
@@ -102,7 +103,7 @@ case class CometTakeOrderedAndProjectExec(
         val topKAndProjection = CometExecUtils
           .getProjectionNativePlan(projectList, child.output, sortOrder, child, limit)
           .get
-        val it = CometExec.getCometIterator(Seq(iter), output.length, topKAndProjection)
+        val it = CometExec.getCometIterator(Seq(iter), output.length, topKAndProjection, 1, 0)
         setSubqueries(it.id, this)
 
         Option(TaskContext.get()).foreach { context =>
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/ZippedPartitionsRDD.scala b/spark/src/main/scala/org/apache/spark/sql/comet/ZippedPartitionsRDD.scala
index 6db8c67d58..fdf8bf393d 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/ZippedPartitionsRDD.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/ZippedPartitionsRDD.scala
@@ -31,16 +31,20 @@ import org.apache.spark.sql.vectorized.ColumnarBatch
  */
 private[spark] class ZippedPartitionsRDD(
     sc: SparkContext,
-    var f: (Seq[Iterator[ColumnarBatch]]) => Iterator[ColumnarBatch],
+    var f: (Seq[Iterator[ColumnarBatch]], Int, Int) => Iterator[ColumnarBatch],
     var zipRdds: Seq[RDD[ColumnarBatch]],
     preservesPartitioning: Boolean = false)
     extends ZippedPartitionsBaseRDD[ColumnarBatch](sc, zipRdds, preservesPartitioning) {
 
+  // We need to get the number of partitions in `compute` but `getNumPartitions` is not available
+  // on the executors. So we need to capture it here.
+  private val numParts: Int = this.getNumPartitions
+
   override def compute(s: Partition, context: TaskContext): Iterator[ColumnarBatch] = {
     val partitions = s.asInstanceOf[ZippedPartitionsPartition].partitions
     val iterators =
       zipRdds.zipWithIndex.map(pair => pair._1.iterator(partitions(pair._2), context))
-    f(iterators)
+    f(iterators, numParts, s.index)
   }
 
   override def clearDependencies(): Unit = {
@@ -52,7 +56,8 @@ private[spark] class ZippedPartitionsRDD(
 
 object ZippedPartitionsRDD {
   def apply(sc: SparkContext, rdds: Seq[RDD[ColumnarBatch]])(
-      f: (Seq[Iterator[ColumnarBatch]]) => Iterator[ColumnarBatch]): RDD[ColumnarBatch] =
+      f: (Seq[Iterator[ColumnarBatch]], Int, Int) => Iterator[ColumnarBatch])
+      : RDD[ColumnarBatch] =
     withScope(sc) {
       new ZippedPartitionsRDD(sc, f, rdds)
     }
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
index 4c3f994f9e..a7a33c40d6 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
@@ -227,13 +227,14 @@ object CometShuffleExchangeExec extends ShimCometShuffleExchangeExec {
       outputPartitioning: Partitioning,
       serializer: Serializer,
       metrics: Map[String, SQLMetric]): ShuffleDependency[Int, ColumnarBatch, ColumnarBatch] = {
+    val numParts = rdd.getNumPartitions
     val dependency = new CometShuffleDependency[Int, ColumnarBatch, ColumnarBatch](
       rdd.map(
         (0, _)
       ), // adding fake partitionId that is always 0 because ShuffleDependency requires it
       serializer = serializer,
       shuffleWriterProcessor =
-        new CometShuffleWriteProcessor(outputPartitioning, outputAttributes, metrics),
+        new CometShuffleWriteProcessor(outputPartitioning, outputAttributes, metrics, numParts),
       shuffleType = CometNativeShuffle,
       partitioner = new Partitioner {
         override def numPartitions: Int = outputPartitioning.numPartitions
@@ -449,7 +450,8 @@ object CometShuffleExchangeExec extends ShimCometShuffleExchangeExec {
 class CometShuffleWriteProcessor(
     outputPartitioning: Partitioning,
     outputAttributes: Seq[Attribute],
-    metrics: Map[String, SQLMetric])
+    metrics: Map[String, SQLMetric],
+    numParts: Int)
     extends ShimCometShuffleWriteProcessor {
 
   private val OFFSET_LENGTH = 8
@@ -499,7 +501,9 @@ class CometShuffleWriteProcessor(
       Seq(newInputs.asInstanceOf[Iterator[ColumnarBatch]]),
       outputAttributes.length,
       nativePlan,
-      nativeMetrics)
+      nativeMetrics,
+      numParts,
+      context.partitionId())
 
     while (cometIter.hasNext) {
       cometIter.next()
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala b/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala
index dd1526d82c..77188312e4 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala
@@ -120,20 +120,37 @@ object CometExec {
   def getCometIterator(
       inputs: Seq[Iterator[ColumnarBatch]],
       numOutputCols: Int,
-      nativePlan: Operator): CometExecIterator = {
-    getCometIterator(inputs, numOutputCols, nativePlan, CometMetricNode(Map.empty))
+      nativePlan: Operator,
+      numParts: Int,
+      partitionIdx: Int): CometExecIterator = {
+    getCometIterator(
+      inputs,
+      numOutputCols,
+      nativePlan,
+      CometMetricNode(Map.empty),
+      numParts,
+      partitionIdx)
   }
 
   def getCometIterator(
       inputs: Seq[Iterator[ColumnarBatch]],
       numOutputCols: Int,
       nativePlan: Operator,
-      nativeMetrics: CometMetricNode): CometExecIterator = {
+      nativeMetrics: CometMetricNode,
+      numParts: Int,
+      partitionIdx: Int): CometExecIterator = {
     val outputStream = new ByteArrayOutputStream()
     nativePlan.writeTo(outputStream)
     outputStream.close()
     val bytes = outputStream.toByteArray
-    new CometExecIterator(newIterId, inputs, numOutputCols, bytes, nativeMetrics)
+    new CometExecIterator(
+      newIterId,
+      inputs,
+      numOutputCols,
+      bytes,
+      nativeMetrics,
+      numParts,
+      partitionIdx)
   }
 
   /**
@@ -214,13 +231,18 @@ abstract class CometNativeExec extends CometExec {
         // TODO: support native metrics for all operators.
         val nativeMetrics = CometMetricNode.fromCometPlan(this)
 
-        def createCometExecIter(inputs: Seq[Iterator[ColumnarBatch]]): CometExecIterator = {
+        def createCometExecIter(
+            inputs: Seq[Iterator[ColumnarBatch]],
+            numParts: Int,
+            partitionIndex: Int): CometExecIterator = {
           val it = new CometExecIterator(
             CometExec.newIterId,
             inputs,
             output.length,
             serializedPlanCopy,
-            nativeMetrics)
+            nativeMetrics,
+            numParts,
+            partitionIndex)
 
           setSubqueries(it.id, this)
 
@@ -295,7 +317,7 @@ abstract class CometNativeExec extends CometExec {
           throw new CometRuntimeException(s"No input for CometNativeExec:\n $this")
         }
 
-        ZippedPartitionsRDD(sparkContext, inputs.toSeq)(createCometExecIter(_))
+        ZippedPartitionsRDD(sparkContext, inputs.toSeq)(createCometExecIter)
     }
   }
 
diff --git a/spark/src/test/scala/org/apache/comet/CometNativeSuite.scala b/spark/src/test/scala/org/apache/comet/CometNativeSuite.scala
index ef0485dfe6..6ca38e8319 100644
--- a/spark/src/test/scala/org/apache/comet/CometNativeSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/CometNativeSuite.scala
@@ -37,7 +37,9 @@ class CometNativeSuite extends CometTestBase {
           override def next(): ColumnarBatch = throw new NullPointerException()
         }),
         1,
-        limitOp)
+        limitOp,
+        1,
+        0)
       cometIter.next()
       cometIter.close()
       value

From ebdde77f58086c49a6bd6fe296a04e03884cf01c Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Mon, 2 Dec 2024 11:26:50 -0700
Subject: [PATCH 18/47] fix: Various metrics bug fixes and improvements (#1111)

---
 native/core/src/execution/datafusion/mod.rs   |   1 +
 .../core/src/execution/datafusion/planner.rs  | 295 ++++++++++++++----
 .../src/execution/datafusion/spark_plan.rs    | 102 ++++++
 native/core/src/execution/jni_api.rs          |  17 +-
 native/core/src/execution/metrics/utils.rs    |  31 +-
 native/proto/src/proto/operator.proto         |   3 +
 .../apache/comet/serde/QueryPlanSerde.scala   |   2 +-
 7 files changed, 372 insertions(+), 79 deletions(-)
 create mode 100644 native/core/src/execution/datafusion/spark_plan.rs

diff --git a/native/core/src/execution/datafusion/mod.rs b/native/core/src/execution/datafusion/mod.rs
index 6f81ee9181..ca41fa0aa0 100644
--- a/native/core/src/execution/datafusion/mod.rs
+++ b/native/core/src/execution/datafusion/mod.rs
@@ -21,4 +21,5 @@ pub mod expressions;
 mod operators;
 pub mod planner;
 pub mod shuffle_writer;
+pub(crate) mod spark_plan;
 mod util;
diff --git a/native/core/src/execution/datafusion/planner.rs b/native/core/src/execution/datafusion/planner.rs
index 73541b0a4e..aa6b3e91cf 100644
--- a/native/core/src/execution/datafusion/planner.rs
+++ b/native/core/src/execution/datafusion/planner.rs
@@ -85,6 +85,7 @@ use datafusion::{
 use datafusion_functions_nested::concat::ArrayAppend;
 use datafusion_physical_expr::aggregate::{AggregateExprBuilder, AggregateFunctionExpr};
 
+use crate::execution::datafusion::spark_plan::SparkPlan;
 use datafusion_comet_proto::{
     spark_expression::{
         self, agg_expr::ExprStruct as AggExprStruct, expr::ExprStruct, literal::Value, AggExpr,
@@ -127,8 +128,8 @@ type PhyExprResult = Result<Vec<(Arc<dyn PhysicalExpr>, String)>, ExecutionError
 type PartitionPhyExprResult = Result<Vec<Arc<dyn PhysicalExpr>>, ExecutionError>;
 
 struct JoinParameters {
-    pub left: Arc<dyn ExecutionPlan>,
-    pub right: Arc<dyn ExecutionPlan>,
+    pub left: Arc<SparkPlan>,
+    pub right: Arc<SparkPlan>,
     pub join_on: Vec<(Arc<dyn PhysicalExpr>, Arc<dyn PhysicalExpr>)>,
     pub join_filter: Option<JoinFilter>,
     pub join_type: DFJoinType,
@@ -847,7 +848,13 @@ impl PhysicalPlanner {
         }
     }
 
-    /// Create a DataFusion physical plan from Spark physical plan.
+    /// Create a DataFusion physical plan from Spark physical plan. There is a level of
+    /// abstraction where a tree of SparkPlan nodes is returned. There is a 1:1 mapping from a
+    /// protobuf Operator (that represents a Spark operator) to a native SparkPlan struct. We
+    /// need this 1:1 mapping so that we can report metrics back to Spark. The native execution
+    /// plan that is generated for each Operator is sometimes a single ExecutionPlan, but in some
+    /// cases we generate a tree of ExecutionPlans and we need to collect metrics for all of these
+    /// plans so we store references to them in the SparkPlan struct.
     ///
     /// `inputs` is a vector of input source IDs. It is used to create `ScanExec`s. Each `ScanExec`
     /// will be assigned a unique ID from `inputs` and the ID will be used to identify the input
@@ -861,11 +868,11 @@ impl PhysicalPlanner {
     ///
     /// Note that we return created `Scan`s which will be kept at JNI API. JNI calls will use it to
     /// feed in new input batch from Spark JVM side.
-    pub fn create_plan<'a>(
+    pub(crate) fn create_plan<'a>(
         &'a self,
         spark_plan: &'a Operator,
         inputs: &mut Vec<Arc<GlobalRef>>,
-    ) -> Result<(Vec<ScanExec>, Arc<dyn ExecutionPlan>), ExecutionError> {
+    ) -> Result<(Vec<ScanExec>, Arc<SparkPlan>), ExecutionError> {
         let children = &spark_plan.children;
         match spark_plan.op_struct.as_ref().unwrap() {
             OpStruct::Projection(project) => {
@@ -880,7 +887,14 @@ impl PhysicalPlanner {
                             .map(|r| (r, format!("col_{}", idx)))
                     })
                     .collect();
-                Ok((scans, Arc::new(ProjectionExec::try_new(exprs?, child)?)))
+                let projection = Arc::new(ProjectionExec::try_new(
+                    exprs?,
+                    Arc::clone(&child.native_plan),
+                )?);
+                Ok((
+                    scans,
+                    Arc::new(SparkPlan::new(spark_plan.plan_id, projection, vec![child])),
+                ))
             }
             OpStruct::Filter(filter) => {
                 assert!(children.len() == 1);
@@ -888,7 +902,14 @@ impl PhysicalPlanner {
                 let predicate =
                     self.create_expr(filter.predicate.as_ref().unwrap(), child.schema())?;
 
-                Ok((scans, Arc::new(FilterExec::try_new(predicate, child)?)))
+                let filter = Arc::new(FilterExec::try_new(
+                    predicate,
+                    Arc::clone(&child.native_plan),
+                )?);
+                Ok((
+                    scans,
+                    Arc::new(SparkPlan::new(spark_plan.plan_id, filter, vec![child])),
+                ))
             }
             OpStruct::HashAgg(agg) => {
                 assert!(children.len() == 1);
@@ -920,13 +941,13 @@ impl PhysicalPlanner {
 
                 let num_agg = agg.agg_exprs.len();
                 let aggr_expr = agg_exprs?.into_iter().map(Arc::new).collect();
-                let aggregate = Arc::new(
+                let aggregate: Arc<dyn ExecutionPlan> = Arc::new(
                     datafusion::physical_plan::aggregates::AggregateExec::try_new(
                         mode,
                         group_by,
                         aggr_expr,
                         vec![None; num_agg], // no filter expressions
-                        Arc::clone(&child),
+                        Arc::clone(&child.native_plan),
                         Arc::clone(&schema),
                     )?,
                 );
@@ -940,8 +961,11 @@ impl PhysicalPlanner {
                     })
                     .collect();
 
-                let exec: Arc<dyn ExecutionPlan> = if agg.result_exprs.is_empty() {
-                    aggregate
+                if agg.result_exprs.is_empty() {
+                    Ok((
+                        scans,
+                        Arc::new(SparkPlan::new(spark_plan.plan_id, aggregate, vec![child])),
+                    ))
                 } else {
                     // For final aggregation, DF's hash aggregate exec doesn't support Spark's
                     // aggregate result expressions like `COUNT(col) + 1`, but instead relying
@@ -950,17 +974,34 @@ impl PhysicalPlanner {
                     //
                     // Note that `result_exprs` should only be set for final aggregation on the
                     // Spark side.
-                    Arc::new(ProjectionExec::try_new(result_exprs?, aggregate)?)
-                };
-
-                Ok((scans, exec))
+                    let projection = Arc::new(ProjectionExec::try_new(
+                        result_exprs?,
+                        Arc::clone(&aggregate),
+                    )?);
+                    Ok((
+                        scans,
+                        Arc::new(SparkPlan::new_with_additional(
+                            spark_plan.plan_id,
+                            projection,
+                            vec![child],
+                            vec![aggregate],
+                        )),
+                    ))
+                }
             }
             OpStruct::Limit(limit) => {
                 assert!(children.len() == 1);
                 let num = limit.limit;
                 let (scans, child) = self.create_plan(&children[0], inputs)?;
 
-                Ok((scans, Arc::new(LocalLimitExec::new(child, num as usize))))
+                let limit = Arc::new(LocalLimitExec::new(
+                    Arc::clone(&child.native_plan),
+                    num as usize,
+                ));
+                Ok((
+                    scans,
+                    Arc::new(SparkPlan::new(spark_plan.plan_id, limit, vec![child])),
+                ))
             }
             OpStruct::Sort(sort) => {
                 assert!(children.len() == 1);
@@ -978,11 +1019,20 @@ impl PhysicalPlanner {
                 // SortExec fails in some cases if we do not unpack dictionary-encoded arrays, and
                 // it would be more efficient if we could avoid that.
                 // https://github.com/apache/datafusion-comet/issues/963
-                let child = Self::wrap_in_copy_exec(child);
+                let child_copied = Self::wrap_in_copy_exec(Arc::clone(&child.native_plan));
+
+                let sort = Arc::new(
+                    SortExec::new(LexOrdering::new(exprs?), Arc::clone(&child_copied))
+                        .with_fetch(fetch),
+                );
 
                 Ok((
                     scans,
-                    Arc::new(SortExec::new(LexOrdering::new(exprs?), child).with_fetch(fetch)),
+                    Arc::new(SparkPlan::new(
+                        spark_plan.plan_id,
+                        sort,
+                        vec![Arc::clone(&child)],
+                    )),
                 ))
             }
             OpStruct::Scan(scan) => {
@@ -1008,7 +1058,10 @@ impl PhysicalPlanner {
                 // The `ScanExec` operator will take actual arrays from Spark during execution
                 let scan =
                     ScanExec::new(self.exec_context_id, input_source, &scan.source, data_types)?;
-                Ok((vec![scan.clone()], Arc::new(scan)))
+                Ok((
+                    vec![scan.clone()],
+                    Arc::new(SparkPlan::new(spark_plan.plan_id, Arc::new(scan), vec![])),
+                ))
             }
             OpStruct::ShuffleWriter(writer) => {
                 assert!(children.len() == 1);
@@ -1017,14 +1070,20 @@ impl PhysicalPlanner {
                 let partitioning = self
                     .create_partitioning(writer.partitioning.as_ref().unwrap(), child.schema())?;
 
+                let shuffle_writer = Arc::new(ShuffleWriterExec::try_new(
+                    Arc::clone(&child.native_plan),
+                    partitioning,
+                    writer.output_data_file.clone(),
+                    writer.output_index_file.clone(),
+                )?);
+
                 Ok((
                     scans,
-                    Arc::new(ShuffleWriterExec::try_new(
-                        child,
-                        partitioning,
-                        writer.output_data_file.clone(),
-                        writer.output_index_file.clone(),
-                    )?),
+                    Arc::new(SparkPlan::new(
+                        spark_plan.plan_id,
+                        shuffle_writer,
+                        vec![Arc::clone(&child)],
+                    )),
                 ))
             }
             OpStruct::Expand(expand) => {
@@ -1068,15 +1127,18 @@ impl PhysicalPlanner {
                 // the data corruption. Note that we only need to copy the input batch
                 // if the child operator is `ScanExec`, because other operators after `ScanExec`
                 // will create new arrays for the output batch.
-                let child = if can_reuse_input_batch(&child) {
-                    Arc::new(CopyExec::new(child, CopyMode::UnpackOrDeepCopy))
+                let input = if can_reuse_input_batch(&child.native_plan) {
+                    Arc::new(CopyExec::new(
+                        Arc::clone(&child.native_plan),
+                        CopyMode::UnpackOrDeepCopy,
+                    ))
                 } else {
-                    child
+                    Arc::clone(&child.native_plan)
                 };
-
+                let expand = Arc::new(CometExpandExec::new(projections, input, schema));
                 Ok((
                     scans,
-                    Arc::new(CometExpandExec::new(projections, child, schema)),
+                    Arc::new(SparkPlan::new(spark_plan.plan_id, expand, vec![child])),
                 ))
             }
             OpStruct::SortMergeJoin(join) => {
@@ -1104,8 +1166,8 @@ impl PhysicalPlanner {
                     .collect();
 
                 let join = Arc::new(SortMergeJoinExec::try_new(
-                    join_params.left,
-                    join_params.right,
+                    Arc::clone(&join_params.left.native_plan),
+                    Arc::clone(&join_params.right.native_plan),
                     join_params.join_on,
                     join_params.join_filter,
                     join_params.join_type,
@@ -1115,7 +1177,17 @@ impl PhysicalPlanner {
                     false,
                 )?);
 
-                Ok((scans, join))
+                Ok((
+                    scans,
+                    Arc::new(SparkPlan::new(
+                        spark_plan.plan_id,
+                        join,
+                        vec![
+                            Arc::clone(&join_params.left),
+                            Arc::clone(&join_params.right),
+                        ],
+                    )),
+                ))
             }
             OpStruct::HashJoin(join) => {
                 let (join_params, scans) = self.parse_join_parameters(
@@ -1131,8 +1203,8 @@ impl PhysicalPlanner {
                 // to copy the input batch to avoid the data corruption from reusing the input
                 // batch. We also need to unpack dictionary arrays, because the join operators
                 // do not support them.
-                let left = Self::wrap_in_copy_exec(join_params.left);
-                let right = Self::wrap_in_copy_exec(join_params.right);
+                let left = Self::wrap_in_copy_exec(Arc::clone(&join_params.left.native_plan));
+                let right = Self::wrap_in_copy_exec(Arc::clone(&join_params.right.native_plan));
 
                 let hash_join = Arc::new(HashJoinExec::try_new(
                     left,
@@ -1148,13 +1220,36 @@ impl PhysicalPlanner {
                 )?);
 
                 // If the hash join is build right, we need to swap the left and right
-                let hash_join = if join.build_side == BuildSide::BuildLeft as i32 {
-                    hash_join
+                if join.build_side == BuildSide::BuildLeft as i32 {
+                    Ok((
+                        scans,
+                        Arc::new(SparkPlan::new(
+                            spark_plan.plan_id,
+                            hash_join,
+                            vec![join_params.left, join_params.right],
+                        )),
+                    ))
                 } else {
-                    swap_hash_join(hash_join.as_ref(), PartitionMode::Partitioned)?
-                };
-
-                Ok((scans, hash_join))
+                    // we insert a projection around the hash join in this case
+                    let projection =
+                        swap_hash_join(hash_join.as_ref(), PartitionMode::Partitioned)?;
+                    let swapped_hash_join = Arc::clone(projection.children()[0]);
+                    let mut additional_native_plans = swapped_hash_join
+                        .children()
+                        .iter()
+                        .map(|p| Arc::clone(p))
+                        .collect::<Vec<_>>();
+                    additional_native_plans.push(Arc::clone(&swapped_hash_join));
+                    Ok((
+                        scans,
+                        Arc::new(SparkPlan::new_with_additional(
+                            spark_plan.plan_id,
+                            projection,
+                            vec![join_params.left, join_params.right],
+                            additional_native_plans,
+                        )),
+                    ))
+                }
             }
             OpStruct::Window(wnd) => {
                 let (scans, child) = self.create_plan(&children[0], inputs)?;
@@ -1187,14 +1282,15 @@ impl PhysicalPlanner {
                     })
                     .collect();
 
+                let window_agg = Arc::new(BoundedWindowAggExec::try_new(
+                    window_expr?,
+                    Arc::clone(&child.native_plan),
+                    partition_exprs.to_vec(),
+                    InputOrderMode::Sorted,
+                )?);
                 Ok((
                     scans,
-                    Arc::new(BoundedWindowAggExec::try_new(
-                        window_expr?,
-                        child,
-                        partition_exprs.to_vec(),
-                        InputOrderMode::Sorted,
-                    )?),
+                    Arc::new(SparkPlan::new(spark_plan.plan_id, window_agg, vec![child])),
                 ))
             }
         }
@@ -1331,8 +1427,8 @@ impl PhysicalPlanner {
 
         Ok((
             JoinParameters {
-                left,
-                right,
+                left: Arc::clone(&left),
+                right: Arc::clone(&right),
                 join_on,
                 join_type,
                 join_filter,
@@ -2199,6 +2295,7 @@ mod tests {
     use crate::execution::operators::ExecutionError;
     use datafusion_comet_proto::{
         spark_expression::expr::ExprStruct::*,
+        spark_expression::Expr,
         spark_expression::{self, literal},
         spark_operator,
         spark_operator::{operator::OpStruct, Operator},
@@ -2207,6 +2304,7 @@ mod tests {
     #[test]
     fn test_unpack_dictionary_primitive() {
         let op_scan = Operator {
+            plan_id: 0,
             children: vec![],
             op_struct: Some(OpStruct::Scan(spark_operator::Scan {
                 fields: vec![spark_expression::DataType {
@@ -2232,7 +2330,7 @@ mod tests {
 
         let session_ctx = SessionContext::new();
         let task_ctx = session_ctx.task_ctx();
-        let mut stream = datafusion_plan.execute(0, task_ctx).unwrap();
+        let mut stream = datafusion_plan.native_plan.execute(0, task_ctx).unwrap();
 
         let runtime = tokio::runtime::Runtime::new().unwrap();
         let (tx, mut rx) = mpsc::channel(1);
@@ -2279,6 +2377,7 @@ mod tests {
     #[test]
     fn test_unpack_dictionary_string() {
         let op_scan = Operator {
+            plan_id: 0,
             children: vec![],
             op_struct: Some(OpStruct::Scan(spark_operator::Scan {
                 fields: vec![spark_expression::DataType {
@@ -2315,7 +2414,7 @@ mod tests {
 
         let session_ctx = SessionContext::new();
         let task_ctx = session_ctx.task_ctx();
-        let mut stream = datafusion_plan.execute(0, task_ctx).unwrap();
+        let mut stream = datafusion_plan.native_plan.execute(0, task_ctx).unwrap();
 
         let runtime = tokio::runtime::Runtime::new().unwrap();
         let (tx, mut rx) = mpsc::channel(1);
@@ -2364,19 +2463,7 @@ mod tests {
     #[tokio::test()]
     #[allow(clippy::field_reassign_with_default)]
     async fn to_datafusion_filter() {
-        let op_scan = spark_operator::Operator {
-            children: vec![],
-            op_struct: Some(spark_operator::operator::OpStruct::Scan(
-                spark_operator::Scan {
-                    fields: vec![spark_expression::DataType {
-                        type_id: 3,
-                        type_info: None,
-                    }],
-                    source: "".to_string(),
-                },
-            )),
-        };
-
+        let op_scan = create_scan();
         let op = create_filter(op_scan, 0);
         let planner = PhysicalPlanner::default();
 
@@ -2388,7 +2475,10 @@ mod tests {
         let session_ctx = SessionContext::new();
         let task_ctx = session_ctx.task_ctx();
 
-        let stream = datafusion_plan.execute(0, Arc::clone(&task_ctx)).unwrap();
+        let stream = datafusion_plan
+            .native_plan
+            .execute(0, Arc::clone(&task_ctx))
+            .unwrap();
         let output = collect(stream).await.unwrap();
         assert!(output.is_empty());
     }
@@ -2442,10 +2532,85 @@ mod tests {
         };
 
         Operator {
+            plan_id: 0,
             children: vec![child_op],
             op_struct: Some(OpStruct::Filter(spark_operator::Filter {
                 predicate: Some(expr),
             })),
         }
     }
+
+    #[test]
+    fn spark_plan_metrics_filter() {
+        let op_scan = create_scan();
+        let op = create_filter(op_scan, 0);
+        let planner = PhysicalPlanner::default();
+
+        let (mut _scans, filter_exec) = planner.create_plan(&op, &mut vec![]).unwrap();
+
+        assert_eq!("FilterExec", filter_exec.native_plan.name());
+        assert_eq!(1, filter_exec.children.len());
+        assert_eq!(1, filter_exec.additional_native_plans.len());
+        assert_eq!("ScanExec", filter_exec.additional_native_plans[0].name());
+
+        let scan_exec = &filter_exec.children()[0];
+        assert_eq!("ScanExec", scan_exec.native_plan.name());
+        assert_eq!(0, scan_exec.additional_native_plans.len());
+    }
+
+    #[test]
+    fn spark_plan_metrics_hash_join() {
+        let op_scan = create_scan();
+        let op_join = Operator {
+            plan_id: 0,
+            children: vec![op_scan.clone(), op_scan.clone()],
+            op_struct: Some(OpStruct::HashJoin(spark_operator::HashJoin {
+                left_join_keys: vec![create_bound_reference(0)],
+                right_join_keys: vec![create_bound_reference(0)],
+                join_type: 0,
+                condition: None,
+                build_side: 0,
+            })),
+        };
+
+        let planner = PhysicalPlanner::default();
+
+        let (_scans, hash_join_exec) = planner.create_plan(&op_join, &mut vec![]).unwrap();
+
+        assert_eq!("HashJoinExec", hash_join_exec.native_plan.name());
+        assert_eq!(2, hash_join_exec.children.len());
+        assert_eq!("ScanExec", hash_join_exec.children[0].native_plan.name());
+        assert_eq!("ScanExec", hash_join_exec.children[1].native_plan.name());
+
+        assert_eq!(2, hash_join_exec.additional_native_plans.len());
+        assert_eq!("ScanExec", hash_join_exec.additional_native_plans[0].name());
+        assert_eq!("ScanExec", hash_join_exec.additional_native_plans[1].name());
+    }
+
+    fn create_bound_reference(index: i32) -> Expr {
+        Expr {
+            expr_struct: Some(Bound(spark_expression::BoundReference {
+                index,
+                datatype: Some(create_proto_datatype()),
+            })),
+        }
+    }
+
+    fn create_scan() -> Operator {
+        Operator {
+            plan_id: 0,
+            children: vec![],
+            op_struct: Some(OpStruct::Scan(spark_operator::Scan {
+                fields: vec![create_proto_datatype()],
+                source: "".to_string(),
+            })),
+        }
+    }
+
+    fn create_proto_datatype() -> spark_expression::DataType {
+        spark_expression::DataType {
+            type_id: 3,
+            type_info: None,
+        }
+    }
 }
diff --git a/native/core/src/execution/datafusion/spark_plan.rs b/native/core/src/execution/datafusion/spark_plan.rs
new file mode 100644
index 0000000000..6660c5bc4f
--- /dev/null
+++ b/native/core/src/execution/datafusion/spark_plan.rs
@@ -0,0 +1,102 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use crate::execution::operators::{CopyExec, ScanExec};
+use arrow_schema::SchemaRef;
+use datafusion::physical_plan::ExecutionPlan;
+use std::sync::Arc;
+
+/// Wrapper around a native plan that maps to a Spark plan and can optionally contain
+/// references to other native plans that should contribute to the Spark SQL metrics
+/// for the root plan (such as CopyExec and ScanExec nodes)
+#[derive(Debug, Clone)]
+pub(crate) struct SparkPlan {
+    /// Spark plan ID (used for informational purposes only)
+    pub(crate) plan_id: u32,
+    /// The root of the native plan that was generated for this Spark plan
+    pub(crate) native_plan: Arc<dyn ExecutionPlan>,
+    /// Child Spark plans
+    pub(crate) children: Vec<Arc<SparkPlan>>,
+    /// Additional native plans that were generated for this Spark plan that we need
+    /// to collect metrics for (such as CopyExec and ScanExec)
+    pub(crate) additional_native_plans: Vec<Arc<dyn ExecutionPlan>>,
+}
+
+impl SparkPlan {
+    /// Create a SparkPlan that consists of a single native plan
+    pub(crate) fn new(
+        plan_id: u32,
+        native_plan: Arc<dyn ExecutionPlan>,
+        children: Vec<Arc<SparkPlan>>,
+    ) -> Self {
+        let mut additional_native_plans: Vec<Arc<dyn ExecutionPlan>> = vec![];
+        for child in &children {
+            collect_additional_plans(Arc::clone(&child.native_plan), &mut additional_native_plans);
+        }
+        Self {
+            plan_id,
+            native_plan,
+            children,
+            additional_native_plans,
+        }
+    }
+
+    /// Create a SparkPlan that consists of more than one native plan
+    pub(crate) fn new_with_additional(
+        plan_id: u32,
+        native_plan: Arc<dyn ExecutionPlan>,
+        children: Vec<Arc<SparkPlan>>,
+        additional_native_plans: Vec<Arc<dyn ExecutionPlan>>,
+    ) -> Self {
+        let mut accum: Vec<Arc<dyn ExecutionPlan>> = vec![];
+        for plan in &additional_native_plans {
+            accum.push(Arc::clone(plan));
+        }
+        for child in &children {
+            collect_additional_plans(Arc::clone(&child.native_plan), &mut accum);
+        }
+        Self {
+            plan_id,
+            native_plan,
+            children,
+            additional_native_plans: accum,
+        }
+    }
+
+    /// Get the schema of the native plan
+    pub(crate) fn schema(&self) -> SchemaRef {
+        self.native_plan.schema()
+    }
+
+    /// Get the child SparkPlan instances
+    pub(crate) fn children(&self) -> &Vec<Arc<SparkPlan>> {
+        &self.children
+    }
+}
+
+fn collect_additional_plans(
+    child: Arc<dyn ExecutionPlan>,
+    additional_native_plans: &mut Vec<Arc<dyn ExecutionPlan>>,
+) {
+    if child.as_any().is::<CopyExec>() {
+        additional_native_plans.push(Arc::clone(&child));
+        // CopyExec may be wrapping a ScanExec
+        collect_additional_plans(Arc::clone(child.children()[0]), additional_native_plans);
+    } else if child.as_any().is::<ScanExec>() {
+        additional_native_plans.push(Arc::clone(&child));
+    }
+}
diff --git a/native/core/src/execution/jni_api.rs b/native/core/src/execution/jni_api.rs
index 448f383c6b..083744f0a4 100644
--- a/native/core/src/execution/jni_api.rs
+++ b/native/core/src/execution/jni_api.rs
@@ -24,7 +24,7 @@ use datafusion::{
         disk_manager::DiskManagerConfig,
         runtime_env::{RuntimeConfig, RuntimeEnv},
     },
-    physical_plan::{display::DisplayableExecutionPlan, ExecutionPlan, SendableRecordBatchStream},
+    physical_plan::{display::DisplayableExecutionPlan, SendableRecordBatchStream},
     prelude::{SessionConfig, SessionContext},
 };
 use futures::poll;
@@ -59,6 +59,7 @@ use jni::{
 };
 use tokio::runtime::Runtime;
 
+use crate::execution::datafusion::spark_plan::SparkPlan;
 use crate::execution::operators::ScanExec;
 use log::info;
 
@@ -69,7 +70,7 @@ struct ExecutionContext {
     /// The deserialized Spark plan
     pub spark_plan: Operator,
     /// The DataFusion root operator converted from the `spark_plan`
-    pub root_op: Option<Arc<dyn ExecutionPlan>>,
+    pub root_op: Option<Arc<SparkPlan>>,
     /// The input sources for the DataFusion plan
     pub scans: Vec<ScanExec>,
     /// The global reference of input sources for the DataFusion plan
@@ -360,7 +361,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_executePlan(
 
             if exec_context.explain_native {
                 let formatted_plan_str =
-                    DisplayableExecutionPlan::new(root_op.as_ref()).indent(true);
+                    DisplayableExecutionPlan::new(root_op.native_plan.as_ref()).indent(true);
                 info!("Comet native query plan:\n{formatted_plan_str:}");
             }
 
@@ -369,6 +370,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_executePlan(
                 .root_op
                 .as_ref()
                 .unwrap()
+                .native_plan
                 .execute(0, task_ctx)?;
             exec_context.stream = Some(stream);
         } else {
@@ -400,12 +402,13 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_executePlan(
                     if exec_context.explain_native {
                         if let Some(plan) = &exec_context.root_op {
                             let formatted_plan_str =
-                                DisplayableExecutionPlan::with_metrics(plan.as_ref()).indent(true);
+                                DisplayableExecutionPlan::with_metrics(plan.native_plan.as_ref())
+                                    .indent(true);
                             info!(
-                                "Comet native query plan with metrics:\
-                            \n[Stage {} Partition {}] plan creation (including CometScans fetching first batches) took {:?}:\
+                                "Comet native query plan with metrics (Plan #{} Stage {} Partition {}):\
+                            \n plan creation (including CometScans fetching first batches) took {:?}:\
                             \n{formatted_plan_str:}",
-                                stage_id, partition, exec_context.plan_creation_time
+                                plan.plan_id, stage_id, partition, exec_context.plan_creation_time
                             );
                         }
                     }
diff --git a/native/core/src/execution/metrics/utils.rs b/native/core/src/execution/metrics/utils.rs
index 9291f32c72..4bb1c4474c 100644
--- a/native/core/src/execution/metrics/utils.rs
+++ b/native/core/src/execution/metrics/utils.rs
@@ -15,12 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::execution::datafusion::spark_plan::SparkPlan;
 use crate::jvm_bridge::jni_new_global_ref;
 use crate::{
     errors::CometError,
     jvm_bridge::{jni_call, jni_new_string},
 };
-use datafusion::physical_plan::ExecutionPlan;
+use datafusion::physical_plan::metrics::MetricValue;
 use jni::objects::{GlobalRef, JString};
 use jni::{objects::JObject, JNIEnv};
 use std::collections::HashMap;
@@ -28,18 +29,36 @@ use std::sync::Arc;
 
 /// Updates the metrics of a CometMetricNode. This function is called recursively to
 /// update the metrics of all the children nodes. The metrics are pulled from the
-/// DataFusion execution plan and pushed to the Java side through JNI.
+/// native execution plan and pushed to the Java side through JNI.
 pub fn update_comet_metric(
     env: &mut JNIEnv,
     metric_node: &JObject,
-    execution_plan: &Arc<dyn ExecutionPlan>,
+    spark_plan: &Arc<SparkPlan>,
     metrics_jstrings: &mut HashMap<String, Arc<GlobalRef>>,
 ) -> Result<(), CometError> {
+    // combine all metrics from all native plans for this SparkPlan
+    let metrics = if spark_plan.additional_native_plans.is_empty() {
+        spark_plan.native_plan.metrics()
+    } else {
+        let mut metrics = spark_plan.native_plan.metrics().unwrap_or_default();
+        for plan in &spark_plan.additional_native_plans {
+            let additional_metrics = plan.metrics().unwrap_or_default();
+            for c in additional_metrics.iter() {
+                match c.value() {
+                    MetricValue::OutputRows(_) => {
+                        // we do not want to double count output rows
+                    }
+                    _ => metrics.push(c.to_owned()),
+                }
+            }
+        }
+        Some(metrics.aggregate_by_name())
+    };
+
     update_metrics(
         env,
         metric_node,
-        &execution_plan
-            .metrics()
+        &metrics
             .unwrap_or_default()
             .iter()
             .map(|m| m.value())
@@ -49,7 +68,7 @@ pub fn update_comet_metric(
     )?;
 
     unsafe {
-        for (i, child_plan) in execution_plan.children().iter().enumerate() {
+        for (i, child_plan) in spark_plan.children().iter().enumerate() {
             let child_metric_node: JObject = jni_call!(env,
                 comet_metric_node(metric_node).get_child_node(i as i32) -> JObject
             )?;
diff --git a/native/proto/src/proto/operator.proto b/native/proto/src/proto/operator.proto
index 533d504c4f..74ec80cb54 100644
--- a/native/proto/src/proto/operator.proto
+++ b/native/proto/src/proto/operator.proto
@@ -31,6 +31,9 @@ message Operator {
   // The child operators of this
   repeated Operator children = 1;
 
+  // Spark plan ID
+  uint32 plan_id = 2;
+
   oneof op_struct {
     Scan scan = 100;
     Projection projection = 101;
diff --git a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
index f7d5fc91a0..2bb467af58 100644
--- a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
+++ b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
@@ -2508,7 +2508,7 @@ object QueryPlanSerde extends Logging with ShimQueryPlanSerde with CometExprShim
    */
   def operator2Proto(op: SparkPlan, childOp: Operator*): Option[Operator] = {
     val conf = op.conf
-    val result = OperatorOuterClass.Operator.newBuilder()
+    val result = OperatorOuterClass.Operator.newBuilder().setPlanId(op.id)
     childOp.foreach(result.addChildren)
 
     op match {

From 9b250c43ee5cfb9a3fb7b05868fef7b7d36501b1 Mon Sep 17 00:00:00 2001
From: Adam Binford <adamq43@gmail.com>
Date: Mon, 2 Dec 2024 17:55:17 -0500
Subject: [PATCH 19/47] fix: Don't create CometScanExec for subclasses of
 ParquetFileFormat (#1129)

* Use exact class comparison for parquet scan

* Add test

* Add comment
---
 .../apache/comet/CometSparkSessionExtensions.scala | 14 +++++++++-----
 .../org/apache/spark/sql/comet/CometScanExec.scala |  8 +++++++-
 .../org/apache/comet/exec/CometExecSuite.scala     |  9 +++++++++
 3 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala b/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
index 1c4ffcf3e5..61c45daff0 100644
--- a/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
+++ b/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
@@ -190,7 +190,7 @@ class CometSparkSessionExtensions
 
           // data source V1
           case scanExec @ FileSourceScanExec(
-                HadoopFsRelation(_, partitionSchema, _, _, _: ParquetFileFormat, _),
+                HadoopFsRelation(_, partitionSchema, _, _, fileFormat, _),
                 _: Seq[_],
                 requiredSchema,
                 _,
@@ -199,14 +199,15 @@ class CometSparkSessionExtensions
                 _,
                 _,
                 _)
-              if CometScanExec.isSchemaSupported(requiredSchema)
+              if CometScanExec.isFileFormatSupported(fileFormat)
+                && CometScanExec.isSchemaSupported(requiredSchema)
                 && CometScanExec.isSchemaSupported(partitionSchema) =>
             logInfo("Comet extension enabled for v1 Scan")
             CometScanExec(scanExec, session)
 
           // data source v1 not supported case
           case scanExec @ FileSourceScanExec(
-                HadoopFsRelation(_, partitionSchema, _, _, _: ParquetFileFormat, _),
+                HadoopFsRelation(_, partitionSchema, _, _, fileFormat, _),
                 _: Seq[_],
                 requiredSchema,
                 _,
@@ -216,12 +217,15 @@ class CometSparkSessionExtensions
                 _,
                 _) =>
             val info1 = createMessage(
+              !CometScanExec.isFileFormatSupported(fileFormat),
+              s"File format $fileFormat is not supported")
+            val info2 = createMessage(
               !CometScanExec.isSchemaSupported(requiredSchema),
               s"Schema $requiredSchema is not supported")
-            val info2 = createMessage(
+            val info3 = createMessage(
               !CometScanExec.isSchemaSupported(partitionSchema),
               s"Partition schema $partitionSchema is not supported")
-            withInfo(scanExec, Seq(info1, info2).flatten.mkString(","))
+            withInfo(scanExec, Seq(info1, info2, info3).flatten.mkString(","))
             scanExec
         }
       }
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/CometScanExec.scala b/spark/src/main/scala/org/apache/spark/sql/comet/CometScanExec.scala
index 49f7694bcf..eb9d5cb314 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/CometScanExec.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/CometScanExec.scala
@@ -35,7 +35,7 @@ import org.apache.spark.sql.catalyst.util.CaseInsensitiveMap
 import org.apache.spark.sql.comet.shims.ShimCometScanExec
 import org.apache.spark.sql.execution._
 import org.apache.spark.sql.execution.datasources._
-import org.apache.spark.sql.execution.datasources.parquet.ParquetOptions
+import org.apache.spark.sql.execution.datasources.parquet.{ParquetFileFormat, ParquetOptions}
 import org.apache.spark.sql.execution.datasources.v2.DataSourceRDD
 import org.apache.spark.sql.execution.metric._
 import org.apache.spark.sql.types._
@@ -503,4 +503,10 @@ object CometScanExec extends DataTypeSupport {
     scanExec.logicalLink.foreach(batchScanExec.setLogicalLink)
     batchScanExec
   }
+
+  def isFileFormatSupported(fileFormat: FileFormat): Boolean = {
+    // Only support Spark's built-in Parquet scans, not others such as Delta which use a subclass
+    // of ParquetFileFormat.
+    fileFormat.getClass().equals(classOf[ParquetFileFormat])
+  }
 }
diff --git a/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala b/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala
index d262e83f65..1027695372 100644
--- a/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala
@@ -39,6 +39,7 @@ import org.apache.spark.sql.comet.{CometBroadcastExchangeExec, CometBroadcastHas
 import org.apache.spark.sql.comet.execution.shuffle.{CometColumnarShuffle, CometShuffleExchangeExec}
 import org.apache.spark.sql.execution.{CollectLimitExec, ProjectExec, SQLExecution, UnionExec}
 import org.apache.spark.sql.execution.adaptive.AdaptiveSparkPlanExec
+import org.apache.spark.sql.execution.datasources.parquet.ParquetFileFormat
 import org.apache.spark.sql.execution.exchange.{BroadcastExchangeExec, ReusedExchangeExec, ShuffleExchangeExec}
 import org.apache.spark.sql.execution.joins.{BroadcastNestedLoopJoinExec, CartesianProductExec, SortMergeJoinExec}
 import org.apache.spark.sql.execution.reuse.ReuseExchangeAndSubquery
@@ -1883,6 +1884,14 @@ class CometExecSuite extends CometTestBase {
       }
     }
   }
+
+  test("Supported file formats for CometScanExec") {
+    assert(CometScanExec.isFileFormatSupported(new ParquetFileFormat()))
+
+    class CustomParquetFileFormat extends ParquetFileFormat {}
+
+    assert(!CometScanExec.isFileFormatSupported(new CustomParquetFileFormat()))
+  }
 }
 
 case class BucketedTableTestSpec(

From 95727aa7ce9885f25f8d9a330d31dd18f4d1dbec Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Mon, 2 Dec 2024 17:07:49 -0700
Subject: [PATCH 20/47] fix: Fix metrics regressions (#1132)

* fix metrics issues

* clippy

* update tests
---
 .../core/src/execution/datafusion/planner.rs  | 30 +++++++------------
 .../src/execution/datafusion/spark_plan.rs    |  8 ++---
 2 files changed, 12 insertions(+), 26 deletions(-)

diff --git a/native/core/src/execution/datafusion/planner.rs b/native/core/src/execution/datafusion/planner.rs
index aa6b3e91cf..83f86dbee8 100644
--- a/native/core/src/execution/datafusion/planner.rs
+++ b/native/core/src/execution/datafusion/planner.rs
@@ -1230,21 +1230,20 @@ impl PhysicalPlanner {
                         )),
                     ))
                 } else {
-                    // we insert a projection around the hash join in this case
-                    let projection =
+                    let swapped_hash_join =
                         swap_hash_join(hash_join.as_ref(), PartitionMode::Partitioned)?;
-                    let swapped_hash_join = Arc::clone(projection.children()[0]);
-                    let mut additional_native_plans = swapped_hash_join
-                        .children()
-                        .iter()
-                        .map(|p| Arc::clone(p))
-                        .collect::<Vec<_>>();
-                    additional_native_plans.push(Arc::clone(&swapped_hash_join));
+
+                    let mut additional_native_plans = vec![];
+                    if swapped_hash_join.as_any().is::<ProjectionExec>() {
+                        // a projection was added to the hash join
+                        additional_native_plans.push(Arc::clone(swapped_hash_join.children()[0]));
+                    }
+
                     Ok((
                         scans,
                         Arc::new(SparkPlan::new_with_additional(
                             spark_plan.plan_id,
-                            projection,
+                            swapped_hash_join,
                             vec![join_params.left, join_params.right],
                             additional_native_plans,
                         )),
@@ -2550,12 +2549,7 @@ mod tests {
 
         assert_eq!("FilterExec", filter_exec.native_plan.name());
         assert_eq!(1, filter_exec.children.len());
-        assert_eq!(1, filter_exec.additional_native_plans.len());
-        assert_eq!("ScanExec", filter_exec.additional_native_plans[0].name());
-
-        let scan_exec = &filter_exec.children()[0];
-        assert_eq!("ScanExec", scan_exec.native_plan.name());
-        assert_eq!(0, scan_exec.additional_native_plans.len());
+        assert_eq!(0, filter_exec.additional_native_plans.len());
     }
 
     #[test]
@@ -2581,10 +2575,6 @@ mod tests {
         assert_eq!(2, hash_join_exec.children.len());
         assert_eq!("ScanExec", hash_join_exec.children[0].native_plan.name());
         assert_eq!("ScanExec", hash_join_exec.children[1].native_plan.name());
-
-        assert_eq!(2, hash_join_exec.additional_native_plans.len());
-        assert_eq!("ScanExec", hash_join_exec.additional_native_plans[0].name());
-        assert_eq!("ScanExec", hash_join_exec.additional_native_plans[1].name());
     }
 
     fn create_bound_reference(index: i32) -> Expr {
diff --git a/native/core/src/execution/datafusion/spark_plan.rs b/native/core/src/execution/datafusion/spark_plan.rs
index 6660c5bc4f..4e26ff888f 100644
--- a/native/core/src/execution/datafusion/spark_plan.rs
+++ b/native/core/src/execution/datafusion/spark_plan.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::execution::operators::{CopyExec, ScanExec};
+use crate::execution::operators::CopyExec;
 use arrow_schema::SchemaRef;
 use datafusion::physical_plan::ExecutionPlan;
 use std::sync::Arc;
@@ -32,7 +32,7 @@ pub(crate) struct SparkPlan {
     /// Child Spark plans
     pub(crate) children: Vec<Arc<SparkPlan>>,
     /// Additional native plans that were generated for this Spark plan that we need
-    /// to collect metrics for (such as CopyExec and ScanExec)
+    /// to collect metrics for
     pub(crate) additional_native_plans: Vec<Arc<dyn ExecutionPlan>>,
 }
 
@@ -94,9 +94,5 @@ fn collect_additional_plans(
 ) {
     if child.as_any().is::<CopyExec>() {
         additional_native_plans.push(Arc::clone(&child));
-        // CopyExec may be wrapping a ScanExec
-        collect_additional_plans(Arc::clone(child.children()[0]), additional_native_plans);
-    } else if child.as_any().is::<ScanExec>() {
-        additional_native_plans.push(Arc::clone(&child));
     }
 }

From 36a2307487c528cdaf93fcfb55f23bcbf4b9b563 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Tue, 3 Dec 2024 11:12:41 -0700
Subject: [PATCH 21/47] docs: Add more technical detail and new diagram to
 Comet plugin overview (#1119)

* Add more technical detail and new diagram to Comet plugin overview

* update diagram

* add info on Arrow IPC

* update diagram

* update diagram

* update docs

* address feedback
---
 .../images/CometNativeParquetReader.drawio    |  100 -
 .../CometNativeParquetReader.drawio.svg       |    4 -
 .../images/CometOverviewDetailed.drawio       |   94 -
 .../images/CometOverviewDetailed.drawio.svg   |    4 -
 .../_static/images/comet-dataflow.excalidraw  | 2134 +++++++++++++++++
 docs/source/_static/images/comet-dataflow.svg |   10 +
 .../contributor-guide/plugin_overview.md      |   67 +-
 7 files changed, 2196 insertions(+), 217 deletions(-)
 delete mode 100644 docs/source/_static/images/CometNativeParquetReader.drawio
 delete mode 100644 docs/source/_static/images/CometNativeParquetReader.drawio.svg
 delete mode 100644 docs/source/_static/images/CometOverviewDetailed.drawio
 delete mode 100644 docs/source/_static/images/CometOverviewDetailed.drawio.svg
 create mode 100644 docs/source/_static/images/comet-dataflow.excalidraw
 create mode 100644 docs/source/_static/images/comet-dataflow.svg

diff --git a/docs/source/_static/images/CometNativeParquetReader.drawio b/docs/source/_static/images/CometNativeParquetReader.drawio
deleted file mode 100644
index 0c7304eff9..0000000000
--- a/docs/source/_static/images/CometNativeParquetReader.drawio
+++ /dev/null
@@ -1,100 +0,0 @@
-<mxfile host="app.diagrams.net" agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15" version="24.7.16">
-  <diagram name="Page-1" id="IdYZ_KFENTEXElLiOEKC">
-    <mxGraphModel dx="1133" dy="729" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="850" pageHeight="1100" math="0" shadow="0">
-      <root>
-        <mxCell id="0" />
-        <mxCell id="1" parent="0" />
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-30" value="Spark Executor" style="rounded=1;whiteSpace=wrap;html=1;dashed=1;verticalAlign=top;" vertex="1" parent="1">
-          <mxGeometry x="10" y="40" width="510" height="430" as="geometry" />
-        </mxCell>
-        <mxCell id="AH3lBTSLKK5181iXBnnY-2" value="JVM Code" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;" parent="1" vertex="1">
-          <mxGeometry x="30" y="70" width="210" height="380" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-24" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.75;exitY=1;exitDx=0;exitDy=0;entryX=0.75;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1" source="t5OBkkhKOG6cYtw1sPyQ-18" target="wVAZ-YzccNhZugPFJvmi-13">
-          <mxGeometry relative="1" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-18" value="Comet Parquet Reader&lt;div&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;IO and Decompression&lt;/div&gt;" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;" parent="1" vertex="1">
-          <mxGeometry x="45" y="110" width="180" height="100" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-1" value="Native Code" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;" vertex="1" parent="1">
-          <mxGeometry x="290" y="70" width="210" height="380" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-21" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0;exitY=0.75;exitDx=0;exitDy=0;entryX=1;entryY=0.75;entryDx=0;entryDy=0;" edge="1" parent="1" source="wVAZ-YzccNhZugPFJvmi-2" target="wVAZ-YzccNhZugPFJvmi-13">
-          <mxGeometry relative="1" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-2" value="Native Execution Plan" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;" vertex="1" parent="1">
-          <mxGeometry x="310" y="240" width="170" height="100" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-19" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0;exitY=0.75;exitDx=0;exitDy=0;entryX=1;entryY=0.75;entryDx=0;entryDy=0;" edge="1" parent="1" source="wVAZ-YzccNhZugPFJvmi-4" target="t5OBkkhKOG6cYtw1sPyQ-18">
-          <mxGeometry relative="1" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-4" value="Parquet Decoding" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;" vertex="1" parent="1">
-          <mxGeometry x="305" y="110" width="180" height="100" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-6" value="" style="shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 801 168" height="168" width="801">&#xa;<g clip-path="url(#clip0_1_181)">&#xa;<path fill="url(#paint0_linear_1_181)" d="M76.1297 168C88.4597 168 99.6097 158.25 107.58 142.55C127.23 144.6 143.09 139.99 149.76 128.51C156.29 117.25 152.65 101.68 141.58 86.09C152.36 70.67 155.85 55.32 149.39 44.19C143.01 33.19 128.19 28.5 109.69 29.92C101.65 11.62 89.5997 0 76.1297 0C62.6597 0 50.4997 11.73 42.4497 30.18C24.3497 28.97 9.87966 33.68 3.59966 44.51C-2.81034 55.56 0.589656 70.78 11.1897 86.09C0.299656 101.57 -3.24034 117.01 3.23966 128.18C9.80966 139.5 25.3097 144.13 44.5597 142.31C52.5397 158.15 63.7297 168 76.1297 168ZM52.7197 141.19C59.5097 154.21 68.6197 162.18 78.6397 162.18C88.6597 162.18 97.6397 154.63 104.76 142.22C95.7497 141.01 86.0297 138.46 76.0797 134.58C68.0497 137.65 60.1797 139.86 52.7197 141.19ZM65.0697 129.77C59.6397 131.52 54.3497 132.84 49.3097 133.72C47.3697 128.87 45.6997 123.54 44.3597 117.82C47.6797 120.07 51.1497 122.25 54.7497 124.32C58.1797 126.29 61.6197 128.11 65.0597 129.77H65.0697ZM76.1197 125.68C82.0597 123.2 88.0897 120.24 94.0797 116.79C102.76 111.8 110.61 106.25 117.41 100.43C118.01 95.13 118.33 89.64 118.33 84C118.33 76.79 117.81 69.8 116.84 63.17C111.11 58.53 104.73 54.12 97.7797 50.13C90.5497 45.98 83.2397 42.57 76.0697 39.91C69.1797 42.52 62.1597 45.82 55.2197 49.81C50.8597 52.32 46.7097 54.99 42.8197 57.78C41.3997 65.98 40.6297 74.8 40.6297 84C40.6297 91.65 41.1597 99.05 42.1597 106.04C47.2997 109.94 52.9197 113.66 58.9297 117.12C64.6597 120.41 70.4297 123.27 76.1197 125.68ZM87.1297 129.83C90.8397 128.07 94.5497 126.12 98.2497 124C104.42 120.45 110.18 116.61 115.48 112.58C113.79 120.73 111.42 128.22 108.52 134.76C101.82 133.95 94.6097 132.3 87.1297 129.83ZM117.71 110.84C116.16 119.65 113.87 127.8 110.98 135.03C127.49 136.56 140.52 132.79 145.95 123.44C151.17 114.43 148.57 101.58 140 88.28C134.26 96.01 126.71 103.7 117.71 110.84ZM136.56 79.61C145.46 66.59 148.33 53.99 143.08 44.93C137.99 36.16 126.02 31.96 110.76 32.43C114.3 41.14 116.97 51.23 118.5 62.2C125.46 67.76 131.53 73.64 136.55 79.61H136.56ZM108.21 32.55C111.86 40.6 114.7 50.11 116.43 60.57C110.98 56.37 105.01 52.37 98.6097 48.69C91.9597 44.87 85.2397 41.62 78.6197 38.96C89.0597 35.24 99.1497 33.11 108.2 32.54L108.21 32.55ZM107.08 30.16C97.4397 31.18 86.8897 33.79 76.0797 37.98C67.2997 34.65 58.7097 32.35 50.6497 31.1C57.5997 15.56 67.5697 5.83 78.6397 5.83C89.7097 5.83 99.7197 15.18 107.08 30.16ZM73.5197 38.99C65.2297 36.1 57.1697 34.21 49.6897 33.32C46.9897 39.84 44.7997 47.28 43.2497 55.38C46.7897 52.94 50.4997 50.6 54.3797 48.37C60.7497 44.71 67.1697 41.58 73.5197 38.99ZM33.7197 62.5C35.2297 51.54 37.8697 41.46 41.3797 32.74C26.5297 32.46 14.9097 36.66 9.91966 45.26C4.70966 54.24 7.48966 66.68 16.1997 79.58C21.0897 73.73 26.9797 67.96 33.7197 62.5ZM12.7697 88.3C18.3697 95.9 25.7197 103.48 34.4997 110.54C36.0297 119.36 38.3097 127.53 41.1797 134.78C25.0597 136.11 12.3797 132.31 7.03966 123.12C1.85966 114.19 4.36966 101.48 12.7597 88.31L12.7697 88.3ZM17.5697 81.54C21.9097 75.99 27.2197 70.45 33.3797 65.17C32.6597 71.22 32.2697 77.53 32.2697 84C32.2697 88.91 32.4897 93.72 32.9097 98.4C26.7997 92.89 21.6197 87.18 17.5597 81.53L17.5697 81.54ZM135.19 81.55C131 87.32 125.65 93.15 119.32 98.76C119.76 93.97 120 89.03 120 84C120 77.41 119.6 70.99 118.85 64.84C125.22 70.21 130.72 75.87 135.19 81.55Z" clip-rule="evenodd" fill-rule="evenodd"/>&#xa;<path fill="#1F2937" d="M204.34 45.97H192.83L190.47 52.2H185.2L196.07 23.88H201.47L212.54 52.2H206.78L204.34 45.97ZM202.74 41.74L198.54 30.99L194.46 41.74H202.73H202.74Z"/>&#xa;<path fill="#1F2937" d="M235.55 23.88H246.82C249.59 23.88 251.9 24.73 253.73 26.44C255.57 28.14 256.49 30.38 256.49 33.15C256.49 35.92 255.57 38.2 253.73 39.9C251.89 41.6 249.59 42.46 246.82 42.46H240.95V52.21H235.56V23.89L235.55 23.88ZM240.94 37.26H246.85C248 37.26 248.96 36.87 249.73 36.1C250.5 35.3 250.89 34.32 250.89 33.14C250.89 31.96 250.5 31 249.73 30.22C248.98 29.45 248.02 29.06 246.85 29.06H240.94V37.25V37.26Z"/>&#xa;<path fill="#1F2937" d="M293.67 45.97H282.16L279.8 52.2H274.53L285.4 23.88H290.79L301.86 52.2H296.1L293.66 45.97H293.67ZM292.07 41.74L287.87 30.99L283.79 41.74H292.06H292.07Z"/>&#xa;<path fill="#1F2937" d="M335.99 23C338.57 23 340.92 23.68 343.02 25.04C345.15 26.37 346.84 28.18 348.1 30.47L343.1 32.87C341.37 29.57 339 27.92 335.99 27.92C333.62 27.92 331.65 28.91 330.07 30.88C328.53 32.82 327.75 35.22 327.75 38.07C327.75 40.92 328.52 43.32 330.07 45.26C331.62 47.18 333.59 48.14 335.99 48.14C337.45 48.14 338.81 47.73 340.07 46.9C341.32 46.05 342.32 44.93 343.07 43.54L347.99 45.9C346.79 48.14 345.13 49.89 342.99 51.17C340.86 52.42 338.53 53.05 336 53.05C331.95 53.05 328.63 51.65 326.05 48.86C323.47 46.04 322.17 42.44 322.17 38.07C322.17 33.7 323.48 30.13 326.09 27.28C328.73 24.43 332.03 23.01 336 23.01L335.99 23Z"/>&#xa;<path fill="#1F2937" d="M393.49 52.2H388.09V40.61H377.1V52.2H371.71V23.88H377.1V35.43H388.09V23.88H393.49V52.2Z"/>&#xa;<path fill="#1F2937" d="M435.17 29.07H423.9V35.46H432.41V40.65H423.9V47H435.17V52.19H418.51V23.87H435.17V29.06V29.07Z"/>&#xa;<path fill="#1F2937" d="M185 76.1H207.25C218.63 76.1 227.58 79.3 234.1 85.69C240.69 92.02 243.98 100.14 243.98 110.04C243.98 119.94 240.69 128.1 234.1 134.49C227.51 140.88 218.53 144.08 207.15 144.08H184.99V76.1H185ZM199.96 90.49V129.7H206.67C209.55 129.7 212.2 129.38 214.63 128.74C217.12 128.1 219.43 127.08 221.54 125.67C223.71 124.26 225.41 122.25 226.62 119.63C227.83 116.95 228.44 113.75 228.44 110.04C228.44 106.33 227.83 103.17 226.62 100.55C225.4 97.93 223.71 95.92 221.54 94.51C219.43 93.1 217.16 92.08 214.73 91.44C212.3 90.8 209.61 90.48 206.67 90.48H199.96V90.49Z"/>&#xa;<path fill="#1F2937" d="M291.82 130.85H264.96L259.97 144.08H245.39L271.38 76.1H286.34L312.91 144.08H296.89L291.81 130.85H291.82ZM287.4 119.35L278.29 95.76L269.37 119.35H287.4Z"/>&#xa;<path fill="#1F2937" d="M362.7 90.49H342.94V144.09H327.98V90.49H308.51V76.11H362.7V90.49Z"/>&#xa;<path fill="#1F2937" d="M404.77 130.85H377.92L372.93 144.08H358.35L384.34 76.1H399.3L425.87 144.08H409.85L404.77 130.85ZM400.36 119.35L391.25 95.76L382.33 119.35H400.36Z"/>&#xa;<path fill="#1F2937" d="M474.73 90.49H448.45V102.95H468.4V117.33H448.45V144.08H433.49V76.1H474.73V90.48V90.49Z"/>&#xa;<path fill="#1F2937" d="M541.71 76.1V118.96C541.65 127.27 538.96 133.85 533.65 138.71C528.41 143.57 521.53 146 513.03 146C504.53 146 497.78 143.57 492.41 138.71C487.04 133.85 484.39 127.27 484.45 118.96V76.1H499.32V119.05C499.32 122.88 500.6 125.95 503.16 128.25C505.78 130.49 509.08 131.61 513.04 131.61C517 131.61 520.27 130.49 522.82 128.25C525.38 125.95 526.69 122.88 526.75 119.05V76.1H541.71Z"/>&#xa;<path fill="#1F2937" d="M578.69 73.99C585.72 73.99 591.96 75.59 597.39 78.78L590.77 91.24C585.98 89.19 581.43 88.17 577.15 88.17C570.95 88.17 567.85 90.25 567.85 94.4C567.85 96.45 569.03 98.17 571.4 99.58C573.83 100.92 577.28 102.39 581.76 103.99C586.3 105.52 589.72 106.96 592.02 108.3C598.22 111.88 601.32 117.25 601.32 124.41C601.32 131.12 598.86 136.4 593.93 140.23C589.01 144.07 582.87 145.98 575.52 145.98C571.36 145.98 567.05 145.21 562.57 143.68C558.09 142.15 554.61 140.39 552.12 138.41L560.18 126.43C567.02 130.46 573.22 132.21 578.79 131.7C580.96 131.51 582.76 130.74 584.16 129.4C585.63 128.06 586.24 126.43 585.98 124.51C585.72 122.72 584.22 121.25 581.47 120.1C578.72 118.89 575.14 117.48 570.73 115.88C566.38 114.28 562.83 112.4 560.08 110.22C555.03 106.13 552.5 101.05 552.5 94.98C552.5 91.98 553.01 89.26 554.03 86.83C555.05 84.4 556.4 82.42 558.06 80.89C559.79 79.29 561.8 77.98 564.1 76.96C566.4 75.87 568.77 75.11 571.2 74.66C573.63 74.21 576.12 73.99 578.68 73.99H578.69Z"/>&#xa;<path fill="#1F2937" d="M626.79 144.08H611.83V76.1H626.79V144.08Z"/>&#xa;<path fill="#1F2937" d="M647.04 84.16C653.88 77.38 662.48 74 672.84 74C683.2 74 691.73 77.39 698.45 84.16C705.23 90.87 708.62 99.4 708.62 109.76C708.62 120.12 705.33 128.68 698.74 135.45C692.15 142.16 683.52 145.68 672.84 146C662.48 146 653.88 142.58 647.04 135.74C640.26 128.84 636.87 120.21 636.87 109.85C636.87 99.49 640.26 90.93 647.04 84.15V84.16ZM672.84 87.61C666.64 87.61 661.68 89.69 657.97 93.84C654.26 97.99 652.41 103.3 652.41 109.76C652.41 116.22 654.26 121.62 657.97 125.96C661.74 130.24 666.7 132.38 672.84 132.38C678.98 132.38 683.96 130.24 687.61 125.96C691.25 121.68 693.08 116.31 693.08 109.85C693.08 103.39 691.26 98.12 687.61 94.03C684.03 89.88 679.11 87.73 672.84 87.61Z"/>&#xa;<path fill="#1F2937" d="M775 144.08H759.65L732.7 101.99V144.08H718.7V76.1H732.99L761 118.57V76.1H775V144.08Z"/>&#xa;<path fill="#1F2937" d="M788.01 78.18H784.62V87.44H782.46V78.18H779.13V76.1H788.01V78.18ZM800.56 87.45H798.48V80.17L795.5 85.79H794.12L791.14 80.17L791.12 87.45H789.1V76.11H791.13L794.87 83.04L798.45 76.11H800.51L800.53 87.45H800.56Z"/>&#xa;</g>&#xa;<defs>&#xa;<linearGradient gradientUnits="userSpaceOnUse" y2="36.78" x2="162.73" y1="117.74" x1="17.0897" id="paint0_linear_1_181">&#xa;<stop stop-color="#EF4137"/>&#xa;<stop stop-color="#FBB042" offset="1"/>&#xa;</linearGradient>&#xa;<clipPath id="clip0_1_181">&#xa;<rect fill="white" height="168" width="800.56"/>&#xa;</clipPath>&#xa;</defs>&#xa;</svg>;" vertex="1" parent="1">
-          <mxGeometry x="323.48" y="273.6" width="143.03" height="30" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-7" value="" style="shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/png,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;" vertex="1" parent="1">
-          <mxGeometry x="360" y="303.6" width="70" height="36.4" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-10" value="" style="shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="394.5" y="340" as="sourcePoint" />
-            <mxPoint x="394.5" y="370" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-11" value="Shuffle Files" style="shape=process;whiteSpace=wrap;html=1;backgroundOutline=1;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" vertex="1" parent="1">
-          <mxGeometry x="310" y="370" width="170" height="50" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-20" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.25;exitDx=0;exitDy=0;entryX=0;entryY=0.25;entryDx=0;entryDy=0;" edge="1" parent="1" source="wVAZ-YzccNhZugPFJvmi-13" target="wVAZ-YzccNhZugPFJvmi-2">
-          <mxGeometry relative="1" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-28" value="executePlan()" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="wVAZ-YzccNhZugPFJvmi-20">
-          <mxGeometry x="-0.1059" y="2" relative="1" as="geometry">
-            <mxPoint y="11" as="offset" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-23" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.25;exitY=0;exitDx=0;exitDy=0;entryX=0.25;entryY=1;entryDx=0;entryDy=0;" edge="1" parent="1" source="wVAZ-YzccNhZugPFJvmi-13" target="t5OBkkhKOG6cYtw1sPyQ-18">
-          <mxGeometry relative="1" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-25" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.75;exitY=1;exitDx=0;exitDy=0;entryX=0.75;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1" source="wVAZ-YzccNhZugPFJvmi-13" target="wVAZ-YzccNhZugPFJvmi-14">
-          <mxGeometry relative="1" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-13" value="CometExecIterator" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=middle;" vertex="1" parent="1">
-          <mxGeometry x="45" y="240" width="180" height="100" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-22" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.25;exitY=0;exitDx=0;exitDy=0;entryX=0.25;entryY=1;entryDx=0;entryDy=0;" edge="1" parent="1" source="wVAZ-YzccNhZugPFJvmi-14" target="wVAZ-YzccNhZugPFJvmi-13">
-          <mxGeometry relative="1" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-26" value="next()" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="wVAZ-YzccNhZugPFJvmi-22">
-          <mxGeometry x="0.0667" y="1" relative="1" as="geometry">
-            <mxPoint x="21" as="offset" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-14" value="Spark Execution Logic" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=middle;" vertex="1" parent="1">
-          <mxGeometry x="45" y="370" width="180" height="40" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-15" value="" style="shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/png,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;" vertex="1" parent="1">
-          <mxGeometry x="360" y="173.60000000000002" width="70" height="36.4" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-16" value="" style="shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="394.5" y="210" as="sourcePoint" />
-            <mxPoint x="394.5" y="240" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-18" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.25;exitDx=0;exitDy=0;entryX=0;entryY=0.25;entryDx=0;entryDy=0;" edge="1" parent="1" source="t5OBkkhKOG6cYtw1sPyQ-18" target="wVAZ-YzccNhZugPFJvmi-4">
-          <mxGeometry relative="1" as="geometry" />
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-29" value="decode()" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="wVAZ-YzccNhZugPFJvmi-18">
-          <mxGeometry x="-0.025" y="-3" relative="1" as="geometry">
-            <mxPoint y="12" as="offset" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="wVAZ-YzccNhZugPFJvmi-27" value="next()" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="1">
-          <mxGeometry x="110" y="220" as="geometry" />
-        </mxCell>
-      </root>
-    </mxGraphModel>
-  </diagram>
-</mxfile>
diff --git a/docs/source/_static/images/CometNativeParquetReader.drawio.svg b/docs/source/_static/images/CometNativeParquetReader.drawio.svg
deleted file mode 100644
index 0c1f93c7b0..0000000000
--- a/docs/source/_static/images/CometNativeParquetReader.drawio.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Do not edit this file with editors other than draw.io -->
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="511px" height="431px" viewBox="-0.5 -0.5 511 431" content="&lt;mxfile host=&quot;app.diagrams.net&quot; agent=&quot;Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15&quot; version=&quot;24.7.16&quot; scale=&quot;1&quot; border=&quot;0&quot;&gt;&#10;  &lt;diagram name=&quot;Page-1&quot; id=&quot;IdYZ_KFENTEXElLiOEKC&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;1133&quot; dy=&quot;729&quot; grid=&quot;1&quot; gridSize=&quot;10&quot; guides=&quot;1&quot; tooltips=&quot;1&quot; connect=&quot;1&quot; arrows=&quot;1&quot; fold=&quot;1&quot; page=&quot;1&quot; pageScale=&quot;1&quot; pageWidth=&quot;850&quot; pageHeight=&quot;1100&quot; math=&quot;0&quot; shadow=&quot;0&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-30&quot; value=&quot;Spark Executor&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;dashed=1;verticalAlign=top;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;10&quot; y=&quot;40&quot; width=&quot;510&quot; height=&quot;430&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;AH3lBTSLKK5181iXBnnY-2&quot; value=&quot;JVM Code&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;30&quot; y=&quot;70&quot; width=&quot;210&quot; height=&quot;380&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-24&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.75;exitY=1;exitDx=0;exitDy=0;entryX=0.75;entryY=0;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot; source=&quot;t5OBkkhKOG6cYtw1sPyQ-18&quot; target=&quot;wVAZ-YzccNhZugPFJvmi-13&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-18&quot; value=&quot;Comet Parquet Reader&amp;lt;div&amp;gt;&amp;lt;br&amp;gt;&amp;lt;/div&amp;gt;&amp;lt;div&amp;gt;&amp;lt;br&amp;gt;&amp;lt;/div&amp;gt;&amp;lt;div&amp;gt;IO and Decompression&amp;lt;/div&amp;gt;&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;45&quot; y=&quot;110&quot; width=&quot;180&quot; height=&quot;100&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-1&quot; value=&quot;Native Code&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;290&quot; y=&quot;70&quot; width=&quot;210&quot; height=&quot;380&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-21&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0;exitY=0.75;exitDx=0;exitDy=0;entryX=1;entryY=0.75;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot; source=&quot;wVAZ-YzccNhZugPFJvmi-2&quot; target=&quot;wVAZ-YzccNhZugPFJvmi-13&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-2&quot; value=&quot;Native Execution Plan&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;310&quot; y=&quot;240&quot; width=&quot;170&quot; height=&quot;100&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-19&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0;exitY=0.75;exitDx=0;exitDy=0;entryX=1;entryY=0.75;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot; source=&quot;wVAZ-YzccNhZugPFJvmi-4&quot; target=&quot;t5OBkkhKOG6cYtw1sPyQ-18&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-4&quot; value=&quot;Parquet Decoding&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;305&quot; y=&quot;110&quot; width=&quot;180&quot; height=&quot;100&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-6&quot; value=&quot;&quot; style=&quot;shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 801 168" height="168" width="801">&#xa;<g clip-path="url(#clip0_1_181)">&#xa;<path fill="url(#paint0_linear_1_181)" d="M76.1297 168C88.4597 168 99.6097 158.25 107.58 142.55C127.23 144.6 143.09 139.99 149.76 128.51C156.29 117.25 152.65 101.68 141.58 86.09C152.36 70.67 155.85 55.32 149.39 44.19C143.01 33.19 128.19 28.5 109.69 29.92C101.65 11.62 89.5997 0 76.1297 0C62.6597 0 50.4997 11.73 42.4497 30.18C24.3497 28.97 9.87966 33.68 3.59966 44.51C-2.81034 55.56 0.589656 70.78 11.1897 86.09C0.299656 101.57 -3.24034 117.01 3.23966 128.18C9.80966 139.5 25.3097 144.13 44.5597 142.31C52.5397 158.15 63.7297 168 76.1297 168ZM52.7197 141.19C59.5097 154.21 68.6197 162.18 78.6397 162.18C88.6597 162.18 97.6397 154.63 104.76 142.22C95.7497 141.01 86.0297 138.46 76.0797 134.58C68.0497 137.65 60.1797 139.86 52.7197 141.19ZM65.0697 129.77C59.6397 131.52 54.3497 132.84 49.3097 133.72C47.3697 128.87 45.6997 123.54 44.3597 117.82C47.6797 120.07 51.1497 122.25 54.7497 124.32C58.1797 126.29 61.6197 128.11 65.0597 129.77H65.0697ZM76.1197 125.68C82.0597 123.2 88.0897 120.24 94.0797 116.79C102.76 111.8 110.61 106.25 117.41 100.43C118.01 95.13 118.33 89.64 118.33 84C118.33 76.79 117.81 69.8 116.84 63.17C111.11 58.53 104.73 54.12 97.7797 50.13C90.5497 45.98 83.2397 42.57 76.0697 39.91C69.1797 42.52 62.1597 45.82 55.2197 49.81C50.8597 52.32 46.7097 54.99 42.8197 57.78C41.3997 65.98 40.6297 74.8 40.6297 84C40.6297 91.65 41.1597 99.05 42.1597 106.04C47.2997 109.94 52.9197 113.66 58.9297 117.12C64.6597 120.41 70.4297 123.27 76.1197 125.68ZM87.1297 129.83C90.8397 128.07 94.5497 126.12 98.2497 124C104.42 120.45 110.18 116.61 115.48 112.58C113.79 120.73 111.42 128.22 108.52 134.76C101.82 133.95 94.6097 132.3 87.1297 129.83ZM117.71 110.84C116.16 119.65 113.87 127.8 110.98 135.03C127.49 136.56 140.52 132.79 145.95 123.44C151.17 114.43 148.57 101.58 140 88.28C134.26 96.01 126.71 103.7 117.71 110.84ZM136.56 79.61C145.46 66.59 148.33 53.99 143.08 44.93C137.99 36.16 126.02 31.96 110.76 32.43C114.3 41.14 116.97 51.23 118.5 62.2C125.46 67.76 131.53 73.64 136.55 79.61H136.56ZM108.21 32.55C111.86 40.6 114.7 50.11 116.43 60.57C110.98 56.37 105.01 52.37 98.6097 48.69C91.9597 44.87 85.2397 41.62 78.6197 38.96C89.0597 35.24 99.1497 33.11 108.2 32.54L108.21 32.55ZM107.08 30.16C97.4397 31.18 86.8897 33.79 76.0797 37.98C67.2997 34.65 58.7097 32.35 50.6497 31.1C57.5997 15.56 67.5697 5.83 78.6397 5.83C89.7097 5.83 99.7197 15.18 107.08 30.16ZM73.5197 38.99C65.2297 36.1 57.1697 34.21 49.6897 33.32C46.9897 39.84 44.7997 47.28 43.2497 55.38C46.7897 52.94 50.4997 50.6 54.3797 48.37C60.7497 44.71 67.1697 41.58 73.5197 38.99ZM33.7197 62.5C35.2297 51.54 37.8697 41.46 41.3797 32.74C26.5297 32.46 14.9097 36.66 9.91966 45.26C4.70966 54.24 7.48966 66.68 16.1997 79.58C21.0897 73.73 26.9797 67.96 33.7197 62.5ZM12.7697 88.3C18.3697 95.9 25.7197 103.48 34.4997 110.54C36.0297 119.36 38.3097 127.53 41.1797 134.78C25.0597 136.11 12.3797 132.31 7.03966 123.12C1.85966 114.19 4.36966 101.48 12.7597 88.31L12.7697 88.3ZM17.5697 81.54C21.9097 75.99 27.2197 70.45 33.3797 65.17C32.6597 71.22 32.2697 77.53 32.2697 84C32.2697 88.91 32.4897 93.72 32.9097 98.4C26.7997 92.89 21.6197 87.18 17.5597 81.53L17.5697 81.54ZM135.19 81.55C131 87.32 125.65 93.15 119.32 98.76C119.76 93.97 120 89.03 120 84C120 77.41 119.6 70.99 118.85 64.84C125.22 70.21 130.72 75.87 135.19 81.55Z" clip-rule="evenodd" fill-rule="evenodd"/>&#xa;<path fill="#1F2937" d="M204.34 45.97H192.83L190.47 52.2H185.2L196.07 23.88H201.47L212.54 52.2H206.78L204.34 45.97ZM202.74 41.74L198.54 30.99L194.46 41.74H202.73H202.74Z"/>&#xa;<path fill="#1F2937" d="M235.55 23.88H246.82C249.59 23.88 251.9 24.73 253.73 26.44C255.57 28.14 256.49 30.38 256.49 33.15C256.49 35.92 255.57 38.2 253.73 39.9C251.89 41.6 249.59 42.46 246.82 42.46H240.95V52.21H235.56V23.89L235.55 23.88ZM240.94 37.26H246.85C248 37.26 248.96 36.87 249.73 36.1C250.5 35.3 250.89 34.32 250.89 33.14C250.89 31.96 250.5 31 249.73 30.22C248.98 29.45 248.02 29.06 246.85 29.06H240.94V37.25V37.26Z"/>&#xa;<path fill="#1F2937" d="M293.67 45.97H282.16L279.8 52.2H274.53L285.4 23.88H290.79L301.86 52.2H296.1L293.66 45.97H293.67ZM292.07 41.74L287.87 30.99L283.79 41.74H292.06H292.07Z"/>&#xa;<path fill="#1F2937" d="M335.99 23C338.57 23 340.92 23.68 343.02 25.04C345.15 26.37 346.84 28.18 348.1 30.47L343.1 32.87C341.37 29.57 339 27.92 335.99 27.92C333.62 27.92 331.65 28.91 330.07 30.88C328.53 32.82 327.75 35.22 327.75 38.07C327.75 40.92 328.52 43.32 330.07 45.26C331.62 47.18 333.59 48.14 335.99 48.14C337.45 48.14 338.81 47.73 340.07 46.9C341.32 46.05 342.32 44.93 343.07 43.54L347.99 45.9C346.79 48.14 345.13 49.89 342.99 51.17C340.86 52.42 338.53 53.05 336 53.05C331.95 53.05 328.63 51.65 326.05 48.86C323.47 46.04 322.17 42.44 322.17 38.07C322.17 33.7 323.48 30.13 326.09 27.28C328.73 24.43 332.03 23.01 336 23.01L335.99 23Z"/>&#xa;<path fill="#1F2937" d="M393.49 52.2H388.09V40.61H377.1V52.2H371.71V23.88H377.1V35.43H388.09V23.88H393.49V52.2Z"/>&#xa;<path fill="#1F2937" d="M435.17 29.07H423.9V35.46H432.41V40.65H423.9V47H435.17V52.19H418.51V23.87H435.17V29.06V29.07Z"/>&#xa;<path fill="#1F2937" d="M185 76.1H207.25C218.63 76.1 227.58 79.3 234.1 85.69C240.69 92.02 243.98 100.14 243.98 110.04C243.98 119.94 240.69 128.1 234.1 134.49C227.51 140.88 218.53 144.08 207.15 144.08H184.99V76.1H185ZM199.96 90.49V129.7H206.67C209.55 129.7 212.2 129.38 214.63 128.74C217.12 128.1 219.43 127.08 221.54 125.67C223.71 124.26 225.41 122.25 226.62 119.63C227.83 116.95 228.44 113.75 228.44 110.04C228.44 106.33 227.83 103.17 226.62 100.55C225.4 97.93 223.71 95.92 221.54 94.51C219.43 93.1 217.16 92.08 214.73 91.44C212.3 90.8 209.61 90.48 206.67 90.48H199.96V90.49Z"/>&#xa;<path fill="#1F2937" d="M291.82 130.85H264.96L259.97 144.08H245.39L271.38 76.1H286.34L312.91 144.08H296.89L291.81 130.85H291.82ZM287.4 119.35L278.29 95.76L269.37 119.35H287.4Z"/>&#xa;<path fill="#1F2937" d="M362.7 90.49H342.94V144.09H327.98V90.49H308.51V76.11H362.7V90.49Z"/>&#xa;<path fill="#1F2937" d="M404.77 130.85H377.92L372.93 144.08H358.35L384.34 76.1H399.3L425.87 144.08H409.85L404.77 130.85ZM400.36 119.35L391.25 95.76L382.33 119.35H400.36Z"/>&#xa;<path fill="#1F2937" d="M474.73 90.49H448.45V102.95H468.4V117.33H448.45V144.08H433.49V76.1H474.73V90.48V90.49Z"/>&#xa;<path fill="#1F2937" d="M541.71 76.1V118.96C541.65 127.27 538.96 133.85 533.65 138.71C528.41 143.57 521.53 146 513.03 146C504.53 146 497.78 143.57 492.41 138.71C487.04 133.85 484.39 127.27 484.45 118.96V76.1H499.32V119.05C499.32 122.88 500.6 125.95 503.16 128.25C505.78 130.49 509.08 131.61 513.04 131.61C517 131.61 520.27 130.49 522.82 128.25C525.38 125.95 526.69 122.88 526.75 119.05V76.1H541.71Z"/>&#xa;<path fill="#1F2937" d="M578.69 73.99C585.72 73.99 591.96 75.59 597.39 78.78L590.77 91.24C585.98 89.19 581.43 88.17 577.15 88.17C570.95 88.17 567.85 90.25 567.85 94.4C567.85 96.45 569.03 98.17 571.4 99.58C573.83 100.92 577.28 102.39 581.76 103.99C586.3 105.52 589.72 106.96 592.02 108.3C598.22 111.88 601.32 117.25 601.32 124.41C601.32 131.12 598.86 136.4 593.93 140.23C589.01 144.07 582.87 145.98 575.52 145.98C571.36 145.98 567.05 145.21 562.57 143.68C558.09 142.15 554.61 140.39 552.12 138.41L560.18 126.43C567.02 130.46 573.22 132.21 578.79 131.7C580.96 131.51 582.76 130.74 584.16 129.4C585.63 128.06 586.24 126.43 585.98 124.51C585.72 122.72 584.22 121.25 581.47 120.1C578.72 118.89 575.14 117.48 570.73 115.88C566.38 114.28 562.83 112.4 560.08 110.22C555.03 106.13 552.5 101.05 552.5 94.98C552.5 91.98 553.01 89.26 554.03 86.83C555.05 84.4 556.4 82.42 558.06 80.89C559.79 79.29 561.8 77.98 564.1 76.96C566.4 75.87 568.77 75.11 571.2 74.66C573.63 74.21 576.12 73.99 578.68 73.99H578.69Z"/>&#xa;<path fill="#1F2937" d="M626.79 144.08H611.83V76.1H626.79V144.08Z"/>&#xa;<path fill="#1F2937" d="M647.04 84.16C653.88 77.38 662.48 74 672.84 74C683.2 74 691.73 77.39 698.45 84.16C705.23 90.87 708.62 99.4 708.62 109.76C708.62 120.12 705.33 128.68 698.74 135.45C692.15 142.16 683.52 145.68 672.84 146C662.48 146 653.88 142.58 647.04 135.74C640.26 128.84 636.87 120.21 636.87 109.85C636.87 99.49 640.26 90.93 647.04 84.15V84.16ZM672.84 87.61C666.64 87.61 661.68 89.69 657.97 93.84C654.26 97.99 652.41 103.3 652.41 109.76C652.41 116.22 654.26 121.62 657.97 125.96C661.74 130.24 666.7 132.38 672.84 132.38C678.98 132.38 683.96 130.24 687.61 125.96C691.25 121.68 693.08 116.31 693.08 109.85C693.08 103.39 691.26 98.12 687.61 94.03C684.03 89.88 679.11 87.73 672.84 87.61Z"/>&#xa;<path fill="#1F2937" d="M775 144.08H759.65L732.7 101.99V144.08H718.7V76.1H732.99L761 118.57V76.1H775V144.08Z"/>&#xa;<path fill="#1F2937" d="M788.01 78.18H784.62V87.44H782.46V78.18H779.13V76.1H788.01V78.18ZM800.56 87.45H798.48V80.17L795.5 85.79H794.12L791.14 80.17L791.12 87.45H789.1V76.11H791.13L794.87 83.04L798.45 76.11H800.51L800.53 87.45H800.56Z"/>&#xa;</g>&#xa;<defs>&#xa;<linearGradient gradientUnits="userSpaceOnUse" y2="36.78" x2="162.73" y1="117.74" x1="17.0897" id="paint0_linear_1_181">&#xa;<stop stop-color="#EF4137"/>&#xa;<stop stop-color="#FBB042" offset="1"/>&#xa;</linearGradient>&#xa;<clipPath id="clip0_1_181">&#xa;<rect fill="white" height="168" width="800.56"/>&#xa;</clipPath>&#xa;</defs>&#xa;</svg>;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;323.48&quot; y=&quot;273.6&quot; width=&quot;143.03&quot; height=&quot;30&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-7&quot; value=&quot;&quot; style=&quot;shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/png,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;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;360&quot; y=&quot;303.6&quot; width=&quot;70&quot; height=&quot;36.4&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-10&quot; value=&quot;&quot; style=&quot;shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry width=&quot;50&quot; height=&quot;50&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint x=&quot;394.5&quot; y=&quot;340&quot; as=&quot;sourcePoint&quot; /&gt;&#10;            &lt;mxPoint x=&quot;394.5&quot; y=&quot;370&quot; as=&quot;targetPoint&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-11&quot; value=&quot;Shuffle Files&quot; style=&quot;shape=process;whiteSpace=wrap;html=1;backgroundOutline=1;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;310&quot; y=&quot;370&quot; width=&quot;170&quot; height=&quot;50&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-20&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.25;exitDx=0;exitDy=0;entryX=0;entryY=0.25;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot; source=&quot;wVAZ-YzccNhZugPFJvmi-13&quot; target=&quot;wVAZ-YzccNhZugPFJvmi-2&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-28&quot; value=&quot;executePlan()&quot; style=&quot;edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];&quot; vertex=&quot;1&quot; connectable=&quot;0&quot; parent=&quot;wVAZ-YzccNhZugPFJvmi-20&quot;&gt;&#10;          &lt;mxGeometry x=&quot;-0.1059&quot; y=&quot;2&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint y=&quot;11&quot; as=&quot;offset&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-23&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.25;exitY=0;exitDx=0;exitDy=0;entryX=0.25;entryY=1;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot; source=&quot;wVAZ-YzccNhZugPFJvmi-13&quot; target=&quot;t5OBkkhKOG6cYtw1sPyQ-18&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-25&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.75;exitY=1;exitDx=0;exitDy=0;entryX=0.75;entryY=0;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot; source=&quot;wVAZ-YzccNhZugPFJvmi-13&quot; target=&quot;wVAZ-YzccNhZugPFJvmi-14&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-13&quot; value=&quot;CometExecIterator&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=middle;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;45&quot; y=&quot;240&quot; width=&quot;180&quot; height=&quot;100&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-22&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.25;exitY=0;exitDx=0;exitDy=0;entryX=0.25;entryY=1;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot; source=&quot;wVAZ-YzccNhZugPFJvmi-14&quot; target=&quot;wVAZ-YzccNhZugPFJvmi-13&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-26&quot; value=&quot;next()&quot; style=&quot;edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];&quot; vertex=&quot;1&quot; connectable=&quot;0&quot; parent=&quot;wVAZ-YzccNhZugPFJvmi-22&quot;&gt;&#10;          &lt;mxGeometry x=&quot;0.0667&quot; y=&quot;1&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint x=&quot;21&quot; as=&quot;offset&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-14&quot; value=&quot;Spark Execution Logic&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=middle;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;45&quot; y=&quot;370&quot; width=&quot;180&quot; height=&quot;40&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-15&quot; value=&quot;&quot; style=&quot;shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/png,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;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;360&quot; y=&quot;173.60000000000002&quot; width=&quot;70&quot; height=&quot;36.4&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-16&quot; value=&quot;&quot; style=&quot;shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry width=&quot;50&quot; height=&quot;50&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint x=&quot;394.5&quot; y=&quot;210&quot; as=&quot;sourcePoint&quot; /&gt;&#10;            &lt;mxPoint x=&quot;394.5&quot; y=&quot;240&quot; as=&quot;targetPoint&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-18&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.25;exitDx=0;exitDy=0;entryX=0;entryY=0.25;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot; source=&quot;t5OBkkhKOG6cYtw1sPyQ-18&quot; target=&quot;wVAZ-YzccNhZugPFJvmi-4&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-29&quot; value=&quot;decode()&quot; style=&quot;edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];&quot; vertex=&quot;1&quot; connectable=&quot;0&quot; parent=&quot;wVAZ-YzccNhZugPFJvmi-18&quot;&gt;&#10;          &lt;mxGeometry x=&quot;-0.025&quot; y=&quot;-3&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint y=&quot;12&quot; as=&quot;offset&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;wVAZ-YzccNhZugPFJvmi-27&quot; value=&quot;next()&quot; style=&quot;edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];&quot; vertex=&quot;1&quot; connectable=&quot;0&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;110&quot; y=&quot;220&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;&lt;/mxfile&gt;&#10;"><defs/><g><g data-cell-id="0"><g data-cell-id="1"><g data-cell-id="wVAZ-YzccNhZugPFJvmi-30"><g><rect x="0" y="0" width="510" height="430" rx="64.5" ry="64.5" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" stroke-dasharray="3 3" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 508px; height: 1px; padding-top: 7px; margin-left: 1px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Spark Executor</div></div></div></foreignObject><image x="1" y="7.5" width="508" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="AH3lBTSLKK5181iXBnnY-2"><g><rect x="20" y="30" width="210" height="380" rx="31.5" ry="31.5" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 208px; height: 1px; padding-top: 37px; margin-left: 21px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">JVM Code</div></div></div></foreignObject><image x="21" y="37.5" width="208" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-24"><g><path d="M 170 170 L 170 193.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 170 198.88 L 166.5 191.88 L 170 193.63 L 173.5 191.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-18"><g><rect x="35" y="70" width="180" height="100" rx="15" ry="15" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 178px; height: 1px; padding-top: 77px; margin-left: 36px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Comet Parquet Reader<div><br /></div><div><br /></div><div>IO and Decompression</div></div></div></div></foreignObject><image x="36" y="77.5" width="178" height="59" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-1"><g><rect x="280" y="30" width="210" height="380" rx="31.5" ry="31.5" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 208px; height: 1px; padding-top: 37px; margin-left: 281px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Native Code</div></div></div></foreignObject><image x="281" y="37.5" width="208" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-21"><g><path d="M 300 275 L 221.37 275" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 216.12 275 L 223.12 271.5 L 221.37 275 L 223.12 278.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-2"><g><rect x="300" y="200" width="170" height="100" rx="15" ry="15" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 168px; height: 1px; padding-top: 207px; margin-left: 301px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Native Execution Plan</div></div></div></foreignObject><image x="301" y="207.5" width="168" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-19"><g><path d="M 295 145 L 221.37 145" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 216.12 145 L 223.12 141.5 L 221.37 145 L 223.12 148.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-4"><g><rect x="295" y="70" width="180" height="100" rx="15" ry="15" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 178px; height: 1px; padding-top: 77px; margin-left: 296px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Parquet Decoding</div></div></div></foreignObject><image x="296" y="77.5" width="178" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-6"><g><g><svg width="143.03" height="30" viewBox="0 0 801 168" fill="none" xmlns="http://www.w3.org/2000/svg" x="312.98" y="233.1" style="font-family: initial;">&#xa;<g clip-path="url(#clip0_1_181)">&#xa;<path fill-rule="evenodd" clip-rule="evenodd" d="M76.1297 168C88.4597 168 99.6097 158.25 107.58 142.55C127.23 144.6 143.09 139.99 149.76 128.51C156.29 117.25 152.65 101.68 141.58 86.09C152.36 70.67 155.85 55.32 149.39 44.19C143.01 33.19 128.19 28.5 109.69 29.92C101.65 11.62 89.5997 0 76.1297 0C62.6597 0 50.4997 11.73 42.4497 30.18C24.3497 28.97 9.87966 33.68 3.59966 44.51C-2.81034 55.56 0.589656 70.78 11.1897 86.09C0.299656 101.57 -3.24034 117.01 3.23966 128.18C9.80966 139.5 25.3097 144.13 44.5597 142.31C52.5397 158.15 63.7297 168 76.1297 168ZM52.7197 141.19C59.5097 154.21 68.6197 162.18 78.6397 162.18C88.6597 162.18 97.6397 154.63 104.76 142.22C95.7497 141.01 86.0297 138.46 76.0797 134.58C68.0497 137.65 60.1797 139.86 52.7197 141.19ZM65.0697 129.77C59.6397 131.52 54.3497 132.84 49.3097 133.72C47.3697 128.87 45.6997 123.54 44.3597 117.82C47.6797 120.07 51.1497 122.25 54.7497 124.32C58.1797 126.29 61.6197 128.11 65.0597 129.77H65.0697ZM76.1197 125.68C82.0597 123.2 88.0897 120.24 94.0797 116.79C102.76 111.8 110.61 106.25 117.41 100.43C118.01 95.13 118.33 89.64 118.33 84C118.33 76.79 117.81 69.8 116.84 63.17C111.11 58.53 104.73 54.12 97.7797 50.13C90.5497 45.98 83.2397 42.57 76.0697 39.91C69.1797 42.52 62.1597 45.82 55.2197 49.81C50.8597 52.32 46.7097 54.99 42.8197 57.78C41.3997 65.98 40.6297 74.8 40.6297 84C40.6297 91.65 41.1597 99.05 42.1597 106.04C47.2997 109.94 52.9197 113.66 58.9297 117.12C64.6597 120.41 70.4297 123.27 76.1197 125.68ZM87.1297 129.83C90.8397 128.07 94.5497 126.12 98.2497 124C104.42 120.45 110.18 116.61 115.48 112.58C113.79 120.73 111.42 128.22 108.52 134.76C101.82 133.95 94.6097 132.3 87.1297 129.83ZM117.71 110.84C116.16 119.65 113.87 127.8 110.98 135.03C127.49 136.56 140.52 132.79 145.95 123.44C151.17 114.43 148.57 101.58 140 88.28C134.26 96.01 126.71 103.7 117.71 110.84ZM136.56 79.61C145.46 66.59 148.33 53.99 143.08 44.93C137.99 36.16 126.02 31.96 110.76 32.43C114.3 41.14 116.97 51.23 118.5 62.2C125.46 67.76 131.53 73.64 136.55 79.61H136.56ZM108.21 32.55C111.86 40.6 114.7 50.11 116.43 60.57C110.98 56.37 105.01 52.37 98.6097 48.69C91.9597 44.87 85.2397 41.62 78.6197 38.96C89.0597 35.24 99.1497 33.11 108.2 32.54L108.21 32.55ZM107.08 30.16C97.4397 31.18 86.8897 33.79 76.0797 37.98C67.2997 34.65 58.7097 32.35 50.6497 31.1C57.5997 15.56 67.5697 5.83 78.6397 5.83C89.7097 5.83 99.7197 15.18 107.08 30.16ZM73.5197 38.99C65.2297 36.1 57.1697 34.21 49.6897 33.32C46.9897 39.84 44.7997 47.28 43.2497 55.38C46.7897 52.94 50.4997 50.6 54.3797 48.37C60.7497 44.71 67.1697 41.58 73.5197 38.99ZM33.7197 62.5C35.2297 51.54 37.8697 41.46 41.3797 32.74C26.5297 32.46 14.9097 36.66 9.91966 45.26C4.70966 54.24 7.48966 66.68 16.1997 79.58C21.0897 73.73 26.9797 67.96 33.7197 62.5ZM12.7697 88.3C18.3697 95.9 25.7197 103.48 34.4997 110.54C36.0297 119.36 38.3097 127.53 41.1797 134.78C25.0597 136.11 12.3797 132.31 7.03966 123.12C1.85966 114.19 4.36966 101.48 12.7597 88.31L12.7697 88.3ZM17.5697 81.54C21.9097 75.99 27.2197 70.45 33.3797 65.17C32.6597 71.22 32.2697 77.53 32.2697 84C32.2697 88.91 32.4897 93.72 32.9097 98.4C26.7997 92.89 21.6197 87.18 17.5597 81.53L17.5697 81.54ZM135.19 81.55C131 87.32 125.65 93.15 119.32 98.76C119.76 93.97 120 89.03 120 84C120 77.41 119.6 70.99 118.85 64.84C125.22 70.21 130.72 75.87 135.19 81.55Z" fill="url(#paint0_linear_1_181)"/>&#xa;<path d="M204.34 45.97H192.83L190.47 52.2H185.2L196.07 23.88H201.47L212.54 52.2H206.78L204.34 45.97ZM202.74 41.74L198.54 30.99L194.46 41.74H202.73H202.74Z" fill="#1F2937"/>&#xa;<path d="M235.55 23.88H246.82C249.59 23.88 251.9 24.73 253.73 26.44C255.57 28.14 256.49 30.38 256.49 33.15C256.49 35.92 255.57 38.2 253.73 39.9C251.89 41.6 249.59 42.46 246.82 42.46H240.95V52.21H235.56V23.89L235.55 23.88ZM240.94 37.26H246.85C248 37.26 248.96 36.87 249.73 36.1C250.5 35.3 250.89 34.32 250.89 33.14C250.89 31.96 250.5 31 249.73 30.22C248.98 29.45 248.02 29.06 246.85 29.06H240.94V37.25V37.26Z" fill="#1F2937"/>&#xa;<path d="M293.67 45.97H282.16L279.8 52.2H274.53L285.4 23.88H290.79L301.86 52.2H296.1L293.66 45.97H293.67ZM292.07 41.74L287.87 30.99L283.79 41.74H292.06H292.07Z" fill="#1F2937"/>&#xa;<path d="M335.99 23C338.57 23 340.92 23.68 343.02 25.04C345.15 26.37 346.84 28.18 348.1 30.47L343.1 32.87C341.37 29.57 339 27.92 335.99 27.92C333.62 27.92 331.65 28.91 330.07 30.88C328.53 32.82 327.75 35.22 327.75 38.07C327.75 40.92 328.52 43.32 330.07 45.26C331.62 47.18 333.59 48.14 335.99 48.14C337.45 48.14 338.81 47.73 340.07 46.9C341.32 46.05 342.32 44.93 343.07 43.54L347.99 45.9C346.79 48.14 345.13 49.89 342.99 51.17C340.86 52.42 338.53 53.05 336 53.05C331.95 53.05 328.63 51.65 326.05 48.86C323.47 46.04 322.17 42.44 322.17 38.07C322.17 33.7 323.48 30.13 326.09 27.28C328.73 24.43 332.03 23.01 336 23.01L335.99 23Z" fill="#1F2937"/>&#xa;<path d="M393.49 52.2H388.09V40.61H377.1V52.2H371.71V23.88H377.1V35.43H388.09V23.88H393.49V52.2Z" fill="#1F2937"/>&#xa;<path d="M435.17 29.07H423.9V35.46H432.41V40.65H423.9V47H435.17V52.19H418.51V23.87H435.17V29.06V29.07Z" fill="#1F2937"/>&#xa;<path d="M185 76.1H207.25C218.63 76.1 227.58 79.3 234.1 85.69C240.69 92.02 243.98 100.14 243.98 110.04C243.98 119.94 240.69 128.1 234.1 134.49C227.51 140.88 218.53 144.08 207.15 144.08H184.99V76.1H185ZM199.96 90.49V129.7H206.67C209.55 129.7 212.2 129.38 214.63 128.74C217.12 128.1 219.43 127.08 221.54 125.67C223.71 124.26 225.41 122.25 226.62 119.63C227.83 116.95 228.44 113.75 228.44 110.04C228.44 106.33 227.83 103.17 226.62 100.55C225.4 97.93 223.71 95.92 221.54 94.51C219.43 93.1 217.16 92.08 214.73 91.44C212.3 90.8 209.61 90.48 206.67 90.48H199.96V90.49Z" fill="#1F2937"/>&#xa;<path d="M291.82 130.85H264.96L259.97 144.08H245.39L271.38 76.1H286.34L312.91 144.08H296.89L291.81 130.85H291.82ZM287.4 119.35L278.29 95.76L269.37 119.35H287.4Z" fill="#1F2937"/>&#xa;<path d="M362.7 90.49H342.94V144.09H327.98V90.49H308.51V76.11H362.7V90.49Z" fill="#1F2937"/>&#xa;<path d="M404.77 130.85H377.92L372.93 144.08H358.35L384.34 76.1H399.3L425.87 144.08H409.85L404.77 130.85ZM400.36 119.35L391.25 95.76L382.33 119.35H400.36Z" fill="#1F2937"/>&#xa;<path d="M474.73 90.49H448.45V102.95H468.4V117.33H448.45V144.08H433.49V76.1H474.73V90.48V90.49Z" fill="#1F2937"/>&#xa;<path d="M541.71 76.1V118.96C541.65 127.27 538.96 133.85 533.65 138.71C528.41 143.57 521.53 146 513.03 146C504.53 146 497.78 143.57 492.41 138.71C487.04 133.85 484.39 127.27 484.45 118.96V76.1H499.32V119.05C499.32 122.88 500.6 125.95 503.16 128.25C505.78 130.49 509.08 131.61 513.04 131.61C517 131.61 520.27 130.49 522.82 128.25C525.38 125.95 526.69 122.88 526.75 119.05V76.1H541.71Z" fill="#1F2937"/>&#xa;<path d="M578.69 73.99C585.72 73.99 591.96 75.59 597.39 78.78L590.77 91.24C585.98 89.19 581.43 88.17 577.15 88.17C570.95 88.17 567.85 90.25 567.85 94.4C567.85 96.45 569.03 98.17 571.4 99.58C573.83 100.92 577.28 102.39 581.76 103.99C586.3 105.52 589.72 106.96 592.02 108.3C598.22 111.88 601.32 117.25 601.32 124.41C601.32 131.12 598.86 136.4 593.93 140.23C589.01 144.07 582.87 145.98 575.52 145.98C571.36 145.98 567.05 145.21 562.57 143.68C558.09 142.15 554.61 140.39 552.12 138.41L560.18 126.43C567.02 130.46 573.22 132.21 578.79 131.7C580.96 131.51 582.76 130.74 584.16 129.4C585.63 128.06 586.24 126.43 585.98 124.51C585.72 122.72 584.22 121.25 581.47 120.1C578.72 118.89 575.14 117.48 570.73 115.88C566.38 114.28 562.83 112.4 560.08 110.22C555.03 106.13 552.5 101.05 552.5 94.98C552.5 91.98 553.01 89.26 554.03 86.83C555.05 84.4 556.4 82.42 558.06 80.89C559.79 79.29 561.8 77.98 564.1 76.96C566.4 75.87 568.77 75.11 571.2 74.66C573.63 74.21 576.12 73.99 578.68 73.99H578.69Z" fill="#1F2937"/>&#xa;<path d="M626.79 144.08H611.83V76.1H626.79V144.08Z" fill="#1F2937"/>&#xa;<path d="M647.04 84.16C653.88 77.38 662.48 74 672.84 74C683.2 74 691.73 77.39 698.45 84.16C705.23 90.87 708.62 99.4 708.62 109.76C708.62 120.12 705.33 128.68 698.74 135.45C692.15 142.16 683.52 145.68 672.84 146C662.48 146 653.88 142.58 647.04 135.74C640.26 128.84 636.87 120.21 636.87 109.85C636.87 99.49 640.26 90.93 647.04 84.15V84.16ZM672.84 87.61C666.64 87.61 661.68 89.69 657.97 93.84C654.26 97.99 652.41 103.3 652.41 109.76C652.41 116.22 654.26 121.62 657.97 125.96C661.74 130.24 666.7 132.38 672.84 132.38C678.98 132.38 683.96 130.24 687.61 125.96C691.25 121.68 693.08 116.31 693.08 109.85C693.08 103.39 691.26 98.12 687.61 94.03C684.03 89.88 679.11 87.73 672.84 87.61Z" fill="#1F2937"/>&#xa;<path d="M775 144.08H759.65L732.7 101.99V144.08H718.7V76.1H732.99L761 118.57V76.1H775V144.08Z" fill="#1F2937"/>&#xa;<path d="M788.01 78.18H784.62V87.44H782.46V78.18H779.13V76.1H788.01V78.18ZM800.56 87.45H798.48V80.17L795.5 85.79H794.12L791.14 80.17L791.12 87.45H789.1V76.11H791.13L794.87 83.04L798.45 76.11H800.51L800.53 87.45H800.56Z" fill="#1F2937"/>&#xa;</g>&#xa;<defs>&#xa;<linearGradient id="paint0_linear_1_181" x1="17.0897" y1="117.74" x2="162.73" y2="36.78" gradientUnits="userSpaceOnUse">&#xa;<stop stop-color="#EF4137"/>&#xa;<stop offset="1" stop-color="#FBB042"/>&#xa;</linearGradient>&#xa;<clipPath id="clip0_1_181">&#xa;<rect width="800.56" height="168" fill="white"/>&#xa;</clipPath>&#xa;</defs>&#xa;</svg></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-7"><g><image x="349.5" y="263.1" width="70" height="36.4" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABwgAAAOoCAMAAADyHlBJAAADAFBMVEUAAAABAQECAgIDAwMEBAQFBQUGBgYHBwcICAgJCQkKCgoLCwsMDAwNDQ0ODg4PDw8QEBARERESEhITExMUFBQVFRUWFhYXFxcYGBgZGRkaGhobGxscHBwdHR0eHh4fHx8gICAhISEiIiIjIyMkJCQlJSUmJiYnJycoKCgpKSkqKiorKyssLCwtLS0uLi4vLy8wMDAxMTEyMjIzMzM0NDQ1NTU2NjY3Nzc4ODg5OTk6Ojo7Ozs8PDw9PT0+Pj4/Pz9AQEBBQUFCQkJDQ0NERERFRUVGRkZHR0dISEhJSUlKSkpLS0tMTExNTU1OTk5PT09QUFBRUVFSUlJTU1NUVFRVVVVWVlZXV1dYWFhZWVlaWlpbW1tcXFxdXV1eXl5fX19gYGBhYWFiYmJjY2NkZGRlZWVmZmZnZ2doaGhpaWlqampra2tsbGxtbW1ubm5vb29wcHBxcXFycnJzc3N0dHR1dXV2dnZ3d3d4eHh5eXl6enp7e3t8fHx9fX1+fn5/f3+AgICBgYGCgoKDg4OEhISFhYWGhoaHh4eIiIiJiYmKioqLi4uMjIyNjY2Ojo6Pj4+QkJCRkZGSkpKTk5OUlJSVlZWWlpaXl5eYmJiZmZmampqbm5ucnJydnZ2enp6fn5+goKChoaGioqKjo6OkpKSlpaWmpqanp6eoqKipqamqqqqrq6usrKytra2urq6vr6+wsLCxsbGysrKzs7O0tLS1tbW2tra3t7e4uLi5ubm6urq7u7u8vLy9vb2+vr6/v7/AwMDBwcHCwsLDw8PExMTFxcXGxsbHx8fIyMjJycnKysrLy8vMzMzNzc3Ozs7Pz8/Q0NDR0dHS0tLT09PU1NTV1dXW1tbX19fY2NjZ2dna2trb29vc3Nzd3d3e3t7f39/g4ODh4eHi4uLj4+Pk5OTl5eXm5ubn5+fo6Ojp6enq6urr6+vs7Ozt7e3u7u7v7+/w8PDx8fHy8vLz8/P09PT19fX29vb39/f4+Pj5+fn6+vr7+/v8/Pz9/f3+/v7////isF19AAAACXBIWXMAAC4jAAAuIwF4pT92AAAgAElEQVR4nO3dd4DlVPn/8bu9sezSexFQEURpAlJEOj9AQYoFVkCUKogKfCkqUkVAQBFFUYogiCACSkelCCtdunSQDtLZXbZOfjtz78zckpznnOTkJifP+/WPMpOcfO41Ph9mJjepRQAAKFYrOgAAAEWiCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhECAFSjCAEAqlGEAADVKEIAgGoUIQBANYoQAKAaRQgAUI0iBACoRhEC1fb000UnsENOFIYiBCrtW7XaPnOKDmGBnCgORQhU2TO1uXYt/+QmJwpEEQJVNrl3cNe+PKvoHBJyokAUIVBl9cFd/p9hyIkCUYRAlTUGd+l/hiEnCkQRAlXWP7jLPrnJiQJRhECVDQzukk9ucqJAFCFQZYODu9x/1yInCkQRAlXWNLhL/TMMOVEgihCosubBXebJTU4UiCIEqqxlcJd4cpMTBaIIgSprHdzlndzkRIEoQqDK2gZ3aSc3OVEgihCosvbBXdbJTU4UiCIEqqxjcJd0cpMTBaIIgSrrHNzlnNzkRIEoQqDKYgZ3KSc3OVEgihCosrjBXcbJTU4UiCIEqix2cJdwcpMTBaIIgSqLH9zlm9zkRIEoQqDKEgZ36SY3OVEgihCosqTBXbbJTU4UiCIEqixxcJdscpMTBaIIgSpLHtzlmtzkRIEoQqDKDIO7VJObnCgQRQhUmWlwl2lykxMFogiBKjMO7hJNbnKiQBQhUGXmwV2eyU1OFIgiBKpMGNylmdzkRIEoQqDKpMFdlslNThSIIgSqTBzcJZnc5ESBKEKgyuTBXY7JTU4UiCIEqsxicJdicpMTBaIIgSqzGdxlmNzkRIEoQqDKrAZ3CSY3OVEgihCoMrvBXfzkJicKRBECVWY5uAuf3OREgShCoMpsB3fRk5ucKBBFCFSZ9eAueHKTEwWiCIEqsx/cxU5ucqJAFCFQZQ6Du9DJTU4UiCIEqsxlcBc5ucmJAlGEQJU5De4CJzc5USCKEKgyt8Fd3OQmJwpEEQJV5ji4C5vc5ESBKEKgylwHd1GTm5woEEUIVJnz4C5ocpMTBaIIgSpzH9zFTG5yokAUIVBlKQZ3IZObnCgQRQhUWZrBXcTkJicKRBECVZZqcBcwucmJAlGEQJWlG9zdn9zkRIEoQqDKUg7urk9ucqJAFCFQZWkHd7cnNzlRIIoQqLLUg7vLk5ucKBBFCFRZ+sHd3clNThSIIgSqLMPg7urkJicKRBECVZZlcHdzcpMTBaIIgSrLNLi7OLnJiQJRhECVZRvc3Zvc5ESBKEKgyjIO7q5NbnKiQBQhUGVZB3e3Jjc5USCKEKiyzIO7S5ObnCgQRQhUWfbB3Z3JTU4UiCIEqszD4O7K5CYnCkQRAlXmY3B3Y3KTEwWiCIEq8zK4uzC5yYkCUYRAlfkZ3PlPbnKiQBRhyUx/8JqzTzn+h8efcubld79edBiEz9Pgzn1ykxMF0lqE59TPxq+btvlN3Pk7ZNzCK2y6388f9naUZm+escGI5oN95Dv3GJM9aVjr341tLhdfUpu7bNMiBL4Gd96Tm5wokNYi3KB+Mo6fYtjG2BpLHPi4n6MMen7vkZ3H+ewNhmQUISTeBnfOk5ucKJDSInyy/2Q817CR0BpDtn7Mx1H6zTxqVML/X15NTEYRQuJvcOc7ucmJAiktwiP6z8XPGDYSW2PE4eYz2eooDU99MvEwi0xOSkYRQuJxcOc6ucmJAukswjlLDpyLhi6xaI3Pmq5nsTtK3c3zG44y6pKEZBQhJD4Hd56Tm5wokM4ivHbwVDwieSub1vjYG1mP0uemMYPbLrzVd4//6QlHfHmVIQNfGnFjfDKKEBKvgzvHyU1OFEhnEX5x8Excck7iVv2tcc1DTR781w2/2v/Dg/uv+UHGo/S6d57+DUd//Y6e/q++fNrS/V8e33plTuYivPyhZNOMUREYv4M7v8lNThRIZRG+1XxZyrWJmxnq5t7tB/b/dsajzPX2h/o3+/yzLd+YftjQxjc+Pdsy2QBjEYq/qkVVeB7cuU1ucqJAKovw580n4k6Jmxlb48r5Gt8d0nEpi9tR5tqxsdHQn3Z869L+T1T8zDpZA0WIXr4Hd16Tm5wokMoiXL3vBBy5TN9/jHozaTNzazy8cOPbm2Y7ShRd3Vho6IUx3zy38c1Fplonq6MI0cv74M5pcpMTBdJYhA/Uz7/tT63/5+lJ2wmt8c/hje/HX11ie5Ro1vKNdU6I/fbOje+eap+sD0WIXv4Hdz6Tm5wokMYiPLB++l3+yrC+/1w1aTupNfZvfD/+r4S2R4l+11hmk/hvvzy6/u2POSTrRRGiVw6DO5fJTU4USGERzlyw7+Sbf0a0Zf00/HfChlJrvNK4L+hSmY4Sfaz+/RFPJXx/70aMph88KULYymNw5zG5yYkCKSzCy+rn3j5RdGH9vx2QsKHYGts1Nngxy1Fuayyyb9JR7mps8D2HZBFFiLpcBncOk5ucKJDCIty6furdHkVT6x/fm396/IZia/RvcFWWo+xZ33BIcjc1PlyxnkOyiCJEXT6D2//kJicKpK8IG3+zW673v+9aPwnb72DWILbGvY0Nfp7hKD2Ni083Tk78jfoWIwablCKErZwGt/fJTU6/OeFEXxGeWD/vjuz97zfW//uW8VuKrfFWY4PjMhzlvsYaZyQn7r+a5iH7ZBFFiLq8BrfvyU1OmrBA+opwxfpp90Tvf5+zRN9/H/pC7JZia8xqbHBYhqP8pLFG0qUy0eAPnpfZJ4soQtTlNrg9T25y0oQFUleEjfN4nfo/HVL/p+NjNxVbY0pjg6MzHKXxMcEJhsgzb6p7yT5ZRBGiLr/B7Xdyk5MmLJC6Imxcm/KL+j89WP+nFWI3FVvj2cYGp3Z8x/4oK9e/t4HTi6AIYSvHwe11cpOTJiyQtiKcOm/fGTei/+lJjcfh3hK3rdga1zQ2uCjDURp35k76cEU8ihC28hzcPic3Of3mhBNtRXh+/YT7fP8/N/5Et1vctmJr/F9jgwfTH+X1xhKGa2XSJIsoQtTlOrg9Tm5y+s0JJ9qKcKP6+XZp/z+/XP+Yw7j3Y7aVWqOncZPQUTPTH+X+xjEucHoVFCFs5Tu4/U1ucvrNCSfKivCZ+lPfJw5+JG/z+vn325iNpda4vPH9rTIc5ZbGGlc6vQyKELZyHtzeJjc5/eaEE2VFeGT9ZNtz8CsX1L+ybszGQmtMWa7x/d9kOMr1jTVudnoZ/clufDZZf03HFmHSjq84xUAA8h7cviY3Of3mhBNdRdhTfzhg81UrU8bVv/RY59bmIpy5TePb87+X4ShXNha51+l19CezEVuESTZ0ioEA5D64PU1ucvrNCSe6irBxj5dlepq+9tX61w7t3NpYhK9s1H/eHpvlKP0/tyU+myIWRQhb+Q9uP5ObnH5zwomuImx8ev17zV+7of61xWZ3bG0owjd/PKH/rP3wlCxHoQiRry4M7tquc8hZtpxwoqoI3xlTP8/+0/zFOYvVv9j5CIn4P6g9euelx202euCcHX5npqNQhMhXNwa3j8lNTr854URVEZ5ZP8s+1frVg+pf3b5jc5u6GfbHbEehCJGvZxzOlfSyT25y+s0JJ6qKcK36Sfaz1q82Pso34vX2zS3qZuzFGY9CESJnezqcLOlln9zk9JsTLjQV4SP1U2z4a21fX6X+9dPat5frZqWH2vdxPUq2q0b5HCFEc3bLOJPtZL7Cg5x+c8KFpiJs/HZy6/avn1T/+irtX5eKcOEz4s5Vt6Nk+xwhRQhZKJObnH5zwoGiIpy1SP0E6/ht5ktD69+4u+3rxiIcucXF09sXSnGU/jvL/MXppVCEcBDK5Can35ywp6gIG7+FHD+t4zub1r+zX9uX44tw9PzLrPfVY//euUqqo/TX1e+dXgpFCBehTG5y+s0Ja4qKcNv62fWphzo0Hpxb+6B1h1St4XiU1xpf/FnSerEoQjgJZXKT029O2NJThK+NEM+7tucKpmkN16P0jKx/cW+n10IRwk0ok5ucfnPCkp4iPEU+7TZr3SNNazgf5WP1L67n9FooQjgKZXKT029O2NFThB+Xz7qh/23ZI01rOB/ly/UvTjSsOfOmupecklGEaBbK5Can35ywoqYI77I5645u2SVFa7gf5cTGF2OeftG+6GVOyShCtAhlcpPTb07YUFOE+9qcdB9qfmBEmtZwP8qdjS/+KHnRsxqbPOKUjCJEq1AmNzn95oQFLUX4wUSrk+4fzfu4t0aKo8xZoP61NZJX3aW+xegZTskoQrQJZXKT029OyLQU4UX1c2pY0iPYV65/f1Lz19xbI81R+v/P9FTSonMWrW+wsVsyihDtQpnc5PSbEyItRbhZ/ZTaIun7P65/f8y7TV9zb400R/l74yh7JO10U2OD492SUYToEMrkJqffnJAoKcLnG/c3S7yBywuNDX7d9DXn1kh1lJ7l618b9njCTpMaMZq+TxEinVAmNzn95oRASREeUz+f5ul4mvyAjetbrN30JefWSHWU6FeNw+wYv8vzjY/or+uYjCJEjFAmNzn95oSZjiLsWa5+Ou2avMm5jTNu8NJM59ZId5Ro+pKNL14Yu8uOje82/5hJESKtUCY3Of3mhJGOIuz/M9uNyZu8N7a+ycGDX3JtjXRHiaI/NPYbe3vMHuc0vrli84M6KUKkFsrkJqffnDDRUYS71s+lxU1Pff5KfZtFBs8319ZId5Ro4Bqb2oTOCr2kcS/S2p+bv0oRIr1QJjc5/eaEgYoifG9c/VQ62LTRNY3z7YqBrzi2RsqjzPXywo2vDv/hzJatpx0ypPGdL7V8nSJEBqFMbnL6zYlkKoqwf/w/YNpoduOJutt27GbZGimP0uvvA8+sWO7Mtwe++twJS/R/edk3Yw+VugivfTLZ20kroipCmdzk9JsTiVQU4br18+gT5q2+Xd9q+Kv9X3AswpRH6XPJsIGzffj6+5145i9OPnSHDw/+P2DBto9WZC5Ck1PsXi4CFsrkJqffnEiioQgfb5xGJ5k3u7ex2cn9X3ArwrRHqbt0jOH8X/y+tkUoQmQTyuQmp9+cSKChCA+tn0RDXxS2W6m+3Ur9/+xWhGmP0nDHUoln/xodS1KEyCiUyU1OvzkRT0ERzl68fg5tKm14QuNku6Pxz05FmPoo/d7dY0gtzuhjZ3asQREiq1AmNzn95kQsBUV4deMU+p204fONJtqr8c9ORZj6KIPu3bLzvB+9Z9zNuClCZBbK5Can35yIo6AIG7dmGfu+uOVG9S3nnVb/R6ciTH2UZo8dsnzzOT9y41Nei12CIkR2oUxucvrNiRgKijAsz1189G7bbbr59rsdcvbtcqkC6YUyucnpNyc6UYSAVqFMbnL6zYkOFCGgViiTm5x+c6IdRQjoFcrkJqffnGhDEQKKhTK5yek3J1pRhIBmoUxucvrNiRYUIaBaKJObnH5zohlFCOgWyuQmp9+caEIRAsqFMrnJ6TcnBlGEgHahTG5y+s2JARQhoF4ok5ucfnOiH0UIIJTJTU6/OdFAEQIIZnKT029O1FGEAMKZ3OT0mxN9KEIAUTiTm5x+c6IXRQigVyiTm5x+cyKiCAE0hDK5yek3JyhCAP1Cmdzk9JsTFCGAfqFMbnL6zQmKEEC/UCY3Of3mVI8iBDAglMlNTr85taMIAQwKZXKT029O5ShCAE1Cmdzk9JtTN4oQQLNQJjc5/eZUjSIE0CKUyU1Ovzk1owgBtAplcpPTb07FKEIAbUKZ3OT0m1MvihBAu1AmNzn95lSLIgTQIZTJTU6/ObWiCAF0CmVyk9NvTqUoQgAxQpnc5PSbUyeKEECcUCY3Of3mVIkiBBArlMlNTr85NaIIAcQLZXKT029OhShCAAlCmdzk9JtTH4oQQJJQJjc5/eZUhyJEVfS8dOt5Jx7ytW02WnfNVVZada0NNt1h7++ddsk9bxedK2ihTG5y+s2pDUWICnjvltMmfXxMwlCYb519f3PvjKIjhiqUyU1OvzmVoQhjzPrOQjbn2tgtnvFzvPd2n5D9zB85foGl19hi0vfP/ef/qhPGxgd/O3ytYWKiMZv9+K7ZKY8wfeeJpqWHrfhHp+Wmfm0+03KLHjDdLd5ta4xIXm3o0ke5rdYhlMlNTr85daEIYxxpe7Kt0uPleHt4/v/AMl844c45lQgjmnLJTmOtoyy01w2ppsM50sLD7nFZbm9pub2d0r1ubOm57ndarlMok5ucfnOqQhF2mrWg9cn2dy8HtPr509HEHS56P/wwglt2tm/BugX2f9j9MOeJy+7lsNr7o6XVRjq9WadJy/3L8eV2CGVyk9NvTk0owk5/sz/X9vVywFH5/B9hzA7XpfiJtVRhTN4/faVUSda/0HVAPC+uuaLDajfIEa9zSfd5YbEhbzm+3E6hTG5y+s2pCEXYaT/7U20xL8M9p+6Za/lTnH8SK1WYZO8ct0DqIB/6teOlMyuISzr8KfQoOeDhLuGkH+FXcXutsUKZ3OT0m1MPirBDzxIOp9pkH0fMr3tqtQWOfy/gMEmmHSP9YcxsybOc/mwp/lWvdoX9YpvL8dZ1yPaEtNg3XV5pklAmNzn95lSDIuzwL5cz7WAfR8yze2q1hdyGfqnCJLhoqcxBVr3Z4XiXiMsdYr3WHIuLckdOs892nrTYJQ4v1BA7kMlNTr85taAIOxzicqIt7+OI+XZPrbbanaGGifWf9bwE+eJr1kf83xBpsU9br/WgTTaHi7D2ktZ6xX4tk1AmNzn95lSCIuwg/0GoWdZr03vl3T21YUfY/1GsVGFizD5JvOrS0oJ/sD7oqtJaIz+wXepXNtGOtH8/Pi4s9RH7pcxCmdzk9JtTB4qw3QNu55nDyEqUe/fUap98MsgwnZ5d22OQHd+xPOpB4lK32L6AXW2CbWj9frw7VFjqG9ZLSUKZ3OT0m1MFirDdUW6nmY9r8rrQPbWJV4cYpsPV83sNssIDdoe9RlzpR7avwOoXDqOtby5znbTU+bYryUKZ3OT0m1MDirDdJxxPsww/3fTrRvfUhpwSYJg2PUeKf6xzNMauJ6YYbmJWt5XlS3jdLpf1D5jiXZCes13JQiiTm5x+cypAEbZ5yvUsOzH7MbvSPbXaoeGFaTVj5xyCHGN16PWlZSZafqL0Cp+p5tpUWGhp24WshDK5yek3Z/VRhG1Ocj3J1s5+zC51j90nykoVpsW7G+cSZC+be3H/UFzmQbsX8X92oTaxfE/mzCssNMlyIdvjBTK5yek3Z+VRhG3WcT3HhryY+Zjd6h6rO5aUKkyzd9bIKchOFk14q7jKmXavQvzRsm7sTLvl7pcWOstuHWuhTG5y+s1ZdRRhq5fc/wj188wH7Vr31E4NLEyT95z/FcXaLvKH/GeOExexehUzkx6a2O52u3fll9I6j9mtYy+UyU1OvzkrjiJs9Qv3U2zjzAftXvcMk2/nXKowg6ZukGOSPeTjbyGtsYzVy7jDNtIJdm/LJGGZReyWcRHK5Can35zVRhG22sT9DBv+RtaDdq97ahOfCCrMgJ4dck0iP7xW/tvxCzav41TbRFvavS/LCcvsaLeMk1AmNzn95qw0irDFm8NTnGHnZD1qF7untqb0f4dShRlwWL5BhlwsBbhXXENcoteOtonG21zCE70mLXO6zSquQpnc5PSbs8oowhbnpjnBtsl61G52T+0HIYXp9/u8g4y+W0gwR/wk//42L8T+ySZ32Sz3Z2kVH3cA7BTK5Can35wVRhG2+Fya82tU1sfsdbV7ht0bUJiGx8VLVTJbTnpAlPi72VUtXshz9oFOtnljDhYWmejjWR8xQpnc5PSbs7oowmZT0t3P+Y8ZD9vV7qmtY/7od6nC1M1YrQtJpKs+xeszh70rv5KL7PNY/Z5hXR+LpBHK5Can35yVRRE2k587F+tLGQ/b3e6p/TacMHXyLa99uMAc4nFxgevlV7K/fZwJFj/MzZD+xzrJ4t1NJ5TJTU6/OauKImz25XRn13jrWyTH63L3LGp87GupwvS5e1hXkizwP3OMJaUFLP7gubpDnvvk5SZLa9whr5FWKJObnH5zVhRF2GSGdL+qJH/Ndtwud0/NeMfrUoXpNbsbvxjttas5hzioNhL/h57qclHyaeJy0U+EJcblOfVCmdzk9JuzmijCJlelPbm+lu243e6ehaeGEqaX9UfvmqV6SsU/jDnOl3YfK46Yf7ik2U5aLYq2F5bYVF4ig1AmNzn95qwkirDJ19OeWwtYfegrUbe7p/arUMLM9dZEl8UW3f6EP9710juzomlvPHPTOYdv5HS56erGK3deEvcXP/FwnEuaBeTriBYTlrB+hkU6oUxucvrNWUUU4aDZC6U+t8w/S0jE7llhZaPlF3O82nXlUMJE1o9r6LXKcY+37z3r9gPtP7pX+4MxyUel3cWbp25lH2Wuh6TlnpFWuFlaIaNQJjc5/easIIpw0E3pTy2rD1MnkrpHfmJRzyv/PGWH8fZ5DcVdqjBzfw6zvUv10O0TfiDruUL6kMGAFYwTYj9p9+2lN0b8UH6LM4TlxNsMjPpAWiGrUCY3Of3mrB6KcNAB6c+sJS0fyxpP6h6rz1ZH0fQrN7PNu3sgYaLo25aLbPqoYZG/rWS5ynmmKJdJe0t3uH7UMkXDTsJyYjOvLy2QXSiTm5x+c1YORThoqQxnVqbr1D11z1z3W7bPhOQPfJQqTPSO3U+WCwg3+px10kirdT5hWuStodLuT5pT/NYqw4CFzatF0arCAkdIC3gQyuQmp9+cVUMRDrgry4l1aJYj++ueKLrU7tdvV4QRJjrZaoG1/itGuWsZq5VuNK0hPhn4XHOGPawiDPqPebn3pc9XujzmKrVQJjc5/easGIpwQKYHHHw4y5F9dk/04po2eb8RRpg5S9vs/+UZFlHeXNtmqa1NS4jX7XzdHGFFmwRNhOtp/ybsPky6faofoUxucvrNWS0U4QDxokAj8RI/A6/dE03dxiLu0mGEudFi79oedneWfv+zFmsNe8WwwvXS3isaA7zl+uHGr5hf0DHC7mtavS3ZhTK5yek3Z6VQhP0eznZaHZ3h0H67J5ph87e5xF+7lSrMrhY7T7K9UGmazc+Epo9ATBX/0Gi8S5vz/RoWN7+eLYXdv2v5vmQWyuQmp9+cVUIR9pP+/VrwyQyH9tw90ZRV5LyJN7suU5gp88j7rm9/o9dXLf5OaHyY0obS3oa/dkbREfLR2xgvvumZL0sYr0KZ3OT0m7NCKMJ+0iV4kqfTH9p390SPywWydwhhLhX3rC0q3Cq7xf0W144+Ydhf/Jelg01H/6x88DZnm5aTfoUx5E2HdyajUCY3Of3mrA6KsOHZrCfVT9If23v3RKeJcdcIIczu4p61q52inCAv+FPD7rdLO3/asPNs96cLG28Dfpaw88ed3pmMQpnc5PSbszIowoZTsp5T66Y/tv/umb2yFHdU0hUmJQrTs6i0o+vtzuesJa64uWH3WdKnGkca7uVyj3joDsuYXsvuws77ub01GYUyucnpN2dVUIQN6wlnzHLSvZ+HvJz62P67J7pQ/L/As+UPc5+431jXN/02cclRUwy7izcLvSV53w66qQsAACAASURBVNPFQ3d6zpDlI8K+wj0GfAtlcpPTb86KoAjrXpXuGvL4sdIp9cvUB8+he2aLt5pO+uh4icL8VNqt9n3nLJ8X1zTd+lT8vcHxyfumeerz75KXe0PaN/2/mKUTyuQmp9+c1UAR1p0pnC6rRA9IZ1T6h7/l0D3Rd6S4SZ/WLlEYsTrGuF8Pcqe0Zu0Ew973Sztvlbyv1b0B2uyRvNxfhF1XcH5rsgplcpPTb85KoAjrNhfOlsOiaFlhk+FvpT14Ht3zT+n8T/rgY4nCLCvtluaByOK9brY17NwjPalrYuKHGuXHGcZYPjmKdCMkQ4fmJZTJTU6/OauAIuzz9gjhZLnN4uEUht9jmeXRPTOkpwImPTmqPGFeF3aq1e5MkUW88/Wipr2/KO39YNKel4ivJs6LiUk+I+xpfJBGTkKZ3OT0m7MCKMI+5wunygJzougG6Xwy/ShhlEf3ROsIi36p9GHE50MulSbKG9Ktqmumn+x/Le18ZtKets+TanVh0nKzxgp7PpPmzckqlMlNTr85w0cR9tlOOFMmzd1m5rzCRmNM1xua5NI9uwiL/r/ShxFLJ90HBNaXljU9UuspaeddkvaUP7gRZ6+k5aRnpSyZ6r3JLJTJTU6/OYNHEfaaKj0Gve9S9J2k0+nSlIfPpXu+Jyy6cenDHCTsVPtrmijRj6Rljb/ilu7StkzCfh9Iv3yPl3gbb+mK2p1TvTfZhTK5yek3Z+gowl7Ss8eHv9271QXS2ZR2+OTSPScKi65X+jDiJx1eSxNFfHqR+TMZ4jMFX4jf71ZpvwSvJuSQ/lgpPMIpP6FMbnL6zRk4irCX9Ju7Dfu2elP669IEm+fixcile84QFv1U6cNI13cmP73J6B3paUjG6y3FmwMkfI79x9J+CS5JyLGksN+j6d4cD0KZ3OT0mzNsFOFcM6W7xjSGv3ShXu2adMfPpXukO3yuX/ow0gfvPpcmSSR/KmMb086vCDsnXY0rf5A/3jfjl3tB2G2hlO+ND6FMbnL6zRk0inCua6VzpPG8vJOl7ZIftW6US/ccJyya9Pn/8oRJ+wEQifTvM0k/K9etJOyd8Bwn6QOISRJunX2xsNv2Kd8bL0KZ3OT0mzNkFOFcewpnSP/Hmh+XTqWF7J6V3i6X7vmWsGjSzz2lCfOesE/tpDRJ5pokrLuscW/p46RD343b6wnpxSQZ8kZsCukNNT1DI3+hTG5y+s0ZMIpw7mm2iHCCHNi/pXSfY9M9lw1y6Z6tpbO+7GHEX0ImfsZOcKiwrvnXildIsa6P2+s8aa9Ef45NIf399L6U740noUxucvrNGS6K0OKCvoFbQh8sbXmg6TiJcumeZYVFv132MM8J+6R+Arv0eN3xxr3fkS6Z+kHcXntJLyZR7Ck1TfgwxoR0v5rwJ5TJTU6/OYNFEcr3/Bg/cDHoLdKJlO5Cxjy650UpatIvFksTRvxFdOyPXhZ+Iqw70ry79Mn4jeJ2+rj0YhLF/s3xZmEnw72/uySUyU1OvzlDRRHKn5EevPBg9gLSiXR3mgB5dM85UtILyh7mQWmnW1Mk6fULaeHEG2f3OVzYe2zMLHlXespXsqFvx2SQbgrw45RvjUehTG5y+s0ZKIpQfnL4OYPbStdZ1A5PkyCP7tlMSnpb2cP8W9rpnymS9JIeuVUzzwLxA/l3de5znbSPQdz9c7YR9pmc8q3xKZTJTU6/OcNEEUZHCGfGkKabe4iPEEi8JZZJDt3ztHhr6XfKHqasRfiB9LGOUzv3OVI6pMHBMRkWNO8ydmbKt8arUCY3Of3mDBJFGH1MODHWatr23ZHSaZTmjh45dM/eUs7EJzeUJkxZizDaWNg95jN8m5q2P9l8BsZ8rPExIUHSfWS7LJTJTU6/OUNEEUpDpXZM89biL/mOSxHBf/c8NFzKmXg5RWnClLYIjxd2X6RjjzmmB5eMn23+i9+w9zrWk/7melTKd8a3UCY3Of3mDBBFKI212r3NW58ubb16igjeu2f2euLJ/qPShyltEd4h7f9k+x73m7beWPr8zrUdCb4hBPhHynfGu1AmNzn95gwPRbiGcFIs3rL1c+JJ9Jx7BO/dI13YWDNcTlGaMKUtwtkThP3Pbd/jl6atj4imm9/zwzoSCLd5Gzkt5TvjXyiTm5x+cwZHfRH+Vzon9mzd/hPS9jGXSkh8d8/vpecr1GrjEi+nKE2Y0hZh9Dlh/6+372C82PgvUWT+mfnT7cu9Lbyl66Z8Y/IQyuQmp9+coVFfhNIDTmtXtm4vPWK2toF7Bs/dc6n4N7labdvyhylvEUrnTMelw8uZtn5duunbiKlty10jHL/zR8gChTK5yek3Z2DUF6H0KILRbVPoTukMGur+uFi/3XOqzYe3Lyp/mPIW4UPSAv9r3f4107a9d3S/yrzcjW3H/75w+JRPA8tJKJObnH5zhkV7Eb4ufcRty7YdehaVzqBfO4fw2T1vfsnmLB/zfvnDlLcII+ku7W13Qf2zadtdIvF3nd9vO7zw+Y1hsc+/KE4ok5ucfnMGRXsRniWdDme07yFdsVfbwjmEv+6Zc/Zidid5AGFKXIRfERZo+wy88V7tfSeY+Vakn2ldbvY85qOnuXA5V6FMbnL6zRkS7UW4pXQ2dFwEeqW0x4ike7Yk8tU9U38t3RygX9L91coUpsRF+FthgbbLW9Y1bXtP7xb7GJcb9UHLcvcJR096rkhxQpnc5PSbMyDKi1C8U0znA8KnjZHOn9+7ppC652iLNXoeP29H4SeFQauFEKbERfissMDIluaaYXpLx/Qd7ELzeje3HP0M4ejxTzAsVCiTm5x+c4ZDeREKAyj2Ajzphsdxt9gyk7pn/v0PMtp/j+1Wlz7b1uL8EMKUuAjNl4HW2h7QPNm05fp9mzxvXq71Xz52Nm88pO1SnVIIZXKT02/OYCgvwh2kMyHm13binxXHun6eWeoe31YyPba1NGHKXIR7Cisc37yx8fmHh9S3Wcq4XOu9Q5c1H3ullG9LvkKZ3OT0mzMUuotw2jjhPFhgdudOL4ufEHf93VS3u+fyIMKUuQgvFlZouXnq9qYtL6tvY/4pb8yMpuVeEY69T8q3JWehTG5y+s0ZCN1FeLl0GuwSt9enpL0mOcbocvesF0aYMhfh68K/DE1sfrav8drZl+rbGG/C1vqLiT8J6ZM/IlqsUCY3Of3mDIPuItxVOgv+ELfXMdJeEx0fB9fd7hn5SBhhylyE4p32Hhzc9BnTdks3NnrQvFzzr1q/Kxz6xZRvS+5Cmdzk9JszCKqLcNZ8wjkw/O243YzPEuhzvVuO7naP8Iye0oQpdRF+W1jil4Ob/t603RcbG/WYT8XNmw69jvnIy6V8V7oglMlNTr85Q6C6CG+QToEN4/dbWtpvb7ccXe2e1WYEEqbURfhXYYmm36nvZ9pu4BbtWxuXm2cw0nThEz+7p3xXuiGUyU1OvzkDoLoIzR9jriV+ePyb0n6Lmi7L7NTN7pnwdChhSl2E7wn3El9mcNNVTdsNPIDqBPN6dw4sd5sQ/pyU70pXzBH/GOHFnnIScnYzZ/lpLsIe8Q5gj8bveJ145rjN6G52j/GK0VKFKXURRp8W1nihf8P3TXezHTm9f7N/mpc7aeDAJwkHfirlu9IdXZrcz5CzXDlLT3MR3i79z5/055YZ46U9v+sUpIvdc3w4YcpdhNITIAYus/qbaau1B9YTHs679cCG25mP2/oc6dIJZXCT02/O0tNchAdJ//N/K2lP8XP4H3IK0r3uOSCgMOUuwpuENfbv39B4jfGBgwuub1xuwsAv24UnXxhup14Cofwqj5x+c5af5iKU7pNVuyFpz9+Jp859LkG61j2TLP52WZow5S7C6cItZ1ft39B4W/eLBxc8zLzevY3NnhKy/zIqsW5d3BFzGwxyFpgzAIqLUBy04xMvaXxDeophxyPkjLrVPfvaXMNTmjDlLsJoM/MaQxsPBeyZaNqq6dkmwsN5+y8vPV/I/nDKN6UbQpnb5PSbMwSKi/AH0glguHm2+fdYNccbPnape44IK0zJi/DHwiLX1Td72LTNok3rvT3UuNy2jc2EK50X7GnPWR6hzG1y+s0ZBMVFuLJ0BpydvK906V6t9phDkq50z9gLAwtT8iK8W1jkB/XNjLdo3655wVWMy83faDjhljbbtccsj1DmNjn95gyD3iJ8QjoDhryavPN/xPPnBIco3eieFR6Uc5QrTMmLcI5wW6KN6pvtbtrmxOYF9zWv90DfRu+Zf24c/IB+6YQyt8npN2cg9Bah9Kut2qdMe384095t8u+eIQdMCS5MyYsw+oJ5kbH1VT5i2qblsYUXmdc7vW8j6WZI96R8T3IXytwmp9+codBbhGtJ54DxUezSnY9rtefto+TePSveGmCYshfhz4VV7urd6A3TFsOnNq/3gnm5Hfs2Osq80bxlnVuhzG1y+s0ZDLVF+KL4VMF7TbvfLJ5DP7PPknP3LPxLl3sFliZM2YvwUWGVvt9S/sW0xWqtC5pvYbtw3zabm4+5Zcq3JG+hzG1y+s0ZDrVFeLp0EixuvP5u9vzS/hvaZ8m1exY57n2nN6Y0YcpehNHi5lX6Ljo2fjpwv9b1zA/n7bvf35wJ5m1+lPItyVkoc5ucfnMGRG0RbiSdBd8w77+LtP+w/1lnybF7Vj5runz8coYpfRFOMq+ySO82nzFtcb5TrjMj8bGFLQ/wLY9Q5jY5/eYMidYilD8Sf4V5gYvF8+i31mHy6p4F979TPnhpw5S+CM8VlnkyimaNNW3wROt6D5mX67152q/Mm4wRHrFVjFDmNjn95gyK1iI8WzoNRglXNr47QlphK+swOXXPnjPTvDOlCVP6InxeWObcKLrL9P0F29YTHs672NxNhFtLfjblO5KrUOY2Of3mDIvWIjQ/B7VmcdnBJtIKI9+1DZNT95yZ6p0pTZjSF6H0GZqvR9FPTd/fun29bczrzf0BcgXzFkemfEfyFMrcJqffnIFRWoTvieP+DGmJn4nn0kW2aXLqnlVS3W6rNGHKX4TC7c4+GkVfNH3/2Pb1hI+2/iZ6XQj+t5TvSI5Cmdvk9JszNEqLUP4L37PSEs+IS+xkm0bqnlX+9Nc4J0m/nb0yzVtTmjDlL8JLhXX+Fy1p+vaN7esJD5+fFF1h3mDE1LiUhQplbpPTb87gKC1C47+p91pZXuPj0hrzfGCZRuqeHyfsd6Sw31q2b0cpw5S/CN8QPot6hfEz8kM7fnU+Y7RxuaWiQ83HWyflG5KfUOY2Of3mDI/OIpwuPmL+UHmRw8XzyfaHIKl7Tk7Y73Xz4Iz5mSOkMOUvwmg18zpbfsf03Y93rreBeb3jhCdo/l/KNyQ3ocxtcvrNGSCdRWi830cfiyH7L3GR3SzjpO2eaC9hxzRXEZYmTABFeLC0kknMB1Xlf7cyuirlG5KXUOY2Of3mDJHOItxdOhfmtzgX5iwirmI5UVN3z+PSfeJut31HShgmgCK8RlrJJOYpX1dnWa829J2Ub0hOQpnb5PSbM0gqi3D2AtLJsIvNMnuI55TlVXypuyf6nLCn/WcZyxcmgCKcIn6Y1OCRzvXeER6yZLZqyvcjJ6HMbXL6zRkmlUX4d/FssPrkg3ANX63jZpJJ0nfPLVKC++wSlDFMAEUYrS8tlWxC3OdJhMfumn0r5fuRj1DmNjn95gyUyiL8pnQ2DH/LZpmp0uUhwo27B6TvnuhTwq47WgUoZZgQivCH0lLJNotbb7/069Vqf0r5fuQilLlNTr85Q6WxCHuWkE6Hz9gtJN6epjbZap0M3SN9IHLof+xeSgnDhFCEt0pLJYu9C4zwcF6z11O+H3kIZW6T02/OYGksQvlyz5PsFhJugTzXwVbrZOie2csK++5q91JKGCaEIpw5Tlor0TVx6wkP5zVaMeXbkYdQ5jY5/eYMl8YiPEQ8IR61W+gl8eG+y1utk6F7otOEfYc/a/dayhcmhCKMtpTWSjLkzdj1lkm7Xq22V8q3IwehzG1y+s0ZMI1FKNy5uFZbznalNcRz6wGbZbJ0z/sThZ33tX0xZQsjPXsvvyJ0uC3qydJaST4av574mMtkv0/5dvgXytwmp9+cIVNYhOKArR1gu9TR4lI/tFkmS/dE/yfsPOpl21dTsjCPC2vVbnF7YQN+Iaw70mGt+6SQSXaLX0/+bXui51O+Hd6FMrfJ6Tdn0BQW4VHiKXG97VLyGFzFZplM3fOi9Fm2g2xfTcnCPCcsVbvO7YUNOElYd7zDWj3iR1ITJDyW6uGUy9Vqy6Z8N7wLZW6T02/OsCksQvGzWuPsn/NtfLpAnyctVsnUPdFXpZfzhvXLKVWYV4Slapc7va5B0s/xC7kstqOUMsG/45frmT/leu5XReUklLlNTr85A6evCJ8Wz4kF7S+W+Iy42IkWq2TrnvulCD+wfjmlCvOutNQFTq9rkHSx1DIui4l/cIw3LmnuCA/nTfbblO+GZ6HMbXL6zRk6fUVocXnDYitb+pC8ls2jcbJ1T7SpsPvEjuf9hBEm7QOhJF8R1l3TZTHxL5nxEu9AfmK69fqeX18CocxtcvrNGTx9RfjprpxZA4a8JEfK2D3XShlOcHl/yhNG+r2z5Q3sOqwrrOt2T9SlpBcc67Ck5W5Ptdzcf3lL+Wb4FcrcJqffnOFTV4Qvi5/98+wMOVPG7hEfEbzwNIc3qDxhVhdWSnFH8T7SjYV2d1ot3ai6Imk54eG8ib6Y8s3wKpS5TU6/OStAXRFK1857t7GcKWv3nCNl+JnDG1SeMNId7BZ3eFVNXpMCJv60Fut8ablYryauJ//ZOZbFv2/lLpS5TU6/OatAXRFu0pVzq8lw+TrJrN0zYzFhgSXtr4MtUZhvCQvVLH7rHOOv0rJul528JC0X50PJ6x2RZr1a7aFU74VXocxtcvrNWQnaivCt4V05uZqdK4bK2j3R8VKG39i/Q+UJc4a00GX2r6rJ96Rlb3Vbb0VpvRhfSV4u3cN+53e4G05OQpnb5PSbsxq0FeF5XTm5WnxODJW5e96S7v28vP3ZXp4w1wvr1PawflHNPiktm/xry1jiQ71inJ68XLqH826b6q3wKZS5TU6/OStCWxF+vitnV4vR70uhMndPtL8U4kLrd6g8YZ6X1ll4jvWrGvSstOpExwX/LC0Y4y7DemJRxzklxTvhVShzm5x+c1aFsiKckvKavEz+KKXK3j1PSz9GrGz9q7MShVlEWKf2D9sX1UT8oN6mjgu+5f4j3OiZhvXS/IRZuzvFO+FTKHObnH5zVoayIrykK6dXmy9JqbJ3T7SDFML6fmQlCiP++O72yPs+c5aVFv2e65JrSit2WNe03B+cl6vVxhc80EKZ2+T0m7M6lBWhdFORXIyfLqTy0D3iw4atb5dSojDiZTfDX7R9VQOukNas/cV1yUPFJdsZbz3+ovNytdoWzu+DV6HMbXL6zVkhuopwxrxdOcHaXSXE8tA94u1SrB+pUaIwN0vLuN9cZs6q0pJDXnddU7yop8OlxvWWdV6vdrxrZq9Cmdvk9JuzSnQV4dVdOcE6SFc3+uge8ZKNz1i+RyUKM3O8tM7wxy1fVb/zpBVraziuGEXTRoqLtnnBuN4k1+XSP6PYi1DmNjn95qwUXUX49a6cYR0WFE45H90zZwUpheWwLFOYbaVlXG+z9tbi4orfd1ux14bioq2WNC/n/nDe0dIv3/MUytwmp9+c1aKqCGcv1JVTrJNwdaOP7pHvHbel3ZtUpjAWlXCW3atq+JK84O1OC/Y5Rl61hXCNzyOOy9VqG7pn9iaUuU1OvzkrRlUR3tSVUyzG/uZcXrpnqvis9Hut3qQyhXlZ/mTCPI9Zvaq6c8XlaoumGBCuT4z4iXk596feuz1x0qtQ5jY5/easGlVFKN68Mi9Lmj8456V7ou9LKba3WqZUYaSnG861/P+sVup1k8Uf875tvdqgWeLfMlvdJqz3ObflarUbU4T2I5S5TU6/OStHVREu3ZWTLM6dxlx+uudVaZkhj9gsU6ow5wmr9Fp3qlWiKHpoosVqqT6ZLj0no9WID4TlTnJarlYbPiVNaB9Cmdvk9JuzejQV4V1dOcliHWoM5qd75EuBJtmsUqow70v3Le213jtWie6Y32KtFe1eXZtTLVYe9ClpuclOy9Vqa6cK7UEoc5ucfnNWkKYiPKwrZ1msDxuDeeqeR6RnDg97xmKVUoWJ9hVW6bOq+eMIdVfNY7OUy5MbBz1gs/SAA6TlZoxxWq92SKrQ2YUyt8npN2cVaSrCj3blNItnfFycp+6JtpJS7G2xSKnCRI9JfdpnwWuldWYdZrXQhPcsX12rHqfLkS8S13N8OO9fU4XOLJS5TU6/OStJURG6X5Xu0TGmZL665x9SilEWj7ItVRiLPu0z5JtvGVe5ey2rZWrftXxx7Sw+ljFI/lFYfGRii6Fvp0ydTShzm5x+c1aToiI8tivnWYJVTcl8dU+0uhTjO/IapQoTRbdKqzQsdGbyh8qf29PyAREj/2v74tqcZZmy18Lyctc6LFerfTJl6GxCmdvk9JuzohQV4WpdOdGSmH4M8NY9F0opxsqfNShVmLm2lJbpt8ixsbfg7rnty8NslxA+75nsKdsjzPV5ebl3nZ7sJP7NMQ+hzG1y+s1ZVXqKUHwga75MH6L21j2zlpJiyM8YKlWYue6z+uNenyHrn3bPrJad37rmO2KKQWNfsX1tHZaxP8oJFsuJtwZvZr6Fdz5Cmdvk9JuzsvQU4SniWTL+D/9M6XLxEbLGR9B5657oJ1KMCeJHDUoVpteXpWVajFt30g9++btLr/zD2aceuO2K9iXa63Drl9ZhD/uj3GSx3P4usV9NHzutUOY2Of3mrC49Rbi+eJqkuN1yP/HemrWhhp82/HXPu+JzpsQH9pQqTK+XuvXsrKUyfC5d/D3wgGE2R7nYIfZH06dOK5S5TU6/OStMTRG+Kv/ZxXz7FyOLh6memby3v+6JDpJiLCjdh6VUYfr8TFrGk8vtX1mHV6yPYrxsqt9LDrH3zBA7nVDmNjn95qwyNUUoP8hgEfMNQc3ESyRrmyXv7LF7nh8u5ThNWKFUYfrMWVNaxout7V9YjJVtD7OP1XIfss99QabcKYQyt8npN2elqSnCzcUT5WtZlj9aXH5E8ifdPHZPtLOUY4kZ5gVKFabu0bHSOh7MH3vNqTXrG7qfZ7XcV+2Dp/3IR1qhzG1y+s1ZbVqK8O0R4plyWZb1/y2fib9L3Nln99wr5vi1eYFShWn4tbhOdpn+54+iK22PY/fYKPtXvEy23M5Cmdvk9Juz4rQU4QXimTIy3d21+snXz2+XuK/P7ok2knIsZ/6/RKnC9NteWiezrH9pe8fyw4rz2/0C/lHr4F/NGNxRKHObnH5zVp2WIvyCeKpsmu0A8gXvYxKvDPHaPVeJQcx/VCpVmH7vWf8JLqU1p7m8rDhr2x3o/9mt1rOgbfLfZA3uJJS5TU6/OStPSRFOlf/K9NNsR7hRPhv/lLSv1+7p+ZiUYyXjDyWlCjPgGetiSGVxq/ueGh1hd6SjLZf7vG30xzMndxDK3Can35zVp6QIL5NPlqeyHWHmBPEIOyft67V7ot+IQYx/DitVmEG3SrmyGJPqcbyt/m53qOstl7N9OO+i2ZPbC2Vuk9NvTgWUFOEu4smS+WPJ8gMIJiRdIum3e6aLt7lZ3bR7qcI0+at8uVNaI8WnOFn4YLTNoYbYPUQ4iv5lmX0nD9FthTK3yek3pwY6inDmRPFsOSjrMS6Sz8ikeeu3e6JjUgcpXZhmf7K+d7aj4Vk+ST9oY5tjrWS72kzLh/P+3Et2K6HMbXL6zamCjiK8Tj5dbsp6jHfkn1iSrkz03D1viH8QXd+wd6nCtPjjSGmpVEZc7PaKkhxvc7A9rJfb0C79A37CWwhlbpPTb04ddBThXuLpMmGWvIpgE/EgC8+J39Nz90T7ikluSd65VGFa3TheXMvdPNc5vqAkd9gczf4az+9bpZ8vy+2QnIQyt8npN6cSKopwjvxwiC9mP4rFLTETRr7v7nlSvK/q5sk7lypMm3vl/yFdLeThOpm62fLlUrXaQ9bLWfwWY67P+UovCWVuk9NvTi1UFKHFU87Pz34UiwceHhi/p+/uibYTkySP/1KFaffip8XF3KzxnOvLSWbxiYd5E34nEOM9qz+JOv+vkVIoc5ucfnOqoaIIvy2eMEOtHpYu+IR4mKXjd/TePbeJSbp0m5usYTrM/Ka4motvTHd9NQYWvxLYxGE5q4fzZnhiiotQ5jY5/ebUQ0URLiueMabH5lqz+KvOPbE7eu+eaB0pyJCHk3YtVZgYf1pIWs7aRA+/B2jysHxEl0deHmDxCubJ/qdtG6HMbXL6zamIhiKUb/1s94RYyd3ycY6I3dF/91wqJunSp/szhonzuq8bj26V/XYyrRYVD3mVw2p/tHgJhmd7eRTK3Can35yaaCjC78nnjJeL0HuWEI+zYuyO/rtn9nJSkmFJd9IpVZh4l8p3OJctmvw0kLTEp07V3nBY7WWLF3Gs99cQI5S5TU6/OVXRUITi/S6T/nbnah/57Hw0bj//3ROdLib5RsKepQqTYNrRWZ9QOOqw991fh+Rs6agfdlpO/PcHh0+eZBDK3Can35y6KCjCx+STZl8/R7pGPtJxcfvl0D1T5pOSjHwhfs9ShUn04n5Z7j064mvPuL8K2XPScd0embSr+DpG+bzWJ0Eoc5ucfnMqo6AIT5DPGpc/3RhMn0c80hpx++XQPdHhYpRufZYjSxiDFw+wurlnjFH7ePzMRAvpZ7hfOK12lvhKNsjpdTQJZW6T029ObRQUofzxrnGZH0bXsJN4qKFTYnaTroM8K0WUl8X7kY2Li1KyMEZvnry8tGyM5U54LcUrsCP9btztT9GPi6/lyJxex6BQ5jY5/eZUR0ERyk+ecP9xJMHNQ6RDDY/r3K+Z9xmT6vd448kqVgAADPVJREFUh4kv++XY/UoVRtBz3aR5xZWbzbvL9Xnek+xB8/1mV3FcTrqN95j/5vIqmoQyt8npN6c+Corw+S3GGc+a+fb295eW85Yz3lBs6DJnx+31zlcN43zox9I9JGjOUUuZannIYj+K369UYWTTL99lYdNb3mTR3f6S99/Url4t+TfL4zZ5wnG1V7c1/a599No35/IamoQyt8npN6dCCooQFddz/0+2kW5CusQXTn+k6JzBCWVuk9NvTo0oQlTCC5f/8CtrLdA5FYYsvsFuP7r29aLjhSiUuU1OvzlVoghRIVNfePj2a/588e/PPfu8Cy+5/IY7//PyjKIjBSuUuU1Ovzl1oggBdAplbpPTb06lKEIAHUKZ2+T0m1MrihBAu1DmNjn95lSLIgTQJpS5TU6/OfWiCAG0CmVuk9NvTsUoQgAtQpnb5PSbUzOKEECzUOY2Of3mVI0iBNAklLlNTr85daMIAQwKZW6T029O5ShCAANCmdvk9JtTO4oQQL9Q5jY5/eZUjyIE0BDK3Can35ygCAHUhTK3yek3JyhCAHWhzG1y+s0JihBAXShzm5x+cyKiCAH0CWVuk9NvTvSiCAGEM7fJ6Tcn+lCEAIKZ2+T0mxN1FCGAUOY2Of3mRANFCKgXytwmp9+c6EcRAtqFMrfJ6TcnBlCEgHKhzG1y+s2JQRQhoFsoc5ucfnOiCUUIqBbK3Can35xoRhECmoUyt8npNydaUISAYqHMbXL6zYlWFCGgVyhzm5x+c6INRQioFcrcJqffnGhHEQJahTK3yek3JzpQhIBSocxtcvrNiU4UIaBTKHObnH5zIgZFCKgUytwmp9+ciEMRAhqFMrfJ6TcnYlGEgEKhzG1y+s2JeBQhoE8oc5ucfnMiAUUIqBPK3Can35xIQhEC2oQyt8npNycSUYSAMqHMbXL6zYlkFCGgSyhzm5x+c8KAIgRUCWVuk9NvTphQhIAmocxtcvrNCSOKEFAklLlNTr85YUYRAnqEMrfJ6TcnBBQhoEYoc5ucfnNCQhECWoQyt8npNydEFCGgRChzm5x+c0JGEQI6hDK3yek3JyxQhIAKocxtcvrNCRsUIaBBKHObnH5zwgpFCCgQytwmp9+csEMRAtUXytwmp9+csEQRApUXytwmp9+csEURAlUXytwmp9+csEYRAhUXytwmp9+csEcRAtUWytwmp9+ccEARApUWytwmp9+ccEERApW2Z1fm9q5zyFmunHBBEQJV9kwgc5ucfnPCCUUIVNnkQOY2Of3mhBOKEKiybgxuH3ObnH5zwglFCFRZFwa3l+s6yOk3J5xQhECV5T+4/cxtcvrNCScUIVBluQ9uT3ObnH5zwglFCFRZ3oPb19wmp9+ccEIRAlWW8+D2NrfJ6TcnnFCEQJXlO7j9zW1y+s0JJxQhUGW5Dm6Pc5ucfnPCCUUIVFmeg9vn3CYnPVggihCoshwHt9e5TU56sEAUIVBl+Q1uv3ObnPRggShCoMpyG9ye5zY56cECUYRAleU1uH3PbXL6zQknFCFQZTkNbu9zm5woEEUIVFk+g9v/3CYnCkQRAlWWy+DOYW6TEwWiCIEqy2Nw5zG3yYkCUYRAleUwuHOZ2+REgShCoMr8D+585jY5USCKEKgy74M7p7lNThSIIgSqzPfgzmtukxMFogiBKvM8uHOb2+REgShCoMr8Du785jY5USCKEKgyr4M7x7lNThSIIgSqzOfgznNukxMFogiBKvM4uHOd2+REgShCoMr8De585zY5USCKEKgyb4M757lNThSIIgSqzNfgzntukxMFogiBKvM0uHOf2+REgShCoMr8DO785zY5USCKEKgyL4O7C3ObnCgQRQhUmY/B3Y25TU4UiCIEqszD4O7K3CYnCkQRAlWWfXB3Z26TEwWiCIEqyzy4uzS3yYkCUYRAlWUd3N2a2+REgShCoMoyDu6uzW1yokAUIVBl2QZ39+Y2OVEgihCoskyDu4tzm5woEEUIVFmWwd3NuU1OFIgiBKosw+Du6twmJwpEEQJVln5wd3dukxMFogiBKks9uLs8t8mJAlGEQJWlHdzdntvkRIEoQqDKUg7urs9tcqJAFCFQZekGd/fnNjlRIIoQqLJUg7uAuU1OFIgiBKoszeAuYm6TEwWiCIEqSzG4C5nb5ESBKEKgytwHdzFzm5woEEUIVJnz4C5obpMTBaIIgSpzHdxFzW1yokAUIVBljoO7sLlNThSIIgSqzG1wFze3yYkCUYRAlTkN7gLnNjlRIIoQqDKXwV3k3CYnCkQRAlXmMLgLndvkRIEoQqDK7Ad3sXObnCgQRQhUmfXgLnhukxMFogiBKrMd3EXPbXKiQBQhUGWWg7vwuU1OFIgiBKrMbnAXP7fJiQJRhECVWQ3uEsxtcqJAFCFQZTaDuwxzm5woEEUIVJnF4C7F3CYnCkQRAlUmD+5yzG1yokAUIVBl4uAuydwmJwpEEQJVJg3ussxtcqJAFCFQZcLgLs3cJicKRBECVWYe3OWZ2+REgShCoMqMg7tEc5ucKBBFCFSZaXCXaW6TEwWiCIEqMwzuUs1tcqJAFCFQZcmDu1xzm5woEEUIVFni4C7Z3CYnCkQRAlWWNLjLNrfJiQJRhECVJQzu0s1tcqJAFCFQZfGDu3xzm5woEEUIVFns4C7h3CYnCkQRAlUWN7jLOLfJiQJRhECVxQzuUs5tcqJAFCFQZZ2Du5xzm5woEEUIVFnH4C7p3CYnCkQRAlXWPrjLOrfJiQJRhECVTQ5kbpMTBaIIgSqbHMjcJicKRBECVTY5kLlNThSIIgSqbHIgc5ucKBBFCFRZ0+DedU7RYQzIiQJRhECVTQ7k5xdyokAUIVBlkwOZ2+REgShCoMomBzK3yYkCUYRAlU0O5O9Z5ESBKEKgyiYH8vMLOVEgihCosmcC+fmFnCgQRQhU2rdqtX1CmNvkRHEoQqDann666AR2yInCUIQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANUoQgCAahQhAEA1ihAAoBpFCABQjSIEAKhGEQIAVKMIAQCqUYQAANX+P5hTe6Ul1nUnAAAAAElFTkSuQmCC" preserveAspectRatio="none"/></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-10"><g><path d="M 379.5 300.5 L 389.5 300.5 L 389.5 310.5 L 400 310.5 L 384.5 329.5 L 369 310.5 L 379.5 310.5 Z" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-11"><g><rect x="300" y="330" width="170" height="50" fill="#f5f5f5" stroke="#666666" pointer-events="all"/><path d="M 317 330 L 317 380 M 453 330 L 453 380" fill="none" stroke="#666666" stroke-miterlimit="10" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 134px; height: 1px; padding-top: 355px; margin-left: 318px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Shuffle Files</div></div></div></foreignObject><image x="318" y="348.5" width="134" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-20"><g><path d="M 215 225 L 293.63 225" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 298.88 225 L 291.88 228.5 L 293.63 225 L 291.88 221.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-28"><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 235px; margin-left: 254px;"><div data-drawio-colors="color: rgb(0, 0, 0); background-color: rgb(255, 255, 255); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; background-color: rgb(255, 255, 255); white-space: nowrap;">executePlan()</div></div></div></foreignObject><image x="220" y="229" width="68" height="15.75" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAARAAAAA/CAYAAAAoh5dCAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAABEKADAAQAAAABAAAAPwAAAACYln/GAAAXE0lEQVR4Ae2dBbTdNg+APWZmZmZmZuyYd9YxM3NH7ZiZmZm5HTMzMzPz/OvLP2e24uTm3ndv+7pa59wX27FlW0lkWZb0BjMlYK3tLbf2LrmdihMFEgUGHQr0GWywwfaJTXfwWGEqSxRIFEgUqEOBxEDqUCnVSRRIFIhSIDGQKFlSYaJAokAdCiQGUodKqU6iQKJAlAKJgUTJkgoTBRIF6lAgMZA6VEp1EgUSBaIUGDJamgoTBTpEgXfffddcf/31RswEmuphiCGGMJNNNpmZdtppzeSTT27IN4LvvvvOXHjhhebPP//Mqg477LBm6623btTsP3F/3333Naeddlo2l9VXX92cddZZWXrXXXc15513Xpbeb7/9zC677NKZ+WIHIr8EiQJtpcCpp54K5+jSb+ihh7YrrriifeONNyrH9sADDwT9jDbaaJX1/ys3X375ZTvUUEPlc7/lllvyqd100015+fDDD2+Foef3KhLYhEUhbWGiZPlvFb7++utGPtz8Jy/UQD3B33//3dx8881mxhlnNKyi5BP8S4Ftt93W/PHHH1nB3HPPbZZffvn8pjBeM8ccc2T5n3/+2VC3IyDcKEkgFSx5YLp14IEH5quOvCxWXqgBNvx2SCDMwf/tvffe0fkMihLIpZdeGtDGlz4ckXwpBDpeffXV7lbZtVQCSToQoWCCAUuBzTbbzMj2IjoIeaPN999/b7788kvz+OOPmw8//LBQ78gjjzQ9evQw88wzT+HeoFQAndBxOJh11lkD6cOVOynkqaeeyop23HFHs8wyy5gRRxzRVal9TQykNqlSxU5RYI899jBTTTVVLfR33HGHWWuttTKm4hr89ddfBib0wgsvuKJB8tq7d2/zySef5HPfa6+98rRO7L///maVVVbJij/66CNz0EEHmaOOOkpXa5hPOpCGJEoVuhMFWCn79u1rxhhjjGBYL774ovnmm2+CskEpg4R28skn51OeZJJJzBprrJHndWKllVYyk046aV58wgknmLfffjvP100kBlKXUqlet6HA7LPPbjbccMPCeF566aVC2aBScPTRR5uffvopny7K0aqj7sEHH9xsueWWeX2Urn369MnzdRMtb2FeffVVc8MNN2Ri46effmrk2MjIsZCB8y277LJmiSWWqJwA+y9f3GLAiLHTTDNN5dgRV2+//fasP/qUI73sN+eccxpxOS5t+/nnnxtRHpmHH3446xc8Qw45ZDZe9s6clbeyBwQPYvV1111nnnvuuQz3cMMNZ0YdddTMXmHKKac0PXv2NFzLgHYffPBBfnuiiSYys8wyS54vS3C6ws/B1FNPbfgBb731lnnllVey9PPPP59d3R9owSmGg+WWW67yWfFiQvN77rnHIO5y6oFtxcQTT2xmnnlms84665hxxhnHoesv1/nmm88cf/zxQV8wkAUXXDAoayWDJHP55Zcb3vF33nknezbDDDOMmWCCCbIfdihso8Yff/yG6PWzXWqppQy4AGh51VVXmSeffNJ8/PHH5tdffzVjjz129k6uvPLKZtFFF618Lq7zr776ypxyyikum30Pm2yySZ4vS2y66aZGFOz5KdYll1xi0CeV6aPK8ETLRXkVPYWRfaZdfPHFA02vICjkhbhWRCr7999/RzW7m2++eaGNvJBWFEHR+q5QuGSh3XTTTVfaj4h2dquttrLCjQvt/HGPMMIIdvvtt2/YvxsHV7T88gFV4qUP+hYmUnrmzj1/LBtttJHfTWlaXuKgHactDg4//PDgno9fp+UFds2Cq7zQVvbVVhhrJS7mt9pqq9n33nsvaB/LxE5hhAnGqlaWPfLII4UxHXDAAUGbZk9hsIngXcE+QtNI55mzKG7tE088EfSpM7LlCnDde++99ocffrDbbbedFSkguKf74N3CpqMRyPYjwMO46oIwqqDtSSedFGtaegojY46DYCkwkIsuusjKqh10KK0r8wsttJD97LPPCoP69ttvLQxDtxdLwUJdVwAxhXsHbTCYEWnGVQmuwv3tuOOOG9TX/em8rP5WpJQATyxzwQUXNGRKGrdIZ/brr78uoGuVgcgeN5hbr169ctzNMBA53cjbuYRIKVa2CgF+PR+dH2mkkSzvSBW0i4HceOONhbGde+65QdfNMJBnn33WihRVwKnnqPMjjzyyjdHPDUQzEOgjUnbtfjB+E+nUoYteRYIM8JUwgWjbY445JmjLeCPQdQbCxGWLEHSmiVmWl+2F/fHHHwvjEpG4gJM+7rvvvkJdEZmtbDUK/R922GGFuhTAbGQbUahfNka/nIcm4nAUL4WcrZfRQsylLS+Vj89PY0GppbJOMBD9Yvhj0Gn9ASAFisl46Rx0ez/PqirbuVLatYuBaNsWxvDYY48F/dZlILIliy5m4GSBkq21lW2Lla1plCajjz66le140LfLaAbi06puWhSeDl3h+ssvvxTGVbagFhpLARKUPw7mCE4FXWMgsie0Y445ZtARnYquw951111W9mAWieLOO++0rIJsB/xBkd5tt93UmP6f3WGHHQp1eWBiJRfUlyOmQr0FFljAwlhiIHvNQn3RQ9grr7wy20ognj/66KNW9tFW9AaFuqy+MaA/tkx6fhhn8QI75vDFF1/Y008/PcpMLrvssgB1JxgITIAXiR9bIn+8zM3d4yo6jmA8GGb59UnDjPn4Ycx8cHLqYc8++2y7yCKLFOqy5SnbiraDgSAt6G0GDF33WZeBiG9IYQ4844ceesiKcjGnDc9edEdWrDsL9fUzdY2qGMhcc81laQdNkTJEp2hFF1fAjdQfk1zpQ3RTQX2+vbJvwo3Jv1JXb1FFp+dXId01BiION8EgeVjHHXdc/rHo3nhwelCiHAoehmsDo4iJdD7Dee211wpcFvyiKHRogisPWX8A6623Xrb3DCr+kxElsJ1++ukLbZ555plC9TPPPLNQj32zYxy6gSjiCmOHYfjQCQbi49erdZUlKnoApCiffvPOO699//33fZR5+rfffrOskH590uK8ldfxE11hIDB9PvYJJ5yw0J8ocv1usnRdBrLuuusG+Piw9QLmI2ex1BIaC2EMyhiIGHxF3xk+aLHPCMYDPcsY1E477RTUXWyxxWLDqCxbeumlAxyMTUHrDASHJZyX/BeED6YR8PC0mC9emNFmrNxayUke0VpOOSySht8/6XPOOSeKixVDP9wZZpghWzWjDf4pRE+D/sPvR78UbMPGG2+8oA7MjxW5Cg455JCgjXiVBtW7EwNZe+21g7Gi1xDrz2C8OgMT4cX1aTf//PPralk+xkDkONGK0VP0t+eee1o5UbBLLrmkHWussYI+XH9IIzEGV5eBsMV2uLhec8010bH7heKDE7ThI4xBjIFUbUnAwVz88ZBGpxUD/W1Ar2ZBjMqC/sSCVaNonYFss802AXIUTXDgOsBD9wmBxrcM9CRoJ85SVo6VAhyUw6HLALt+v0/SdZSi4OPEwW8rxkqWj8MB2x//PumLL77Y3S69xl4I/8SiuzAQpA89vxNPPLF0Xv4Ntq+6LdKXhhgD0e2azZfpweoyELZ0KLjdDwVyIzjiiCOC+bJljoFmIOiI2P41AvRwPh18idxvq7ffxx57rH+7VprTUr8vdDoKShlIQzsQbZyDzcAoo4wi/TUGzsrvvvvuvCIWhGWAaS1eok8//XReBetCzJx9wN7AxTbwy11ajxdbBWwG6gDj3Weff6PXc76ODQU2JsCbb74ZoMGOZIUVVgjKYhnsOg4++GAjjDe/jS1FdwNNO8aHjUcdkMXCyItnZK+eV+d5N7LrySu3kBDpyMiJgxEdTwut/20ieqB/MzVSsqiYa6+9tkbNYhWRVIxIxMUbqgQ7oH79+uWlPl3zQklg0+NDKzYcPDcfsIPBsAw7q0bQkIH4hkogw5hGxP1GeLP72rhIzr+zF0wPmMoMluAvuBrzgMpAjuqMKHTLbgeGVVQiCE3d8YoCymChJ/qMHL+syjkDwTjLBxgTBmN1AAbZ3UE/a+YGLerSD2btv+jQrhMgWxkjehmD+TXPt1PAR4SBH/NwP8y9WRTr0kSPTXRtuiian2KKKQIGgsGiBsbnL0rcb4WBaLcAkT6MHALUMpSrZCB88NpaVMRFw69VYFWPMRDwwZkPPfRQs/vuu0fRi+4l6l3oV9YfgRwJG7EF8as0lWa8DjQDcVaf7v7AftW04+VsF+2qaMMzxwKzCpD2sADlHalaQKpw1Ll36623GtmWZtahPG9/ManTvlGduh84C1kjwP9FQ138fjvNQLiHZFPH0raSgYgC1e+nLekq6YIOCLEmJzyZaa/foShVDfb+jUB/BI3qN7rvj1czEFbCAQntfrk7SbsqOrF1rOuNW4WnK/dEYZ9tl1lwOgmEVWwXICVoqKte8NvFmI4vSfp1dbqSzfmrr27Yal6OqSqb4leCX4AGRDhWhioAt9gCVFVp+p4/Xnx+fGAPPiCBmJ8+IHp2Bdr9vH3adWVcnW4r9jpZLJFGzINFjChoxFWV06qWhlVHsqiLOEZftjXNQmwhEjOJWmgqJRDf3ddhk6NNI8ZDLtvUFWc7gpyUAVwPB58yIFgKyjr2hzFAzEVH4wedQafiK0Zj7arKRIue30akk9OTPK8VWPmN/pRot/s6z1uMtPLRs5qhc2oVCKfX3UFsfYzYUhSGyeJAKEDeH/QW0Ib3zkkQOPJdccUVhXb9syCmf2tlEYi9R3Wl60oGgoIK5abP1eDA4jjVETrJkXFB5+J3hFcoGvf7778/U3b691wavYTPQBCN2zVecPsMxPegdf2XXanrn7zAjPDa7Qr48+wKHtdW63R4idpFO9dHd7vKsXJBaY90IVa2ld7Zvuv8gJpTbOvRCgPRiljm0xYG4hRXYgma08hP54UlCSQKf0VDeVomgeA+rTk6ruJil298XYyYF2e6EH2864bAsaF4PLqsaWa8bAE4OnNbAcTNRcWl2gEfmJjuu2x2xJtnKhIoo2mLu7YDXLhdcFtX5q51tmG46rdbAtJHrpw8wPQImVAH0COIsV1eFQmkriicN+rPCZ63D4QDwK2d7UoViI1J1e3+cg8JkXH6JzR1dRf+ALUEwsJW97lV6kDoRK9KfOT+SuoPRKc5TSEuiPv5AUz8uug8dHRoJB90Hhzt6n0jR6Jl4ev0eGFg2JPUAQlIayRUQT5eYjf4egat6MMupMq2xfVJ7A2feaD1nm222dztLI5KnpGEz3T9cj/tx/Nw5WL565ItXTXt2GOLCXUtXNiQiPVpTjueebP2FbU6amMlnom27cFOoxHz4P3vDgyE70IvyO2QQOpKHzyKhgzEX4FpgNgsruwkK4GP9vzzzw/qrLnmmkHeZYhnqTknEsZMM82UnffvvPPOrmp25QESkSrGyBZeeOEgsBDSRJ1jZ05b+BcBPsBAfK02YeC0cQ2GTFXAGMUMOaiCXsVnitpehiA2MbHSIYGpEfhFg5OcdHndPBKfFouJUhVTsmmcxN/0V0KOf9sR3Ef30848z0AzC6TuRsA/bOJfInQH0PpIsXpuelhImj7UOb519RsyEAl8UpBC+NDEf8XhKFyZxMYbbxy8eDwscVoq1D3jjDPMbbfdFpQjSvuGV+JLUhgDkZ569eoVtCMjZsmmZ8+eQbmYoFdar7JNwsZEE3L99dcP8GCHoP+zGZHIJJBNUM9l+KD5sHREMKx5fRDnMD+bpSW4UUA/V4EtAnqJmA2Aq6OvPrPiHtun2B5ewhBkdjh+e7aARO2OafypxxwldEAQ4YxyLFj1x0l5dwK2ZnrbhoVpbGFi3DBSFraY0rWrzLtVumgGwha/WZDgTEETLTQEN+tmhCB5QCHtMiw4ssA+uMKLbUTuVYhLMi7esmpznhj85F/tCcoQRHwseO3igCdK0rCi5B588MFCBCd5QaN+LqIbiMYC2WKLLSxBhuQFyfDL3i9zh4655xMIST6awjjAHYv3IQwzC2cgkkMW+4SIWSLGBzSAJvLCFryC8QZmLppmuHbjfyPbAyvbmiz0AI54up7L43UbA8IKuDruKkzW8v9BoKsPIkVY2V4V6hOFjjm5uC54qxIOQXtygl9WMAudYhDzhRH7k1jVLpfV8YXZYIMNCnMlTIUwzrx/kU6tMJbKSHzMWaTovI1LaF8Y4rTUAR2xTw4Pos3oUxaIYA68T3VBDkgKoRFEL6Sb95bn2hwIhpyBgE1WvWCQgi3P47FJvAi/zE/LtqLwMfKiiohbaFPl6SsrYaE+sUN0PAvGqx2E/PHgXYxToF/mp4l9Ils10EQBBzO/ft00XqNljlQ6PGEdnNrtXiSy6HgJ3FSFT4ctwPlQv5SuPeV4JMcYHnUojwWEcgPrbgxEpMNClDs3VzEJsHJ8G/ybSHcvtkjK9ifDBcN30GkGQj94z7pxcZU4q677hlfiwfhtWRxhKgq6zkCIUoR7u3bR9zuPpfGoFSWpGo+12puRtjww2d8X6roCGIWcxQcTph0ewzHA5Z+4IbFxlZXBCCMcuICeh9QMbkIxlsV0ADmxLmJxNcrGCUPXnsplEgjMmmBKZbh0RDLG07dv30J4g7L2rhzmIVtSmpdCd2MgDDQWrMrNKXYloBCrvCidozTt3wxEL6w6DEXpw5AbhD/058h7FYGuMxCHlO2MKMiCTv0BuDTxTnkwBJDVII5IUa5fFi/Eb8/HHWNiiPgxIJ5JLBSiG6e7IkVBeNGDxNBEy3hRdOwRh89dWbFF4VsLL1srAuO4trErgZlEiZetEvrhw5TLgO0HbWM4YwwEPGzxdHyQWHtWXuo1CjAMzth2qlNbGCKK+eNlm1EGovC3hG/w6+u0nE5k20gYMkDcEB0rhzY+A9HxSmGgdYB30e+/bAsDLqIC+nUJjlUXdMgNHVf2HzylDKT03E8a0mhv+RWAUwCUNbje88NuAZsElIFYgnLKsOqqq1Yq0XDSkz5y3PKh1Xbcoi+t1OMkQ1bAHJ+foC6KIjdejo3BwXEqY8ZdH8UrSsRmgTngI4Nikh82H/w48uUn0a0KirpGfXAu78aKpSS0QdknzCr7lxnOhB5ln69MZT7uXwbE+uDYkuNH/l2BfAQGPIwRz9YqWw+OlYU5ZGPi+NwdF0M7xoT1cEwRHBsDRonah6Pq2cVw1C3j2eB+4N4zrEjLHDnBCS0xHeAEETsb3idohJcxVqn8uxJ9CkddvHM5OcObG6tV/kWIMxJ074MbM46AVbR29Tjl8U/isOKOWZ5Sn/lxBO8fSfN9cqxeBRg3YmHrTtk4OWMeztrWa9tHnvm/cS68G6VJGVSgA5F8gkSBRIFuSgEtjcoJYsOR6ti3FcGI2iuBlHKddCNRIFFggFAA6RJfHeeIiiSKzVZZ6ANMFwh05QzPCKeA9IGkE4FSCaShHUgEWSpKFEgU6GYUYNvhGyxiGOn/tzo9XDlgyJkH97BXKmEeummQb0kHEmBImUSBRIFuQwGMwFxYAnQmGEf61tQMFJ0g/2rVOYYSpAk9V4UVbpJAus0TTgNJFOggBTCzd0palLCEfdSAotgxD+7JyVAV89DNg3zawgTkSJlEgYGbAmJVHcS/Ibqf7xCK9EEISQf4lOE/1iokBtIq5VK7RIFuSgE5XTEwEkBLIUgfLjQnWxux1erSLBq7HnYJfWqcKJAo0L8pwBYGJam4XGRd+ycx2A65f9XRo0cPoz3Bmx1rUqI2S7FUP1Fg0KNAUqIOes88zThRoPMUqNrC9Ot896mHRIFEgYGAAv0GgjGmISYKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAokCiQKJAp0hgL/AzY8ewcM6T6aAAAAAElFTkSuQmCC"/></switch></g></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-23"><g><path d="M 80 200 L 80 176.37" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 80 171.12 L 83.5 178.12 L 80 176.37 L 76.5 178.12 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-25"><g><path d="M 170 300 L 170 323.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 170 328.88 L 166.5 321.88 L 170 323.63 L 173.5 321.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-13"><g><rect x="35" y="200" width="180" height="100" rx="15" ry="15" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 178px; height: 1px; padding-top: 250px; margin-left: 36px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">CometExecIterator</div></div></div></foreignObject><image x="36" y="243.5" width="178" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-22"><g><path d="M 80 330 L 80 306.37" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 80 301.12 L 83.5 308.12 L 80 306.37 L 76.5 308.12 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-26"><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 315px; margin-left: 101px;"><div data-drawio-colors="color: rgb(0, 0, 0); background-color: rgb(255, 255, 255); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; background-color: rgb(255, 255, 255); white-space: nowrap;">next()</div></div></div></foreignObject><image x="87" y="309" width="28" height="15.75" xlink:href="data:image/png;base64,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"/></switch></g></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-14"><g><rect x="35" y="330" width="180" height="40" rx="6" ry="6" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 178px; height: 1px; padding-top: 350px; margin-left: 36px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Spark Execution Logic</div></div></div></foreignObject><image x="36" y="343.5" width="178" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-15"><g><image x="349.5" y="133.1" width="70" height="36.4" xlink:href="data:image/png;base64,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" preserveAspectRatio="none"/></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-16"><g><path d="M 379.5 170.5 L 389.5 170.5 L 389.5 180.5 L 400 180.5 L 384.5 199.5 L 369 180.5 L 379.5 180.5 Z" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-18"><g><path d="M 215 95 L 288.63 95" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 293.88 95 L 286.88 98.5 L 288.63 95 L 286.88 91.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-29"><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 111px; margin-left: 255px;"><div data-drawio-colors="color: rgb(0, 0, 0); background-color: rgb(255, 255, 255); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; background-color: rgb(255, 255, 255); white-space: nowrap;">decode()</div></div></div></foreignObject><image x="233.5" y="105" width="43" height="15.75" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAKwAAAA/CAYAAAB9wyM1AAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAArKADAAQAAAABAAAAPwAAAABhosEZAAARFUlEQVR4Ae2dBcwmNROAe3C4++Hu7hAgWJDgLiF4gODuBHd3CC7B3d3d3V3vcHfpP0/zdVNdee8L3B86yXtbmU67s7PT6czsdwNUAFrrwdI0KGgu1cKBf4MDQwYMGDCxO/FwbqWUCweGdQ4UgR3Wn1BZn8eBIrAeO0plWOdAEdhh/QmV9XkcKALrsaNUhnUOFIEd1p9QWZ/HgYFerR8qf/31lzr66KPV119/baiNPvro6oADDugHyoVEyIGffvpJHXnkkerXX381XVNMMYXafvvtQ7R/pf7hhx+qBRdcUP32229m/pdffllNMskk6p133lELLbSQQk4mnnhi9eSTT6rRRhut9zXih5Vfz/DRRx9pmb36TTDBBD3TKgPrOfDAAw9UfIbnIiD1A/7B3tVXX71a2+KLL17NLIKqZ5111qpvt912q/oSBWICHhSTwGNHqfQHB2677TZ13XXXVaQOOuigqjzccMOp/fffv6qfeOKJ6sUXX6zqTYUisE0cKv2dOIAJ4Jolol0VPxfWWmstJVrWNP35559qq622UqJdXZRsuQhsljWloxcOHHXUUcZOtWP32WcfW6yuoZZ9/PHH1dlnn1311xWKwNZxp/R14sAnn3yijjjiiGrMvPPOq5Zddtmq7hbQsjPPPHPVtPfee6svv/yyqucKRWBznCntnTngeiwYvOuuu2ZpoGW33Xbbqh+v0sEHH1zVc4UisDnOlPZOHPj000/VOeecU43BhYUWrYMNN9zQc2mdddZZavDgyDHgkejkh33hhRfULbfcosR1pT7//HM15phjKnx/qP4VV1xRDT/88B7xrhVOizfeeKN69dVX1ZAhQ9RII42k8ONONdVUhj7Gu6SbdSWrvvrqK3Xttdeqm2++Wb333nvq559/Nn5A6E4zzTRqrrnmUptttpnHvKZJvv/+e0MPmm+++ab67LPP1KijjqomnXRSNcccc5jfEkssYeg30Qr7OYA8+uij6u6771Zss2yV4403npp88snVYostppZccslwSKc69J944gl10003qbffflt98cUXauSRR1ZjjTWWmnbaaZW4pMwz7UIU37v1BzMOfo4wwgi1JJCfDTbYQCGoAAc2bFnXi1BLgE65mcgP+/TTT+u555678p2BFv5EcPUVV1yhe/HDPvXUU1qcyRHNcI4pp5xSX3DBBbLEdoDP76STTtLyIBpp4y8+5phjtDC9ljg0zzzzTD3++OM30hxxxBH1IYccon///fdamm7nHXfcoeUlqqUttp++//77dS9+WOjPNNNMtfThO77SW2+91V1atsz9jTHGGB5NeYmz+G7Hww8/7I1DjhyoV7ey0EhgEZCBAwd6RENBcuu77LKLh9sUODjllFO0aE1vjEsvVV5uueX0t99+69xXXISJ66yzTie6zLXpppvGxPpa/vjjD73++ut3pjnnnHPqZ599NkvXdogN15o2z2SHHXbw8JsCBzjpU/ysa9t4440bX7j77rvPoys7gb2lxqtoVT3KKKN442Unt+O6Ceydd97ZSVhTN14nsCeffLK30NT4XJtsi5qbzYFsSVnaaFwxN7L9559/fpIswpxbDxpGtu1sPxpZtt4kXRrF/suOzc0ZttcJ7M4779wzfbE19d9//51d+5577unRXnfddbO4qQ6epXsvYl5YtPYCKw5dPd1003mEIIoAiq/NbEkSF9Y33HCDrhOOnMCKbaYlhhzRX3PNNfW9995rNKjYnmZbEl9eUsAOP/xwe2Pe9bnnntNyCvVoiz2loSOHA4PL1s76N998cw+Pe+SN/+677zyamEXhTiA2u5aTsX7ppZc09AC2wvPOOy+57aKtUsBukTJb4D8mzWOPPWboXnnllXrVVVeN1msfdk5gn3nmmYgfjNl66631I488on/88UfDF7Hz9XbbbRfdJ7iXX355aummTWx2b02suQuIzeqNX3rppe3w9gJ72WWXeURYtByutCQ1WGLe9dJLL9Vy6IjG5AR2k0028XARqHPPPdej6Vawp0KtyANNgfj+ItpyWEyhmrbjjjvOw+de5TDl4YdagPUiQDn4+OOPtRzqIrr33HNPNOSwww6L8JZffnn9zTffRLg0HHvssZqXhXW6v5zAymHVw+PlCO/PnUgOQZHQLrPMMi5KVUbxuGugzJmkC8jh0qPBc5bEHki0E1jU/+yzz+4RGTRokCWSXctpp53mjWHxKYFNvfFovyaQU21E/8EHH/SGYcaEDNx99909nLCCdpxnnnm8ce4YhD2kyb02wVtvvRUdzuabbz5vGA8GHrn0WYvV2B6yUxEfpzeG8SmBveaaayI8zI8mQEu6a2LHSikrdlgXj4Mmtn4X+OGHHzwa0OM5CrQTWEleiAgcf/zxjWvghD3ZZJN5Y1MCu95663k4nIp/+eWXRvogoOVdBqGpXQgPWryt4fbu4tvyCSec4NGdf/75bZdeaaWVvL6xxx5bi2us6q8r7LHHHt5Y1uMKY+olv/766+tImj5xo0U7WkpgF1hgAW9+cYvV2qN2Yg6tE044oTeWQ2EIoe2NYusFwt2576WKBDYZOCBH0QU5MJgEBbctVZaHoXbaaadUl9f2yiuvePXVVlvN+AG9xkxl7bXX9nrkhOrV8Su6gC8Uf18TrLHGGko8HNVPPBHVEPysLmy00UZK7Fy3KVsO14uv8f3336/wQ17LzqZWWWWVqj9XEGFS8rLmuqt2fNouyIGolS8bHyrPxYWQ1/Thj3dhnHHGcauty+OOO66Hi187BcnAAUm2LuBYxyneBmabbbZaNHn7jLPaRcLZnlugi0d5ookm8prEVlRk/Iibx7SHa19hhRU8/FyFAIjYslG3aEMTbHA75ODjVmvLBFUIqEDHAi8AAQsgXO/CCy/cSqAY28Rrok9yoAK1gi68Fm1ZjaPgvmi2g6CDC70KLIERnqWF8EWw7a0EVhz2Fr/xyoOvA6Jksv17KMSc6+LOHnJQQRBkyzeRICJalF2YYYYZ3GrnMpnzYpN545ru0UUmMidmkYnc2fY33nhDyaHKVEOB7U9ehzsDExLF6hXgbwj9KbAu7ZzAJk2CkImEBNtC08NMMbEt7Rwe2ywQrps2hGVoQA5O0XCx06O2ugY5lXvdNl5OiNiWLUIXXjfh9jevLZ/tWrmGAhveq4tbVw41s/3EKhyTFNgQOdQwIRG3zvZcB6m3tA6/TZ+dk/yDEMShHzZ1qocpb3IKbm1v24lCfvItEyBuK4tSXYdlXrtmjV2w5b2td1m/HcNVPFNu1eSQeA19laRJgJZ0Dy/idkiNTbax5dcBCSchHHjggYrDRi/AG221OhlCIbC1DI1ZEGoxOT2bZBpsrjYAfij0JJgA2Ii8AOBY6MJr1+az491ritcXXnhhVhjcsalyir/iMfFQe1VI4cub2xmTAjv99NN7Aosd1xaaBDYlPBweOKUPLbDuEJrWY/HRDO59kq859dRTqxTNDz74wNjMdmzdlYMKB00X7IGLwxhzYNNacNdg23LXpntL8RrFIIlMOZKd28OtvFeBlWifN3dOYJMmQfiQcL2Eqt+j7lQkKODU4iI3GC7GfWDxCL8FjSmh2+rnusjQtqEXoe0HbuJgVxI5q35LLbWUmRgtSIqjCxKmdau1ZfdjPIuIkFoIeU1aYVto4nVKYLvwmhfT5fW7774bLS10R4XmTzQg0xBqWNx2rUC0weBTTz3VcxjLQH3VVVc1+oMJHOA4Bt/+RDijcYssskjVD94ss8zSypkNIfENemMJYbqw6KKLev0iwI3ZRowXDe+N22KLLSqyYWolUcC2QKaW5QVXMQe8oWF2GzhEAptADmtRqDoVOBB72Ztf3HxNpE2/2Kta3Jne2G222SYaS0qpe38EAHoBUTYenb7chShwIHP5IJMNFmdzFKsmQtIEknzrTSqUk6HZfffdN8K7+uqrm8jrMHcS+mH+QRixAueSSy6ppU3qH7kB4NofiSAWUmHQu+66y3Znr2G+KrTDkO7tt99ezWnnlsBElqbtkG+gonEpgU2lQ7ZJdbzooosi+hI4sNNXVznoRnhis1f9bQqilSMafSH3dgLLJPLpbUREIitaTIPkGkhgkIhSNCalYYkdiwHv4crBScv2naRNo2xlmsRl+1C5SpZ8lBdLymGYdMK6HnrooSRtEkzEhvboIrxuOFfsMk041p0bzV2X5MG9iPnjjRGnfTJBnMQSlzZl+Ws5yfXSePHFF2ti9uGYlMDKth6FcNGcYitn6ZMdFmpmQu5o3RTMOOOM3lrIL+gCJDa594KW7gvVtxdYYtVhFjlE5VMYk5jAWwGIXaPJMwg1lF1ASmAZR3aXxbFX0g3JFJKDCigGKJM3G8aaGUOWVQrQqJamvTKedbLdygFLoxnYdsIXB/wdd9wxIkuGlKVlr6yXmLe7XvEFG4EKTSPGcB8pIGE5TIcEn/xbtDQvOAlJ7HwkCYVpjnY9KYFlvkMPPTRaO3kCZJthWgAIo/htzYuSSth3dxwzwPlnyy239OizI3WB/fbbzxvvmC3tBZYJyXu1zEhdUxo1vNmcwEI/TNlz58CmSdG3OCuvvDIkksDDraNtaaSuEhpN2rxo7lR+sKXBesPMedvHFS1el+CT2tHseIRZDn7RswjnywksZws53EXjLX0Sz1O5ybafLxvqIFQ+buJQ3TjbR/6rnYsrX6H0QTeBZZD8KZlOXx0wmfguqwXUCSyaoy6L370Jt8yDYZuuAwSMBGV3XFNZwqLmm7QcXXYdPs9pohP2s2Wi0esAU4uUxnBsro5iwO53+3MCy7zMj+Zy8duUyX6Dl3UQ5sSyNpLC2wD3Hb6MEgOwQ7sLLCPZlrDZ6m6QT0DIVwXEnVLh1gmsQZZ/YLy4R6oxuXnQEmyrdZrK0rRXvkkLNVFIH1uTDxDb0EV78wlHzgRyaYPDd1Tyha1dTuOVbTp8gC5NyqRjYmeyjZOuaPvrBNZOjAeoiR/Qw6ThEN0WQk9KXYK4SzPMX+YDSQcigR0gi/NAkEHy03SkAceunNzM58f4Cvn8GJ8nUSbZnk0qmmwrhhY+NXn4poxzHLwmwH8nn2sofItyijVZRrQRt+cnOanmU2+SSbqCaAjzB8fwn/JjTQA+UH6kIIYRm6Y58FHyqfTzzz+v5JMcxZ++FC2m8B+yXv7iCZ++t7n3cC7oWF6LYJrIGuFcAg7yCZFJnCFCBhBFs5Ey2kgFbQKyuHiG8Bl+M57P1lk3z5MMN9Zv+dREj34+1eZvZFkgo03yem01e+UzbzEpqn7oiEvR1qP/RSZ6+jmBtRTKtXAgxQFeWELBNgyNsL8nfwMiDG27Y0kp5QWxLxxlUgJkZ7JokcAmI10Wu1wLB9pygN3VTREVc6X6Axk5GvL3HSphBWevvfZyhTU5rGjYJFtKYy8cEG+EkqhllfAu5xclLr9k8j+pleT+Wo2Mdn799dfNX/tx5i4a1mFGKfYzB/hzR+IlqqiSK3v66adXdbcg/utKWGmXjx5DYXXR82VsWOeUVoqFA505wN+WEAkzPwIUfZ9sV3Rwk8kBr8LhI88MRF6CYsPm393S0yMHxPVo/rAcw8muC7Us2tXm8qKVwe8ZRNKLhs287qW5PQfOOOOMSoO6Wpaom6tdU5+OO7NEGjaZwN2ztJeBhQN9HMAn+9prrxkNi5sKt5fkc5j/DktSQA2WBDCU/N2GTjwrXoJO7CrI/zAHipfgH2Z4ma6fOZAyCbCAh+5T035eZCH3n+VA+69f/7MsKjdeOFA4UDhQOFA4UDhQOFA4UDhQOFA4UDhQOFA4UDhQOFA4UDhQOFA4UDhQOFA4UDhQOFA4UDhQOFA4UDhQOFA48H/Dgf8B2/VEQZQOJpcAAAAASUVORK5CYII="/></switch></g></g></g></g><g data-cell-id="wVAZ-YzccNhZugPFJvmi-27"><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 181px; margin-left: 101px;"><div data-drawio-colors="color: rgb(0, 0, 0); background-color: rgb(255, 255, 255); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; background-color: rgb(255, 255, 255); white-space: nowrap;">next()</div></div></div></foreignObject><image x="87" y="175" width="28" height="15.75" xlink:href="data:image/png;base64,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"/></switch></g></g></g></g></g></g></svg>
\ No newline at end of file
diff --git a/docs/source/_static/images/CometOverviewDetailed.drawio b/docs/source/_static/images/CometOverviewDetailed.drawio
deleted file mode 100644
index ff7f4c5911..0000000000
--- a/docs/source/_static/images/CometOverviewDetailed.drawio
+++ /dev/null
@@ -1,94 +0,0 @@
-<mxfile host="app.diagrams.net" agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15" version="24.7.16">
-  <diagram name="Page-1" id="IdYZ_KFENTEXElLiOEKC">
-    <mxGraphModel dx="1193" dy="827" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="850" pageHeight="1100" math="0" shadow="0">
-      <root>
-        <mxCell id="0" />
-        <mxCell id="1" parent="0" />
-        <mxCell id="AH3lBTSLKK5181iXBnnY-2" value="Spark Executor" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;" parent="1" vertex="1">
-          <mxGeometry x="290" width="210" height="430" as="geometry" />
-        </mxCell>
-        <mxCell id="AH3lBTSLKK5181iXBnnY-16" value="Spark Driver" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;" parent="1" vertex="1">
-          <mxGeometry y="40" width="200" height="350" as="geometry" />
-        </mxCell>
-        <mxCell id="AH3lBTSLKK5181iXBnnY-17" value="" style="shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/svg+xml,<svg xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;" xml:space="preserve" version="1.1" viewBox="0 0 1008 241" height="100%" width="100%">&#xa;    <g transform="matrix(1,0,0,1,-85.3519,-181.196)" id="path1">&#xa;        <path style="fill:rgb(234,151,52);fill-rule:nonzero;" d="M315.318,338.335C314.573,341.101 314.401,339.494 314.575,331.378C316.01,264.251 257.149,217.797 189.369,232.561C187.782,232.907 186.445,233.25 185.268,233.489C179.698,234.621 179.735,234.93 177.187,233.775C174.023,232.342 169.792,229.462 159.886,223.212C156.414,221.022 157,220.058 159.212,218.758C170.165,212.32 200.292,207.23 225.306,211.683C288.142,222.871 330.339,282.647 315.319,338.335L315.318,338.335ZM291.072,356.082C290.554,356.044 289.252,354.65 288.18,352.998C286.231,349.993 286.231,349.993 285.505,352.493C284.477,356.036 283.898,355.533 278.47,346.393C272.599,336.504 261.642,321.875 261.056,323.142C260.822,323.646 261.447,327.701 262.445,332.152C264.821,342.745 265.707,342.99 246.55,327.749C237.363,320.44 223.898,309.787 216.627,304.075C209.357,298.363 201.152,291.907 198.396,289.728C195.639,287.549 188.043,281.657 181.515,276.635C174.987,271.613 164.563,263.57 158.351,258.761C145.419,248.75 142.981,243.653 181.857,307.906C203.722,344.043 202.779,342.496 214.032,360.693C223.882,376.62 224.916,375.982 203.028,367.486C199.434,366.09 219.918,385.23 228.275,391.075C233.869,394.987 233.869,394.987 230.061,395.129C226.252,395.263 226.252,395.263 229.59,398.125C234.955,402.71 234.004,403.13 221.858,401.542C201.113,398.831 181.794,389.134 167.022,374.019C162.317,369.204 162.166,369.367 170.952,369.786C178.467,370.143 178.467,370.143 166.62,361.216C149.107,348.019 115.227,316.596 117.006,315.198C117.644,314.698 128.749,318.662 144.82,325.128C157.881,330.383 159.715,330.759 157.422,327.712C156.213,326.104 151.367,316.768 140.333,294.792C137.816,289.778 134.738,283.73 133.493,281.35C130.579,275.782 100.857,214.958 94.62,201.8C91.999,196.272 88.629,189.268 87.13,186.235C83.701,179.302 84.366,179.378 96.936,187.363C109.422,195.294 140.946,215.668 149.064,221.054C152.359,223.239 163.973,230.925 174.873,238.134C197.503,253.101 217.452,266.507 224.119,271.228C229.764,275.225 229.589,275.438 227.553,267.055C222.87,247.767 220.147,234.998 220.537,234.157C221.703,231.639 249.221,268.527 259.368,286.211C268.491,302.111 267.706,301.505 268.533,293.293C269.371,284.96 269.585,284.886 274.423,291.216C288.63,309.803 300.715,356.886 291.072,356.082L291.072,356.082ZM213.876,421.215C123.844,428.556 61.477,334.755 107.965,261.924C114.494,251.697 114.266,251.715 118.708,261.045C120.524,264.86 122.916,269.712 124.024,271.827C126.038,275.673 126.038,275.673 122.081,283.158C91.278,341.428 131.256,410.574 200.829,419.363C208.547,420.338 214.419,421.171 213.876,421.215L213.876,421.215Z"/>&#xa;    </g>&#xa;    <g transform="matrix(0.968859,0,0,0.920768,-70.9157,-151.37)" id="path3">&#xa;        <path style="fill:rgb(230,74,25);fill-rule:nonzero;" d="M285.493,345.632C282.234,341.53 282.234,341.53 282.111,344.281C281.939,348.324 280.979,347.656 276.9,340.6C270.215,329.052 257.352,312.116 256.166,313.3C255.944,313.534 256.814,318.034 258.112,323.299C261.066,335.197 261.621,335.007 250.322,325.982C239.351,317.216 193.938,281.579 178.993,270.007C173.41,265.683 163.508,258.014 156.99,252.964C143.371,242.412 141.022,240.821 142.086,242.866C143.03,244.684 162.92,277.769 175.06,297.721C180.369,306.445 186.516,316.567 188.722,320.213C195.871,332.031 212.9,359.45 217.395,366.383C221.949,373.405 222,373.375 211.621,369.826C206.608,368.11 202.08,366.715 201.561,366.719C199.733,366.738 214.451,381.192 223.86,388.63C233.301,396.091 233.349,396.151 230.259,396.555C227.146,396.968 227.146,396.968 230.791,400.324C240.962,409.751 203.686,401.213 186.752,390.218C170.285,379.542 156.298,371.294 164.839,371.549C172.991,371.79 178.789,371.913 174.59,369.035C151.709,353.315 100.466,307.638 109.333,310.655C112.607,311.769 136.117,321.922 141.112,323.793C147.026,326.011 153.655,329.093 143.818,310.353C127.827,279.892 78.938,174.522 76.594,169.808C71.449,159.458 78.239,166.828 86.193,172.077C89.669,174.373 172.252,229.674 203.14,252.141C229.292,271.163 222.786,268.496 218.454,244.292C215.958,230.346 214.043,222.266 214.242,222.067C215.859,220.453 246.86,264.84 257.024,282.948C263.429,294.362 263.29,292.845 263.586,283.122C263.915,272.333 273.722,284.976 282.262,306.256C289.314,323.826 291.76,353.503 285.507,345.634L285.493,345.632Z"/>&#xa;    </g>&#xa;    <g transform="matrix(1.15167,0,0,1.15167,-376.043,-0.54078)">&#xa;        <g transform="matrix(32,0,0,32,561.496,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,599.839,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.08,-0.716L0.347,-0.716C0.406,-0.716 0.455,-0.71 0.494,-0.699C0.534,-0.689 0.565,-0.665 0.588,-0.629C0.611,-0.592 0.623,-0.552 0.623,-0.507C0.623,-0.435 0.6,-0.38 0.554,-0.342C0.508,-0.305 0.442,-0.286 0.355,-0.286L0.175,-0.286L0.175,-0L0.08,-0L0.08,-0.716ZM0.175,-0.371L0.356,-0.371C0.417,-0.371 0.46,-0.382 0.486,-0.405C0.512,-0.428 0.525,-0.461 0.525,-0.504C0.525,-0.533 0.518,-0.558 0.503,-0.58C0.489,-0.602 0.471,-0.616 0.449,-0.622C0.427,-0.628 0.395,-0.631 0.354,-0.631L0.175,-0.631L0.175,-0.371Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,638.183,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,676.527,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.38,0.012C0.279,0.012 0.198,-0.021 0.137,-0.088C0.077,-0.154 0.047,-0.244 0.047,-0.358C0.047,-0.472 0.077,-0.562 0.137,-0.628C0.198,-0.695 0.279,-0.728 0.38,-0.728C0.458,-0.728 0.524,-0.707 0.579,-0.665C0.633,-0.623 0.664,-0.568 0.671,-0.499L0.573,-0.499C0.569,-0.544 0.55,-0.58 0.514,-0.607C0.479,-0.634 0.435,-0.647 0.381,-0.647C0.308,-0.647 0.251,-0.622 0.208,-0.572C0.166,-0.522 0.145,-0.451 0.145,-0.358C0.145,-0.265 0.166,-0.194 0.208,-0.144C0.25,-0.094 0.307,-0.069 0.379,-0.069C0.435,-0.069 0.48,-0.083 0.515,-0.11C0.549,-0.137 0.569,-0.176 0.573,-0.227L0.671,-0.227C0.664,-0.151 0.634,-0.092 0.581,-0.05C0.528,-0.009 0.461,0.012 0.38,0.012Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,716.636,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.642,-0L0.547,-0L0.547,-0.337L0.175,-0.337L0.175,-0L0.08,-0L0.08,-0.716L0.175,-0.716L0.175,-0.422L0.547,-0.422L0.547,-0.716L0.642,-0.716L0.642,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,756.746,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.614,-0L0.08,-0L0.08,-0.716L0.597,-0.716L0.597,-0.631L0.175,-0.631L0.175,-0.412L0.57,-0.412L0.57,-0.327L0.175,-0.327L0.175,-0.085L0.614,-0.085L0.614,-0Z"/>&#xa;        </g>&#xa;    </g>&#xa;    <g transform="matrix(1,0,0,1,-91.3519,-191.196)" id="text2">&#xa;        <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M403.965,341.559C403.965,345.669 403.027,349.353 401.15,352.613C399.273,355.853 396.902,358.343 394.037,360.081C391.884,361.385 389.523,362.294 386.955,362.808C384.386,363.321 381.344,363.578 377.827,363.578L362.269,363.578L362.269,319.452L378.271,319.452C381.867,319.452 384.969,319.758 387.577,320.371C390.185,320.964 392.378,321.813 394.156,322.92C397.198,324.777 399.589,327.286 401.327,330.447C403.086,333.588 403.965,337.293 403.965,341.56L403.965,341.559ZM392.2,341.464C392.2,338.56 391.667,336.08 390.6,334.026C389.552,331.951 387.883,330.331 385.592,329.165C384.426,328.592 383.23,328.206 382.006,328.009C380.8,327.791 378.973,327.682 376.524,327.682L373.649,327.682L373.649,355.302L376.524,355.302C379.23,355.302 381.216,355.183 382.48,354.946C383.744,354.689 384.979,354.235 386.184,353.583C388.259,352.398 389.78,350.818 390.748,348.842C391.717,346.846 392.201,344.387 392.201,341.463L392.2,341.464ZM453.426,363.572L441.661,363.572L438.608,354.651L422.25,354.651L419.197,363.572L407.729,363.572L424.028,319.445L437.126,319.445L453.426,363.572ZM435.852,346.561L430.429,330.736L425.006,346.561L435.852,346.561ZM494.292,327.98L480.512,327.98L480.512,363.572L469.132,363.572L469.132,327.98L455.352,327.98L455.352,319.445L494.292,319.445L494.292,327.98ZM541.915,363.572L530.15,363.572L527.098,354.651L510.74,354.651L507.687,363.572L496.218,363.572L512.518,319.445L525.616,319.445L541.915,363.572ZM524.342,346.561L518.919,330.736L513.496,346.561L524.342,346.561ZM579.878,327.98L559.578,327.98L559.578,336.189L578.396,336.189L578.396,344.724L559.578,344.724L559.578,363.572L548.257,363.572L548.257,319.445L579.878,319.445L579.878,327.98ZM626.375,347.598C626.375,353.051 624.716,357.23 621.396,360.134C618.077,363.038 613.187,364.49 606.727,364.49C600.267,364.49 595.377,363.038 592.058,360.134C588.758,357.23 587.109,353.061 587.109,347.628L587.109,319.445L598.548,319.445L598.548,346.976C598.548,350.038 599.19,352.32 600.474,353.822C601.758,355.323 603.843,356.074 606.727,356.074C609.572,356.074 611.646,355.353 612.95,353.91C614.274,352.468 614.936,350.157 614.936,346.976L614.936,319.445L626.375,319.445L626.375,347.598ZM672.339,349.702C672.339,354.049 670.492,357.585 666.797,360.312C663.122,363.018 658.124,364.372 651.802,364.372C648.147,364.372 644.956,364.056 642.23,363.424C639.523,362.771 636.984,361.951 634.614,360.964L634.614,350.384L635.858,350.384C638.209,352.261 640.837,353.703 643.741,354.711C646.665,355.719 649.47,356.223 652.157,356.223C652.849,356.223 653.758,356.166 654.884,356.051C656.01,355.936 656.929,355.739 657.64,355.458C658.509,355.103 659.22,354.658 659.773,354.124C660.347,353.59 660.634,352.8 660.634,351.753C660.634,350.785 660.219,349.955 659.389,349.264C658.579,348.553 657.383,348.009 655.803,347.633C654.144,347.238 652.385,346.872 650.528,346.536C648.691,346.18 646.962,345.736 645.342,345.202C641.628,343.996 638.951,342.366 637.311,340.312C635.691,338.238 634.881,335.669 634.881,332.607C634.881,328.497 636.718,325.149 640.393,322.561C644.088,319.953 648.829,318.649 654.618,318.649C657.522,318.649 660.387,318.936 663.212,319.509C666.057,320.062 668.517,320.764 670.591,321.613L670.591,331.778L669.375,331.778C667.597,330.356 665.414,329.17 662.826,328.222C660.258,327.253 657.63,326.769 654.943,326.769C653.995,326.769 653.047,326.838 652.098,326.976C651.169,327.09 650.27,327.327 649.401,327.687C648.63,327.984 647.969,328.438 647.416,329.05C646.863,329.642 646.586,330.324 646.586,331.094C646.586,332.26 647.031,333.159 647.921,333.791C648.81,334.404 650.489,334.967 652.958,335.481C654.578,335.817 656.129,336.144 657.611,336.46C659.113,336.776 660.723,337.21 662.442,337.763C665.82,338.87 668.309,340.381 669.91,342.298C671.53,344.194 672.34,346.664 672.34,349.706L672.339,349.702ZM703.989,363.572L678.147,363.572L678.147,355.748L685.378,355.748L685.378,327.269L678.147,327.269L678.147,319.445L703.989,319.445L703.989,327.269L696.758,327.269L696.758,355.748L703.989,355.748L703.989,363.572ZM756.176,341.523C756.176,348.557 754.161,354.148 750.13,358.297C746.1,362.426 740.529,364.49 733.416,364.49C726.324,364.49 720.762,362.426 716.732,358.297C712.701,354.148 710.686,348.557 710.686,341.523C710.686,334.431 712.701,328.83 716.732,324.72C720.762,320.591 726.324,318.526 733.416,318.526C740.489,318.526 746.051,320.591 750.101,324.72C754.151,328.83 756.176,334.431 756.176,341.523ZM741.092,352.696C742.198,351.352 743.018,349.772 743.551,347.954C744.085,346.117 744.352,343.963 744.352,341.494C744.352,338.846 744.046,336.594 743.433,334.737C742.82,332.88 742.02,331.378 741.032,330.232C740.024,329.047 738.859,328.188 737.535,327.654C736.232,327.121 734.868,326.855 733.446,326.855C732.004,326.855 730.64,327.112 729.356,327.625C728.092,328.139 726.926,328.988 725.859,330.174C724.872,331.28 724.062,332.811 723.429,334.767C722.816,336.704 722.51,338.956 722.51,341.524C722.51,344.152 722.806,346.394 723.399,348.251C724.012,350.089 724.812,351.59 725.799,352.756C726.787,353.922 727.943,354.781 729.266,355.334C730.59,355.887 731.983,356.164 733.445,356.164C734.907,356.164 736.3,355.887 737.623,355.334C738.947,354.761 740.103,353.881 741.091,352.696L741.092,352.696ZM804.985,363.572L794.02,363.572L775.29,333.285L775.29,363.572L764.859,363.572L764.859,319.445L778.461,319.445L794.553,344.724L794.553,319.445L804.985,319.445L804.985,363.572ZM856.934,364.432C853.655,364.432 850.622,363.947 847.837,362.979C845.071,362.01 842.69,360.568 840.695,358.652C838.699,356.736 837.148,354.345 836.042,351.481C834.955,348.616 834.411,345.307 834.411,341.553C834.411,338.056 834.935,334.885 835.983,332.04C837.03,329.195 838.552,326.755 840.546,324.72C842.463,322.765 844.834,321.253 847.659,320.186C850.504,319.12 853.606,318.586 856.964,318.586C858.821,318.586 860.491,318.695 861.972,318.913C863.474,319.111 864.857,319.378 866.121,319.714C867.445,320.089 868.64,320.514 869.707,320.989C870.794,321.444 871.743,321.869 872.552,322.264L872.552,332.962L871.249,332.962C870.695,332.488 869.994,331.925 869.144,331.273C868.315,330.62 867.366,329.978 866.299,329.346C865.212,328.714 864.037,328.181 862.773,327.746C861.509,327.312 860.155,327.094 858.713,327.094C857.113,327.094 855.591,327.351 854.149,327.865C852.707,328.358 851.373,329.188 850.148,330.354C848.982,331.481 848.034,332.972 847.303,334.829C846.592,336.686 846.237,338.938 846.237,341.586C846.237,344.352 846.622,346.663 847.393,348.52C848.183,350.377 849.171,351.839 850.357,352.906C851.562,353.993 852.906,354.774 854.387,355.247C855.869,355.702 857.331,355.93 858.773,355.93C860.156,355.93 861.519,355.722 862.863,355.307C864.226,354.891 865.48,354.328 866.626,353.617C867.595,353.043 868.494,352.431 869.323,351.78C870.153,351.127 870.834,350.564 871.368,350.09L872.553,350.09L872.553,360.64C871.447,361.134 870.39,361.599 869.382,362.034C868.374,362.468 867.317,362.843 866.211,363.159C864.769,363.575 863.416,363.891 862.151,364.108C860.887,364.325 859.149,364.434 856.935,364.434L856.934,364.432ZM923.821,341.524C923.821,348.557 921.805,354.148 917.775,358.297C913.745,362.426 908.173,364.491 901.061,364.491C893.968,364.491 888.407,362.426 884.377,358.297C880.346,354.148 878.331,348.557 878.331,341.524C878.331,334.431 880.346,328.83 884.377,324.721C888.407,320.592 893.968,318.527 901.061,318.527C908.134,318.527 913.695,320.592 917.746,324.721C921.796,328.83 923.821,334.431 923.821,341.524ZM908.736,352.696C909.843,351.353 910.663,349.772 911.196,347.955C911.73,346.117 911.997,343.964 911.997,341.494C911.997,338.847 911.691,336.595 911.078,334.737C910.465,332.88 909.664,331.379 908.677,330.233C907.669,329.048 906.504,328.188 905.18,327.655C903.876,327.122 902.513,326.856 901.091,326.856C899.648,326.856 898.285,327.112 897.001,327.626C895.737,328.14 894.571,328.989 893.504,330.175C892.517,331.281 891.706,332.812 891.074,334.768C890.461,336.704 890.155,338.956 890.155,341.525C890.155,344.153 890.451,346.395 891.043,348.252C891.656,350.089 892.457,351.591 893.444,352.756C894.432,353.923 895.587,354.782 896.911,355.335C898.235,355.888 899.628,356.164 901.09,356.164C902.552,356.164 903.944,355.888 905.268,355.335C906.592,354.761 907.748,353.882 908.736,352.697L908.736,352.696ZM978.764,363.572L967.443,363.572L967.443,334.026L959.264,353.2L951.411,353.2L943.231,334.026L943.231,363.572L932.504,363.572L932.504,319.446L945.721,319.446L955.648,341.583L965.547,319.446L978.764,319.446L978.764,363.572ZM1021.94,363.572L990.025,363.572L990.025,319.446L1021.94,319.446L1021.94,327.981L1001.35,327.981L1001.35,335.597L1020.46,335.597L1020.46,344.132L1001.35,344.132L1001.35,355.038L1021.94,355.038L1021.94,363.572ZM1066.01,327.981L1052.23,327.981L1052.23,363.572L1040.85,363.572L1040.85,327.981L1027.07,327.981L1027.07,319.446L1066.01,319.446L1066.01,327.981Z"/>&#xa;    </g>&#xa;    <g transform="matrix(1,0,0,1,-95.3519,-190.196)" id="text3">&#xa;        <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M1089.2,319.918L1084.49,319.918L1084.49,331.546L1082.74,331.546L1082.74,319.918L1078.03,319.918L1078.03,318.36L1089.2,318.36L1089.2,319.918ZM1102.72,331.546L1100.96,331.546L1100.96,320.184L1097.3,327.915L1096.25,327.915L1092.61,320.184L1092.61,331.546L1090.97,331.546L1090.97,318.36L1093.37,318.36L1096.88,325.701L1100.28,318.36L1102.72,318.36L1102.72,331.546Z"/>&#xa;    </g>&#xa;</svg>;imageBorder=default;" parent="1" vertex="1">
-          <mxGeometry x="34.519999999999996" y="200" width="125.48" height="30" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-1" value="Spark Logical Plan" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
-          <mxGeometry x="10" y="80" width="180" height="30" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-2" value="Spark Physical Plan" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
-          <mxGeometry x="10" y="140" width="180" height="30" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-3" value="Comet Physical Plan" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;" vertex="1" parent="1">
-          <mxGeometry x="10" y="260" width="180" height="100" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-4" value="protobuf intermediate representation" style="shape=process;whiteSpace=wrap;html=1;backgroundOutline=1;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" vertex="1" parent="1">
-          <mxGeometry x="40" y="290" width="120" height="50" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-12" value="" style="shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1" source="t5OBkkhKOG6cYtw1sPyQ-1" target="t5OBkkhKOG6cYtw1sPyQ-2">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="270" y="270" as="sourcePoint" />
-            <mxPoint x="320" y="220" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-13" value="" style="shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="96.75999999999999" y="170" as="sourcePoint" />
-            <mxPoint x="96.75999999999999" y="200" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-14" value="" style="shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="96.75999999999999" y="230" as="sourcePoint" />
-            <mxPoint x="96.75999999999999" y="260" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-15" value="" style="shape=flexArrow;endArrow=classic;html=1;rounded=0;endWidth=28;endSize=9.67;width=11;fillColor=#000000;" edge="1" parent="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="200" y="204.5" as="sourcePoint" />
-            <mxPoint x="290" y="204.5" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-16" value="Native Execution Plan" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;" vertex="1" parent="1">
-          <mxGeometry x="310" y="230" width="170" height="100" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-17" value="" style="shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/svg+xml,<svg xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;" xml:space="preserve" version="1.1" viewBox="0 0 1008 241" height="100%" width="100%">&#xa;    <g transform="matrix(1,0,0,1,-85.3519,-181.196)" id="path1">&#xa;        <path style="fill:rgb(234,151,52);fill-rule:nonzero;" d="M315.318,338.335C314.573,341.101 314.401,339.494 314.575,331.378C316.01,264.251 257.149,217.797 189.369,232.561C187.782,232.907 186.445,233.25 185.268,233.489C179.698,234.621 179.735,234.93 177.187,233.775C174.023,232.342 169.792,229.462 159.886,223.212C156.414,221.022 157,220.058 159.212,218.758C170.165,212.32 200.292,207.23 225.306,211.683C288.142,222.871 330.339,282.647 315.319,338.335L315.318,338.335ZM291.072,356.082C290.554,356.044 289.252,354.65 288.18,352.998C286.231,349.993 286.231,349.993 285.505,352.493C284.477,356.036 283.898,355.533 278.47,346.393C272.599,336.504 261.642,321.875 261.056,323.142C260.822,323.646 261.447,327.701 262.445,332.152C264.821,342.745 265.707,342.99 246.55,327.749C237.363,320.44 223.898,309.787 216.627,304.075C209.357,298.363 201.152,291.907 198.396,289.728C195.639,287.549 188.043,281.657 181.515,276.635C174.987,271.613 164.563,263.57 158.351,258.761C145.419,248.75 142.981,243.653 181.857,307.906C203.722,344.043 202.779,342.496 214.032,360.693C223.882,376.62 224.916,375.982 203.028,367.486C199.434,366.09 219.918,385.23 228.275,391.075C233.869,394.987 233.869,394.987 230.061,395.129C226.252,395.263 226.252,395.263 229.59,398.125C234.955,402.71 234.004,403.13 221.858,401.542C201.113,398.831 181.794,389.134 167.022,374.019C162.317,369.204 162.166,369.367 170.952,369.786C178.467,370.143 178.467,370.143 166.62,361.216C149.107,348.019 115.227,316.596 117.006,315.198C117.644,314.698 128.749,318.662 144.82,325.128C157.881,330.383 159.715,330.759 157.422,327.712C156.213,326.104 151.367,316.768 140.333,294.792C137.816,289.778 134.738,283.73 133.493,281.35C130.579,275.782 100.857,214.958 94.62,201.8C91.999,196.272 88.629,189.268 87.13,186.235C83.701,179.302 84.366,179.378 96.936,187.363C109.422,195.294 140.946,215.668 149.064,221.054C152.359,223.239 163.973,230.925 174.873,238.134C197.503,253.101 217.452,266.507 224.119,271.228C229.764,275.225 229.589,275.438 227.553,267.055C222.87,247.767 220.147,234.998 220.537,234.157C221.703,231.639 249.221,268.527 259.368,286.211C268.491,302.111 267.706,301.505 268.533,293.293C269.371,284.96 269.585,284.886 274.423,291.216C288.63,309.803 300.715,356.886 291.072,356.082L291.072,356.082ZM213.876,421.215C123.844,428.556 61.477,334.755 107.965,261.924C114.494,251.697 114.266,251.715 118.708,261.045C120.524,264.86 122.916,269.712 124.024,271.827C126.038,275.673 126.038,275.673 122.081,283.158C91.278,341.428 131.256,410.574 200.829,419.363C208.547,420.338 214.419,421.171 213.876,421.215L213.876,421.215Z"/>&#xa;    </g>&#xa;    <g transform="matrix(0.968859,0,0,0.920768,-70.9157,-151.37)" id="path3">&#xa;        <path style="fill:rgb(230,74,25);fill-rule:nonzero;" d="M285.493,345.632C282.234,341.53 282.234,341.53 282.111,344.281C281.939,348.324 280.979,347.656 276.9,340.6C270.215,329.052 257.352,312.116 256.166,313.3C255.944,313.534 256.814,318.034 258.112,323.299C261.066,335.197 261.621,335.007 250.322,325.982C239.351,317.216 193.938,281.579 178.993,270.007C173.41,265.683 163.508,258.014 156.99,252.964C143.371,242.412 141.022,240.821 142.086,242.866C143.03,244.684 162.92,277.769 175.06,297.721C180.369,306.445 186.516,316.567 188.722,320.213C195.871,332.031 212.9,359.45 217.395,366.383C221.949,373.405 222,373.375 211.621,369.826C206.608,368.11 202.08,366.715 201.561,366.719C199.733,366.738 214.451,381.192 223.86,388.63C233.301,396.091 233.349,396.151 230.259,396.555C227.146,396.968 227.146,396.968 230.791,400.324C240.962,409.751 203.686,401.213 186.752,390.218C170.285,379.542 156.298,371.294 164.839,371.549C172.991,371.79 178.789,371.913 174.59,369.035C151.709,353.315 100.466,307.638 109.333,310.655C112.607,311.769 136.117,321.922 141.112,323.793C147.026,326.011 153.655,329.093 143.818,310.353C127.827,279.892 78.938,174.522 76.594,169.808C71.449,159.458 78.239,166.828 86.193,172.077C89.669,174.373 172.252,229.674 203.14,252.141C229.292,271.163 222.786,268.496 218.454,244.292C215.958,230.346 214.043,222.266 214.242,222.067C215.859,220.453 246.86,264.84 257.024,282.948C263.429,294.362 263.29,292.845 263.586,283.122C263.915,272.333 273.722,284.976 282.262,306.256C289.314,323.826 291.76,353.503 285.507,345.634L285.493,345.632Z"/>&#xa;    </g>&#xa;    <g transform="matrix(1.15167,0,0,1.15167,-376.043,-0.54078)">&#xa;        <g transform="matrix(32,0,0,32,561.496,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,599.839,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.08,-0.716L0.347,-0.716C0.406,-0.716 0.455,-0.71 0.494,-0.699C0.534,-0.689 0.565,-0.665 0.588,-0.629C0.611,-0.592 0.623,-0.552 0.623,-0.507C0.623,-0.435 0.6,-0.38 0.554,-0.342C0.508,-0.305 0.442,-0.286 0.355,-0.286L0.175,-0.286L0.175,-0L0.08,-0L0.08,-0.716ZM0.175,-0.371L0.356,-0.371C0.417,-0.371 0.46,-0.382 0.486,-0.405C0.512,-0.428 0.525,-0.461 0.525,-0.504C0.525,-0.533 0.518,-0.558 0.503,-0.58C0.489,-0.602 0.471,-0.616 0.449,-0.622C0.427,-0.628 0.395,-0.631 0.354,-0.631L0.175,-0.631L0.175,-0.371Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,638.183,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,676.527,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.38,0.012C0.279,0.012 0.198,-0.021 0.137,-0.088C0.077,-0.154 0.047,-0.244 0.047,-0.358C0.047,-0.472 0.077,-0.562 0.137,-0.628C0.198,-0.695 0.279,-0.728 0.38,-0.728C0.458,-0.728 0.524,-0.707 0.579,-0.665C0.633,-0.623 0.664,-0.568 0.671,-0.499L0.573,-0.499C0.569,-0.544 0.55,-0.58 0.514,-0.607C0.479,-0.634 0.435,-0.647 0.381,-0.647C0.308,-0.647 0.251,-0.622 0.208,-0.572C0.166,-0.522 0.145,-0.451 0.145,-0.358C0.145,-0.265 0.166,-0.194 0.208,-0.144C0.25,-0.094 0.307,-0.069 0.379,-0.069C0.435,-0.069 0.48,-0.083 0.515,-0.11C0.549,-0.137 0.569,-0.176 0.573,-0.227L0.671,-0.227C0.664,-0.151 0.634,-0.092 0.581,-0.05C0.528,-0.009 0.461,0.012 0.38,0.012Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,716.636,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.642,-0L0.547,-0L0.547,-0.337L0.175,-0.337L0.175,-0L0.08,-0L0.08,-0.716L0.175,-0.716L0.175,-0.422L0.547,-0.422L0.547,-0.716L0.642,-0.716L0.642,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,756.746,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.614,-0L0.08,-0L0.08,-0.716L0.597,-0.716L0.597,-0.631L0.175,-0.631L0.175,-0.412L0.57,-0.412L0.57,-0.327L0.175,-0.327L0.175,-0.085L0.614,-0.085L0.614,-0Z"/>&#xa;        </g>&#xa;    </g>&#xa;    <g transform="matrix(1,0,0,1,-91.3519,-191.196)" id="text2">&#xa;        <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M403.965,341.559C403.965,345.669 403.027,349.353 401.15,352.613C399.273,355.853 396.902,358.343 394.037,360.081C391.884,361.385 389.523,362.294 386.955,362.808C384.386,363.321 381.344,363.578 377.827,363.578L362.269,363.578L362.269,319.452L378.271,319.452C381.867,319.452 384.969,319.758 387.577,320.371C390.185,320.964 392.378,321.813 394.156,322.92C397.198,324.777 399.589,327.286 401.327,330.447C403.086,333.588 403.965,337.293 403.965,341.56L403.965,341.559ZM392.2,341.464C392.2,338.56 391.667,336.08 390.6,334.026C389.552,331.951 387.883,330.331 385.592,329.165C384.426,328.592 383.23,328.206 382.006,328.009C380.8,327.791 378.973,327.682 376.524,327.682L373.649,327.682L373.649,355.302L376.524,355.302C379.23,355.302 381.216,355.183 382.48,354.946C383.744,354.689 384.979,354.235 386.184,353.583C388.259,352.398 389.78,350.818 390.748,348.842C391.717,346.846 392.201,344.387 392.201,341.463L392.2,341.464ZM453.426,363.572L441.661,363.572L438.608,354.651L422.25,354.651L419.197,363.572L407.729,363.572L424.028,319.445L437.126,319.445L453.426,363.572ZM435.852,346.561L430.429,330.736L425.006,346.561L435.852,346.561ZM494.292,327.98L480.512,327.98L480.512,363.572L469.132,363.572L469.132,327.98L455.352,327.98L455.352,319.445L494.292,319.445L494.292,327.98ZM541.915,363.572L530.15,363.572L527.098,354.651L510.74,354.651L507.687,363.572L496.218,363.572L512.518,319.445L525.616,319.445L541.915,363.572ZM524.342,346.561L518.919,330.736L513.496,346.561L524.342,346.561ZM579.878,327.98L559.578,327.98L559.578,336.189L578.396,336.189L578.396,344.724L559.578,344.724L559.578,363.572L548.257,363.572L548.257,319.445L579.878,319.445L579.878,327.98ZM626.375,347.598C626.375,353.051 624.716,357.23 621.396,360.134C618.077,363.038 613.187,364.49 606.727,364.49C600.267,364.49 595.377,363.038 592.058,360.134C588.758,357.23 587.109,353.061 587.109,347.628L587.109,319.445L598.548,319.445L598.548,346.976C598.548,350.038 599.19,352.32 600.474,353.822C601.758,355.323 603.843,356.074 606.727,356.074C609.572,356.074 611.646,355.353 612.95,353.91C614.274,352.468 614.936,350.157 614.936,346.976L614.936,319.445L626.375,319.445L626.375,347.598ZM672.339,349.702C672.339,354.049 670.492,357.585 666.797,360.312C663.122,363.018 658.124,364.372 651.802,364.372C648.147,364.372 644.956,364.056 642.23,363.424C639.523,362.771 636.984,361.951 634.614,360.964L634.614,350.384L635.858,350.384C638.209,352.261 640.837,353.703 643.741,354.711C646.665,355.719 649.47,356.223 652.157,356.223C652.849,356.223 653.758,356.166 654.884,356.051C656.01,355.936 656.929,355.739 657.64,355.458C658.509,355.103 659.22,354.658 659.773,354.124C660.347,353.59 660.634,352.8 660.634,351.753C660.634,350.785 660.219,349.955 659.389,349.264C658.579,348.553 657.383,348.009 655.803,347.633C654.144,347.238 652.385,346.872 650.528,346.536C648.691,346.18 646.962,345.736 645.342,345.202C641.628,343.996 638.951,342.366 637.311,340.312C635.691,338.238 634.881,335.669 634.881,332.607C634.881,328.497 636.718,325.149 640.393,322.561C644.088,319.953 648.829,318.649 654.618,318.649C657.522,318.649 660.387,318.936 663.212,319.509C666.057,320.062 668.517,320.764 670.591,321.613L670.591,331.778L669.375,331.778C667.597,330.356 665.414,329.17 662.826,328.222C660.258,327.253 657.63,326.769 654.943,326.769C653.995,326.769 653.047,326.838 652.098,326.976C651.169,327.09 650.27,327.327 649.401,327.687C648.63,327.984 647.969,328.438 647.416,329.05C646.863,329.642 646.586,330.324 646.586,331.094C646.586,332.26 647.031,333.159 647.921,333.791C648.81,334.404 650.489,334.967 652.958,335.481C654.578,335.817 656.129,336.144 657.611,336.46C659.113,336.776 660.723,337.21 662.442,337.763C665.82,338.87 668.309,340.381 669.91,342.298C671.53,344.194 672.34,346.664 672.34,349.706L672.339,349.702ZM703.989,363.572L678.147,363.572L678.147,355.748L685.378,355.748L685.378,327.269L678.147,327.269L678.147,319.445L703.989,319.445L703.989,327.269L696.758,327.269L696.758,355.748L703.989,355.748L703.989,363.572ZM756.176,341.523C756.176,348.557 754.161,354.148 750.13,358.297C746.1,362.426 740.529,364.49 733.416,364.49C726.324,364.49 720.762,362.426 716.732,358.297C712.701,354.148 710.686,348.557 710.686,341.523C710.686,334.431 712.701,328.83 716.732,324.72C720.762,320.591 726.324,318.526 733.416,318.526C740.489,318.526 746.051,320.591 750.101,324.72C754.151,328.83 756.176,334.431 756.176,341.523ZM741.092,352.696C742.198,351.352 743.018,349.772 743.551,347.954C744.085,346.117 744.352,343.963 744.352,341.494C744.352,338.846 744.046,336.594 743.433,334.737C742.82,332.88 742.02,331.378 741.032,330.232C740.024,329.047 738.859,328.188 737.535,327.654C736.232,327.121 734.868,326.855 733.446,326.855C732.004,326.855 730.64,327.112 729.356,327.625C728.092,328.139 726.926,328.988 725.859,330.174C724.872,331.28 724.062,332.811 723.429,334.767C722.816,336.704 722.51,338.956 722.51,341.524C722.51,344.152 722.806,346.394 723.399,348.251C724.012,350.089 724.812,351.59 725.799,352.756C726.787,353.922 727.943,354.781 729.266,355.334C730.59,355.887 731.983,356.164 733.445,356.164C734.907,356.164 736.3,355.887 737.623,355.334C738.947,354.761 740.103,353.881 741.091,352.696L741.092,352.696ZM804.985,363.572L794.02,363.572L775.29,333.285L775.29,363.572L764.859,363.572L764.859,319.445L778.461,319.445L794.553,344.724L794.553,319.445L804.985,319.445L804.985,363.572ZM856.934,364.432C853.655,364.432 850.622,363.947 847.837,362.979C845.071,362.01 842.69,360.568 840.695,358.652C838.699,356.736 837.148,354.345 836.042,351.481C834.955,348.616 834.411,345.307 834.411,341.553C834.411,338.056 834.935,334.885 835.983,332.04C837.03,329.195 838.552,326.755 840.546,324.72C842.463,322.765 844.834,321.253 847.659,320.186C850.504,319.12 853.606,318.586 856.964,318.586C858.821,318.586 860.491,318.695 861.972,318.913C863.474,319.111 864.857,319.378 866.121,319.714C867.445,320.089 868.64,320.514 869.707,320.989C870.794,321.444 871.743,321.869 872.552,322.264L872.552,332.962L871.249,332.962C870.695,332.488 869.994,331.925 869.144,331.273C868.315,330.62 867.366,329.978 866.299,329.346C865.212,328.714 864.037,328.181 862.773,327.746C861.509,327.312 860.155,327.094 858.713,327.094C857.113,327.094 855.591,327.351 854.149,327.865C852.707,328.358 851.373,329.188 850.148,330.354C848.982,331.481 848.034,332.972 847.303,334.829C846.592,336.686 846.237,338.938 846.237,341.586C846.237,344.352 846.622,346.663 847.393,348.52C848.183,350.377 849.171,351.839 850.357,352.906C851.562,353.993 852.906,354.774 854.387,355.247C855.869,355.702 857.331,355.93 858.773,355.93C860.156,355.93 861.519,355.722 862.863,355.307C864.226,354.891 865.48,354.328 866.626,353.617C867.595,353.043 868.494,352.431 869.323,351.78C870.153,351.127 870.834,350.564 871.368,350.09L872.553,350.09L872.553,360.64C871.447,361.134 870.39,361.599 869.382,362.034C868.374,362.468 867.317,362.843 866.211,363.159C864.769,363.575 863.416,363.891 862.151,364.108C860.887,364.325 859.149,364.434 856.935,364.434L856.934,364.432ZM923.821,341.524C923.821,348.557 921.805,354.148 917.775,358.297C913.745,362.426 908.173,364.491 901.061,364.491C893.968,364.491 888.407,362.426 884.377,358.297C880.346,354.148 878.331,348.557 878.331,341.524C878.331,334.431 880.346,328.83 884.377,324.721C888.407,320.592 893.968,318.527 901.061,318.527C908.134,318.527 913.695,320.592 917.746,324.721C921.796,328.83 923.821,334.431 923.821,341.524ZM908.736,352.696C909.843,351.353 910.663,349.772 911.196,347.955C911.73,346.117 911.997,343.964 911.997,341.494C911.997,338.847 911.691,336.595 911.078,334.737C910.465,332.88 909.664,331.379 908.677,330.233C907.669,329.048 906.504,328.188 905.18,327.655C903.876,327.122 902.513,326.856 901.091,326.856C899.648,326.856 898.285,327.112 897.001,327.626C895.737,328.14 894.571,328.989 893.504,330.175C892.517,331.281 891.706,332.812 891.074,334.768C890.461,336.704 890.155,338.956 890.155,341.525C890.155,344.153 890.451,346.395 891.043,348.252C891.656,350.089 892.457,351.591 893.444,352.756C894.432,353.923 895.587,354.782 896.911,355.335C898.235,355.888 899.628,356.164 901.09,356.164C902.552,356.164 903.944,355.888 905.268,355.335C906.592,354.761 907.748,353.882 908.736,352.697L908.736,352.696ZM978.764,363.572L967.443,363.572L967.443,334.026L959.264,353.2L951.411,353.2L943.231,334.026L943.231,363.572L932.504,363.572L932.504,319.446L945.721,319.446L955.648,341.583L965.547,319.446L978.764,319.446L978.764,363.572ZM1021.94,363.572L990.025,363.572L990.025,319.446L1021.94,319.446L1021.94,327.981L1001.35,327.981L1001.35,335.597L1020.46,335.597L1020.46,344.132L1001.35,344.132L1001.35,355.038L1021.94,355.038L1021.94,363.572ZM1066.01,327.981L1052.23,327.981L1052.23,363.572L1040.85,363.572L1040.85,327.981L1027.07,327.981L1027.07,319.446L1066.01,319.446L1066.01,327.981Z"/>&#xa;    </g>&#xa;    <g transform="matrix(1,0,0,1,-95.3519,-190.196)" id="text3">&#xa;        <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M1089.2,319.918L1084.49,319.918L1084.49,331.546L1082.74,331.546L1082.74,319.918L1078.03,319.918L1078.03,318.36L1089.2,318.36L1089.2,319.918ZM1102.72,331.546L1100.96,331.546L1100.96,320.184L1097.3,327.915L1096.25,327.915L1092.61,320.184L1092.61,331.546L1090.97,331.546L1090.97,318.36L1093.37,318.36L1096.88,325.701L1100.28,318.36L1102.72,318.36L1102.72,331.546Z"/>&#xa;    </g>&#xa;</svg>;imageBorder=default;" vertex="1" parent="1">
-          <mxGeometry x="332.26" y="170" width="125.48" height="30" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-18" value="Comet Physical Plan" style="rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;" vertex="1" parent="1">
-          <mxGeometry x="305" y="40" width="180" height="100" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-19" value="protobuf intermediate representation" style="shape=process;whiteSpace=wrap;html=1;backgroundOutline=1;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" vertex="1" parent="1">
-          <mxGeometry x="335" y="70" width="120" height="50" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-20" value="" style="shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 801 168" height="168" width="801">&#xa;<g clip-path="url(#clip0_1_181)">&#xa;<path fill="url(#paint0_linear_1_181)" d="M76.1297 168C88.4597 168 99.6097 158.25 107.58 142.55C127.23 144.6 143.09 139.99 149.76 128.51C156.29 117.25 152.65 101.68 141.58 86.09C152.36 70.67 155.85 55.32 149.39 44.19C143.01 33.19 128.19 28.5 109.69 29.92C101.65 11.62 89.5997 0 76.1297 0C62.6597 0 50.4997 11.73 42.4497 30.18C24.3497 28.97 9.87966 33.68 3.59966 44.51C-2.81034 55.56 0.589656 70.78 11.1897 86.09C0.299656 101.57 -3.24034 117.01 3.23966 128.18C9.80966 139.5 25.3097 144.13 44.5597 142.31C52.5397 158.15 63.7297 168 76.1297 168ZM52.7197 141.19C59.5097 154.21 68.6197 162.18 78.6397 162.18C88.6597 162.18 97.6397 154.63 104.76 142.22C95.7497 141.01 86.0297 138.46 76.0797 134.58C68.0497 137.65 60.1797 139.86 52.7197 141.19ZM65.0697 129.77C59.6397 131.52 54.3497 132.84 49.3097 133.72C47.3697 128.87 45.6997 123.54 44.3597 117.82C47.6797 120.07 51.1497 122.25 54.7497 124.32C58.1797 126.29 61.6197 128.11 65.0597 129.77H65.0697ZM76.1197 125.68C82.0597 123.2 88.0897 120.24 94.0797 116.79C102.76 111.8 110.61 106.25 117.41 100.43C118.01 95.13 118.33 89.64 118.33 84C118.33 76.79 117.81 69.8 116.84 63.17C111.11 58.53 104.73 54.12 97.7797 50.13C90.5497 45.98 83.2397 42.57 76.0697 39.91C69.1797 42.52 62.1597 45.82 55.2197 49.81C50.8597 52.32 46.7097 54.99 42.8197 57.78C41.3997 65.98 40.6297 74.8 40.6297 84C40.6297 91.65 41.1597 99.05 42.1597 106.04C47.2997 109.94 52.9197 113.66 58.9297 117.12C64.6597 120.41 70.4297 123.27 76.1197 125.68ZM87.1297 129.83C90.8397 128.07 94.5497 126.12 98.2497 124C104.42 120.45 110.18 116.61 115.48 112.58C113.79 120.73 111.42 128.22 108.52 134.76C101.82 133.95 94.6097 132.3 87.1297 129.83ZM117.71 110.84C116.16 119.65 113.87 127.8 110.98 135.03C127.49 136.56 140.52 132.79 145.95 123.44C151.17 114.43 148.57 101.58 140 88.28C134.26 96.01 126.71 103.7 117.71 110.84ZM136.56 79.61C145.46 66.59 148.33 53.99 143.08 44.93C137.99 36.16 126.02 31.96 110.76 32.43C114.3 41.14 116.97 51.23 118.5 62.2C125.46 67.76 131.53 73.64 136.55 79.61H136.56ZM108.21 32.55C111.86 40.6 114.7 50.11 116.43 60.57C110.98 56.37 105.01 52.37 98.6097 48.69C91.9597 44.87 85.2397 41.62 78.6197 38.96C89.0597 35.24 99.1497 33.11 108.2 32.54L108.21 32.55ZM107.08 30.16C97.4397 31.18 86.8897 33.79 76.0797 37.98C67.2997 34.65 58.7097 32.35 50.6497 31.1C57.5997 15.56 67.5697 5.83 78.6397 5.83C89.7097 5.83 99.7197 15.18 107.08 30.16ZM73.5197 38.99C65.2297 36.1 57.1697 34.21 49.6897 33.32C46.9897 39.84 44.7997 47.28 43.2497 55.38C46.7897 52.94 50.4997 50.6 54.3797 48.37C60.7497 44.71 67.1697 41.58 73.5197 38.99ZM33.7197 62.5C35.2297 51.54 37.8697 41.46 41.3797 32.74C26.5297 32.46 14.9097 36.66 9.91966 45.26C4.70966 54.24 7.48966 66.68 16.1997 79.58C21.0897 73.73 26.9797 67.96 33.7197 62.5ZM12.7697 88.3C18.3697 95.9 25.7197 103.48 34.4997 110.54C36.0297 119.36 38.3097 127.53 41.1797 134.78C25.0597 136.11 12.3797 132.31 7.03966 123.12C1.85966 114.19 4.36966 101.48 12.7597 88.31L12.7697 88.3ZM17.5697 81.54C21.9097 75.99 27.2197 70.45 33.3797 65.17C32.6597 71.22 32.2697 77.53 32.2697 84C32.2697 88.91 32.4897 93.72 32.9097 98.4C26.7997 92.89 21.6197 87.18 17.5597 81.53L17.5697 81.54ZM135.19 81.55C131 87.32 125.65 93.15 119.32 98.76C119.76 93.97 120 89.03 120 84C120 77.41 119.6 70.99 118.85 64.84C125.22 70.21 130.72 75.87 135.19 81.55Z" clip-rule="evenodd" fill-rule="evenodd"/>&#xa;<path fill="#1F2937" d="M204.34 45.97H192.83L190.47 52.2H185.2L196.07 23.88H201.47L212.54 52.2H206.78L204.34 45.97ZM202.74 41.74L198.54 30.99L194.46 41.74H202.73H202.74Z"/>&#xa;<path fill="#1F2937" d="M235.55 23.88H246.82C249.59 23.88 251.9 24.73 253.73 26.44C255.57 28.14 256.49 30.38 256.49 33.15C256.49 35.92 255.57 38.2 253.73 39.9C251.89 41.6 249.59 42.46 246.82 42.46H240.95V52.21H235.56V23.89L235.55 23.88ZM240.94 37.26H246.85C248 37.26 248.96 36.87 249.73 36.1C250.5 35.3 250.89 34.32 250.89 33.14C250.89 31.96 250.5 31 249.73 30.22C248.98 29.45 248.02 29.06 246.85 29.06H240.94V37.25V37.26Z"/>&#xa;<path fill="#1F2937" d="M293.67 45.97H282.16L279.8 52.2H274.53L285.4 23.88H290.79L301.86 52.2H296.1L293.66 45.97H293.67ZM292.07 41.74L287.87 30.99L283.79 41.74H292.06H292.07Z"/>&#xa;<path fill="#1F2937" d="M335.99 23C338.57 23 340.92 23.68 343.02 25.04C345.15 26.37 346.84 28.18 348.1 30.47L343.1 32.87C341.37 29.57 339 27.92 335.99 27.92C333.62 27.92 331.65 28.91 330.07 30.88C328.53 32.82 327.75 35.22 327.75 38.07C327.75 40.92 328.52 43.32 330.07 45.26C331.62 47.18 333.59 48.14 335.99 48.14C337.45 48.14 338.81 47.73 340.07 46.9C341.32 46.05 342.32 44.93 343.07 43.54L347.99 45.9C346.79 48.14 345.13 49.89 342.99 51.17C340.86 52.42 338.53 53.05 336 53.05C331.95 53.05 328.63 51.65 326.05 48.86C323.47 46.04 322.17 42.44 322.17 38.07C322.17 33.7 323.48 30.13 326.09 27.28C328.73 24.43 332.03 23.01 336 23.01L335.99 23Z"/>&#xa;<path fill="#1F2937" d="M393.49 52.2H388.09V40.61H377.1V52.2H371.71V23.88H377.1V35.43H388.09V23.88H393.49V52.2Z"/>&#xa;<path fill="#1F2937" d="M435.17 29.07H423.9V35.46H432.41V40.65H423.9V47H435.17V52.19H418.51V23.87H435.17V29.06V29.07Z"/>&#xa;<path fill="#1F2937" d="M185 76.1H207.25C218.63 76.1 227.58 79.3 234.1 85.69C240.69 92.02 243.98 100.14 243.98 110.04C243.98 119.94 240.69 128.1 234.1 134.49C227.51 140.88 218.53 144.08 207.15 144.08H184.99V76.1H185ZM199.96 90.49V129.7H206.67C209.55 129.7 212.2 129.38 214.63 128.74C217.12 128.1 219.43 127.08 221.54 125.67C223.71 124.26 225.41 122.25 226.62 119.63C227.83 116.95 228.44 113.75 228.44 110.04C228.44 106.33 227.83 103.17 226.62 100.55C225.4 97.93 223.71 95.92 221.54 94.51C219.43 93.1 217.16 92.08 214.73 91.44C212.3 90.8 209.61 90.48 206.67 90.48H199.96V90.49Z"/>&#xa;<path fill="#1F2937" d="M291.82 130.85H264.96L259.97 144.08H245.39L271.38 76.1H286.34L312.91 144.08H296.89L291.81 130.85H291.82ZM287.4 119.35L278.29 95.76L269.37 119.35H287.4Z"/>&#xa;<path fill="#1F2937" d="M362.7 90.49H342.94V144.09H327.98V90.49H308.51V76.11H362.7V90.49Z"/>&#xa;<path fill="#1F2937" d="M404.77 130.85H377.92L372.93 144.08H358.35L384.34 76.1H399.3L425.87 144.08H409.85L404.77 130.85ZM400.36 119.35L391.25 95.76L382.33 119.35H400.36Z"/>&#xa;<path fill="#1F2937" d="M474.73 90.49H448.45V102.95H468.4V117.33H448.45V144.08H433.49V76.1H474.73V90.48V90.49Z"/>&#xa;<path fill="#1F2937" d="M541.71 76.1V118.96C541.65 127.27 538.96 133.85 533.65 138.71C528.41 143.57 521.53 146 513.03 146C504.53 146 497.78 143.57 492.41 138.71C487.04 133.85 484.39 127.27 484.45 118.96V76.1H499.32V119.05C499.32 122.88 500.6 125.95 503.16 128.25C505.78 130.49 509.08 131.61 513.04 131.61C517 131.61 520.27 130.49 522.82 128.25C525.38 125.95 526.69 122.88 526.75 119.05V76.1H541.71Z"/>&#xa;<path fill="#1F2937" d="M578.69 73.99C585.72 73.99 591.96 75.59 597.39 78.78L590.77 91.24C585.98 89.19 581.43 88.17 577.15 88.17C570.95 88.17 567.85 90.25 567.85 94.4C567.85 96.45 569.03 98.17 571.4 99.58C573.83 100.92 577.28 102.39 581.76 103.99C586.3 105.52 589.72 106.96 592.02 108.3C598.22 111.88 601.32 117.25 601.32 124.41C601.32 131.12 598.86 136.4 593.93 140.23C589.01 144.07 582.87 145.98 575.52 145.98C571.36 145.98 567.05 145.21 562.57 143.68C558.09 142.15 554.61 140.39 552.12 138.41L560.18 126.43C567.02 130.46 573.22 132.21 578.79 131.7C580.96 131.51 582.76 130.74 584.16 129.4C585.63 128.06 586.24 126.43 585.98 124.51C585.72 122.72 584.22 121.25 581.47 120.1C578.72 118.89 575.14 117.48 570.73 115.88C566.38 114.28 562.83 112.4 560.08 110.22C555.03 106.13 552.5 101.05 552.5 94.98C552.5 91.98 553.01 89.26 554.03 86.83C555.05 84.4 556.4 82.42 558.06 80.89C559.79 79.29 561.8 77.98 564.1 76.96C566.4 75.87 568.77 75.11 571.2 74.66C573.63 74.21 576.12 73.99 578.68 73.99H578.69Z"/>&#xa;<path fill="#1F2937" d="M626.79 144.08H611.83V76.1H626.79V144.08Z"/>&#xa;<path fill="#1F2937" d="M647.04 84.16C653.88 77.38 662.48 74 672.84 74C683.2 74 691.73 77.39 698.45 84.16C705.23 90.87 708.62 99.4 708.62 109.76C708.62 120.12 705.33 128.68 698.74 135.45C692.15 142.16 683.52 145.68 672.84 146C662.48 146 653.88 142.58 647.04 135.74C640.26 128.84 636.87 120.21 636.87 109.85C636.87 99.49 640.26 90.93 647.04 84.15V84.16ZM672.84 87.61C666.64 87.61 661.68 89.69 657.97 93.84C654.26 97.99 652.41 103.3 652.41 109.76C652.41 116.22 654.26 121.62 657.97 125.96C661.74 130.24 666.7 132.38 672.84 132.38C678.98 132.38 683.96 130.24 687.61 125.96C691.25 121.68 693.08 116.31 693.08 109.85C693.08 103.39 691.26 98.12 687.61 94.03C684.03 89.88 679.11 87.73 672.84 87.61Z"/>&#xa;<path fill="#1F2937" d="M775 144.08H759.65L732.7 101.99V144.08H718.7V76.1H732.99L761 118.57V76.1H775V144.08Z"/>&#xa;<path fill="#1F2937" d="M788.01 78.18H784.62V87.44H782.46V78.18H779.13V76.1H788.01V78.18ZM800.56 87.45H798.48V80.17L795.5 85.79H794.12L791.14 80.17L791.12 87.45H789.1V76.11H791.13L794.87 83.04L798.45 76.11H800.51L800.53 87.45H800.56Z"/>&#xa;</g>&#xa;<defs>&#xa;<linearGradient gradientUnits="userSpaceOnUse" y2="36.78" x2="162.73" y1="117.74" x1="17.0897" id="paint0_linear_1_181">&#xa;<stop stop-color="#EF4137"/>&#xa;<stop stop-color="#FBB042" offset="1"/>&#xa;</linearGradient>&#xa;<clipPath id="clip0_1_181">&#xa;<rect fill="white" height="168" width="800.56"/>&#xa;</clipPath>&#xa;</defs>&#xa;</svg>;" vertex="1" parent="1">
-          <mxGeometry x="323.48" y="263.6" width="143.03" height="30" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-21" value="" style="shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/png,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;" vertex="1" parent="1">
-          <mxGeometry x="360" y="293.6" width="70" height="36.4" as="geometry" />
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-22" value="" style="shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="394.5" y="140" as="sourcePoint" />
-            <mxPoint x="394.5" y="170" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-23" value="" style="shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1" source="t5OBkkhKOG6cYtw1sPyQ-17" target="t5OBkkhKOG6cYtw1sPyQ-16">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="140" y="210" as="sourcePoint" />
-            <mxPoint x="140" y="240" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-24" value="" style="shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="394.5" y="330" as="sourcePoint" />
-            <mxPoint x="394.5" y="360" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="t5OBkkhKOG6cYtw1sPyQ-25" value="Shuffle Files" style="shape=process;whiteSpace=wrap;html=1;backgroundOutline=1;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" vertex="1" parent="1">
-          <mxGeometry x="310" y="360" width="170" height="50" as="geometry" />
-        </mxCell>
-      </root>
-    </mxGraphModel>
-  </diagram>
-</mxfile>
diff --git a/docs/source/_static/images/CometOverviewDetailed.drawio.svg b/docs/source/_static/images/CometOverviewDetailed.drawio.svg
deleted file mode 100644
index 0f29083b11..0000000000
--- a/docs/source/_static/images/CometOverviewDetailed.drawio.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Do not edit this file with editors other than draw.io -->
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="501px" height="431px" viewBox="-0.5 -0.5 501 431" content="&lt;mxfile host=&quot;app.diagrams.net&quot; agent=&quot;Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15&quot; version=&quot;24.7.16&quot; scale=&quot;1&quot; border=&quot;0&quot;&gt;&#10;  &lt;diagram name=&quot;Page-1&quot; id=&quot;IdYZ_KFENTEXElLiOEKC&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;1193&quot; dy=&quot;827&quot; grid=&quot;1&quot; gridSize=&quot;10&quot; guides=&quot;1&quot; tooltips=&quot;1&quot; connect=&quot;1&quot; arrows=&quot;1&quot; fold=&quot;1&quot; page=&quot;1&quot; pageScale=&quot;1&quot; pageWidth=&quot;850&quot; pageHeight=&quot;1100&quot; math=&quot;0&quot; shadow=&quot;0&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;AH3lBTSLKK5181iXBnnY-2&quot; value=&quot;Spark Executor&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;290&quot; width=&quot;210&quot; height=&quot;430&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;AH3lBTSLKK5181iXBnnY-16&quot; value=&quot;Spark Driver&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry y=&quot;40&quot; width=&quot;200&quot; height=&quot;350&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;AH3lBTSLKK5181iXBnnY-17&quot; value=&quot;&quot; style=&quot;shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/svg+xml,<svg xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;" xml:space="preserve" version="1.1" viewBox="0 0 1008 241" height="100%" width="100%">&#xa;    <g transform="matrix(1,0,0,1,-85.3519,-181.196)" id="path1">&#xa;        <path style="fill:rgb(234,151,52);fill-rule:nonzero;" d="M315.318,338.335C314.573,341.101 314.401,339.494 314.575,331.378C316.01,264.251 257.149,217.797 189.369,232.561C187.782,232.907 186.445,233.25 185.268,233.489C179.698,234.621 179.735,234.93 177.187,233.775C174.023,232.342 169.792,229.462 159.886,223.212C156.414,221.022 157,220.058 159.212,218.758C170.165,212.32 200.292,207.23 225.306,211.683C288.142,222.871 330.339,282.647 315.319,338.335L315.318,338.335ZM291.072,356.082C290.554,356.044 289.252,354.65 288.18,352.998C286.231,349.993 286.231,349.993 285.505,352.493C284.477,356.036 283.898,355.533 278.47,346.393C272.599,336.504 261.642,321.875 261.056,323.142C260.822,323.646 261.447,327.701 262.445,332.152C264.821,342.745 265.707,342.99 246.55,327.749C237.363,320.44 223.898,309.787 216.627,304.075C209.357,298.363 201.152,291.907 198.396,289.728C195.639,287.549 188.043,281.657 181.515,276.635C174.987,271.613 164.563,263.57 158.351,258.761C145.419,248.75 142.981,243.653 181.857,307.906C203.722,344.043 202.779,342.496 214.032,360.693C223.882,376.62 224.916,375.982 203.028,367.486C199.434,366.09 219.918,385.23 228.275,391.075C233.869,394.987 233.869,394.987 230.061,395.129C226.252,395.263 226.252,395.263 229.59,398.125C234.955,402.71 234.004,403.13 221.858,401.542C201.113,398.831 181.794,389.134 167.022,374.019C162.317,369.204 162.166,369.367 170.952,369.786C178.467,370.143 178.467,370.143 166.62,361.216C149.107,348.019 115.227,316.596 117.006,315.198C117.644,314.698 128.749,318.662 144.82,325.128C157.881,330.383 159.715,330.759 157.422,327.712C156.213,326.104 151.367,316.768 140.333,294.792C137.816,289.778 134.738,283.73 133.493,281.35C130.579,275.782 100.857,214.958 94.62,201.8C91.999,196.272 88.629,189.268 87.13,186.235C83.701,179.302 84.366,179.378 96.936,187.363C109.422,195.294 140.946,215.668 149.064,221.054C152.359,223.239 163.973,230.925 174.873,238.134C197.503,253.101 217.452,266.507 224.119,271.228C229.764,275.225 229.589,275.438 227.553,267.055C222.87,247.767 220.147,234.998 220.537,234.157C221.703,231.639 249.221,268.527 259.368,286.211C268.491,302.111 267.706,301.505 268.533,293.293C269.371,284.96 269.585,284.886 274.423,291.216C288.63,309.803 300.715,356.886 291.072,356.082L291.072,356.082ZM213.876,421.215C123.844,428.556 61.477,334.755 107.965,261.924C114.494,251.697 114.266,251.715 118.708,261.045C120.524,264.86 122.916,269.712 124.024,271.827C126.038,275.673 126.038,275.673 122.081,283.158C91.278,341.428 131.256,410.574 200.829,419.363C208.547,420.338 214.419,421.171 213.876,421.215L213.876,421.215Z"/>&#xa;    </g>&#xa;    <g transform="matrix(0.968859,0,0,0.920768,-70.9157,-151.37)" id="path3">&#xa;        <path style="fill:rgb(230,74,25);fill-rule:nonzero;" d="M285.493,345.632C282.234,341.53 282.234,341.53 282.111,344.281C281.939,348.324 280.979,347.656 276.9,340.6C270.215,329.052 257.352,312.116 256.166,313.3C255.944,313.534 256.814,318.034 258.112,323.299C261.066,335.197 261.621,335.007 250.322,325.982C239.351,317.216 193.938,281.579 178.993,270.007C173.41,265.683 163.508,258.014 156.99,252.964C143.371,242.412 141.022,240.821 142.086,242.866C143.03,244.684 162.92,277.769 175.06,297.721C180.369,306.445 186.516,316.567 188.722,320.213C195.871,332.031 212.9,359.45 217.395,366.383C221.949,373.405 222,373.375 211.621,369.826C206.608,368.11 202.08,366.715 201.561,366.719C199.733,366.738 214.451,381.192 223.86,388.63C233.301,396.091 233.349,396.151 230.259,396.555C227.146,396.968 227.146,396.968 230.791,400.324C240.962,409.751 203.686,401.213 186.752,390.218C170.285,379.542 156.298,371.294 164.839,371.549C172.991,371.79 178.789,371.913 174.59,369.035C151.709,353.315 100.466,307.638 109.333,310.655C112.607,311.769 136.117,321.922 141.112,323.793C147.026,326.011 153.655,329.093 143.818,310.353C127.827,279.892 78.938,174.522 76.594,169.808C71.449,159.458 78.239,166.828 86.193,172.077C89.669,174.373 172.252,229.674 203.14,252.141C229.292,271.163 222.786,268.496 218.454,244.292C215.958,230.346 214.043,222.266 214.242,222.067C215.859,220.453 246.86,264.84 257.024,282.948C263.429,294.362 263.29,292.845 263.586,283.122C263.915,272.333 273.722,284.976 282.262,306.256C289.314,323.826 291.76,353.503 285.507,345.634L285.493,345.632Z"/>&#xa;    </g>&#xa;    <g transform="matrix(1.15167,0,0,1.15167,-376.043,-0.54078)">&#xa;        <g transform="matrix(32,0,0,32,561.496,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,599.839,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.08,-0.716L0.347,-0.716C0.406,-0.716 0.455,-0.71 0.494,-0.699C0.534,-0.689 0.565,-0.665 0.588,-0.629C0.611,-0.592 0.623,-0.552 0.623,-0.507C0.623,-0.435 0.6,-0.38 0.554,-0.342C0.508,-0.305 0.442,-0.286 0.355,-0.286L0.175,-0.286L0.175,-0L0.08,-0L0.08,-0.716ZM0.175,-0.371L0.356,-0.371C0.417,-0.371 0.46,-0.382 0.486,-0.405C0.512,-0.428 0.525,-0.461 0.525,-0.504C0.525,-0.533 0.518,-0.558 0.503,-0.58C0.489,-0.602 0.471,-0.616 0.449,-0.622C0.427,-0.628 0.395,-0.631 0.354,-0.631L0.175,-0.631L0.175,-0.371Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,638.183,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,676.527,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.38,0.012C0.279,0.012 0.198,-0.021 0.137,-0.088C0.077,-0.154 0.047,-0.244 0.047,-0.358C0.047,-0.472 0.077,-0.562 0.137,-0.628C0.198,-0.695 0.279,-0.728 0.38,-0.728C0.458,-0.728 0.524,-0.707 0.579,-0.665C0.633,-0.623 0.664,-0.568 0.671,-0.499L0.573,-0.499C0.569,-0.544 0.55,-0.58 0.514,-0.607C0.479,-0.634 0.435,-0.647 0.381,-0.647C0.308,-0.647 0.251,-0.622 0.208,-0.572C0.166,-0.522 0.145,-0.451 0.145,-0.358C0.145,-0.265 0.166,-0.194 0.208,-0.144C0.25,-0.094 0.307,-0.069 0.379,-0.069C0.435,-0.069 0.48,-0.083 0.515,-0.11C0.549,-0.137 0.569,-0.176 0.573,-0.227L0.671,-0.227C0.664,-0.151 0.634,-0.092 0.581,-0.05C0.528,-0.009 0.461,0.012 0.38,0.012Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,716.636,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.642,-0L0.547,-0L0.547,-0.337L0.175,-0.337L0.175,-0L0.08,-0L0.08,-0.716L0.175,-0.716L0.175,-0.422L0.547,-0.422L0.547,-0.716L0.642,-0.716L0.642,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,756.746,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.614,-0L0.08,-0L0.08,-0.716L0.597,-0.716L0.597,-0.631L0.175,-0.631L0.175,-0.412L0.57,-0.412L0.57,-0.327L0.175,-0.327L0.175,-0.085L0.614,-0.085L0.614,-0Z"/>&#xa;        </g>&#xa;    </g>&#xa;    <g transform="matrix(1,0,0,1,-91.3519,-191.196)" id="text2">&#xa;        <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M403.965,341.559C403.965,345.669 403.027,349.353 401.15,352.613C399.273,355.853 396.902,358.343 394.037,360.081C391.884,361.385 389.523,362.294 386.955,362.808C384.386,363.321 381.344,363.578 377.827,363.578L362.269,363.578L362.269,319.452L378.271,319.452C381.867,319.452 384.969,319.758 387.577,320.371C390.185,320.964 392.378,321.813 394.156,322.92C397.198,324.777 399.589,327.286 401.327,330.447C403.086,333.588 403.965,337.293 403.965,341.56L403.965,341.559ZM392.2,341.464C392.2,338.56 391.667,336.08 390.6,334.026C389.552,331.951 387.883,330.331 385.592,329.165C384.426,328.592 383.23,328.206 382.006,328.009C380.8,327.791 378.973,327.682 376.524,327.682L373.649,327.682L373.649,355.302L376.524,355.302C379.23,355.302 381.216,355.183 382.48,354.946C383.744,354.689 384.979,354.235 386.184,353.583C388.259,352.398 389.78,350.818 390.748,348.842C391.717,346.846 392.201,344.387 392.201,341.463L392.2,341.464ZM453.426,363.572L441.661,363.572L438.608,354.651L422.25,354.651L419.197,363.572L407.729,363.572L424.028,319.445L437.126,319.445L453.426,363.572ZM435.852,346.561L430.429,330.736L425.006,346.561L435.852,346.561ZM494.292,327.98L480.512,327.98L480.512,363.572L469.132,363.572L469.132,327.98L455.352,327.98L455.352,319.445L494.292,319.445L494.292,327.98ZM541.915,363.572L530.15,363.572L527.098,354.651L510.74,354.651L507.687,363.572L496.218,363.572L512.518,319.445L525.616,319.445L541.915,363.572ZM524.342,346.561L518.919,330.736L513.496,346.561L524.342,346.561ZM579.878,327.98L559.578,327.98L559.578,336.189L578.396,336.189L578.396,344.724L559.578,344.724L559.578,363.572L548.257,363.572L548.257,319.445L579.878,319.445L579.878,327.98ZM626.375,347.598C626.375,353.051 624.716,357.23 621.396,360.134C618.077,363.038 613.187,364.49 606.727,364.49C600.267,364.49 595.377,363.038 592.058,360.134C588.758,357.23 587.109,353.061 587.109,347.628L587.109,319.445L598.548,319.445L598.548,346.976C598.548,350.038 599.19,352.32 600.474,353.822C601.758,355.323 603.843,356.074 606.727,356.074C609.572,356.074 611.646,355.353 612.95,353.91C614.274,352.468 614.936,350.157 614.936,346.976L614.936,319.445L626.375,319.445L626.375,347.598ZM672.339,349.702C672.339,354.049 670.492,357.585 666.797,360.312C663.122,363.018 658.124,364.372 651.802,364.372C648.147,364.372 644.956,364.056 642.23,363.424C639.523,362.771 636.984,361.951 634.614,360.964L634.614,350.384L635.858,350.384C638.209,352.261 640.837,353.703 643.741,354.711C646.665,355.719 649.47,356.223 652.157,356.223C652.849,356.223 653.758,356.166 654.884,356.051C656.01,355.936 656.929,355.739 657.64,355.458C658.509,355.103 659.22,354.658 659.773,354.124C660.347,353.59 660.634,352.8 660.634,351.753C660.634,350.785 660.219,349.955 659.389,349.264C658.579,348.553 657.383,348.009 655.803,347.633C654.144,347.238 652.385,346.872 650.528,346.536C648.691,346.18 646.962,345.736 645.342,345.202C641.628,343.996 638.951,342.366 637.311,340.312C635.691,338.238 634.881,335.669 634.881,332.607C634.881,328.497 636.718,325.149 640.393,322.561C644.088,319.953 648.829,318.649 654.618,318.649C657.522,318.649 660.387,318.936 663.212,319.509C666.057,320.062 668.517,320.764 670.591,321.613L670.591,331.778L669.375,331.778C667.597,330.356 665.414,329.17 662.826,328.222C660.258,327.253 657.63,326.769 654.943,326.769C653.995,326.769 653.047,326.838 652.098,326.976C651.169,327.09 650.27,327.327 649.401,327.687C648.63,327.984 647.969,328.438 647.416,329.05C646.863,329.642 646.586,330.324 646.586,331.094C646.586,332.26 647.031,333.159 647.921,333.791C648.81,334.404 650.489,334.967 652.958,335.481C654.578,335.817 656.129,336.144 657.611,336.46C659.113,336.776 660.723,337.21 662.442,337.763C665.82,338.87 668.309,340.381 669.91,342.298C671.53,344.194 672.34,346.664 672.34,349.706L672.339,349.702ZM703.989,363.572L678.147,363.572L678.147,355.748L685.378,355.748L685.378,327.269L678.147,327.269L678.147,319.445L703.989,319.445L703.989,327.269L696.758,327.269L696.758,355.748L703.989,355.748L703.989,363.572ZM756.176,341.523C756.176,348.557 754.161,354.148 750.13,358.297C746.1,362.426 740.529,364.49 733.416,364.49C726.324,364.49 720.762,362.426 716.732,358.297C712.701,354.148 710.686,348.557 710.686,341.523C710.686,334.431 712.701,328.83 716.732,324.72C720.762,320.591 726.324,318.526 733.416,318.526C740.489,318.526 746.051,320.591 750.101,324.72C754.151,328.83 756.176,334.431 756.176,341.523ZM741.092,352.696C742.198,351.352 743.018,349.772 743.551,347.954C744.085,346.117 744.352,343.963 744.352,341.494C744.352,338.846 744.046,336.594 743.433,334.737C742.82,332.88 742.02,331.378 741.032,330.232C740.024,329.047 738.859,328.188 737.535,327.654C736.232,327.121 734.868,326.855 733.446,326.855C732.004,326.855 730.64,327.112 729.356,327.625C728.092,328.139 726.926,328.988 725.859,330.174C724.872,331.28 724.062,332.811 723.429,334.767C722.816,336.704 722.51,338.956 722.51,341.524C722.51,344.152 722.806,346.394 723.399,348.251C724.012,350.089 724.812,351.59 725.799,352.756C726.787,353.922 727.943,354.781 729.266,355.334C730.59,355.887 731.983,356.164 733.445,356.164C734.907,356.164 736.3,355.887 737.623,355.334C738.947,354.761 740.103,353.881 741.091,352.696L741.092,352.696ZM804.985,363.572L794.02,363.572L775.29,333.285L775.29,363.572L764.859,363.572L764.859,319.445L778.461,319.445L794.553,344.724L794.553,319.445L804.985,319.445L804.985,363.572ZM856.934,364.432C853.655,364.432 850.622,363.947 847.837,362.979C845.071,362.01 842.69,360.568 840.695,358.652C838.699,356.736 837.148,354.345 836.042,351.481C834.955,348.616 834.411,345.307 834.411,341.553C834.411,338.056 834.935,334.885 835.983,332.04C837.03,329.195 838.552,326.755 840.546,324.72C842.463,322.765 844.834,321.253 847.659,320.186C850.504,319.12 853.606,318.586 856.964,318.586C858.821,318.586 860.491,318.695 861.972,318.913C863.474,319.111 864.857,319.378 866.121,319.714C867.445,320.089 868.64,320.514 869.707,320.989C870.794,321.444 871.743,321.869 872.552,322.264L872.552,332.962L871.249,332.962C870.695,332.488 869.994,331.925 869.144,331.273C868.315,330.62 867.366,329.978 866.299,329.346C865.212,328.714 864.037,328.181 862.773,327.746C861.509,327.312 860.155,327.094 858.713,327.094C857.113,327.094 855.591,327.351 854.149,327.865C852.707,328.358 851.373,329.188 850.148,330.354C848.982,331.481 848.034,332.972 847.303,334.829C846.592,336.686 846.237,338.938 846.237,341.586C846.237,344.352 846.622,346.663 847.393,348.52C848.183,350.377 849.171,351.839 850.357,352.906C851.562,353.993 852.906,354.774 854.387,355.247C855.869,355.702 857.331,355.93 858.773,355.93C860.156,355.93 861.519,355.722 862.863,355.307C864.226,354.891 865.48,354.328 866.626,353.617C867.595,353.043 868.494,352.431 869.323,351.78C870.153,351.127 870.834,350.564 871.368,350.09L872.553,350.09L872.553,360.64C871.447,361.134 870.39,361.599 869.382,362.034C868.374,362.468 867.317,362.843 866.211,363.159C864.769,363.575 863.416,363.891 862.151,364.108C860.887,364.325 859.149,364.434 856.935,364.434L856.934,364.432ZM923.821,341.524C923.821,348.557 921.805,354.148 917.775,358.297C913.745,362.426 908.173,364.491 901.061,364.491C893.968,364.491 888.407,362.426 884.377,358.297C880.346,354.148 878.331,348.557 878.331,341.524C878.331,334.431 880.346,328.83 884.377,324.721C888.407,320.592 893.968,318.527 901.061,318.527C908.134,318.527 913.695,320.592 917.746,324.721C921.796,328.83 923.821,334.431 923.821,341.524ZM908.736,352.696C909.843,351.353 910.663,349.772 911.196,347.955C911.73,346.117 911.997,343.964 911.997,341.494C911.997,338.847 911.691,336.595 911.078,334.737C910.465,332.88 909.664,331.379 908.677,330.233C907.669,329.048 906.504,328.188 905.18,327.655C903.876,327.122 902.513,326.856 901.091,326.856C899.648,326.856 898.285,327.112 897.001,327.626C895.737,328.14 894.571,328.989 893.504,330.175C892.517,331.281 891.706,332.812 891.074,334.768C890.461,336.704 890.155,338.956 890.155,341.525C890.155,344.153 890.451,346.395 891.043,348.252C891.656,350.089 892.457,351.591 893.444,352.756C894.432,353.923 895.587,354.782 896.911,355.335C898.235,355.888 899.628,356.164 901.09,356.164C902.552,356.164 903.944,355.888 905.268,355.335C906.592,354.761 907.748,353.882 908.736,352.697L908.736,352.696ZM978.764,363.572L967.443,363.572L967.443,334.026L959.264,353.2L951.411,353.2L943.231,334.026L943.231,363.572L932.504,363.572L932.504,319.446L945.721,319.446L955.648,341.583L965.547,319.446L978.764,319.446L978.764,363.572ZM1021.94,363.572L990.025,363.572L990.025,319.446L1021.94,319.446L1021.94,327.981L1001.35,327.981L1001.35,335.597L1020.46,335.597L1020.46,344.132L1001.35,344.132L1001.35,355.038L1021.94,355.038L1021.94,363.572ZM1066.01,327.981L1052.23,327.981L1052.23,363.572L1040.85,363.572L1040.85,327.981L1027.07,327.981L1027.07,319.446L1066.01,319.446L1066.01,327.981Z"/>&#xa;    </g>&#xa;    <g transform="matrix(1,0,0,1,-95.3519,-190.196)" id="text3">&#xa;        <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M1089.2,319.918L1084.49,319.918L1084.49,331.546L1082.74,331.546L1082.74,319.918L1078.03,319.918L1078.03,318.36L1089.2,318.36L1089.2,319.918ZM1102.72,331.546L1100.96,331.546L1100.96,320.184L1097.3,327.915L1096.25,327.915L1092.61,320.184L1092.61,331.546L1090.97,331.546L1090.97,318.36L1093.37,318.36L1096.88,325.701L1100.28,318.36L1102.72,318.36L1102.72,331.546Z"/>&#xa;    </g>&#xa;</svg>;imageBorder=default;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;34.519999999999996&quot; y=&quot;200&quot; width=&quot;125.48&quot; height=&quot;30&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-1&quot; value=&quot;Spark Logical Plan&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;10&quot; y=&quot;80&quot; width=&quot;180&quot; height=&quot;30&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-2&quot; value=&quot;Spark Physical Plan&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;10&quot; y=&quot;140&quot; width=&quot;180&quot; height=&quot;30&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-3&quot; value=&quot;Comet Physical Plan&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;10&quot; y=&quot;260&quot; width=&quot;180&quot; height=&quot;100&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-4&quot; value=&quot;protobuf intermediate representation&quot; style=&quot;shape=process;whiteSpace=wrap;html=1;backgroundOutline=1;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;40&quot; y=&quot;290&quot; width=&quot;120&quot; height=&quot;50&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-12&quot; value=&quot;&quot; style=&quot;shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot; source=&quot;t5OBkkhKOG6cYtw1sPyQ-1&quot; target=&quot;t5OBkkhKOG6cYtw1sPyQ-2&quot;&gt;&#10;          &lt;mxGeometry width=&quot;50&quot; height=&quot;50&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint x=&quot;270&quot; y=&quot;270&quot; as=&quot;sourcePoint&quot; /&gt;&#10;            &lt;mxPoint x=&quot;320&quot; y=&quot;220&quot; as=&quot;targetPoint&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-13&quot; value=&quot;&quot; style=&quot;shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry width=&quot;50&quot; height=&quot;50&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint x=&quot;96.75999999999999&quot; y=&quot;170&quot; as=&quot;sourcePoint&quot; /&gt;&#10;            &lt;mxPoint x=&quot;96.75999999999999&quot; y=&quot;200&quot; as=&quot;targetPoint&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-14&quot; value=&quot;&quot; style=&quot;shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry width=&quot;50&quot; height=&quot;50&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint x=&quot;96.75999999999999&quot; y=&quot;230&quot; as=&quot;sourcePoint&quot; /&gt;&#10;            &lt;mxPoint x=&quot;96.75999999999999&quot; y=&quot;260&quot; as=&quot;targetPoint&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-15&quot; value=&quot;&quot; style=&quot;shape=flexArrow;endArrow=classic;html=1;rounded=0;endWidth=28;endSize=9.67;width=11;fillColor=#000000;&quot; edge=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry width=&quot;50&quot; height=&quot;50&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint x=&quot;200&quot; y=&quot;204.5&quot; as=&quot;sourcePoint&quot; /&gt;&#10;            &lt;mxPoint x=&quot;290&quot; y=&quot;204.5&quot; as=&quot;targetPoint&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-16&quot; value=&quot;Native Execution Plan&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;310&quot; y=&quot;230&quot; width=&quot;170&quot; height=&quot;100&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-17&quot; value=&quot;&quot; style=&quot;shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/svg+xml,<svg xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;" xml:space="preserve" version="1.1" viewBox="0 0 1008 241" height="100%" width="100%">&#xa;    <g transform="matrix(1,0,0,1,-85.3519,-181.196)" id="path1">&#xa;        <path style="fill:rgb(234,151,52);fill-rule:nonzero;" d="M315.318,338.335C314.573,341.101 314.401,339.494 314.575,331.378C316.01,264.251 257.149,217.797 189.369,232.561C187.782,232.907 186.445,233.25 185.268,233.489C179.698,234.621 179.735,234.93 177.187,233.775C174.023,232.342 169.792,229.462 159.886,223.212C156.414,221.022 157,220.058 159.212,218.758C170.165,212.32 200.292,207.23 225.306,211.683C288.142,222.871 330.339,282.647 315.319,338.335L315.318,338.335ZM291.072,356.082C290.554,356.044 289.252,354.65 288.18,352.998C286.231,349.993 286.231,349.993 285.505,352.493C284.477,356.036 283.898,355.533 278.47,346.393C272.599,336.504 261.642,321.875 261.056,323.142C260.822,323.646 261.447,327.701 262.445,332.152C264.821,342.745 265.707,342.99 246.55,327.749C237.363,320.44 223.898,309.787 216.627,304.075C209.357,298.363 201.152,291.907 198.396,289.728C195.639,287.549 188.043,281.657 181.515,276.635C174.987,271.613 164.563,263.57 158.351,258.761C145.419,248.75 142.981,243.653 181.857,307.906C203.722,344.043 202.779,342.496 214.032,360.693C223.882,376.62 224.916,375.982 203.028,367.486C199.434,366.09 219.918,385.23 228.275,391.075C233.869,394.987 233.869,394.987 230.061,395.129C226.252,395.263 226.252,395.263 229.59,398.125C234.955,402.71 234.004,403.13 221.858,401.542C201.113,398.831 181.794,389.134 167.022,374.019C162.317,369.204 162.166,369.367 170.952,369.786C178.467,370.143 178.467,370.143 166.62,361.216C149.107,348.019 115.227,316.596 117.006,315.198C117.644,314.698 128.749,318.662 144.82,325.128C157.881,330.383 159.715,330.759 157.422,327.712C156.213,326.104 151.367,316.768 140.333,294.792C137.816,289.778 134.738,283.73 133.493,281.35C130.579,275.782 100.857,214.958 94.62,201.8C91.999,196.272 88.629,189.268 87.13,186.235C83.701,179.302 84.366,179.378 96.936,187.363C109.422,195.294 140.946,215.668 149.064,221.054C152.359,223.239 163.973,230.925 174.873,238.134C197.503,253.101 217.452,266.507 224.119,271.228C229.764,275.225 229.589,275.438 227.553,267.055C222.87,247.767 220.147,234.998 220.537,234.157C221.703,231.639 249.221,268.527 259.368,286.211C268.491,302.111 267.706,301.505 268.533,293.293C269.371,284.96 269.585,284.886 274.423,291.216C288.63,309.803 300.715,356.886 291.072,356.082L291.072,356.082ZM213.876,421.215C123.844,428.556 61.477,334.755 107.965,261.924C114.494,251.697 114.266,251.715 118.708,261.045C120.524,264.86 122.916,269.712 124.024,271.827C126.038,275.673 126.038,275.673 122.081,283.158C91.278,341.428 131.256,410.574 200.829,419.363C208.547,420.338 214.419,421.171 213.876,421.215L213.876,421.215Z"/>&#xa;    </g>&#xa;    <g transform="matrix(0.968859,0,0,0.920768,-70.9157,-151.37)" id="path3">&#xa;        <path style="fill:rgb(230,74,25);fill-rule:nonzero;" d="M285.493,345.632C282.234,341.53 282.234,341.53 282.111,344.281C281.939,348.324 280.979,347.656 276.9,340.6C270.215,329.052 257.352,312.116 256.166,313.3C255.944,313.534 256.814,318.034 258.112,323.299C261.066,335.197 261.621,335.007 250.322,325.982C239.351,317.216 193.938,281.579 178.993,270.007C173.41,265.683 163.508,258.014 156.99,252.964C143.371,242.412 141.022,240.821 142.086,242.866C143.03,244.684 162.92,277.769 175.06,297.721C180.369,306.445 186.516,316.567 188.722,320.213C195.871,332.031 212.9,359.45 217.395,366.383C221.949,373.405 222,373.375 211.621,369.826C206.608,368.11 202.08,366.715 201.561,366.719C199.733,366.738 214.451,381.192 223.86,388.63C233.301,396.091 233.349,396.151 230.259,396.555C227.146,396.968 227.146,396.968 230.791,400.324C240.962,409.751 203.686,401.213 186.752,390.218C170.285,379.542 156.298,371.294 164.839,371.549C172.991,371.79 178.789,371.913 174.59,369.035C151.709,353.315 100.466,307.638 109.333,310.655C112.607,311.769 136.117,321.922 141.112,323.793C147.026,326.011 153.655,329.093 143.818,310.353C127.827,279.892 78.938,174.522 76.594,169.808C71.449,159.458 78.239,166.828 86.193,172.077C89.669,174.373 172.252,229.674 203.14,252.141C229.292,271.163 222.786,268.496 218.454,244.292C215.958,230.346 214.043,222.266 214.242,222.067C215.859,220.453 246.86,264.84 257.024,282.948C263.429,294.362 263.29,292.845 263.586,283.122C263.915,272.333 273.722,284.976 282.262,306.256C289.314,323.826 291.76,353.503 285.507,345.634L285.493,345.632Z"/>&#xa;    </g>&#xa;    <g transform="matrix(1.15167,0,0,1.15167,-376.043,-0.54078)">&#xa;        <g transform="matrix(32,0,0,32,561.496,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,599.839,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.08,-0.716L0.347,-0.716C0.406,-0.716 0.455,-0.71 0.494,-0.699C0.534,-0.689 0.565,-0.665 0.588,-0.629C0.611,-0.592 0.623,-0.552 0.623,-0.507C0.623,-0.435 0.6,-0.38 0.554,-0.342C0.508,-0.305 0.442,-0.286 0.355,-0.286L0.175,-0.286L0.175,-0L0.08,-0L0.08,-0.716ZM0.175,-0.371L0.356,-0.371C0.417,-0.371 0.46,-0.382 0.486,-0.405C0.512,-0.428 0.525,-0.461 0.525,-0.504C0.525,-0.533 0.518,-0.558 0.503,-0.58C0.489,-0.602 0.471,-0.616 0.449,-0.622C0.427,-0.628 0.395,-0.631 0.354,-0.631L0.175,-0.631L0.175,-0.371Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,638.183,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,676.527,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.38,0.012C0.279,0.012 0.198,-0.021 0.137,-0.088C0.077,-0.154 0.047,-0.244 0.047,-0.358C0.047,-0.472 0.077,-0.562 0.137,-0.628C0.198,-0.695 0.279,-0.728 0.38,-0.728C0.458,-0.728 0.524,-0.707 0.579,-0.665C0.633,-0.623 0.664,-0.568 0.671,-0.499L0.573,-0.499C0.569,-0.544 0.55,-0.58 0.514,-0.607C0.479,-0.634 0.435,-0.647 0.381,-0.647C0.308,-0.647 0.251,-0.622 0.208,-0.572C0.166,-0.522 0.145,-0.451 0.145,-0.358C0.145,-0.265 0.166,-0.194 0.208,-0.144C0.25,-0.094 0.307,-0.069 0.379,-0.069C0.435,-0.069 0.48,-0.083 0.515,-0.11C0.549,-0.137 0.569,-0.176 0.573,-0.227L0.671,-0.227C0.664,-0.151 0.634,-0.092 0.581,-0.05C0.528,-0.009 0.461,0.012 0.38,0.012Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,716.636,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.642,-0L0.547,-0L0.547,-0.337L0.175,-0.337L0.175,-0L0.08,-0L0.08,-0.716L0.175,-0.716L0.175,-0.422L0.547,-0.422L0.547,-0.716L0.642,-0.716L0.642,-0Z"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,756.746,84.0074)">&#xa;            <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M0.614,-0L0.08,-0L0.08,-0.716L0.597,-0.716L0.597,-0.631L0.175,-0.631L0.175,-0.412L0.57,-0.412L0.57,-0.327L0.175,-0.327L0.175,-0.085L0.614,-0.085L0.614,-0Z"/>&#xa;        </g>&#xa;    </g>&#xa;    <g transform="matrix(1,0,0,1,-91.3519,-191.196)" id="text2">&#xa;        <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M403.965,341.559C403.965,345.669 403.027,349.353 401.15,352.613C399.273,355.853 396.902,358.343 394.037,360.081C391.884,361.385 389.523,362.294 386.955,362.808C384.386,363.321 381.344,363.578 377.827,363.578L362.269,363.578L362.269,319.452L378.271,319.452C381.867,319.452 384.969,319.758 387.577,320.371C390.185,320.964 392.378,321.813 394.156,322.92C397.198,324.777 399.589,327.286 401.327,330.447C403.086,333.588 403.965,337.293 403.965,341.56L403.965,341.559ZM392.2,341.464C392.2,338.56 391.667,336.08 390.6,334.026C389.552,331.951 387.883,330.331 385.592,329.165C384.426,328.592 383.23,328.206 382.006,328.009C380.8,327.791 378.973,327.682 376.524,327.682L373.649,327.682L373.649,355.302L376.524,355.302C379.23,355.302 381.216,355.183 382.48,354.946C383.744,354.689 384.979,354.235 386.184,353.583C388.259,352.398 389.78,350.818 390.748,348.842C391.717,346.846 392.201,344.387 392.201,341.463L392.2,341.464ZM453.426,363.572L441.661,363.572L438.608,354.651L422.25,354.651L419.197,363.572L407.729,363.572L424.028,319.445L437.126,319.445L453.426,363.572ZM435.852,346.561L430.429,330.736L425.006,346.561L435.852,346.561ZM494.292,327.98L480.512,327.98L480.512,363.572L469.132,363.572L469.132,327.98L455.352,327.98L455.352,319.445L494.292,319.445L494.292,327.98ZM541.915,363.572L530.15,363.572L527.098,354.651L510.74,354.651L507.687,363.572L496.218,363.572L512.518,319.445L525.616,319.445L541.915,363.572ZM524.342,346.561L518.919,330.736L513.496,346.561L524.342,346.561ZM579.878,327.98L559.578,327.98L559.578,336.189L578.396,336.189L578.396,344.724L559.578,344.724L559.578,363.572L548.257,363.572L548.257,319.445L579.878,319.445L579.878,327.98ZM626.375,347.598C626.375,353.051 624.716,357.23 621.396,360.134C618.077,363.038 613.187,364.49 606.727,364.49C600.267,364.49 595.377,363.038 592.058,360.134C588.758,357.23 587.109,353.061 587.109,347.628L587.109,319.445L598.548,319.445L598.548,346.976C598.548,350.038 599.19,352.32 600.474,353.822C601.758,355.323 603.843,356.074 606.727,356.074C609.572,356.074 611.646,355.353 612.95,353.91C614.274,352.468 614.936,350.157 614.936,346.976L614.936,319.445L626.375,319.445L626.375,347.598ZM672.339,349.702C672.339,354.049 670.492,357.585 666.797,360.312C663.122,363.018 658.124,364.372 651.802,364.372C648.147,364.372 644.956,364.056 642.23,363.424C639.523,362.771 636.984,361.951 634.614,360.964L634.614,350.384L635.858,350.384C638.209,352.261 640.837,353.703 643.741,354.711C646.665,355.719 649.47,356.223 652.157,356.223C652.849,356.223 653.758,356.166 654.884,356.051C656.01,355.936 656.929,355.739 657.64,355.458C658.509,355.103 659.22,354.658 659.773,354.124C660.347,353.59 660.634,352.8 660.634,351.753C660.634,350.785 660.219,349.955 659.389,349.264C658.579,348.553 657.383,348.009 655.803,347.633C654.144,347.238 652.385,346.872 650.528,346.536C648.691,346.18 646.962,345.736 645.342,345.202C641.628,343.996 638.951,342.366 637.311,340.312C635.691,338.238 634.881,335.669 634.881,332.607C634.881,328.497 636.718,325.149 640.393,322.561C644.088,319.953 648.829,318.649 654.618,318.649C657.522,318.649 660.387,318.936 663.212,319.509C666.057,320.062 668.517,320.764 670.591,321.613L670.591,331.778L669.375,331.778C667.597,330.356 665.414,329.17 662.826,328.222C660.258,327.253 657.63,326.769 654.943,326.769C653.995,326.769 653.047,326.838 652.098,326.976C651.169,327.09 650.27,327.327 649.401,327.687C648.63,327.984 647.969,328.438 647.416,329.05C646.863,329.642 646.586,330.324 646.586,331.094C646.586,332.26 647.031,333.159 647.921,333.791C648.81,334.404 650.489,334.967 652.958,335.481C654.578,335.817 656.129,336.144 657.611,336.46C659.113,336.776 660.723,337.21 662.442,337.763C665.82,338.87 668.309,340.381 669.91,342.298C671.53,344.194 672.34,346.664 672.34,349.706L672.339,349.702ZM703.989,363.572L678.147,363.572L678.147,355.748L685.378,355.748L685.378,327.269L678.147,327.269L678.147,319.445L703.989,319.445L703.989,327.269L696.758,327.269L696.758,355.748L703.989,355.748L703.989,363.572ZM756.176,341.523C756.176,348.557 754.161,354.148 750.13,358.297C746.1,362.426 740.529,364.49 733.416,364.49C726.324,364.49 720.762,362.426 716.732,358.297C712.701,354.148 710.686,348.557 710.686,341.523C710.686,334.431 712.701,328.83 716.732,324.72C720.762,320.591 726.324,318.526 733.416,318.526C740.489,318.526 746.051,320.591 750.101,324.72C754.151,328.83 756.176,334.431 756.176,341.523ZM741.092,352.696C742.198,351.352 743.018,349.772 743.551,347.954C744.085,346.117 744.352,343.963 744.352,341.494C744.352,338.846 744.046,336.594 743.433,334.737C742.82,332.88 742.02,331.378 741.032,330.232C740.024,329.047 738.859,328.188 737.535,327.654C736.232,327.121 734.868,326.855 733.446,326.855C732.004,326.855 730.64,327.112 729.356,327.625C728.092,328.139 726.926,328.988 725.859,330.174C724.872,331.28 724.062,332.811 723.429,334.767C722.816,336.704 722.51,338.956 722.51,341.524C722.51,344.152 722.806,346.394 723.399,348.251C724.012,350.089 724.812,351.59 725.799,352.756C726.787,353.922 727.943,354.781 729.266,355.334C730.59,355.887 731.983,356.164 733.445,356.164C734.907,356.164 736.3,355.887 737.623,355.334C738.947,354.761 740.103,353.881 741.091,352.696L741.092,352.696ZM804.985,363.572L794.02,363.572L775.29,333.285L775.29,363.572L764.859,363.572L764.859,319.445L778.461,319.445L794.553,344.724L794.553,319.445L804.985,319.445L804.985,363.572ZM856.934,364.432C853.655,364.432 850.622,363.947 847.837,362.979C845.071,362.01 842.69,360.568 840.695,358.652C838.699,356.736 837.148,354.345 836.042,351.481C834.955,348.616 834.411,345.307 834.411,341.553C834.411,338.056 834.935,334.885 835.983,332.04C837.03,329.195 838.552,326.755 840.546,324.72C842.463,322.765 844.834,321.253 847.659,320.186C850.504,319.12 853.606,318.586 856.964,318.586C858.821,318.586 860.491,318.695 861.972,318.913C863.474,319.111 864.857,319.378 866.121,319.714C867.445,320.089 868.64,320.514 869.707,320.989C870.794,321.444 871.743,321.869 872.552,322.264L872.552,332.962L871.249,332.962C870.695,332.488 869.994,331.925 869.144,331.273C868.315,330.62 867.366,329.978 866.299,329.346C865.212,328.714 864.037,328.181 862.773,327.746C861.509,327.312 860.155,327.094 858.713,327.094C857.113,327.094 855.591,327.351 854.149,327.865C852.707,328.358 851.373,329.188 850.148,330.354C848.982,331.481 848.034,332.972 847.303,334.829C846.592,336.686 846.237,338.938 846.237,341.586C846.237,344.352 846.622,346.663 847.393,348.52C848.183,350.377 849.171,351.839 850.357,352.906C851.562,353.993 852.906,354.774 854.387,355.247C855.869,355.702 857.331,355.93 858.773,355.93C860.156,355.93 861.519,355.722 862.863,355.307C864.226,354.891 865.48,354.328 866.626,353.617C867.595,353.043 868.494,352.431 869.323,351.78C870.153,351.127 870.834,350.564 871.368,350.09L872.553,350.09L872.553,360.64C871.447,361.134 870.39,361.599 869.382,362.034C868.374,362.468 867.317,362.843 866.211,363.159C864.769,363.575 863.416,363.891 862.151,364.108C860.887,364.325 859.149,364.434 856.935,364.434L856.934,364.432ZM923.821,341.524C923.821,348.557 921.805,354.148 917.775,358.297C913.745,362.426 908.173,364.491 901.061,364.491C893.968,364.491 888.407,362.426 884.377,358.297C880.346,354.148 878.331,348.557 878.331,341.524C878.331,334.431 880.346,328.83 884.377,324.721C888.407,320.592 893.968,318.527 901.061,318.527C908.134,318.527 913.695,320.592 917.746,324.721C921.796,328.83 923.821,334.431 923.821,341.524ZM908.736,352.696C909.843,351.353 910.663,349.772 911.196,347.955C911.73,346.117 911.997,343.964 911.997,341.494C911.997,338.847 911.691,336.595 911.078,334.737C910.465,332.88 909.664,331.379 908.677,330.233C907.669,329.048 906.504,328.188 905.18,327.655C903.876,327.122 902.513,326.856 901.091,326.856C899.648,326.856 898.285,327.112 897.001,327.626C895.737,328.14 894.571,328.989 893.504,330.175C892.517,331.281 891.706,332.812 891.074,334.768C890.461,336.704 890.155,338.956 890.155,341.525C890.155,344.153 890.451,346.395 891.043,348.252C891.656,350.089 892.457,351.591 893.444,352.756C894.432,353.923 895.587,354.782 896.911,355.335C898.235,355.888 899.628,356.164 901.09,356.164C902.552,356.164 903.944,355.888 905.268,355.335C906.592,354.761 907.748,353.882 908.736,352.697L908.736,352.696ZM978.764,363.572L967.443,363.572L967.443,334.026L959.264,353.2L951.411,353.2L943.231,334.026L943.231,363.572L932.504,363.572L932.504,319.446L945.721,319.446L955.648,341.583L965.547,319.446L978.764,319.446L978.764,363.572ZM1021.94,363.572L990.025,363.572L990.025,319.446L1021.94,319.446L1021.94,327.981L1001.35,327.981L1001.35,335.597L1020.46,335.597L1020.46,344.132L1001.35,344.132L1001.35,355.038L1021.94,355.038L1021.94,363.572ZM1066.01,327.981L1052.23,327.981L1052.23,363.572L1040.85,363.572L1040.85,327.981L1027.07,327.981L1027.07,319.446L1066.01,319.446L1066.01,327.981Z"/>&#xa;    </g>&#xa;    <g transform="matrix(1,0,0,1,-95.3519,-190.196)" id="text3">&#xa;        <path style="fill:rgb(31,41,55);fill-rule:nonzero;" d="M1089.2,319.918L1084.49,319.918L1084.49,331.546L1082.74,331.546L1082.74,319.918L1078.03,319.918L1078.03,318.36L1089.2,318.36L1089.2,319.918ZM1102.72,331.546L1100.96,331.546L1100.96,320.184L1097.3,327.915L1096.25,327.915L1092.61,320.184L1092.61,331.546L1090.97,331.546L1090.97,318.36L1093.37,318.36L1096.88,325.701L1100.28,318.36L1102.72,318.36L1102.72,331.546Z"/>&#xa;    </g>&#xa;</svg>;imageBorder=default;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;332.26&quot; y=&quot;170&quot; width=&quot;125.48&quot; height=&quot;30&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-18&quot; value=&quot;Comet Physical Plan&quot; style=&quot;rounded=1;whiteSpace=wrap;html=1;verticalAlign=top;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;305&quot; y=&quot;40&quot; width=&quot;180&quot; height=&quot;100&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-19&quot; value=&quot;protobuf intermediate representation&quot; style=&quot;shape=process;whiteSpace=wrap;html=1;backgroundOutline=1;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;335&quot; y=&quot;70&quot; width=&quot;120&quot; height=&quot;50&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-20&quot; value=&quot;&quot; style=&quot;shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 801 168" height="168" width="801">&#xa;<g clip-path="url(#clip0_1_181)">&#xa;<path fill="url(#paint0_linear_1_181)" d="M76.1297 168C88.4597 168 99.6097 158.25 107.58 142.55C127.23 144.6 143.09 139.99 149.76 128.51C156.29 117.25 152.65 101.68 141.58 86.09C152.36 70.67 155.85 55.32 149.39 44.19C143.01 33.19 128.19 28.5 109.69 29.92C101.65 11.62 89.5997 0 76.1297 0C62.6597 0 50.4997 11.73 42.4497 30.18C24.3497 28.97 9.87966 33.68 3.59966 44.51C-2.81034 55.56 0.589656 70.78 11.1897 86.09C0.299656 101.57 -3.24034 117.01 3.23966 128.18C9.80966 139.5 25.3097 144.13 44.5597 142.31C52.5397 158.15 63.7297 168 76.1297 168ZM52.7197 141.19C59.5097 154.21 68.6197 162.18 78.6397 162.18C88.6597 162.18 97.6397 154.63 104.76 142.22C95.7497 141.01 86.0297 138.46 76.0797 134.58C68.0497 137.65 60.1797 139.86 52.7197 141.19ZM65.0697 129.77C59.6397 131.52 54.3497 132.84 49.3097 133.72C47.3697 128.87 45.6997 123.54 44.3597 117.82C47.6797 120.07 51.1497 122.25 54.7497 124.32C58.1797 126.29 61.6197 128.11 65.0597 129.77H65.0697ZM76.1197 125.68C82.0597 123.2 88.0897 120.24 94.0797 116.79C102.76 111.8 110.61 106.25 117.41 100.43C118.01 95.13 118.33 89.64 118.33 84C118.33 76.79 117.81 69.8 116.84 63.17C111.11 58.53 104.73 54.12 97.7797 50.13C90.5497 45.98 83.2397 42.57 76.0697 39.91C69.1797 42.52 62.1597 45.82 55.2197 49.81C50.8597 52.32 46.7097 54.99 42.8197 57.78C41.3997 65.98 40.6297 74.8 40.6297 84C40.6297 91.65 41.1597 99.05 42.1597 106.04C47.2997 109.94 52.9197 113.66 58.9297 117.12C64.6597 120.41 70.4297 123.27 76.1197 125.68ZM87.1297 129.83C90.8397 128.07 94.5497 126.12 98.2497 124C104.42 120.45 110.18 116.61 115.48 112.58C113.79 120.73 111.42 128.22 108.52 134.76C101.82 133.95 94.6097 132.3 87.1297 129.83ZM117.71 110.84C116.16 119.65 113.87 127.8 110.98 135.03C127.49 136.56 140.52 132.79 145.95 123.44C151.17 114.43 148.57 101.58 140 88.28C134.26 96.01 126.71 103.7 117.71 110.84ZM136.56 79.61C145.46 66.59 148.33 53.99 143.08 44.93C137.99 36.16 126.02 31.96 110.76 32.43C114.3 41.14 116.97 51.23 118.5 62.2C125.46 67.76 131.53 73.64 136.55 79.61H136.56ZM108.21 32.55C111.86 40.6 114.7 50.11 116.43 60.57C110.98 56.37 105.01 52.37 98.6097 48.69C91.9597 44.87 85.2397 41.62 78.6197 38.96C89.0597 35.24 99.1497 33.11 108.2 32.54L108.21 32.55ZM107.08 30.16C97.4397 31.18 86.8897 33.79 76.0797 37.98C67.2997 34.65 58.7097 32.35 50.6497 31.1C57.5997 15.56 67.5697 5.83 78.6397 5.83C89.7097 5.83 99.7197 15.18 107.08 30.16ZM73.5197 38.99C65.2297 36.1 57.1697 34.21 49.6897 33.32C46.9897 39.84 44.7997 47.28 43.2497 55.38C46.7897 52.94 50.4997 50.6 54.3797 48.37C60.7497 44.71 67.1697 41.58 73.5197 38.99ZM33.7197 62.5C35.2297 51.54 37.8697 41.46 41.3797 32.74C26.5297 32.46 14.9097 36.66 9.91966 45.26C4.70966 54.24 7.48966 66.68 16.1997 79.58C21.0897 73.73 26.9797 67.96 33.7197 62.5ZM12.7697 88.3C18.3697 95.9 25.7197 103.48 34.4997 110.54C36.0297 119.36 38.3097 127.53 41.1797 134.78C25.0597 136.11 12.3797 132.31 7.03966 123.12C1.85966 114.19 4.36966 101.48 12.7597 88.31L12.7697 88.3ZM17.5697 81.54C21.9097 75.99 27.2197 70.45 33.3797 65.17C32.6597 71.22 32.2697 77.53 32.2697 84C32.2697 88.91 32.4897 93.72 32.9097 98.4C26.7997 92.89 21.6197 87.18 17.5597 81.53L17.5697 81.54ZM135.19 81.55C131 87.32 125.65 93.15 119.32 98.76C119.76 93.97 120 89.03 120 84C120 77.41 119.6 70.99 118.85 64.84C125.22 70.21 130.72 75.87 135.19 81.55Z" clip-rule="evenodd" fill-rule="evenodd"/>&#xa;<path fill="#1F2937" d="M204.34 45.97H192.83L190.47 52.2H185.2L196.07 23.88H201.47L212.54 52.2H206.78L204.34 45.97ZM202.74 41.74L198.54 30.99L194.46 41.74H202.73H202.74Z"/>&#xa;<path fill="#1F2937" d="M235.55 23.88H246.82C249.59 23.88 251.9 24.73 253.73 26.44C255.57 28.14 256.49 30.38 256.49 33.15C256.49 35.92 255.57 38.2 253.73 39.9C251.89 41.6 249.59 42.46 246.82 42.46H240.95V52.21H235.56V23.89L235.55 23.88ZM240.94 37.26H246.85C248 37.26 248.96 36.87 249.73 36.1C250.5 35.3 250.89 34.32 250.89 33.14C250.89 31.96 250.5 31 249.73 30.22C248.98 29.45 248.02 29.06 246.85 29.06H240.94V37.25V37.26Z"/>&#xa;<path fill="#1F2937" d="M293.67 45.97H282.16L279.8 52.2H274.53L285.4 23.88H290.79L301.86 52.2H296.1L293.66 45.97H293.67ZM292.07 41.74L287.87 30.99L283.79 41.74H292.06H292.07Z"/>&#xa;<path fill="#1F2937" d="M335.99 23C338.57 23 340.92 23.68 343.02 25.04C345.15 26.37 346.84 28.18 348.1 30.47L343.1 32.87C341.37 29.57 339 27.92 335.99 27.92C333.62 27.92 331.65 28.91 330.07 30.88C328.53 32.82 327.75 35.22 327.75 38.07C327.75 40.92 328.52 43.32 330.07 45.26C331.62 47.18 333.59 48.14 335.99 48.14C337.45 48.14 338.81 47.73 340.07 46.9C341.32 46.05 342.32 44.93 343.07 43.54L347.99 45.9C346.79 48.14 345.13 49.89 342.99 51.17C340.86 52.42 338.53 53.05 336 53.05C331.95 53.05 328.63 51.65 326.05 48.86C323.47 46.04 322.17 42.44 322.17 38.07C322.17 33.7 323.48 30.13 326.09 27.28C328.73 24.43 332.03 23.01 336 23.01L335.99 23Z"/>&#xa;<path fill="#1F2937" d="M393.49 52.2H388.09V40.61H377.1V52.2H371.71V23.88H377.1V35.43H388.09V23.88H393.49V52.2Z"/>&#xa;<path fill="#1F2937" d="M435.17 29.07H423.9V35.46H432.41V40.65H423.9V47H435.17V52.19H418.51V23.87H435.17V29.06V29.07Z"/>&#xa;<path fill="#1F2937" d="M185 76.1H207.25C218.63 76.1 227.58 79.3 234.1 85.69C240.69 92.02 243.98 100.14 243.98 110.04C243.98 119.94 240.69 128.1 234.1 134.49C227.51 140.88 218.53 144.08 207.15 144.08H184.99V76.1H185ZM199.96 90.49V129.7H206.67C209.55 129.7 212.2 129.38 214.63 128.74C217.12 128.1 219.43 127.08 221.54 125.67C223.71 124.26 225.41 122.25 226.62 119.63C227.83 116.95 228.44 113.75 228.44 110.04C228.44 106.33 227.83 103.17 226.62 100.55C225.4 97.93 223.71 95.92 221.54 94.51C219.43 93.1 217.16 92.08 214.73 91.44C212.3 90.8 209.61 90.48 206.67 90.48H199.96V90.49Z"/>&#xa;<path fill="#1F2937" d="M291.82 130.85H264.96L259.97 144.08H245.39L271.38 76.1H286.34L312.91 144.08H296.89L291.81 130.85H291.82ZM287.4 119.35L278.29 95.76L269.37 119.35H287.4Z"/>&#xa;<path fill="#1F2937" d="M362.7 90.49H342.94V144.09H327.98V90.49H308.51V76.11H362.7V90.49Z"/>&#xa;<path fill="#1F2937" d="M404.77 130.85H377.92L372.93 144.08H358.35L384.34 76.1H399.3L425.87 144.08H409.85L404.77 130.85ZM400.36 119.35L391.25 95.76L382.33 119.35H400.36Z"/>&#xa;<path fill="#1F2937" d="M474.73 90.49H448.45V102.95H468.4V117.33H448.45V144.08H433.49V76.1H474.73V90.48V90.49Z"/>&#xa;<path fill="#1F2937" d="M541.71 76.1V118.96C541.65 127.27 538.96 133.85 533.65 138.71C528.41 143.57 521.53 146 513.03 146C504.53 146 497.78 143.57 492.41 138.71C487.04 133.85 484.39 127.27 484.45 118.96V76.1H499.32V119.05C499.32 122.88 500.6 125.95 503.16 128.25C505.78 130.49 509.08 131.61 513.04 131.61C517 131.61 520.27 130.49 522.82 128.25C525.38 125.95 526.69 122.88 526.75 119.05V76.1H541.71Z"/>&#xa;<path fill="#1F2937" d="M578.69 73.99C585.72 73.99 591.96 75.59 597.39 78.78L590.77 91.24C585.98 89.19 581.43 88.17 577.15 88.17C570.95 88.17 567.85 90.25 567.85 94.4C567.85 96.45 569.03 98.17 571.4 99.58C573.83 100.92 577.28 102.39 581.76 103.99C586.3 105.52 589.72 106.96 592.02 108.3C598.22 111.88 601.32 117.25 601.32 124.41C601.32 131.12 598.86 136.4 593.93 140.23C589.01 144.07 582.87 145.98 575.52 145.98C571.36 145.98 567.05 145.21 562.57 143.68C558.09 142.15 554.61 140.39 552.12 138.41L560.18 126.43C567.02 130.46 573.22 132.21 578.79 131.7C580.96 131.51 582.76 130.74 584.16 129.4C585.63 128.06 586.24 126.43 585.98 124.51C585.72 122.72 584.22 121.25 581.47 120.1C578.72 118.89 575.14 117.48 570.73 115.88C566.38 114.28 562.83 112.4 560.08 110.22C555.03 106.13 552.5 101.05 552.5 94.98C552.5 91.98 553.01 89.26 554.03 86.83C555.05 84.4 556.4 82.42 558.06 80.89C559.79 79.29 561.8 77.98 564.1 76.96C566.4 75.87 568.77 75.11 571.2 74.66C573.63 74.21 576.12 73.99 578.68 73.99H578.69Z"/>&#xa;<path fill="#1F2937" d="M626.79 144.08H611.83V76.1H626.79V144.08Z"/>&#xa;<path fill="#1F2937" d="M647.04 84.16C653.88 77.38 662.48 74 672.84 74C683.2 74 691.73 77.39 698.45 84.16C705.23 90.87 708.62 99.4 708.62 109.76C708.62 120.12 705.33 128.68 698.74 135.45C692.15 142.16 683.52 145.68 672.84 146C662.48 146 653.88 142.58 647.04 135.74C640.26 128.84 636.87 120.21 636.87 109.85C636.87 99.49 640.26 90.93 647.04 84.15V84.16ZM672.84 87.61C666.64 87.61 661.68 89.69 657.97 93.84C654.26 97.99 652.41 103.3 652.41 109.76C652.41 116.22 654.26 121.62 657.97 125.96C661.74 130.24 666.7 132.38 672.84 132.38C678.98 132.38 683.96 130.24 687.61 125.96C691.25 121.68 693.08 116.31 693.08 109.85C693.08 103.39 691.26 98.12 687.61 94.03C684.03 89.88 679.11 87.73 672.84 87.61Z"/>&#xa;<path fill="#1F2937" d="M775 144.08H759.65L732.7 101.99V144.08H718.7V76.1H732.99L761 118.57V76.1H775V144.08Z"/>&#xa;<path fill="#1F2937" d="M788.01 78.18H784.62V87.44H782.46V78.18H779.13V76.1H788.01V78.18ZM800.56 87.45H798.48V80.17L795.5 85.79H794.12L791.14 80.17L791.12 87.45H789.1V76.11H791.13L794.87 83.04L798.45 76.11H800.51L800.53 87.45H800.56Z"/>&#xa;</g>&#xa;<defs>&#xa;<linearGradient gradientUnits="userSpaceOnUse" y2="36.78" x2="162.73" y1="117.74" x1="17.0897" id="paint0_linear_1_181">&#xa;<stop stop-color="#EF4137"/>&#xa;<stop stop-color="#FBB042" offset="1"/>&#xa;</linearGradient>&#xa;<clipPath id="clip0_1_181">&#xa;<rect fill="white" height="168" width="800.56"/>&#xa;</clipPath>&#xa;</defs>&#xa;</svg>;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;323.48&quot; y=&quot;263.6&quot; width=&quot;143.03&quot; height=&quot;30&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-21&quot; value=&quot;&quot; style=&quot;shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/png,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;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;360&quot; y=&quot;293.6&quot; width=&quot;70&quot; height=&quot;36.4&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-22&quot; value=&quot;&quot; style=&quot;shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry width=&quot;50&quot; height=&quot;50&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint x=&quot;394.5&quot; y=&quot;140&quot; as=&quot;sourcePoint&quot; /&gt;&#10;            &lt;mxPoint x=&quot;394.5&quot; y=&quot;170&quot; as=&quot;targetPoint&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-23&quot; value=&quot;&quot; style=&quot;shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot; source=&quot;t5OBkkhKOG6cYtw1sPyQ-17&quot; target=&quot;t5OBkkhKOG6cYtw1sPyQ-16&quot;&gt;&#10;          &lt;mxGeometry width=&quot;50&quot; height=&quot;50&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint x=&quot;140&quot; y=&quot;210&quot; as=&quot;sourcePoint&quot; /&gt;&#10;            &lt;mxPoint x=&quot;140&quot; y=&quot;240&quot; as=&quot;targetPoint&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-24&quot; value=&quot;&quot; style=&quot;shape=flexArrow;endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;&quot; edge=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry width=&quot;50&quot; height=&quot;50&quot; relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;mxPoint x=&quot;394.5&quot; y=&quot;330&quot; as=&quot;sourcePoint&quot; /&gt;&#10;            &lt;mxPoint x=&quot;394.5&quot; y=&quot;360&quot; as=&quot;targetPoint&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;t5OBkkhKOG6cYtw1sPyQ-25&quot; value=&quot;Shuffle Files&quot; style=&quot;shape=process;whiteSpace=wrap;html=1;backgroundOutline=1;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;310&quot; y=&quot;360&quot; width=&quot;170&quot; height=&quot;50&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;&lt;/mxfile&gt;&#10;"><defs/><g><g data-cell-id="0"><g data-cell-id="1"><g data-cell-id="AH3lBTSLKK5181iXBnnY-2"><g><rect x="290" y="0" width="210" height="430" rx="31.5" ry="31.5" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 208px; height: 1px; padding-top: 7px; margin-left: 291px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Spark Executor</div></div></div></foreignObject><image x="291" y="7.5" width="208" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="AH3lBTSLKK5181iXBnnY-16"><g><rect x="0" y="40" width="200" height="350" rx="30" ry="30" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 198px; height: 1px; padding-top: 47px; margin-left: 1px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Spark Driver</div></div></div></foreignObject><image x="1" y="47.5" width="198" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="AH3lBTSLKK5181iXBnnY-17"><g><g><svg width="125.48" height="30" viewBox="0 0 1008 241" version="1.1" xml:space="preserve" style="fill-rule: evenodd; clip-rule: evenodd; stroke-linejoin: round; stroke-miterlimit: 2; font-family: initial;" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="34.02" y="199.5">&#xa;    <g id="path1" transform="matrix(1,0,0,1,-85.3519,-181.196)">&#xa;        <path d="M315.318,338.335C314.573,341.101 314.401,339.494 314.575,331.378C316.01,264.251 257.149,217.797 189.369,232.561C187.782,232.907 186.445,233.25 185.268,233.489C179.698,234.621 179.735,234.93 177.187,233.775C174.023,232.342 169.792,229.462 159.886,223.212C156.414,221.022 157,220.058 159.212,218.758C170.165,212.32 200.292,207.23 225.306,211.683C288.142,222.871 330.339,282.647 315.319,338.335L315.318,338.335ZM291.072,356.082C290.554,356.044 289.252,354.65 288.18,352.998C286.231,349.993 286.231,349.993 285.505,352.493C284.477,356.036 283.898,355.533 278.47,346.393C272.599,336.504 261.642,321.875 261.056,323.142C260.822,323.646 261.447,327.701 262.445,332.152C264.821,342.745 265.707,342.99 246.55,327.749C237.363,320.44 223.898,309.787 216.627,304.075C209.357,298.363 201.152,291.907 198.396,289.728C195.639,287.549 188.043,281.657 181.515,276.635C174.987,271.613 164.563,263.57 158.351,258.761C145.419,248.75 142.981,243.653 181.857,307.906C203.722,344.043 202.779,342.496 214.032,360.693C223.882,376.62 224.916,375.982 203.028,367.486C199.434,366.09 219.918,385.23 228.275,391.075C233.869,394.987 233.869,394.987 230.061,395.129C226.252,395.263 226.252,395.263 229.59,398.125C234.955,402.71 234.004,403.13 221.858,401.542C201.113,398.831 181.794,389.134 167.022,374.019C162.317,369.204 162.166,369.367 170.952,369.786C178.467,370.143 178.467,370.143 166.62,361.216C149.107,348.019 115.227,316.596 117.006,315.198C117.644,314.698 128.749,318.662 144.82,325.128C157.881,330.383 159.715,330.759 157.422,327.712C156.213,326.104 151.367,316.768 140.333,294.792C137.816,289.778 134.738,283.73 133.493,281.35C130.579,275.782 100.857,214.958 94.62,201.8C91.999,196.272 88.629,189.268 87.13,186.235C83.701,179.302 84.366,179.378 96.936,187.363C109.422,195.294 140.946,215.668 149.064,221.054C152.359,223.239 163.973,230.925 174.873,238.134C197.503,253.101 217.452,266.507 224.119,271.228C229.764,275.225 229.589,275.438 227.553,267.055C222.87,247.767 220.147,234.998 220.537,234.157C221.703,231.639 249.221,268.527 259.368,286.211C268.491,302.111 267.706,301.505 268.533,293.293C269.371,284.96 269.585,284.886 274.423,291.216C288.63,309.803 300.715,356.886 291.072,356.082L291.072,356.082ZM213.876,421.215C123.844,428.556 61.477,334.755 107.965,261.924C114.494,251.697 114.266,251.715 118.708,261.045C120.524,264.86 122.916,269.712 124.024,271.827C126.038,275.673 126.038,275.673 122.081,283.158C91.278,341.428 131.256,410.574 200.829,419.363C208.547,420.338 214.419,421.171 213.876,421.215L213.876,421.215Z" style="fill:rgb(234,151,52);fill-rule:nonzero;"/>&#xa;    </g>&#xa;    <g id="path3" transform="matrix(0.968859,0,0,0.920768,-70.9157,-151.37)">&#xa;        <path d="M285.493,345.632C282.234,341.53 282.234,341.53 282.111,344.281C281.939,348.324 280.979,347.656 276.9,340.6C270.215,329.052 257.352,312.116 256.166,313.3C255.944,313.534 256.814,318.034 258.112,323.299C261.066,335.197 261.621,335.007 250.322,325.982C239.351,317.216 193.938,281.579 178.993,270.007C173.41,265.683 163.508,258.014 156.99,252.964C143.371,242.412 141.022,240.821 142.086,242.866C143.03,244.684 162.92,277.769 175.06,297.721C180.369,306.445 186.516,316.567 188.722,320.213C195.871,332.031 212.9,359.45 217.395,366.383C221.949,373.405 222,373.375 211.621,369.826C206.608,368.11 202.08,366.715 201.561,366.719C199.733,366.738 214.451,381.192 223.86,388.63C233.301,396.091 233.349,396.151 230.259,396.555C227.146,396.968 227.146,396.968 230.791,400.324C240.962,409.751 203.686,401.213 186.752,390.218C170.285,379.542 156.298,371.294 164.839,371.549C172.991,371.79 178.789,371.913 174.59,369.035C151.709,353.315 100.466,307.638 109.333,310.655C112.607,311.769 136.117,321.922 141.112,323.793C147.026,326.011 153.655,329.093 143.818,310.353C127.827,279.892 78.938,174.522 76.594,169.808C71.449,159.458 78.239,166.828 86.193,172.077C89.669,174.373 172.252,229.674 203.14,252.141C229.292,271.163 222.786,268.496 218.454,244.292C215.958,230.346 214.043,222.266 214.242,222.067C215.859,220.453 246.86,264.84 257.024,282.948C263.429,294.362 263.29,292.845 263.586,283.122C263.915,272.333 273.722,284.976 282.262,306.256C289.314,323.826 291.76,353.503 285.507,345.634L285.493,345.632Z" style="fill:rgb(230,74,25);fill-rule:nonzero;"/>&#xa;    </g>&#xa;    <g transform="matrix(1.15167,0,0,1.15167,-376.043,-0.54078)">&#xa;        <g transform="matrix(32,0,0,32,561.496,84.0074)">&#xa;            <path d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,599.839,84.0074)">&#xa;            <path d="M0.08,-0.716L0.347,-0.716C0.406,-0.716 0.455,-0.71 0.494,-0.699C0.534,-0.689 0.565,-0.665 0.588,-0.629C0.611,-0.592 0.623,-0.552 0.623,-0.507C0.623,-0.435 0.6,-0.38 0.554,-0.342C0.508,-0.305 0.442,-0.286 0.355,-0.286L0.175,-0.286L0.175,-0L0.08,-0L0.08,-0.716ZM0.175,-0.371L0.356,-0.371C0.417,-0.371 0.46,-0.382 0.486,-0.405C0.512,-0.428 0.525,-0.461 0.525,-0.504C0.525,-0.533 0.518,-0.558 0.503,-0.58C0.489,-0.602 0.471,-0.616 0.449,-0.622C0.427,-0.628 0.395,-0.631 0.354,-0.631L0.175,-0.631L0.175,-0.371Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,638.183,84.0074)">&#xa;            <path d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,676.527,84.0074)">&#xa;            <path d="M0.38,0.012C0.279,0.012 0.198,-0.021 0.137,-0.088C0.077,-0.154 0.047,-0.244 0.047,-0.358C0.047,-0.472 0.077,-0.562 0.137,-0.628C0.198,-0.695 0.279,-0.728 0.38,-0.728C0.458,-0.728 0.524,-0.707 0.579,-0.665C0.633,-0.623 0.664,-0.568 0.671,-0.499L0.573,-0.499C0.569,-0.544 0.55,-0.58 0.514,-0.607C0.479,-0.634 0.435,-0.647 0.381,-0.647C0.308,-0.647 0.251,-0.622 0.208,-0.572C0.166,-0.522 0.145,-0.451 0.145,-0.358C0.145,-0.265 0.166,-0.194 0.208,-0.144C0.25,-0.094 0.307,-0.069 0.379,-0.069C0.435,-0.069 0.48,-0.083 0.515,-0.11C0.549,-0.137 0.569,-0.176 0.573,-0.227L0.671,-0.227C0.664,-0.151 0.634,-0.092 0.581,-0.05C0.528,-0.009 0.461,0.012 0.38,0.012Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,716.636,84.0074)">&#xa;            <path d="M0.642,-0L0.547,-0L0.547,-0.337L0.175,-0.337L0.175,-0L0.08,-0L0.08,-0.716L0.175,-0.716L0.175,-0.422L0.547,-0.422L0.547,-0.716L0.642,-0.716L0.642,-0Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,756.746,84.0074)">&#xa;            <path d="M0.614,-0L0.08,-0L0.08,-0.716L0.597,-0.716L0.597,-0.631L0.175,-0.631L0.175,-0.412L0.57,-0.412L0.57,-0.327L0.175,-0.327L0.175,-0.085L0.614,-0.085L0.614,-0Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;    </g>&#xa;    <g id="text2" transform="matrix(1,0,0,1,-91.3519,-191.196)">&#xa;        <path d="M403.965,341.559C403.965,345.669 403.027,349.353 401.15,352.613C399.273,355.853 396.902,358.343 394.037,360.081C391.884,361.385 389.523,362.294 386.955,362.808C384.386,363.321 381.344,363.578 377.827,363.578L362.269,363.578L362.269,319.452L378.271,319.452C381.867,319.452 384.969,319.758 387.577,320.371C390.185,320.964 392.378,321.813 394.156,322.92C397.198,324.777 399.589,327.286 401.327,330.447C403.086,333.588 403.965,337.293 403.965,341.56L403.965,341.559ZM392.2,341.464C392.2,338.56 391.667,336.08 390.6,334.026C389.552,331.951 387.883,330.331 385.592,329.165C384.426,328.592 383.23,328.206 382.006,328.009C380.8,327.791 378.973,327.682 376.524,327.682L373.649,327.682L373.649,355.302L376.524,355.302C379.23,355.302 381.216,355.183 382.48,354.946C383.744,354.689 384.979,354.235 386.184,353.583C388.259,352.398 389.78,350.818 390.748,348.842C391.717,346.846 392.201,344.387 392.201,341.463L392.2,341.464ZM453.426,363.572L441.661,363.572L438.608,354.651L422.25,354.651L419.197,363.572L407.729,363.572L424.028,319.445L437.126,319.445L453.426,363.572ZM435.852,346.561L430.429,330.736L425.006,346.561L435.852,346.561ZM494.292,327.98L480.512,327.98L480.512,363.572L469.132,363.572L469.132,327.98L455.352,327.98L455.352,319.445L494.292,319.445L494.292,327.98ZM541.915,363.572L530.15,363.572L527.098,354.651L510.74,354.651L507.687,363.572L496.218,363.572L512.518,319.445L525.616,319.445L541.915,363.572ZM524.342,346.561L518.919,330.736L513.496,346.561L524.342,346.561ZM579.878,327.98L559.578,327.98L559.578,336.189L578.396,336.189L578.396,344.724L559.578,344.724L559.578,363.572L548.257,363.572L548.257,319.445L579.878,319.445L579.878,327.98ZM626.375,347.598C626.375,353.051 624.716,357.23 621.396,360.134C618.077,363.038 613.187,364.49 606.727,364.49C600.267,364.49 595.377,363.038 592.058,360.134C588.758,357.23 587.109,353.061 587.109,347.628L587.109,319.445L598.548,319.445L598.548,346.976C598.548,350.038 599.19,352.32 600.474,353.822C601.758,355.323 603.843,356.074 606.727,356.074C609.572,356.074 611.646,355.353 612.95,353.91C614.274,352.468 614.936,350.157 614.936,346.976L614.936,319.445L626.375,319.445L626.375,347.598ZM672.339,349.702C672.339,354.049 670.492,357.585 666.797,360.312C663.122,363.018 658.124,364.372 651.802,364.372C648.147,364.372 644.956,364.056 642.23,363.424C639.523,362.771 636.984,361.951 634.614,360.964L634.614,350.384L635.858,350.384C638.209,352.261 640.837,353.703 643.741,354.711C646.665,355.719 649.47,356.223 652.157,356.223C652.849,356.223 653.758,356.166 654.884,356.051C656.01,355.936 656.929,355.739 657.64,355.458C658.509,355.103 659.22,354.658 659.773,354.124C660.347,353.59 660.634,352.8 660.634,351.753C660.634,350.785 660.219,349.955 659.389,349.264C658.579,348.553 657.383,348.009 655.803,347.633C654.144,347.238 652.385,346.872 650.528,346.536C648.691,346.18 646.962,345.736 645.342,345.202C641.628,343.996 638.951,342.366 637.311,340.312C635.691,338.238 634.881,335.669 634.881,332.607C634.881,328.497 636.718,325.149 640.393,322.561C644.088,319.953 648.829,318.649 654.618,318.649C657.522,318.649 660.387,318.936 663.212,319.509C666.057,320.062 668.517,320.764 670.591,321.613L670.591,331.778L669.375,331.778C667.597,330.356 665.414,329.17 662.826,328.222C660.258,327.253 657.63,326.769 654.943,326.769C653.995,326.769 653.047,326.838 652.098,326.976C651.169,327.09 650.27,327.327 649.401,327.687C648.63,327.984 647.969,328.438 647.416,329.05C646.863,329.642 646.586,330.324 646.586,331.094C646.586,332.26 647.031,333.159 647.921,333.791C648.81,334.404 650.489,334.967 652.958,335.481C654.578,335.817 656.129,336.144 657.611,336.46C659.113,336.776 660.723,337.21 662.442,337.763C665.82,338.87 668.309,340.381 669.91,342.298C671.53,344.194 672.34,346.664 672.34,349.706L672.339,349.702ZM703.989,363.572L678.147,363.572L678.147,355.748L685.378,355.748L685.378,327.269L678.147,327.269L678.147,319.445L703.989,319.445L703.989,327.269L696.758,327.269L696.758,355.748L703.989,355.748L703.989,363.572ZM756.176,341.523C756.176,348.557 754.161,354.148 750.13,358.297C746.1,362.426 740.529,364.49 733.416,364.49C726.324,364.49 720.762,362.426 716.732,358.297C712.701,354.148 710.686,348.557 710.686,341.523C710.686,334.431 712.701,328.83 716.732,324.72C720.762,320.591 726.324,318.526 733.416,318.526C740.489,318.526 746.051,320.591 750.101,324.72C754.151,328.83 756.176,334.431 756.176,341.523ZM741.092,352.696C742.198,351.352 743.018,349.772 743.551,347.954C744.085,346.117 744.352,343.963 744.352,341.494C744.352,338.846 744.046,336.594 743.433,334.737C742.82,332.88 742.02,331.378 741.032,330.232C740.024,329.047 738.859,328.188 737.535,327.654C736.232,327.121 734.868,326.855 733.446,326.855C732.004,326.855 730.64,327.112 729.356,327.625C728.092,328.139 726.926,328.988 725.859,330.174C724.872,331.28 724.062,332.811 723.429,334.767C722.816,336.704 722.51,338.956 722.51,341.524C722.51,344.152 722.806,346.394 723.399,348.251C724.012,350.089 724.812,351.59 725.799,352.756C726.787,353.922 727.943,354.781 729.266,355.334C730.59,355.887 731.983,356.164 733.445,356.164C734.907,356.164 736.3,355.887 737.623,355.334C738.947,354.761 740.103,353.881 741.091,352.696L741.092,352.696ZM804.985,363.572L794.02,363.572L775.29,333.285L775.29,363.572L764.859,363.572L764.859,319.445L778.461,319.445L794.553,344.724L794.553,319.445L804.985,319.445L804.985,363.572ZM856.934,364.432C853.655,364.432 850.622,363.947 847.837,362.979C845.071,362.01 842.69,360.568 840.695,358.652C838.699,356.736 837.148,354.345 836.042,351.481C834.955,348.616 834.411,345.307 834.411,341.553C834.411,338.056 834.935,334.885 835.983,332.04C837.03,329.195 838.552,326.755 840.546,324.72C842.463,322.765 844.834,321.253 847.659,320.186C850.504,319.12 853.606,318.586 856.964,318.586C858.821,318.586 860.491,318.695 861.972,318.913C863.474,319.111 864.857,319.378 866.121,319.714C867.445,320.089 868.64,320.514 869.707,320.989C870.794,321.444 871.743,321.869 872.552,322.264L872.552,332.962L871.249,332.962C870.695,332.488 869.994,331.925 869.144,331.273C868.315,330.62 867.366,329.978 866.299,329.346C865.212,328.714 864.037,328.181 862.773,327.746C861.509,327.312 860.155,327.094 858.713,327.094C857.113,327.094 855.591,327.351 854.149,327.865C852.707,328.358 851.373,329.188 850.148,330.354C848.982,331.481 848.034,332.972 847.303,334.829C846.592,336.686 846.237,338.938 846.237,341.586C846.237,344.352 846.622,346.663 847.393,348.52C848.183,350.377 849.171,351.839 850.357,352.906C851.562,353.993 852.906,354.774 854.387,355.247C855.869,355.702 857.331,355.93 858.773,355.93C860.156,355.93 861.519,355.722 862.863,355.307C864.226,354.891 865.48,354.328 866.626,353.617C867.595,353.043 868.494,352.431 869.323,351.78C870.153,351.127 870.834,350.564 871.368,350.09L872.553,350.09L872.553,360.64C871.447,361.134 870.39,361.599 869.382,362.034C868.374,362.468 867.317,362.843 866.211,363.159C864.769,363.575 863.416,363.891 862.151,364.108C860.887,364.325 859.149,364.434 856.935,364.434L856.934,364.432ZM923.821,341.524C923.821,348.557 921.805,354.148 917.775,358.297C913.745,362.426 908.173,364.491 901.061,364.491C893.968,364.491 888.407,362.426 884.377,358.297C880.346,354.148 878.331,348.557 878.331,341.524C878.331,334.431 880.346,328.83 884.377,324.721C888.407,320.592 893.968,318.527 901.061,318.527C908.134,318.527 913.695,320.592 917.746,324.721C921.796,328.83 923.821,334.431 923.821,341.524ZM908.736,352.696C909.843,351.353 910.663,349.772 911.196,347.955C911.73,346.117 911.997,343.964 911.997,341.494C911.997,338.847 911.691,336.595 911.078,334.737C910.465,332.88 909.664,331.379 908.677,330.233C907.669,329.048 906.504,328.188 905.18,327.655C903.876,327.122 902.513,326.856 901.091,326.856C899.648,326.856 898.285,327.112 897.001,327.626C895.737,328.14 894.571,328.989 893.504,330.175C892.517,331.281 891.706,332.812 891.074,334.768C890.461,336.704 890.155,338.956 890.155,341.525C890.155,344.153 890.451,346.395 891.043,348.252C891.656,350.089 892.457,351.591 893.444,352.756C894.432,353.923 895.587,354.782 896.911,355.335C898.235,355.888 899.628,356.164 901.09,356.164C902.552,356.164 903.944,355.888 905.268,355.335C906.592,354.761 907.748,353.882 908.736,352.697L908.736,352.696ZM978.764,363.572L967.443,363.572L967.443,334.026L959.264,353.2L951.411,353.2L943.231,334.026L943.231,363.572L932.504,363.572L932.504,319.446L945.721,319.446L955.648,341.583L965.547,319.446L978.764,319.446L978.764,363.572ZM1021.94,363.572L990.025,363.572L990.025,319.446L1021.94,319.446L1021.94,327.981L1001.35,327.981L1001.35,335.597L1020.46,335.597L1020.46,344.132L1001.35,344.132L1001.35,355.038L1021.94,355.038L1021.94,363.572ZM1066.01,327.981L1052.23,327.981L1052.23,363.572L1040.85,363.572L1040.85,327.981L1027.07,327.981L1027.07,319.446L1066.01,319.446L1066.01,327.981Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;    </g>&#xa;    <g id="text3" transform="matrix(1,0,0,1,-95.3519,-190.196)">&#xa;        <path d="M1089.2,319.918L1084.49,319.918L1084.49,331.546L1082.74,331.546L1082.74,319.918L1078.03,319.918L1078.03,318.36L1089.2,318.36L1089.2,319.918ZM1102.72,331.546L1100.96,331.546L1100.96,320.184L1097.3,327.915L1096.25,327.915L1092.61,320.184L1092.61,331.546L1090.97,331.546L1090.97,318.36L1093.37,318.36L1096.88,325.701L1100.28,318.36L1102.72,318.36L1102.72,331.546Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;    </g>&#xa;</svg></g><rect x="34.52" y="200" width="125.48" height="30" fill="none" stroke="rgb(0, 0, 0)" pointer-events="all"/></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-1"><g><rect x="10" y="80" width="180" height="30" rx="4.5" ry="4.5" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 178px; height: 1px; padding-top: 95px; margin-left: 11px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Spark Logical Plan</div></div></div></foreignObject><image x="11" y="88.5" width="178" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-2"><g><rect x="10" y="140" width="180" height="30" rx="4.5" ry="4.5" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 178px; height: 1px; padding-top: 155px; margin-left: 11px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Spark Physical Plan</div></div></div></foreignObject><image x="11" y="148.5" width="178" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-3"><g><rect x="10" y="260" width="180" height="100" rx="15" ry="15" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 178px; height: 1px; padding-top: 267px; margin-left: 11px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Comet Physical Plan</div></div></div></foreignObject><image x="11" y="267.5" width="178" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-4"><g><rect x="40" y="290" width="120" height="50" fill="#f5f5f5" stroke="#666666" pointer-events="all"/><path d="M 52 290 L 52 340 M 148 290 L 148 340" fill="none" stroke="#666666" stroke-miterlimit="10" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 94px; height: 1px; padding-top: 315px; margin-left: 53px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">protobuf intermediate representation</div></div></div></foreignObject><image x="53" y="294.5" width="94" height="45" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-12"><g><path d="M 95 110.5 L 105 110.5 L 105 120.5 L 115.5 120.5 L 100 139.5 L 84.5 120.5 L 95 120.5 Z" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-13"><g><path d="M 91.76 170.5 L 101.76 170.5 L 101.76 180.5 L 112.26 180.5 L 96.76 199.5 L 81.26 180.5 L 91.76 180.5 Z" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-14"><g><path d="M 91.76 230.5 L 101.76 230.5 L 101.76 240.5 L 112.26 240.5 L 96.76 259.5 L 81.26 240.5 L 91.76 240.5 Z" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-15"><g><path d="M 200.5 210 L 200.5 199 L 259.49 199 L 259.49 184.5 L 289.5 204.5 L 259.49 224.5 L 259.49 210 Z" fill="#000000" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-16"><g><rect x="310" y="230" width="170" height="100" rx="15" ry="15" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 168px; height: 1px; padding-top: 237px; margin-left: 311px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Native Execution Plan</div></div></div></foreignObject><image x="311" y="237.5" width="168" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-17"><g><g><svg width="125.48" height="30" viewBox="0 0 1008 241" version="1.1" xml:space="preserve" style="fill-rule: evenodd; clip-rule: evenodd; stroke-linejoin: round; stroke-miterlimit: 2; font-family: initial;" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="331.76" y="169.5">&#xa;    <g id="path1" transform="matrix(1,0,0,1,-85.3519,-181.196)">&#xa;        <path d="M315.318,338.335C314.573,341.101 314.401,339.494 314.575,331.378C316.01,264.251 257.149,217.797 189.369,232.561C187.782,232.907 186.445,233.25 185.268,233.489C179.698,234.621 179.735,234.93 177.187,233.775C174.023,232.342 169.792,229.462 159.886,223.212C156.414,221.022 157,220.058 159.212,218.758C170.165,212.32 200.292,207.23 225.306,211.683C288.142,222.871 330.339,282.647 315.319,338.335L315.318,338.335ZM291.072,356.082C290.554,356.044 289.252,354.65 288.18,352.998C286.231,349.993 286.231,349.993 285.505,352.493C284.477,356.036 283.898,355.533 278.47,346.393C272.599,336.504 261.642,321.875 261.056,323.142C260.822,323.646 261.447,327.701 262.445,332.152C264.821,342.745 265.707,342.99 246.55,327.749C237.363,320.44 223.898,309.787 216.627,304.075C209.357,298.363 201.152,291.907 198.396,289.728C195.639,287.549 188.043,281.657 181.515,276.635C174.987,271.613 164.563,263.57 158.351,258.761C145.419,248.75 142.981,243.653 181.857,307.906C203.722,344.043 202.779,342.496 214.032,360.693C223.882,376.62 224.916,375.982 203.028,367.486C199.434,366.09 219.918,385.23 228.275,391.075C233.869,394.987 233.869,394.987 230.061,395.129C226.252,395.263 226.252,395.263 229.59,398.125C234.955,402.71 234.004,403.13 221.858,401.542C201.113,398.831 181.794,389.134 167.022,374.019C162.317,369.204 162.166,369.367 170.952,369.786C178.467,370.143 178.467,370.143 166.62,361.216C149.107,348.019 115.227,316.596 117.006,315.198C117.644,314.698 128.749,318.662 144.82,325.128C157.881,330.383 159.715,330.759 157.422,327.712C156.213,326.104 151.367,316.768 140.333,294.792C137.816,289.778 134.738,283.73 133.493,281.35C130.579,275.782 100.857,214.958 94.62,201.8C91.999,196.272 88.629,189.268 87.13,186.235C83.701,179.302 84.366,179.378 96.936,187.363C109.422,195.294 140.946,215.668 149.064,221.054C152.359,223.239 163.973,230.925 174.873,238.134C197.503,253.101 217.452,266.507 224.119,271.228C229.764,275.225 229.589,275.438 227.553,267.055C222.87,247.767 220.147,234.998 220.537,234.157C221.703,231.639 249.221,268.527 259.368,286.211C268.491,302.111 267.706,301.505 268.533,293.293C269.371,284.96 269.585,284.886 274.423,291.216C288.63,309.803 300.715,356.886 291.072,356.082L291.072,356.082ZM213.876,421.215C123.844,428.556 61.477,334.755 107.965,261.924C114.494,251.697 114.266,251.715 118.708,261.045C120.524,264.86 122.916,269.712 124.024,271.827C126.038,275.673 126.038,275.673 122.081,283.158C91.278,341.428 131.256,410.574 200.829,419.363C208.547,420.338 214.419,421.171 213.876,421.215L213.876,421.215Z" style="fill:rgb(234,151,52);fill-rule:nonzero;"/>&#xa;    </g>&#xa;    <g id="path3" transform="matrix(0.968859,0,0,0.920768,-70.9157,-151.37)">&#xa;        <path d="M285.493,345.632C282.234,341.53 282.234,341.53 282.111,344.281C281.939,348.324 280.979,347.656 276.9,340.6C270.215,329.052 257.352,312.116 256.166,313.3C255.944,313.534 256.814,318.034 258.112,323.299C261.066,335.197 261.621,335.007 250.322,325.982C239.351,317.216 193.938,281.579 178.993,270.007C173.41,265.683 163.508,258.014 156.99,252.964C143.371,242.412 141.022,240.821 142.086,242.866C143.03,244.684 162.92,277.769 175.06,297.721C180.369,306.445 186.516,316.567 188.722,320.213C195.871,332.031 212.9,359.45 217.395,366.383C221.949,373.405 222,373.375 211.621,369.826C206.608,368.11 202.08,366.715 201.561,366.719C199.733,366.738 214.451,381.192 223.86,388.63C233.301,396.091 233.349,396.151 230.259,396.555C227.146,396.968 227.146,396.968 230.791,400.324C240.962,409.751 203.686,401.213 186.752,390.218C170.285,379.542 156.298,371.294 164.839,371.549C172.991,371.79 178.789,371.913 174.59,369.035C151.709,353.315 100.466,307.638 109.333,310.655C112.607,311.769 136.117,321.922 141.112,323.793C147.026,326.011 153.655,329.093 143.818,310.353C127.827,279.892 78.938,174.522 76.594,169.808C71.449,159.458 78.239,166.828 86.193,172.077C89.669,174.373 172.252,229.674 203.14,252.141C229.292,271.163 222.786,268.496 218.454,244.292C215.958,230.346 214.043,222.266 214.242,222.067C215.859,220.453 246.86,264.84 257.024,282.948C263.429,294.362 263.29,292.845 263.586,283.122C263.915,272.333 273.722,284.976 282.262,306.256C289.314,323.826 291.76,353.503 285.507,345.634L285.493,345.632Z" style="fill:rgb(230,74,25);fill-rule:nonzero;"/>&#xa;    </g>&#xa;    <g transform="matrix(1.15167,0,0,1.15167,-376.043,-0.54078)">&#xa;        <g transform="matrix(32,0,0,32,561.496,84.0074)">&#xa;            <path d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,599.839,84.0074)">&#xa;            <path d="M0.08,-0.716L0.347,-0.716C0.406,-0.716 0.455,-0.71 0.494,-0.699C0.534,-0.689 0.565,-0.665 0.588,-0.629C0.611,-0.592 0.623,-0.552 0.623,-0.507C0.623,-0.435 0.6,-0.38 0.554,-0.342C0.508,-0.305 0.442,-0.286 0.355,-0.286L0.175,-0.286L0.175,-0L0.08,-0L0.08,-0.716ZM0.175,-0.371L0.356,-0.371C0.417,-0.371 0.46,-0.382 0.486,-0.405C0.512,-0.428 0.525,-0.461 0.525,-0.504C0.525,-0.533 0.518,-0.558 0.503,-0.58C0.489,-0.602 0.471,-0.616 0.449,-0.622C0.427,-0.628 0.395,-0.631 0.354,-0.631L0.175,-0.631L0.175,-0.371Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,638.183,84.0074)">&#xa;            <path d="M0.45,-0.293L0.324,-0.625L0.204,-0.293L0.45,-0.293ZM0.668,-0L0.561,-0L0.478,-0.218L0.178,-0.218L0.099,-0L-0.001,-0L0.274,-0.716L0.376,-0.716L0.668,-0Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,676.527,84.0074)">&#xa;            <path d="M0.38,0.012C0.279,0.012 0.198,-0.021 0.137,-0.088C0.077,-0.154 0.047,-0.244 0.047,-0.358C0.047,-0.472 0.077,-0.562 0.137,-0.628C0.198,-0.695 0.279,-0.728 0.38,-0.728C0.458,-0.728 0.524,-0.707 0.579,-0.665C0.633,-0.623 0.664,-0.568 0.671,-0.499L0.573,-0.499C0.569,-0.544 0.55,-0.58 0.514,-0.607C0.479,-0.634 0.435,-0.647 0.381,-0.647C0.308,-0.647 0.251,-0.622 0.208,-0.572C0.166,-0.522 0.145,-0.451 0.145,-0.358C0.145,-0.265 0.166,-0.194 0.208,-0.144C0.25,-0.094 0.307,-0.069 0.379,-0.069C0.435,-0.069 0.48,-0.083 0.515,-0.11C0.549,-0.137 0.569,-0.176 0.573,-0.227L0.671,-0.227C0.664,-0.151 0.634,-0.092 0.581,-0.05C0.528,-0.009 0.461,0.012 0.38,0.012Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,716.636,84.0074)">&#xa;            <path d="M0.642,-0L0.547,-0L0.547,-0.337L0.175,-0.337L0.175,-0L0.08,-0L0.08,-0.716L0.175,-0.716L0.175,-0.422L0.547,-0.422L0.547,-0.716L0.642,-0.716L0.642,-0Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;        <g transform="matrix(32,0,0,32,756.746,84.0074)">&#xa;            <path d="M0.614,-0L0.08,-0L0.08,-0.716L0.597,-0.716L0.597,-0.631L0.175,-0.631L0.175,-0.412L0.57,-0.412L0.57,-0.327L0.175,-0.327L0.175,-0.085L0.614,-0.085L0.614,-0Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;        </g>&#xa;    </g>&#xa;    <g id="text2" transform="matrix(1,0,0,1,-91.3519,-191.196)">&#xa;        <path d="M403.965,341.559C403.965,345.669 403.027,349.353 401.15,352.613C399.273,355.853 396.902,358.343 394.037,360.081C391.884,361.385 389.523,362.294 386.955,362.808C384.386,363.321 381.344,363.578 377.827,363.578L362.269,363.578L362.269,319.452L378.271,319.452C381.867,319.452 384.969,319.758 387.577,320.371C390.185,320.964 392.378,321.813 394.156,322.92C397.198,324.777 399.589,327.286 401.327,330.447C403.086,333.588 403.965,337.293 403.965,341.56L403.965,341.559ZM392.2,341.464C392.2,338.56 391.667,336.08 390.6,334.026C389.552,331.951 387.883,330.331 385.592,329.165C384.426,328.592 383.23,328.206 382.006,328.009C380.8,327.791 378.973,327.682 376.524,327.682L373.649,327.682L373.649,355.302L376.524,355.302C379.23,355.302 381.216,355.183 382.48,354.946C383.744,354.689 384.979,354.235 386.184,353.583C388.259,352.398 389.78,350.818 390.748,348.842C391.717,346.846 392.201,344.387 392.201,341.463L392.2,341.464ZM453.426,363.572L441.661,363.572L438.608,354.651L422.25,354.651L419.197,363.572L407.729,363.572L424.028,319.445L437.126,319.445L453.426,363.572ZM435.852,346.561L430.429,330.736L425.006,346.561L435.852,346.561ZM494.292,327.98L480.512,327.98L480.512,363.572L469.132,363.572L469.132,327.98L455.352,327.98L455.352,319.445L494.292,319.445L494.292,327.98ZM541.915,363.572L530.15,363.572L527.098,354.651L510.74,354.651L507.687,363.572L496.218,363.572L512.518,319.445L525.616,319.445L541.915,363.572ZM524.342,346.561L518.919,330.736L513.496,346.561L524.342,346.561ZM579.878,327.98L559.578,327.98L559.578,336.189L578.396,336.189L578.396,344.724L559.578,344.724L559.578,363.572L548.257,363.572L548.257,319.445L579.878,319.445L579.878,327.98ZM626.375,347.598C626.375,353.051 624.716,357.23 621.396,360.134C618.077,363.038 613.187,364.49 606.727,364.49C600.267,364.49 595.377,363.038 592.058,360.134C588.758,357.23 587.109,353.061 587.109,347.628L587.109,319.445L598.548,319.445L598.548,346.976C598.548,350.038 599.19,352.32 600.474,353.822C601.758,355.323 603.843,356.074 606.727,356.074C609.572,356.074 611.646,355.353 612.95,353.91C614.274,352.468 614.936,350.157 614.936,346.976L614.936,319.445L626.375,319.445L626.375,347.598ZM672.339,349.702C672.339,354.049 670.492,357.585 666.797,360.312C663.122,363.018 658.124,364.372 651.802,364.372C648.147,364.372 644.956,364.056 642.23,363.424C639.523,362.771 636.984,361.951 634.614,360.964L634.614,350.384L635.858,350.384C638.209,352.261 640.837,353.703 643.741,354.711C646.665,355.719 649.47,356.223 652.157,356.223C652.849,356.223 653.758,356.166 654.884,356.051C656.01,355.936 656.929,355.739 657.64,355.458C658.509,355.103 659.22,354.658 659.773,354.124C660.347,353.59 660.634,352.8 660.634,351.753C660.634,350.785 660.219,349.955 659.389,349.264C658.579,348.553 657.383,348.009 655.803,347.633C654.144,347.238 652.385,346.872 650.528,346.536C648.691,346.18 646.962,345.736 645.342,345.202C641.628,343.996 638.951,342.366 637.311,340.312C635.691,338.238 634.881,335.669 634.881,332.607C634.881,328.497 636.718,325.149 640.393,322.561C644.088,319.953 648.829,318.649 654.618,318.649C657.522,318.649 660.387,318.936 663.212,319.509C666.057,320.062 668.517,320.764 670.591,321.613L670.591,331.778L669.375,331.778C667.597,330.356 665.414,329.17 662.826,328.222C660.258,327.253 657.63,326.769 654.943,326.769C653.995,326.769 653.047,326.838 652.098,326.976C651.169,327.09 650.27,327.327 649.401,327.687C648.63,327.984 647.969,328.438 647.416,329.05C646.863,329.642 646.586,330.324 646.586,331.094C646.586,332.26 647.031,333.159 647.921,333.791C648.81,334.404 650.489,334.967 652.958,335.481C654.578,335.817 656.129,336.144 657.611,336.46C659.113,336.776 660.723,337.21 662.442,337.763C665.82,338.87 668.309,340.381 669.91,342.298C671.53,344.194 672.34,346.664 672.34,349.706L672.339,349.702ZM703.989,363.572L678.147,363.572L678.147,355.748L685.378,355.748L685.378,327.269L678.147,327.269L678.147,319.445L703.989,319.445L703.989,327.269L696.758,327.269L696.758,355.748L703.989,355.748L703.989,363.572ZM756.176,341.523C756.176,348.557 754.161,354.148 750.13,358.297C746.1,362.426 740.529,364.49 733.416,364.49C726.324,364.49 720.762,362.426 716.732,358.297C712.701,354.148 710.686,348.557 710.686,341.523C710.686,334.431 712.701,328.83 716.732,324.72C720.762,320.591 726.324,318.526 733.416,318.526C740.489,318.526 746.051,320.591 750.101,324.72C754.151,328.83 756.176,334.431 756.176,341.523ZM741.092,352.696C742.198,351.352 743.018,349.772 743.551,347.954C744.085,346.117 744.352,343.963 744.352,341.494C744.352,338.846 744.046,336.594 743.433,334.737C742.82,332.88 742.02,331.378 741.032,330.232C740.024,329.047 738.859,328.188 737.535,327.654C736.232,327.121 734.868,326.855 733.446,326.855C732.004,326.855 730.64,327.112 729.356,327.625C728.092,328.139 726.926,328.988 725.859,330.174C724.872,331.28 724.062,332.811 723.429,334.767C722.816,336.704 722.51,338.956 722.51,341.524C722.51,344.152 722.806,346.394 723.399,348.251C724.012,350.089 724.812,351.59 725.799,352.756C726.787,353.922 727.943,354.781 729.266,355.334C730.59,355.887 731.983,356.164 733.445,356.164C734.907,356.164 736.3,355.887 737.623,355.334C738.947,354.761 740.103,353.881 741.091,352.696L741.092,352.696ZM804.985,363.572L794.02,363.572L775.29,333.285L775.29,363.572L764.859,363.572L764.859,319.445L778.461,319.445L794.553,344.724L794.553,319.445L804.985,319.445L804.985,363.572ZM856.934,364.432C853.655,364.432 850.622,363.947 847.837,362.979C845.071,362.01 842.69,360.568 840.695,358.652C838.699,356.736 837.148,354.345 836.042,351.481C834.955,348.616 834.411,345.307 834.411,341.553C834.411,338.056 834.935,334.885 835.983,332.04C837.03,329.195 838.552,326.755 840.546,324.72C842.463,322.765 844.834,321.253 847.659,320.186C850.504,319.12 853.606,318.586 856.964,318.586C858.821,318.586 860.491,318.695 861.972,318.913C863.474,319.111 864.857,319.378 866.121,319.714C867.445,320.089 868.64,320.514 869.707,320.989C870.794,321.444 871.743,321.869 872.552,322.264L872.552,332.962L871.249,332.962C870.695,332.488 869.994,331.925 869.144,331.273C868.315,330.62 867.366,329.978 866.299,329.346C865.212,328.714 864.037,328.181 862.773,327.746C861.509,327.312 860.155,327.094 858.713,327.094C857.113,327.094 855.591,327.351 854.149,327.865C852.707,328.358 851.373,329.188 850.148,330.354C848.982,331.481 848.034,332.972 847.303,334.829C846.592,336.686 846.237,338.938 846.237,341.586C846.237,344.352 846.622,346.663 847.393,348.52C848.183,350.377 849.171,351.839 850.357,352.906C851.562,353.993 852.906,354.774 854.387,355.247C855.869,355.702 857.331,355.93 858.773,355.93C860.156,355.93 861.519,355.722 862.863,355.307C864.226,354.891 865.48,354.328 866.626,353.617C867.595,353.043 868.494,352.431 869.323,351.78C870.153,351.127 870.834,350.564 871.368,350.09L872.553,350.09L872.553,360.64C871.447,361.134 870.39,361.599 869.382,362.034C868.374,362.468 867.317,362.843 866.211,363.159C864.769,363.575 863.416,363.891 862.151,364.108C860.887,364.325 859.149,364.434 856.935,364.434L856.934,364.432ZM923.821,341.524C923.821,348.557 921.805,354.148 917.775,358.297C913.745,362.426 908.173,364.491 901.061,364.491C893.968,364.491 888.407,362.426 884.377,358.297C880.346,354.148 878.331,348.557 878.331,341.524C878.331,334.431 880.346,328.83 884.377,324.721C888.407,320.592 893.968,318.527 901.061,318.527C908.134,318.527 913.695,320.592 917.746,324.721C921.796,328.83 923.821,334.431 923.821,341.524ZM908.736,352.696C909.843,351.353 910.663,349.772 911.196,347.955C911.73,346.117 911.997,343.964 911.997,341.494C911.997,338.847 911.691,336.595 911.078,334.737C910.465,332.88 909.664,331.379 908.677,330.233C907.669,329.048 906.504,328.188 905.18,327.655C903.876,327.122 902.513,326.856 901.091,326.856C899.648,326.856 898.285,327.112 897.001,327.626C895.737,328.14 894.571,328.989 893.504,330.175C892.517,331.281 891.706,332.812 891.074,334.768C890.461,336.704 890.155,338.956 890.155,341.525C890.155,344.153 890.451,346.395 891.043,348.252C891.656,350.089 892.457,351.591 893.444,352.756C894.432,353.923 895.587,354.782 896.911,355.335C898.235,355.888 899.628,356.164 901.09,356.164C902.552,356.164 903.944,355.888 905.268,355.335C906.592,354.761 907.748,353.882 908.736,352.697L908.736,352.696ZM978.764,363.572L967.443,363.572L967.443,334.026L959.264,353.2L951.411,353.2L943.231,334.026L943.231,363.572L932.504,363.572L932.504,319.446L945.721,319.446L955.648,341.583L965.547,319.446L978.764,319.446L978.764,363.572ZM1021.94,363.572L990.025,363.572L990.025,319.446L1021.94,319.446L1021.94,327.981L1001.35,327.981L1001.35,335.597L1020.46,335.597L1020.46,344.132L1001.35,344.132L1001.35,355.038L1021.94,355.038L1021.94,363.572ZM1066.01,327.981L1052.23,327.981L1052.23,363.572L1040.85,363.572L1040.85,327.981L1027.07,327.981L1027.07,319.446L1066.01,319.446L1066.01,327.981Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;    </g>&#xa;    <g id="text3" transform="matrix(1,0,0,1,-95.3519,-190.196)">&#xa;        <path d="M1089.2,319.918L1084.49,319.918L1084.49,331.546L1082.74,331.546L1082.74,319.918L1078.03,319.918L1078.03,318.36L1089.2,318.36L1089.2,319.918ZM1102.72,331.546L1100.96,331.546L1100.96,320.184L1097.3,327.915L1096.25,327.915L1092.61,320.184L1092.61,331.546L1090.97,331.546L1090.97,318.36L1093.37,318.36L1096.88,325.701L1100.28,318.36L1102.72,318.36L1102.72,331.546Z" style="fill:rgb(31,41,55);fill-rule:nonzero;"/>&#xa;    </g>&#xa;</svg></g><rect x="332.26" y="170" width="125.48" height="30" fill="none" stroke="rgb(0, 0, 0)" pointer-events="all"/></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-18"><g><rect x="305" y="40" width="180" height="100" rx="15" ry="15" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 178px; height: 1px; padding-top: 47px; margin-left: 306px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Comet Physical Plan</div></div></div></foreignObject><image x="306" y="47.5" width="178" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-19"><g><rect x="335" y="70" width="120" height="50" fill="#f5f5f5" stroke="#666666" pointer-events="all"/><path d="M 347 70 L 347 120 M 443 70 L 443 120" fill="none" stroke="#666666" stroke-miterlimit="10" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 94px; height: 1px; padding-top: 95px; margin-left: 348px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">protobuf intermediate representation</div></div></div></foreignObject><image x="348" y="74.5" width="94" height="45" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-20"><g><g><svg width="143.03" height="30" viewBox="0 0 801 168" fill="none" xmlns="http://www.w3.org/2000/svg" x="322.98" y="263.1" style="font-family: initial;">&#xa;<g clip-path="url(#clip0_1_181)">&#xa;<path fill-rule="evenodd" clip-rule="evenodd" d="M76.1297 168C88.4597 168 99.6097 158.25 107.58 142.55C127.23 144.6 143.09 139.99 149.76 128.51C156.29 117.25 152.65 101.68 141.58 86.09C152.36 70.67 155.85 55.32 149.39 44.19C143.01 33.19 128.19 28.5 109.69 29.92C101.65 11.62 89.5997 0 76.1297 0C62.6597 0 50.4997 11.73 42.4497 30.18C24.3497 28.97 9.87966 33.68 3.59966 44.51C-2.81034 55.56 0.589656 70.78 11.1897 86.09C0.299656 101.57 -3.24034 117.01 3.23966 128.18C9.80966 139.5 25.3097 144.13 44.5597 142.31C52.5397 158.15 63.7297 168 76.1297 168ZM52.7197 141.19C59.5097 154.21 68.6197 162.18 78.6397 162.18C88.6597 162.18 97.6397 154.63 104.76 142.22C95.7497 141.01 86.0297 138.46 76.0797 134.58C68.0497 137.65 60.1797 139.86 52.7197 141.19ZM65.0697 129.77C59.6397 131.52 54.3497 132.84 49.3097 133.72C47.3697 128.87 45.6997 123.54 44.3597 117.82C47.6797 120.07 51.1497 122.25 54.7497 124.32C58.1797 126.29 61.6197 128.11 65.0597 129.77H65.0697ZM76.1197 125.68C82.0597 123.2 88.0897 120.24 94.0797 116.79C102.76 111.8 110.61 106.25 117.41 100.43C118.01 95.13 118.33 89.64 118.33 84C118.33 76.79 117.81 69.8 116.84 63.17C111.11 58.53 104.73 54.12 97.7797 50.13C90.5497 45.98 83.2397 42.57 76.0697 39.91C69.1797 42.52 62.1597 45.82 55.2197 49.81C50.8597 52.32 46.7097 54.99 42.8197 57.78C41.3997 65.98 40.6297 74.8 40.6297 84C40.6297 91.65 41.1597 99.05 42.1597 106.04C47.2997 109.94 52.9197 113.66 58.9297 117.12C64.6597 120.41 70.4297 123.27 76.1197 125.68ZM87.1297 129.83C90.8397 128.07 94.5497 126.12 98.2497 124C104.42 120.45 110.18 116.61 115.48 112.58C113.79 120.73 111.42 128.22 108.52 134.76C101.82 133.95 94.6097 132.3 87.1297 129.83ZM117.71 110.84C116.16 119.65 113.87 127.8 110.98 135.03C127.49 136.56 140.52 132.79 145.95 123.44C151.17 114.43 148.57 101.58 140 88.28C134.26 96.01 126.71 103.7 117.71 110.84ZM136.56 79.61C145.46 66.59 148.33 53.99 143.08 44.93C137.99 36.16 126.02 31.96 110.76 32.43C114.3 41.14 116.97 51.23 118.5 62.2C125.46 67.76 131.53 73.64 136.55 79.61H136.56ZM108.21 32.55C111.86 40.6 114.7 50.11 116.43 60.57C110.98 56.37 105.01 52.37 98.6097 48.69C91.9597 44.87 85.2397 41.62 78.6197 38.96C89.0597 35.24 99.1497 33.11 108.2 32.54L108.21 32.55ZM107.08 30.16C97.4397 31.18 86.8897 33.79 76.0797 37.98C67.2997 34.65 58.7097 32.35 50.6497 31.1C57.5997 15.56 67.5697 5.83 78.6397 5.83C89.7097 5.83 99.7197 15.18 107.08 30.16ZM73.5197 38.99C65.2297 36.1 57.1697 34.21 49.6897 33.32C46.9897 39.84 44.7997 47.28 43.2497 55.38C46.7897 52.94 50.4997 50.6 54.3797 48.37C60.7497 44.71 67.1697 41.58 73.5197 38.99ZM33.7197 62.5C35.2297 51.54 37.8697 41.46 41.3797 32.74C26.5297 32.46 14.9097 36.66 9.91966 45.26C4.70966 54.24 7.48966 66.68 16.1997 79.58C21.0897 73.73 26.9797 67.96 33.7197 62.5ZM12.7697 88.3C18.3697 95.9 25.7197 103.48 34.4997 110.54C36.0297 119.36 38.3097 127.53 41.1797 134.78C25.0597 136.11 12.3797 132.31 7.03966 123.12C1.85966 114.19 4.36966 101.48 12.7597 88.31L12.7697 88.3ZM17.5697 81.54C21.9097 75.99 27.2197 70.45 33.3797 65.17C32.6597 71.22 32.2697 77.53 32.2697 84C32.2697 88.91 32.4897 93.72 32.9097 98.4C26.7997 92.89 21.6197 87.18 17.5597 81.53L17.5697 81.54ZM135.19 81.55C131 87.32 125.65 93.15 119.32 98.76C119.76 93.97 120 89.03 120 84C120 77.41 119.6 70.99 118.85 64.84C125.22 70.21 130.72 75.87 135.19 81.55Z" fill="url(#paint0_linear_1_181)"/>&#xa;<path d="M204.34 45.97H192.83L190.47 52.2H185.2L196.07 23.88H201.47L212.54 52.2H206.78L204.34 45.97ZM202.74 41.74L198.54 30.99L194.46 41.74H202.73H202.74Z" fill="#1F2937"/>&#xa;<path d="M235.55 23.88H246.82C249.59 23.88 251.9 24.73 253.73 26.44C255.57 28.14 256.49 30.38 256.49 33.15C256.49 35.92 255.57 38.2 253.73 39.9C251.89 41.6 249.59 42.46 246.82 42.46H240.95V52.21H235.56V23.89L235.55 23.88ZM240.94 37.26H246.85C248 37.26 248.96 36.87 249.73 36.1C250.5 35.3 250.89 34.32 250.89 33.14C250.89 31.96 250.5 31 249.73 30.22C248.98 29.45 248.02 29.06 246.85 29.06H240.94V37.25V37.26Z" fill="#1F2937"/>&#xa;<path d="M293.67 45.97H282.16L279.8 52.2H274.53L285.4 23.88H290.79L301.86 52.2H296.1L293.66 45.97H293.67ZM292.07 41.74L287.87 30.99L283.79 41.74H292.06H292.07Z" fill="#1F2937"/>&#xa;<path d="M335.99 23C338.57 23 340.92 23.68 343.02 25.04C345.15 26.37 346.84 28.18 348.1 30.47L343.1 32.87C341.37 29.57 339 27.92 335.99 27.92C333.62 27.92 331.65 28.91 330.07 30.88C328.53 32.82 327.75 35.22 327.75 38.07C327.75 40.92 328.52 43.32 330.07 45.26C331.62 47.18 333.59 48.14 335.99 48.14C337.45 48.14 338.81 47.73 340.07 46.9C341.32 46.05 342.32 44.93 343.07 43.54L347.99 45.9C346.79 48.14 345.13 49.89 342.99 51.17C340.86 52.42 338.53 53.05 336 53.05C331.95 53.05 328.63 51.65 326.05 48.86C323.47 46.04 322.17 42.44 322.17 38.07C322.17 33.7 323.48 30.13 326.09 27.28C328.73 24.43 332.03 23.01 336 23.01L335.99 23Z" fill="#1F2937"/>&#xa;<path d="M393.49 52.2H388.09V40.61H377.1V52.2H371.71V23.88H377.1V35.43H388.09V23.88H393.49V52.2Z" fill="#1F2937"/>&#xa;<path d="M435.17 29.07H423.9V35.46H432.41V40.65H423.9V47H435.17V52.19H418.51V23.87H435.17V29.06V29.07Z" fill="#1F2937"/>&#xa;<path d="M185 76.1H207.25C218.63 76.1 227.58 79.3 234.1 85.69C240.69 92.02 243.98 100.14 243.98 110.04C243.98 119.94 240.69 128.1 234.1 134.49C227.51 140.88 218.53 144.08 207.15 144.08H184.99V76.1H185ZM199.96 90.49V129.7H206.67C209.55 129.7 212.2 129.38 214.63 128.74C217.12 128.1 219.43 127.08 221.54 125.67C223.71 124.26 225.41 122.25 226.62 119.63C227.83 116.95 228.44 113.75 228.44 110.04C228.44 106.33 227.83 103.17 226.62 100.55C225.4 97.93 223.71 95.92 221.54 94.51C219.43 93.1 217.16 92.08 214.73 91.44C212.3 90.8 209.61 90.48 206.67 90.48H199.96V90.49Z" fill="#1F2937"/>&#xa;<path d="M291.82 130.85H264.96L259.97 144.08H245.39L271.38 76.1H286.34L312.91 144.08H296.89L291.81 130.85H291.82ZM287.4 119.35L278.29 95.76L269.37 119.35H287.4Z" fill="#1F2937"/>&#xa;<path d="M362.7 90.49H342.94V144.09H327.98V90.49H308.51V76.11H362.7V90.49Z" fill="#1F2937"/>&#xa;<path d="M404.77 130.85H377.92L372.93 144.08H358.35L384.34 76.1H399.3L425.87 144.08H409.85L404.77 130.85ZM400.36 119.35L391.25 95.76L382.33 119.35H400.36Z" fill="#1F2937"/>&#xa;<path d="M474.73 90.49H448.45V102.95H468.4V117.33H448.45V144.08H433.49V76.1H474.73V90.48V90.49Z" fill="#1F2937"/>&#xa;<path d="M541.71 76.1V118.96C541.65 127.27 538.96 133.85 533.65 138.71C528.41 143.57 521.53 146 513.03 146C504.53 146 497.78 143.57 492.41 138.71C487.04 133.85 484.39 127.27 484.45 118.96V76.1H499.32V119.05C499.32 122.88 500.6 125.95 503.16 128.25C505.78 130.49 509.08 131.61 513.04 131.61C517 131.61 520.27 130.49 522.82 128.25C525.38 125.95 526.69 122.88 526.75 119.05V76.1H541.71Z" fill="#1F2937"/>&#xa;<path d="M578.69 73.99C585.72 73.99 591.96 75.59 597.39 78.78L590.77 91.24C585.98 89.19 581.43 88.17 577.15 88.17C570.95 88.17 567.85 90.25 567.85 94.4C567.85 96.45 569.03 98.17 571.4 99.58C573.83 100.92 577.28 102.39 581.76 103.99C586.3 105.52 589.72 106.96 592.02 108.3C598.22 111.88 601.32 117.25 601.32 124.41C601.32 131.12 598.86 136.4 593.93 140.23C589.01 144.07 582.87 145.98 575.52 145.98C571.36 145.98 567.05 145.21 562.57 143.68C558.09 142.15 554.61 140.39 552.12 138.41L560.18 126.43C567.02 130.46 573.22 132.21 578.79 131.7C580.96 131.51 582.76 130.74 584.16 129.4C585.63 128.06 586.24 126.43 585.98 124.51C585.72 122.72 584.22 121.25 581.47 120.1C578.72 118.89 575.14 117.48 570.73 115.88C566.38 114.28 562.83 112.4 560.08 110.22C555.03 106.13 552.5 101.05 552.5 94.98C552.5 91.98 553.01 89.26 554.03 86.83C555.05 84.4 556.4 82.42 558.06 80.89C559.79 79.29 561.8 77.98 564.1 76.96C566.4 75.87 568.77 75.11 571.2 74.66C573.63 74.21 576.12 73.99 578.68 73.99H578.69Z" fill="#1F2937"/>&#xa;<path d="M626.79 144.08H611.83V76.1H626.79V144.08Z" fill="#1F2937"/>&#xa;<path d="M647.04 84.16C653.88 77.38 662.48 74 672.84 74C683.2 74 691.73 77.39 698.45 84.16C705.23 90.87 708.62 99.4 708.62 109.76C708.62 120.12 705.33 128.68 698.74 135.45C692.15 142.16 683.52 145.68 672.84 146C662.48 146 653.88 142.58 647.04 135.74C640.26 128.84 636.87 120.21 636.87 109.85C636.87 99.49 640.26 90.93 647.04 84.15V84.16ZM672.84 87.61C666.64 87.61 661.68 89.69 657.97 93.84C654.26 97.99 652.41 103.3 652.41 109.76C652.41 116.22 654.26 121.62 657.97 125.96C661.74 130.24 666.7 132.38 672.84 132.38C678.98 132.38 683.96 130.24 687.61 125.96C691.25 121.68 693.08 116.31 693.08 109.85C693.08 103.39 691.26 98.12 687.61 94.03C684.03 89.88 679.11 87.73 672.84 87.61Z" fill="#1F2937"/>&#xa;<path d="M775 144.08H759.65L732.7 101.99V144.08H718.7V76.1H732.99L761 118.57V76.1H775V144.08Z" fill="#1F2937"/>&#xa;<path d="M788.01 78.18H784.62V87.44H782.46V78.18H779.13V76.1H788.01V78.18ZM800.56 87.45H798.48V80.17L795.5 85.79H794.12L791.14 80.17L791.12 87.45H789.1V76.11H791.13L794.87 83.04L798.45 76.11H800.51L800.53 87.45H800.56Z" fill="#1F2937"/>&#xa;</g>&#xa;<defs>&#xa;<linearGradient id="paint0_linear_1_181" x1="17.0897" y1="117.74" x2="162.73" y2="36.78" gradientUnits="userSpaceOnUse">&#xa;<stop stop-color="#EF4137"/>&#xa;<stop offset="1" stop-color="#FBB042"/>&#xa;</linearGradient>&#xa;<clipPath id="clip0_1_181">&#xa;<rect width="800.56" height="168" fill="white"/>&#xa;</clipPath>&#xa;</defs>&#xa;</svg></g></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-21"><g><image x="359.5" y="293.1" width="70" height="36.4" xlink:href="data:image/png;base64,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" preserveAspectRatio="none"/></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-22"><g><path d="M 389.5 140.5 L 399.5 140.5 L 399.5 150.5 L 410 150.5 L 394.5 169.5 L 379 150.5 L 389.5 150.5 Z" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-23"><g><path d="M 390 200.5 L 400 200.5 L 400 210.5 L 410.5 210.5 L 395 229.5 L 379.5 210.5 L 390 210.5 Z" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-24"><g><path d="M 389.5 330.5 L 399.5 330.5 L 399.5 340.5 L 410 340.5 L 394.5 359.5 L 379 340.5 L 389.5 340.5 Z" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="t5OBkkhKOG6cYtw1sPyQ-25"><g><rect x="310" y="360" width="170" height="50" fill="#f5f5f5" stroke="#666666" pointer-events="all"/><path d="M 327 360 L 327 410 M 463 360 L 463 410" fill="none" stroke="#666666" stroke-miterlimit="10" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 134px; height: 1px; padding-top: 385px; margin-left: 328px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Shuffle Files</div></div></div></foreignObject><image x="328" y="378.5" width="134" height="17" xlink:href="data:image/png;base64,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"/></switch></g></g></g></g></g></g></svg>
\ No newline at end of file
diff --git a/docs/source/_static/images/comet-dataflow.excalidraw b/docs/source/_static/images/comet-dataflow.excalidraw
new file mode 100644
index 0000000000..dd12099834
--- /dev/null
+++ b/docs/source/_static/images/comet-dataflow.excalidraw
@@ -0,0 +1,2134 @@
+{
+  "type": "excalidraw",
+  "version": 2,
+  "source": "https://excalidraw.com",
+  "elements": [
+    {
+      "id": "dDrwaYB6MkVSDP_FHWS-F",
+      "type": "rectangle",
+      "x": 825.6666870117188,
+      "y": 116.83334350585938,
+      "width": 321.9999999999999,
+      "height": 324,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#ffd8a8",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "Zz",
+      "roundness": {
+        "type": 3
+      },
+      "seed": 1163356465,
+      "version": 243,
+      "versionNonce": 743550265,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "id": "u84B3vp5oTVNXI5uXsZ-r",
+          "type": "arrow"
+        },
+        {
+          "id": "dlyj3Gno71fx16oqbbjXF",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1733167126280,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "8pVcXTnP3tefe_O3kTE0b",
+      "type": "text",
+      "x": 467.66668701171875,
+      "y": 48.833343505859375,
+      "width": 61,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "dotted",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "aS",
+      "roundness": null,
+      "seed": 306458015,
+      "version": 181,
+      "versionNonce": 110788633,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167570417,
+      "link": null,
+      "locked": false,
+      "text": "JVM",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "JVM",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "Ax7J0LoYh5TwQoRBM47cz",
+      "type": "text",
+      "x": 941.6666870117188,
+      "y": 56.833343505859375,
+      "width": 97,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "dotted",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "aT",
+      "roundness": null,
+      "seed": 1762016049,
+      "version": 173,
+      "versionNonce": 1117284823,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167564367,
+      "link": null,
+      "locked": false,
+      "text": "Native",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "Native",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "lSUrwgLq2W49ULouPfm0h",
+      "type": "rectangle",
+      "x": 868.1666870117188,
+      "y": 168.83334350585938,
+      "width": 245.00000000000006,
+      "height": 83.99999999999997,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "aU",
+      "roundness": {
+        "type": 3
+      },
+      "seed": 1188956881,
+      "version": 337,
+      "versionNonce": 502265527,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "M6A-P7jOlvlDx-Kc0nsrQ"
+        },
+        {
+          "id": "MqWIMNh5n51EVvWedfTIA",
+          "type": "arrow"
+        },
+        {
+          "id": "GPIY241P4rRnRn48VdbYe",
+          "type": "arrow"
+        },
+        {
+          "id": "6KmKXuc4aon2_yKt2fdZE",
+          "type": "arrow"
+        },
+        {
+          "id": "ou2srC_Up4kjWcmgzdEH4",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1733167585167,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "M6A-P7jOlvlDx-Kc0nsrQ",
+      "type": "text",
+      "x": 903.4791870117188,
+      "y": 198.33334350585938,
+      "width": 174.375,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "aV",
+      "roundness": null,
+      "seed": 1968605361,
+      "version": 333,
+      "versionNonce": 1113091385,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733166946960,
+      "link": null,
+      "locked": false,
+      "text": "ShuffleWriterExec",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "lSUrwgLq2W49ULouPfm0h",
+      "originalText": "ShuffleWriterExec",
+      "autoResize": true,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "GHKyE6o_at1-J0KO1mWpt",
+      "type": "rectangle",
+      "x": 363.85928382109046,
+      "y": 505.8341459769945,
+      "width": 262.9999999999998,
+      "height": 93.99611799705886,
+      "angle": 0.003703686768755432,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#a5d8ff",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "aa",
+      "roundness": {
+        "type": 3
+      },
+      "seed": 952999857,
+      "version": 632,
+      "versionNonce": 906119703,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "yHFb7s7QYOWZst8xXlFG2"
+        },
+        {
+          "id": "Jd5Fqfx6eFl_OJ6x0TUki",
+          "type": "arrow"
+        },
+        {
+          "id": "7KEns52XY_jok50o5G5op",
+          "type": "arrow"
+        },
+        {
+          "id": "quv5xELoqOR6W5SJipUrY",
+          "type": "arrow"
+        },
+        {
+          "id": "kQzva6A57whXeUyhhNxOl",
+          "type": "arrow"
+        },
+        {
+          "id": "Pjo3gnqBVibIixMHpFvkK",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1733167372550,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "yHFb7s7QYOWZst8xXlFG2",
+      "type": "text",
+      "x": 399.93428382109033,
+      "y": 540.3322049755238,
+      "width": 190.85000000000002,
+      "height": 25,
+      "angle": 0.003703686768755432,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#a5d8ff",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "ab",
+      "roundness": null,
+      "seed": 1354040959,
+      "version": 598,
+      "versionNonce": 226422583,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167372550,
+      "link": null,
+      "locked": false,
+      "text": "CometExecIterator",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "GHKyE6o_at1-J0KO1mWpt",
+      "originalText": "CometExecIterator",
+      "autoResize": true,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "Iv4y4lEpq-EOkw5bBAWNA",
+      "type": "text",
+      "x": 930.6666870117188,
+      "y": 130.83334350585938,
+      "width": 109.9000015258789,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#ffd8a8",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b06",
+      "roundness": null,
+      "seed": 952057055,
+      "version": 92,
+      "versionNonce": 52977177,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733166946960,
+      "link": null,
+      "locked": false,
+      "text": "Native Plan",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "Native Plan",
+      "autoResize": true,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "Ro2R78aPw-luRF_bB2EKU",
+      "type": "rectangle",
+      "x": 366.34678047371074,
+      "y": 307.83595662631933,
+      "width": 262.99999999999983,
+      "height": 92.00353907094141,
+      "angle": 0.003703686768755432,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#a5d8ff",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0g",
+      "roundness": {
+        "type": 3
+      },
+      "seed": 959895479,
+      "version": 644,
+      "versionNonce": 1083149527,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "twg3z-vK6jWmVl4xySGde"
+        },
+        {
+          "id": "u84B3vp5oTVNXI5uXsZ-r",
+          "type": "arrow"
+        },
+        {
+          "id": "IISSP3sEmCbjsvI4SFgaX",
+          "type": "arrow"
+        },
+        {
+          "id": "7KEns52XY_jok50o5G5op",
+          "type": "arrow"
+        },
+        {
+          "id": "quv5xELoqOR6W5SJipUrY",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1733167372551,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "twg3z-vK6jWmVl4xySGde",
+      "type": "text",
+      "x": 396.18428047371066,
+      "y": 341.33772616179004,
+      "width": 203.32500000000002,
+      "height": 25,
+      "angle": 0.003703686768755432,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#a5d8ff",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0h",
+      "roundness": null,
+      "seed": 34654423,
+      "version": 631,
+      "versionNonce": 1121311223,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167372551,
+      "link": null,
+      "locked": false,
+      "text": "CometBatchIterator",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "Ro2R78aPw-luRF_bB2EKU",
+      "originalText": "CometBatchIterator",
+      "autoResize": true,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "macb6DKtgx8DhcqjKk6no",
+      "type": "rectangle",
+      "x": 366.1634633724364,
+      "y": 157.33528450732996,
+      "width": 262.9999999999998,
+      "height": 93.99611799705886,
+      "angle": 0.003703686768755432,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#a5d8ff",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0i",
+      "roundness": {
+        "type": 3
+      },
+      "seed": 1827361271,
+      "version": 674,
+      "versionNonce": 1149488599,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "HzfSeR8C3p6yYRHlGGIdM"
+        },
+        {
+          "id": "dlyj3Gno71fx16oqbbjXF",
+          "type": "arrow"
+        },
+        {
+          "id": "MqWIMNh5n51EVvWedfTIA",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1733167385065,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "HzfSeR8C3p6yYRHlGGIdM",
+      "type": "text",
+      "x": 402.2384633724363,
+      "y": 191.83334350585938,
+      "width": 190.85000000000002,
+      "height": 25,
+      "angle": 0.003703686768755432,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#a5d8ff",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0j",
+      "roundness": null,
+      "seed": 901511959,
+      "version": 643,
+      "versionNonce": 1747825847,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167372551,
+      "link": null,
+      "locked": false,
+      "text": "CometExecIterator",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "macb6DKtgx8DhcqjKk6no",
+      "originalText": "CometExecIterator",
+      "autoResize": true,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "7VTYHzsqQvUuKMy0ShKZn",
+      "type": "rectangle",
+      "x": 871.1634633724364,
+      "y": 304.3333435058594,
+      "width": 245.00000000000006,
+      "height": 83.99999999999997,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0k",
+      "roundness": {
+        "type": 3
+      },
+      "seed": 1785572407,
+      "version": 379,
+      "versionNonce": 1216788985,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "YKETugAZBRtG7oeas8CPz"
+        },
+        {
+          "id": "IISSP3sEmCbjsvI4SFgaX",
+          "type": "arrow"
+        },
+        {
+          "id": "u84B3vp5oTVNXI5uXsZ-r",
+          "type": "arrow"
+        },
+        {
+          "id": "GPIY241P4rRnRn48VdbYe",
+          "type": "arrow"
+        },
+        {
+          "id": "6KmKXuc4aon2_yKt2fdZE",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1733167417649,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "YKETugAZBRtG7oeas8CPz",
+      "type": "text",
+      "x": 947.8009641353758,
+      "y": 333.8333435058594,
+      "width": 91.7249984741211,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0l",
+      "roundness": null,
+      "seed": 2121862487,
+      "version": 357,
+      "versionNonce": 1828219865,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733166946960,
+      "link": null,
+      "locked": false,
+      "text": "ScanExec",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "7VTYHzsqQvUuKMy0ShKZn",
+      "originalText": "ScanExec",
+      "autoResize": true,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "_a8_bfztXdYiD4AXJxPee",
+      "type": "rectangle",
+      "x": 820.6634633724364,
+      "y": 473.3333435058594,
+      "width": 334.9999999999999,
+      "height": 329,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#ffd8a8",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0m",
+      "roundness": {
+        "type": 3
+      },
+      "seed": 1577231703,
+      "version": 409,
+      "versionNonce": 1832634263,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "id": "kQzva6A57whXeUyhhNxOl",
+          "type": "arrow"
+        },
+        {
+          "id": "Pjo3gnqBVibIixMHpFvkK",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1733167465343,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "aiAipugp154jY5IgHqjTm",
+      "type": "rectangle",
+      "x": 862.1634633724364,
+      "y": 535.3333435058594,
+      "width": 245.00000000000006,
+      "height": 83.99999999999997,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0n",
+      "roundness": {
+        "type": 3
+      },
+      "seed": 1666310775,
+      "version": 392,
+      "versionNonce": 1164820153,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "XPpjuVi7ZYpwo3X03G9P1"
+        },
+        {
+          "id": "Pjo3gnqBVibIixMHpFvkK",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1733167345582,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "XPpjuVi7ZYpwo3X03G9P1",
+      "type": "text",
+      "x": 924.6759633724364,
+      "y": 564.8333435058594,
+      "width": 119.97500000000001,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0o",
+      "roundness": null,
+      "seed": 838630295,
+      "version": 403,
+      "versionNonce": 1508263831,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733166982872,
+      "link": null,
+      "locked": false,
+      "text": "ProjectExec",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "aiAipugp154jY5IgHqjTm",
+      "originalText": "ProjectExec",
+      "autoResize": true,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "aE2QBjfmrpzBTUB_t6QRY",
+      "type": "text",
+      "x": 924.6634633724364,
+      "y": 497.3333435058594,
+      "width": 109.9000015258789,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#ffd8a8",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0p",
+      "roundness": null,
+      "seed": 1043787959,
+      "version": 150,
+      "versionNonce": 1187544183,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733166977658,
+      "link": null,
+      "locked": false,
+      "text": "Native Plan",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "Native Plan",
+      "autoResize": true,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "vG9tTZvROj2ybA4oAS_bb",
+      "type": "rectangle",
+      "x": 864.160239733154,
+      "y": 671.8333435058594,
+      "width": 245.00000000000006,
+      "height": 83.99999999999997,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0q",
+      "roundness": {
+        "type": 3
+      },
+      "seed": 27640279,
+      "version": 529,
+      "versionNonce": 1105701913,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "oWkZozTacCvv40wRG7g3s"
+        }
+      ],
+      "updated": 1733167462816,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "oWkZozTacCvv40wRG7g3s",
+      "type": "text",
+      "x": 978.160239733154,
+      "y": 701.3333435058594,
+      "width": 17,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0r",
+      "roundness": null,
+      "seed": 1297968887,
+      "version": 526,
+      "versionNonce": 271368441,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167462816,
+      "link": null,
+      "locked": false,
+      "text": "...",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "vG9tTZvROj2ybA4oAS_bb",
+      "originalText": "...",
+      "autoResize": true,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "kQzva6A57whXeUyhhNxOl",
+      "type": "arrow",
+      "x": 627.9453883765393,
+      "y": 529.8293445331748,
+      "width": 192.71807499589704,
+      "height": 0.234522891430629,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0w",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 562773463,
+      "version": 217,
+      "versionNonce": 611157943,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167475920,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          192.71807499589704,
+          0.234522891430629
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "GHKyE6o_at1-J0KO1mWpt",
+        "focus": -0.48947127224675757,
+        "gap": 1,
+        "fixedPoint": null
+      },
+      "endBinding": {
+        "elementId": "C3-eUJazhRorbXp9Um-Mo",
+        "focus": -1.9941089907787155,
+        "gap": 12.73052391874603,
+        "fixedPoint": null
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "Pjo3gnqBVibIixMHpFvkK",
+      "type": "arrow",
+      "x": 861.6634633724364,
+      "y": 571.3333435058594,
+      "width": 233.87028528948713,
+      "height": 0.4072197033743805,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0y",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 189975865,
+      "version": 190,
+      "versionNonce": 1899895735,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167372551,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          -233.87028528948713,
+          -0.4072197033743805
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "aiAipugp154jY5IgHqjTm",
+        "focus": 0.1262072643242283,
+        "gap": 1,
+        "fixedPoint": null
+      },
+      "endBinding": {
+        "elementId": "GHKyE6o_at1-J0KO1mWpt",
+        "focus": 0.37801089214584216,
+        "gap": 1,
+        "fixedPoint": null
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "u84B3vp5oTVNXI5uXsZ-r",
+      "type": "arrow",
+      "x": 867.6634633724364,
+      "y": 335.3333435058594,
+      "width": 235.9983810536769,
+      "height": 0.5628844927418868,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b0z",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 849585047,
+      "version": 139,
+      "versionNonce": 2098561815,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167372551,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          -235.9983810536769,
+          0.5628844927418868
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "7VTYHzsqQvUuKMy0ShKZn",
+        "focus": 0.261904761904762,
+        "gap": 3.5,
+        "fixedPoint": null
+      },
+      "endBinding": {
+        "elementId": "Ro2R78aPw-luRF_bB2EKU",
+        "focus": -0.3765315568105985,
+        "gap": 2.2509344960505473,
+        "fixedPoint": null
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "IISSP3sEmCbjsvI4SFgaX",
+      "type": "arrow",
+      "x": 630.6644917368169,
+      "y": 368.0556851230956,
+      "width": 238.99897163561945,
+      "height": 0.7223416172362249,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b12",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 1980422201,
+      "version": 131,
+      "versionNonce": 1606617143,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167372551,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          238.99897163561945,
+          -0.7223416172362249
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "Ro2R78aPw-luRF_bB2EKU",
+        "focus": 0.31181090317651905,
+        "gap": 1.3694590603334404,
+        "fixedPoint": null
+      },
+      "endBinding": {
+        "elementId": "7VTYHzsqQvUuKMy0ShKZn",
+        "focus": -0.5000000000000002,
+        "gap": 1.5,
+        "fixedPoint": null
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "7KEns52XY_jok50o5G5op",
+      "type": "arrow",
+      "x": 437.66346337243635,
+      "y": 399.3333435058594,
+      "width": 4,
+      "height": 104,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b13",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 1651841465,
+      "version": 252,
+      "versionNonce": 1005623161,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167373032,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          4,
+          104
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "Ro2R78aPw-luRF_bB2EKU",
+        "focus": 0.46419678699387723,
+        "gap": 1,
+        "fixedPoint": null
+      },
+      "endBinding": {
+        "elementId": "GHKyE6o_at1-J0KO1mWpt",
+        "focus": -0.3880655447790852,
+        "gap": 2.3015909311958467,
+        "fixedPoint": null
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "quv5xELoqOR6W5SJipUrY",
+      "type": "arrow",
+      "x": 555.6634633724364,
+      "y": 503.3333435058594,
+      "width": 0,
+      "height": 103,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b14",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 1677615735,
+      "version": 236,
+      "versionNonce": 55168313,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167373032,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          0,
+          -103
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "GHKyE6o_at1-J0KO1mWpt",
+        "focus": 0.4579838276843583,
+        "gap": 2.723810257547825,
+        "fixedPoint": null
+      },
+      "endBinding": {
+        "elementId": "Ro2R78aPw-luRF_bB2EKU",
+        "focus": -0.43910468547182224,
+        "gap": 1,
+        "fixedPoint": null
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "dlyj3Gno71fx16oqbbjXF",
+      "type": "arrow",
+      "x": 632.6636522386541,
+      "y": 181.2823496270506,
+      "width": 193.99981113378226,
+      "height": 0.9490061211912177,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b15",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 1072669367,
+      "version": 132,
+      "versionNonce": 1271110743,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167393399,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          193.99981113378226,
+          -0.9490061211912177
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "macb6DKtgx8DhcqjKk6no",
+        "focus": -0.4652381310069499,
+        "gap": 3.4138894826694752,
+        "fixedPoint": null
+      },
+      "endBinding": {
+        "elementId": "OFwuou30qsm3aMZ96ASUO",
+        "focus": -1.5667144994299218,
+        "gap": 7.5,
+        "fixedPoint": null
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "C3-eUJazhRorbXp9Um-Mo",
+      "type": "text",
+      "x": 664.6634633724364,
+      "y": 492.3333435058594,
+      "width": 189,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b16",
+      "roundness": null,
+      "seed": 755500537,
+      "version": 76,
+      "versionNonce": 1747049559,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "id": "kQzva6A57whXeUyhhNxOl",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1733167475516,
+      "link": null,
+      "locked": false,
+      "text": "executePlan()",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "executePlan()",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "OFwuou30qsm3aMZ96ASUO",
+      "type": "text",
+      "x": 669.1634633724364,
+      "y": 147.83334350585938,
+      "width": 189,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b17",
+      "roundness": null,
+      "seed": 1806263479,
+      "version": 124,
+      "versionNonce": 1646888249,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "id": "dlyj3Gno71fx16oqbbjXF",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1733167389568,
+      "link": null,
+      "locked": false,
+      "text": "executePlan()",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "executePlan()",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "2ZoBSXI-amAjEfzxoQ17b",
+      "type": "text",
+      "x": 749.1634633724364,
+      "y": 308.8333435058594,
+      "width": 111,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b18",
+      "roundness": null,
+      "seed": 1238305721,
+      "version": 97,
+      "versionNonce": 1368434199,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167188224,
+      "link": null,
+      "locked": false,
+      "text": "next()",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "next()",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "1-lAVH11BDSwJVoMYl80T",
+      "type": "text",
+      "x": 371.16346337243635,
+      "y": 439.8333435058594,
+      "width": 111,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b19",
+      "roundness": null,
+      "seed": 756108375,
+      "version": 211,
+      "versionNonce": 161358135,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167372551,
+      "link": null,
+      "locked": false,
+      "text": "next()",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "next()",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "VFm7kotI1oNa1rIxLMh6W",
+      "type": "text",
+      "x": 676.6634633724364,
+      "y": 376.3333435058594,
+      "width": 147,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1A",
+      "roundness": null,
+      "seed": 1623222905,
+      "version": 76,
+      "versionNonce": 1030050969,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167271120,
+      "link": null,
+      "locked": false,
+      "text": "exportBatch()",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "exportBatch()",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "LZtRekUnAEPkjsECzd7zb",
+      "type": "text",
+      "x": 663.6634633724364,
+      "y": 575.3333435058594,
+      "width": 217,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1B",
+      "roundness": null,
+      "seed": 187512855,
+      "version": 127,
+      "versionNonce": 1917573399,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167377483,
+      "link": null,
+      "locked": false,
+      "text": "importVectors()",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "importVectors()",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "MqWIMNh5n51EVvWedfTIA",
+      "type": "arrow",
+      "x": 868.6634633724364,
+      "y": 220.33334350585938,
+      "width": 239,
+      "height": 1,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1C",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 685490007,
+      "version": 35,
+      "versionNonce": 652639415,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167385065,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          -239,
+          1
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "lSUrwgLq2W49ULouPfm0h",
+        "focus": -0.2114558118557865,
+        "gap": 1,
+        "fixedPoint": null
+      },
+      "endBinding": {
+        "elementId": "macb6DKtgx8DhcqjKk6no",
+        "focus": 0.3654122251883526,
+        "gap": 1,
+        "fixedPoint": null
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "RYdCN0xyvNHqlA1WDARNx",
+      "type": "text",
+      "x": 670.1634633724364,
+      "y": 225.83334350585938,
+      "width": 217,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1D",
+      "roundness": null,
+      "seed": 546285145,
+      "version": 165,
+      "versionNonce": 1950128183,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167400420,
+      "link": null,
+      "locked": false,
+      "text": "importVectors()",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "importVectors()",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "GPIY241P4rRnRn48VdbYe",
+      "type": "arrow",
+      "x": 941.6634633724364,
+      "y": 264.3333435058594,
+      "width": 2,
+      "height": 32,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1E",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 1958688375,
+      "version": 17,
+      "versionNonce": 1070980535,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167413149,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          2,
+          32
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "lSUrwgLq2W49ULouPfm0h",
+        "focus": 0.4183574316825765,
+        "gap": 11.500000000000014,
+        "fixedPoint": null
+      },
+      "endBinding": {
+        "elementId": "7VTYHzsqQvUuKMy0ShKZn",
+        "focus": -0.37462537462537454,
+        "gap": 8,
+        "fixedPoint": null
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "6KmKXuc4aon2_yKt2fdZE",
+      "type": "arrow",
+      "x": 1052.6634633724364,
+      "y": 290.3333435058594,
+      "width": 1,
+      "height": 30,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1F",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 1971585785,
+      "version": 15,
+      "versionNonce": 1869550297,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167417649,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          -1,
+          -30
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "7VTYHzsqQvUuKMy0ShKZn",
+        "focus": 0.4912563895614742,
+        "gap": 14,
+        "fixedPoint": null
+      },
+      "endBinding": {
+        "elementId": "lSUrwgLq2W49ULouPfm0h",
+        "focus": -0.4789893168742339,
+        "gap": 7.500000000000014,
+        "fixedPoint": null
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "0HMrFdchM3CqZB7BeDX-8",
+      "type": "text",
+      "x": 866.1634633724364,
+      "y": 269.8333435058594,
+      "width": 111,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1G",
+      "roundness": null,
+      "seed": 752246361,
+      "version": 154,
+      "versionNonce": 350456215,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167430100,
+      "link": null,
+      "locked": false,
+      "text": "next()",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "next()",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "laDFG84hR_vbCVHWMp16w",
+      "type": "arrow",
+      "x": 942.7269220990613,
+      "y": 628.5394176529115,
+      "width": 2,
+      "height": 32,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1H",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 1602854839,
+      "version": 100,
+      "versionNonce": 1479430905,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167459736,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          2,
+          32
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": null,
+      "endBinding": null,
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "PKnVxmYbX4yxvUMYxiED6",
+      "type": "arrow",
+      "x": 1053.7269220990613,
+      "y": 654.5394176529115,
+      "width": 1,
+      "height": 30,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1I",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 1657442519,
+      "version": 98,
+      "versionNonce": 951815129,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167459736,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          -1,
+          -30
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": null,
+      "endBinding": null,
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    },
+    {
+      "id": "3s_jHVea7P3zpwyhsYqNO",
+      "type": "text",
+      "x": 867.2269220990613,
+      "y": 634.0394176529115,
+      "width": 111,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1J",
+      "roundness": null,
+      "seed": 1863343607,
+      "version": 237,
+      "versionNonce": 149858489,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167459736,
+      "link": null,
+      "locked": false,
+      "text": "next()",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "next()",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "9t3RnkE-nqccuTgRaqj2w",
+      "type": "text",
+      "x": 492.66346337243635,
+      "y": 444.3333435058594,
+      "width": 60.000000000000014,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1K",
+      "roundness": null,
+      "seed": 1235248153,
+      "version": 108,
+      "versionNonce": 91341817,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167501667,
+      "link": null,
+      "locked": false,
+      "text": "batch",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "batch",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "3xNt8fnnjY9QtNoev_FMj",
+      "type": "text",
+      "x": 1070.6634633724364,
+      "y": 265.8333435058594,
+      "width": 60.000000000000014,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1L",
+      "roundness": null,
+      "seed": 1471691417,
+      "version": 154,
+      "versionNonce": 195092727,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167506301,
+      "link": null,
+      "locked": false,
+      "text": "batch",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "batch",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "p9iXL4J6GojVzXDDx1NVM",
+      "type": "text",
+      "x": 1071.6634633724364,
+      "y": 629.8333435058594,
+      "width": 60.000000000000014,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1M",
+      "roundness": null,
+      "seed": 951602999,
+      "version": 150,
+      "versionNonce": 595097273,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167509787,
+      "link": null,
+      "locked": false,
+      "text": "batch",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "containerId": null,
+      "originalText": "batch",
+      "autoResize": false,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "xdQ0w3-b5BGEpSvQ2Uc8A",
+      "type": "rectangle",
+      "x": 1212.6634633724364,
+      "y": 131.83334350585938,
+      "width": 260,
+      "height": 128.99999999999997,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#eaddd7",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1N",
+      "roundness": {
+        "type": 3
+      },
+      "seed": 407784057,
+      "version": 373,
+      "versionNonce": 1796011255,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "h6I3dPlbn7bb50l-R-ZrT"
+        },
+        {
+          "id": "ou2srC_Up4kjWcmgzdEH4",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1733167585167,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "h6I3dPlbn7bb50l-R-ZrT",
+      "type": "text",
+      "x": 1282.2634633724363,
+      "y": 136.83334350585938,
+      "width": 120.80000000000001,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#eaddd7",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1O",
+      "roundness": null,
+      "seed": 1894814553,
+      "version": 326,
+      "versionNonce": 1273706233,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167557133,
+      "link": null,
+      "locked": false,
+      "text": "Shuffle Files",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "center",
+      "verticalAlign": "top",
+      "containerId": "xdQ0w3-b5BGEpSvQ2Uc8A",
+      "originalText": "Shuffle Files",
+      "autoResize": true,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "rpX5p5xVzE-agyW9ssfpT",
+      "type": "rectangle",
+      "x": 1253.6634633724364,
+      "y": 182.33334350585938,
+      "width": 190,
+      "height": 45,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#ffec99",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1P",
+      "roundness": {
+        "type": 3
+      },
+      "seed": 337035321,
+      "version": 422,
+      "versionNonce": 1799090137,
+      "isDeleted": false,
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "ZHswgvVioPRH-MY0pzRZO"
+        }
+      ],
+      "updated": 1733167557133,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "ZHswgvVioPRH-MY0pzRZO",
+      "type": "text",
+      "x": 1264.0634648983153,
+      "y": 192.33334350585938,
+      "width": 169.1999969482422,
+      "height": 25,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#ffec99",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1Q",
+      "roundness": null,
+      "seed": 1336168729,
+      "version": 390,
+      "versionNonce": 1438813369,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1733167557133,
+      "link": null,
+      "locked": false,
+      "text": "Arrow IPC Batch",
+      "fontSize": 20,
+      "fontFamily": 5,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "rpX5p5xVzE-agyW9ssfpT",
+      "originalText": "Arrow IPC Batch",
+      "autoResize": true,
+      "lineHeight": 1.25
+    },
+    {
+      "id": "ou2srC_Up4kjWcmgzdEH4",
+      "type": "arrow",
+      "x": 1114.6634633724364,
+      "y": 210.33334350585938,
+      "width": 97,
+      "height": 2,
+      "angle": 0,
+      "strokeColor": "#1e1e1e",
+      "backgroundColor": "#b2f2bb",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "frameId": null,
+      "index": "b1R",
+      "roundness": {
+        "type": 2
+      },
+      "seed": 1875512793,
+      "version": 40,
+      "versionNonce": 1347291095,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1733167585167,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          97,
+          -2
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "lSUrwgLq2W49ULouPfm0h",
+        "focus": 0.04618975520292551,
+        "gap": 1.496776360717604,
+        "fixedPoint": null
+      },
+      "endBinding": {
+        "elementId": "xdQ0w3-b5BGEpSvQ2Uc8A",
+        "focus": -0.13841786234942072,
+        "gap": 1,
+        "fixedPoint": null
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "elbowed": false
+    }
+  ],
+  "appState": {
+    "gridSize": 20,
+    "gridStep": 5,
+    "gridModeEnabled": false,
+    "viewBackgroundColor": "#ffffff"
+  },
+  "files": {}
+}
\ No newline at end of file
diff --git a/docs/source/_static/images/comet-dataflow.svg b/docs/source/_static/images/comet-dataflow.svg
new file mode 100644
index 0000000000..20a573c1fa
--- /dev/null
+++ b/docs/source/_static/images/comet-dataflow.svg
@@ -0,0 +1,10 @@
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1128.9773433315036 773.5" width="1128.9773433315036" height="773.5">
+  <!-- svg-source:excalidraw -->
+  
+  <defs>
+    <style class="style-fonts">
+      @font-face { font-family: Excalifont; src: url(data:font/woff2;base64,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); }
+    </style>
+    
+  </defs>
+  <rect x="0" y="0" width="1128.9773433315036" height="773.5" fill="#ffffff"></rect><g stroke-linecap="round" transform="translate(471.9805669707859 78) rotate(0 161 162)"><path d="M32 0 C123.09 3.55, 219.04 5.56, 290 0 C313.3 0.74, 320.33 10.98, 322 32 C323.23 106.37, 328.2 181.34, 322 292 C319.1 315.56, 311.42 326.96, 290 324 C232.9 325.78, 173.6 325.1, 32 324 C12.98 324.29, -2.09 313.02, 0 292 C1.81 236.77, 0.94 174.2, 0 32 C-0.73 8.19, 7.39 -2.91, 32 0" stroke="none" stroke-width="0" fill="#ffd8a8"></path><path d="M32 0 C126.05 -1.75, 224.65 -0.15, 290 0 M32 0 C102.46 -2.44, 173.47 -2.12, 290 0 M290 0 C310.18 0.7, 323.74 9.75, 322 32 M290 0 C312.23 1.66, 321.24 8.9, 322 32 M322 32 C322.33 136.07, 320.56 237.48, 322 292 M322 32 C323.43 103.2, 323.5 173.94, 322 292 M322 292 C322.18 312.12, 311.96 322.41, 290 324 M322 292 C320.29 314.52, 310.19 323.38, 290 324 M290 324 C224.58 325.22, 159.18 326.68, 32 324 M290 324 C202.71 324.59, 115.86 325.38, 32 324 M32 324 C10.75 324.98, -1.75 312.34, 0 292 M32 324 C11.41 325.74, 2.09 314.32, 0 292 M0 292 C0.25 204.73, 2.55 116.96, 0 32 M0 292 C-0.35 238.25, 0.06 185.11, 0 32 M0 32 C-0.7 10.95, 12.58 1.94, 32 0 M0 32 C-1.99 12.77, 12.76 -0.82, 32 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(113.9805669707859 10) rotate(0 30.5 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">JVM</text></g><g transform="translate(587.980566970786 18) rotate(0 48.5 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">Native</text></g><g stroke-linecap="round" transform="translate(514.480566970786 130) rotate(0 122.5 41.999999999999986)"><path d="M21 0 C82.35 -3.08, 140.82 -4.1, 224 0 C234.46 -2.69, 244.5 5.44, 245 21 C244.7 36.63, 247.46 54.95, 245 63 C245.95 78.37, 235.36 85.95, 224 84 C145.17 87.8, 62.94 87.54, 21 84 C9.62 85.42, -1.02 79.62, 0 63 C1.15 51.95, -1.01 38.95, 0 21 C2.8 9.08, 3.84 0.54, 21 0" stroke="none" stroke-width="0" fill="#b2f2bb"></path><path d="M21 0 C72.74 2.19, 125.36 2.03, 224 0 M21 0 C84.25 -0.05, 148.77 0.18, 224 0 M224 0 C236.32 1.62, 246.56 7.18, 245 21 M224 0 C237.78 -1.48, 246.15 8.75, 245 21 M245 21 C246.14 36.05, 246.25 46.96, 245 63 M245 21 C244.83 33.86, 245.86 47.44, 245 63 M245 63 C243.59 75.11, 236.41 84.04, 224 84 M245 63 C243.82 78.45, 238.07 82.98, 224 84 M224 84 C147.96 81.98, 71.98 83.78, 21 84 M224 84 C148.12 86.2, 70.91 85.52, 21 84 M21 84 C6.01 82.46, -0.19 76.61, 0 63 M21 84 C8.46 84.14, 0.68 79.11, 0 63 M0 63 C1.13 47.4, -1.57 30.81, 0 21 M0 63 C1.07 49.23, 0.94 37.59, 0 21 M0 21 C-1.33 5.32, 7.97 -1.97, 21 0 M0 21 C1.42 9.03, 8.92 1.46, 21 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(549.793066970786 159.5) rotate(0 87.1875 12.5)"><text x="87.1875" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="middle" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">ShuffleWriterExec</text></g><g stroke-linecap="round" transform="translate(10.173163780157608 467.0008024711351) rotate(0.21220562048813155 131.4999999999999 46.998058998529416)"><path d="M23.5 0 C79.23 4.6, 135.02 0.28, 239.5 0 C258.37 -3.45, 263.9 9.32, 263 23.5 C265.61 32.81, 264.36 48.72, 263 70.5 C263.84 89.05, 251.77 95.94, 239.5 94 C170.58 89.11, 104.04 93.05, 23.5 94 C10.47 93.45, -2.81 88.3, 0 70.5 C3.78 53.85, -0.58 45.07, 0 23.5 C-2.31 5.63, 11.16 3.29, 23.5 0" stroke="none" stroke-width="0" fill="#a5d8ff"></path><path d="M23.5 0 C86.2 -2.65, 150.18 -1.32, 239.5 0 M23.5 0 C98.83 -1.91, 173.18 -2.38, 239.5 0 M239.5 0 C253.22 0.98, 264.13 8.35, 263 23.5 M239.5 0 C253.97 0.59, 262.88 7.05, 263 23.5 M263 23.5 C264.13 32.8, 262.53 42.02, 263 70.5 M263 23.5 C262.1 37.08, 263.1 50.86, 263 70.5 M263 70.5 C264.59 87.6, 255.57 94.57, 239.5 94 M263 70.5 C262.13 83.97, 255.77 91.91, 239.5 94 M239.5 94 C183.89 96.36, 127.11 93.9, 23.5 94 M239.5 94 C179.18 93.19, 118.94 94.6, 23.5 94 M23.5 94 C8.25 95.31, 0.77 85.34, 0 70.5 M23.5 94 C6.35 95.18, -2.03 84.3, 0 70.5 M0 70.5 C1.05 54.46, 1.29 38.77, 0 23.5 M0 70.5 C-0.64 59.63, 1.09 46.81, 0 23.5 M0 23.5 C0.83 7.74, 9.21 1.44, 23.5 0 M0 23.5 C-1.71 5.64, 7.15 0.12, 23.5 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(46.24816378015748 501.49886146966446) rotate(0.21220562048813155 95.42500000000004 12.5)"><text x="95.42500000000001" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="middle" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">CometExecIterator</text></g><g transform="translate(576.980566970786 92) rotate(0 54.95000076293945 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">Native Plan</text></g><g stroke-linecap="round" transform="translate(12.660660432777888 269.00261312045996) rotate(0.21220562048813155 131.49999999999994 46.001769535470714)"><path d="M23 0 C93.83 3.47, 160.85 6.44, 240 0 C258.89 -2.46, 266.03 9.18, 263 23 C264.26 38.32, 260.11 50.09, 263 69 C264.66 85.14, 254.02 95, 240 92 C179.56 93.66, 115.6 93.87, 23 92 C4.64 94.27, -3.18 82.2, 0 69 C-1.18 56.96, -3.33 46.99, 0 23 C1.53 10.86, 4.7 -2.51, 23 0" stroke="none" stroke-width="0" fill="#a5d8ff"></path><path d="M23 0 C86.57 -2.23, 148.9 -0.45, 240 0 M23 0 C84.79 -1.4, 147.63 -1.07, 240 0 M240 0 C256.33 0.96, 261.37 7.91, 263 23 M240 0 C256.05 -2.05, 263.58 6.19, 263 23 M263 23 C263.33 36.51, 261.77 52.3, 263 69 M263 23 C263.37 39.01, 262.58 56.11, 263 69 M263 69 C262.52 86.24, 253.87 93.53, 240 92 M263 69 C264.82 85.4, 253.48 93.51, 240 92 M240 92 C166.34 89.95, 95.46 89.54, 23 92 M240 92 C174.71 90.48, 109.78 90.23, 23 92 M23 92 C6.13 90.09, 1.48 84.56, 0 69 M23 92 C8.9 90.41, -1.26 84.18, 0 69 M0 69 C-0.5 50.86, 0.28 33.62, 0 23 M0 69 C0.57 54.44, -0.47 41.01, 0 23 M0 23 C1.82 9.05, 5.89 -1.22, 23 0 M0 23 C-0.58 6.44, 7.83 -0.03, 23 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(42.49816043277781 302.50438265593067) rotate(0.21220562048813155 101.6625 12.5)"><text x="101.66250000000001" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="middle" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">CometBatchIterator</text></g><g stroke-linecap="round" transform="translate(12.477343331503562 118.50194100147058) rotate(0.21220562048813155 131.49999999999986 46.99805899852943)"><path d="M23.5 0 C93.99 -1.42, 165.47 -0.1, 239.5 0 C252.35 3.54, 263.18 7.14, 263 23.5 C266.3 36.09, 264.49 50.66, 263 70.5 C262.62 82.93, 252.07 92.07, 239.5 94 C165.51 92.14, 85.69 95.53, 23.5 94 C8.78 96.87, 2.33 82.91, 0 70.5 C0.77 50.16, -1.62 35.78, 0 23.5 C3.5 8.47, 5.92 -2, 23.5 0" stroke="none" stroke-width="0" fill="#a5d8ff"></path><path d="M23.5 0 C79.56 -0.23, 135.03 0.96, 239.5 0 M23.5 0 C86.58 -0.46, 150.81 -0.27, 239.5 0 M239.5 0 C255.11 0.71, 261.76 8.44, 263 23.5 M239.5 0 C257.14 -0.66, 263.34 5.94, 263 23.5 M263 23.5 C263.99 37.66, 264.85 53.3, 263 70.5 M263 23.5 C263.53 37.95, 263.92 54.26, 263 70.5 M263 70.5 C262.97 87.67, 253.65 93.6, 239.5 94 M263 70.5 C261.11 84.24, 257.11 94.68, 239.5 94 M239.5 94 C161.06 96.34, 78.32 94.4, 23.5 94 M239.5 94 C194.9 95.18, 151.53 94.2, 23.5 94 M23.5 94 C9.03 95.63, 1.95 85.65, 0 70.5 M23.5 94 C8.49 93.05, 0.79 87.77, 0 70.5 M0 70.5 C-0.34 57.33, 0.22 44.53, 0 23.5 M0 70.5 C0.84 56.86, 0.73 44.57, 0 23.5 M0 23.5 C0.85 8.78, 5.89 0.04, 23.5 0 M0 23.5 C-0.87 8.22, 6.11 -1.8, 23.5 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(48.55234333150344 153) rotate(0.21220562048813155 95.42500000000001 12.5)"><text x="95.42500000000001" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="middle" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">CometExecIterator</text></g><g stroke-linecap="round" transform="translate(517.4773433315036 265.5) rotate(0 122.5 42)"><path d="M21 0 C102.01 -0.35, 179.34 -2.2, 224 0 C235.25 -2.29, 244.45 7.75, 245 21 C244.78 38.95, 247.37 52.08, 245 63 C241.76 75.5, 235.33 82.04, 224 84 C155.29 84.67, 89.16 86.13, 21 84 C6.69 80.86, -0.66 79.08, 0 63 C1.41 54.06, -2.46 45.77, 0 21 C-0.31 9.92, 9.08 -1.89, 21 0" stroke="none" stroke-width="0" fill="#b2f2bb"></path><path d="M21 0 C103.07 3.15, 181.23 3.2, 224 0 M21 0 C83.67 1.13, 147.27 1.29, 224 0 M224 0 C239.95 -1.86, 246.66 7.88, 245 21 M224 0 C237.19 -1.71, 245.63 4.76, 245 21 M245 21 C244.68 29.21, 245.86 37.66, 245 63 M245 21 C244.4 35.69, 244.01 50.82, 245 63 M245 63 C246.31 76.17, 236.95 82.55, 224 84 M245 63 C245.34 77.74, 237.2 82.36, 224 84 M224 84 C145.17 83.46, 69.46 85.47, 21 84 M224 84 C149.14 86.01, 75.82 86, 21 84 M21 84 C5.06 84.5, -0.16 78.96, 0 63 M21 84 C7.35 85.79, 0.62 75.4, 0 63 M0 63 C-0.49 51.71, -1.6 36.52, 0 21 M0 63 C-0.47 50.15, 0.82 36.75, 0 21 M0 21 C1.13 6.44, 8.6 1.69, 21 0 M0 21 C-0.94 6.8, 5.93 1.62, 21 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(594.114844094443 295) rotate(0 45.86249923706055 12.5)"><text x="45.86249923706055" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="middle" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">ScanExec</text></g><g stroke-linecap="round" transform="translate(466.9773433315035 434.5) rotate(0 167.4999999999999 164.5)"><path d="M32 0 C113.92 -0.75, 189.21 1.58, 303 0 C327.89 1.59, 332.52 10.78, 335 32 C334.04 119.47, 334.1 204.34, 335 297 C334.28 317.66, 323.91 329.1, 303 329 C211.3 325.22, 118.96 326.03, 32 329 C7.93 327.21, -0.71 316.81, 0 297 C-4.92 210.78, -5.42 129.95, 0 32 C2.43 8.43, 8.36 -2.8, 32 0" stroke="none" stroke-width="0" fill="#ffd8a8"></path><path d="M32 0 C135.36 1.71, 239.36 0.22, 303 0 M32 0 C87.15 -0.1, 141.45 -0.79, 303 0 M303 0 C322.48 1.21, 336.33 8.95, 335 32 M303 0 C322.89 -1.2, 334.33 10.64, 335 32 M335 32 C333.62 134.21, 333.62 237.6, 335 297 M335 32 C333.04 131.27, 333.48 232.63, 335 297 M335 297 C333.1 316.63, 322.7 328.89, 303 329 M335 297 C333.89 319.36, 322.19 329.41, 303 329 M303 329 C197.3 329.46, 89.12 327.39, 32 329 M303 329 C200.81 329.03, 98.49 329.38, 32 329 M32 329 C10.28 329.96, 1.75 319.09, 0 297 M32 329 C8.96 328.38, 2.24 318.87, 0 297 M0 297 C2.54 203.56, 0.74 110.72, 0 32 M0 297 C-1.72 238.93, -1.49 180.25, 0 32 M0 32 C-0.92 9.36, 9.12 -1.66, 32 0 M0 32 C-1.01 11.54, 8.38 2.06, 32 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g stroke-linecap="round" transform="translate(508.4773433315035 496.5) rotate(0 122.5 42)"><path d="M21 0 C76.38 2.69, 138.42 3.12, 224 0 C235.52 0.11, 245.98 4.94, 245 21 C246.91 28.06, 244.59 37.23, 245 63 C244.58 77.1, 239.39 84.51, 224 84 C172 80.31, 118.67 80.07, 21 84 C6.29 82.47, 0.58 80.31, 0 63 C-2.08 49.47, 2.82 32.51, 0 21 C-2.3 4.2, 10.11 -0.17, 21 0" stroke="none" stroke-width="0" fill="#b2f2bb"></path><path d="M21 0 C70.76 -1.72, 118.88 -1.38, 224 0 M21 0 C85.74 -1.19, 150.45 -0.25, 224 0 M224 0 C239.33 -1.72, 243.75 5.96, 245 21 M224 0 C237.33 -0.03, 246.97 5.56, 245 21 M245 21 C244.9 38.95, 246.53 52.3, 245 63 M245 21 C244.7 31.18, 243.79 39.16, 245 63 M245 63 C243.37 76.89, 237.04 84.9, 224 84 M245 63 C242.86 77.41, 240.18 84.2, 224 84 M224 84 C171.97 84.78, 120.97 84.21, 21 84 M224 84 C155.64 82.03, 88.32 82.85, 21 84 M21 84 C8.75 84.76, -1.48 76.46, 0 63 M21 84 C9.24 84.54, 1.2 75, 0 63 M0 63 C-1.56 54.47, -1.77 46.45, 0 21 M0 63 C-0.04 49.61, -0.22 34.95, 0 21 M0 21 C-1.54 5.34, 6.12 0.76, 21 0 M0 21 C-2.29 9.06, 6.84 -1.7, 21 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(570.9898433315036 526) rotate(0 59.987499999999955 12.5)"><text x="59.987500000000004" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="middle" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">ProjectExec</text></g><g transform="translate(570.9773433315036 458.5) rotate(0 54.95000076293945 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">Native Plan</text></g><g stroke-linecap="round" transform="translate(510.4741196922211 633) rotate(0 122.5 42)"><path d="M21 0 C91.77 -1.94, 157.59 1.25, 224 0 C238.94 1.59, 243.61 6.28, 245 21 C246.3 33.32, 243.23 44.72, 245 63 C242.44 76.37, 236.47 81.27, 224 84 C173.7 85.58, 123.53 80.98, 21 84 C3.89 81.53, 0.6 79.43, 0 63 C3.6 52.84, -0.9 42.69, 0 21 C-2.91 9.85, 5.32 -0.17, 21 0" stroke="none" stroke-width="0" fill="#b2f2bb"></path><path d="M21 0 C74.41 -1.38, 125.46 -2.25, 224 0 M21 0 C93.58 1.1, 167.02 1.55, 224 0 M224 0 C239.71 -1.25, 246.79 6.92, 245 21 M224 0 C238.06 -0.09, 246.83 8.78, 245 21 M245 21 C242.74 30.54, 246.04 38.38, 245 63 M245 21 C244.18 30.46, 243.73 39.21, 245 63 M245 63 C246.9 77.18, 237.14 85.68, 224 84 M245 63 C247.02 77.21, 236.96 85.76, 224 84 M224 84 C177.17 82.34, 132.69 83.2, 21 84 M224 84 C152.65 84.45, 83.51 84.9, 21 84 M21 84 C8.04 82.26, -1.77 77.9, 0 63 M21 84 C6.77 82.43, 0.41 75.18, 0 63 M0 63 C0.97 47.3, 0.52 31.82, 0 21 M0 63 C-0.12 53.53, -0.67 44.2, 0 21 M0 21 C-0.14 5.52, 6.63 1.82, 21 0 M0 21 C-1.19 5.76, 7.71 2.27, 21 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(624.4741196922212 662.5) rotate(0 8.5 12.5)"><text x="8.5" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="middle" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">...</text></g><g stroke-linecap="round"><g transform="translate(274.25926833560646 490.9960010273154) rotate(0 96.35903749794852 0.1172614457153145)"><path d="M0.08 -0.5 C32.07 -0.36, 160.79 0.8, 193.09 1 M-1.34 -1.8 C30.42 -2.03, 159.83 -0.8, 192.33 -0.72" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(274.25926833560646 490.9960010273154) rotate(0 96.35903749794852 0.1172614457153145)"><path d="M168.79 7.68 C177.3 4.94, 188.75 2.86, 192.33 -0.72 M168.79 7.68 C177.47 5.12, 184.08 2.01, 192.33 -0.72" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(274.25926833560646 490.9960010273154) rotate(0 96.35903749794852 0.1172614457153145)"><path d="M168.89 -9.42 C177.39 -5.37, 188.8 -0.65, 192.33 -0.72 M168.89 -9.42 C177.57 -6.16, 184.15 -3.45, 192.33 -0.72" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g stroke-linecap="round"><g transform="translate(507.9773433315035 532.5) rotate(0 -116.93514264474356 -0.20360985168719026)"><path d="M1.17 0.61 C-37.6 0.22, -193.86 -0.93, -233.22 -1.17 M0.33 -0.12 C-38.5 0.14, -195 -0.1, -233.82 -0.03" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(507.9773433315035 532.5) rotate(0 -116.93514264474356 -0.20360985168719026)"><path d="M-210.33 -8.58 C-215.18 -5.09, -223.4 -5.82, -233.82 -0.03 M-210.33 -8.58 C-216.4 -5.98, -221.96 -3.44, -233.82 -0.03" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(507.9773433315035 532.5) rotate(0 -116.93514264474356 -0.20360985168719026)"><path d="M-210.33 8.52 C-215.34 7.68, -223.56 2.63, -233.82 -0.03 M-210.33 8.52 C-216.39 6.55, -221.96 4.51, -233.82 -0.03" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g stroke-linecap="round"><g transform="translate(513.9773433315036 296.5) rotate(0 -117.99919052683845 0.2814422463709434)"><path d="M0.42 -0.89 C-38.93 -0.89, -195.85 0.58, -235.12 0.91 M-0.81 1.26 C-40.34 0.81, -196.49 -0.66, -235.61 -1.03" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(513.9773433315036 296.5) rotate(0 -117.99919052683845 0.2814422463709434)"><path d="M-212.04 -9.36 C-222.5 -4.62, -229.49 -1.56, -235.61 -1.03 M-212.04 -9.36 C-220.04 -7.28, -228.4 -3.63, -235.61 -1.03" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(513.9773433315036 296.5) rotate(0 -117.99919052683845 0.2814422463709434)"><path d="M-212.2 7.74 C-222.73 5.92, -229.65 2.42, -235.61 -1.03 M-212.2 7.74 C-220.05 3.95, -228.35 1.74, -235.61 -1.03" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g stroke-linecap="round"><g transform="translate(276.97837169588405 329.2223416172362) rotate(0 119.49948581780973 -0.36117080861811246)"><path d="M-0.94 -0.02 C38.84 0.07, 199.62 -0.36, 239.44 -0.43 M0.77 -1.08 C40.37 -1.28, 198.8 -2.75, 238.72 -2.4" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(276.97837169588405 329.2223416172362) rotate(0 119.49948581780973 -0.36117080861811246)"><path d="M215.24 6.19 C223.74 4, 232.73 -1.57, 238.72 -2.4 M215.24 6.19 C222.48 2.95, 230.69 1.49, 238.72 -2.4" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(276.97837169588405 329.2223416172362) rotate(0 119.49948581780973 -0.36117080861811246)"><path d="M215.21 -10.91 C223.58 -6.93, 232.59 -6.34, 238.72 -2.4 M215.21 -10.91 C222.51 -8.59, 230.73 -4.49, 238.72 -2.4" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g stroke-linecap="round"><g transform="translate(83.9773433315035 360.5) rotate(0 2 52)"><path d="M-0.46 0.82 C-0.02 18.07, 2.91 86.4, 3.82 103.55 M1.5 0.21 C1.67 17.61, 2.24 87.4, 2.78 104.85" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(83.9773433315035 360.5) rotate(0 2 52)"><path d="M-6.19 81.52 C-1.25 90.52, 0.2 101.74, 2.78 104.85 M-6.19 81.52 C-4.36 88.16, -1 94.02, 2.78 104.85" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(83.9773433315035 360.5) rotate(0 2 52)"><path d="M10.91 81.21 C9.06 90.27, 3.71 101.61, 2.78 104.85 M10.91 81.21 C7.96 87.94, 6.55 93.89, 2.78 104.85" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g stroke-linecap="round"><g transform="translate(201.9773433315035 464.5) rotate(0 0 -51.5)"><path d="M-0.94 0.56 C-0.76 -16.55, 0.6 -84.68, 0.73 -101.88 M0.76 -0.19 C0.89 -17.68, 0.46 -85.99, 0.17 -103.42" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(201.9773433315035 464.5) rotate(0 0 -51.5)"><path d="M8.96 -80.02 C7.39 -85.14, 5.96 -92.87, 0.17 -103.42 M8.96 -80.02 C6.33 -87.33, 4.16 -95.49, 0.17 -103.42" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(201.9773433315035 464.5) rotate(0 0 -51.5)"><path d="M-8.14 -79.84 C-5.13 -84.87, -1.98 -92.65, 0.17 -103.42 M-8.14 -79.84 C-5.11 -87.3, -1.62 -95.51, 0.17 -103.42" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g stroke-linecap="round"><g transform="translate(278.97753219772125 142.44900612119122) rotate(0 96.99990556689113 -0.47450306059560887)"><path d="M0.83 -0.11 C33.31 -0.39, 162.56 -0.53, 194.64 -0.81 M-0.19 -1.22 C32.21 -1.35, 161.96 0.75, 194.03 0.8" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(278.97753219772125 142.44900612119122) rotate(0 96.99990556689113 -0.47450306059560887)"><path d="M170.45 9.12 C176.78 7.7, 183.76 3.16, 194.03 0.8 M170.45 9.12 C175.29 7.58, 180.5 5.96, 194.03 0.8" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(278.97753219772125 142.44900612119122) rotate(0 96.99990556689113 -0.47450306059560887)"><path d="M170.62 -7.98 C177.02 -4.63, 183.95 -4.41, 194.03 0.8 M170.62 -7.98 C175.55 -5.62, 180.72 -3.35, 194.03 0.8" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g transform="translate(310.9773433315035 453.5) rotate(0 94.5 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">executePlan()</text></g><g transform="translate(315.4773433315035 109) rotate(0 94.5 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">executePlan()</text></g><g transform="translate(395.4773433315035 270) rotate(0 55.5 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">next()</text></g><g transform="translate(17.477343331503505 401) rotate(0 55.5 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">next()</text></g><g transform="translate(322.9773433315035 337.5) rotate(0 73.5 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">exportBatch()</text></g><g transform="translate(309.9773433315035 536.5) rotate(0 108.5 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">importVectors()</text></g><g stroke-linecap="round"><g transform="translate(514.9773433315036 181.5) rotate(0 -119.5 0.5)"><path d="M-1.17 -0.73 C-40.9 -0.58, -198.88 1.5, -238.63 1.65 M0.42 1.49 C-39.41 1.23, -199.18 -0.05, -239.38 -0.13" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(514.9773433315036 181.5) rotate(0 -119.5 0.5)"><path d="M-215.84 -8.55 C-223.6 -5.8, -227.89 -5.12, -239.38 -0.13 M-215.84 -8.55 C-221.98 -6.54, -226.07 -4.86, -239.38 -0.13" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(514.9773433315036 181.5) rotate(0 -119.5 0.5)"><path d="M-215.93 8.55 C-223.78 6.51, -228.04 2.4, -239.38 -0.13 M-215.93 8.55 C-222.21 6.66, -226.29 4.43, -239.38 -0.13" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g transform="translate(316.4773433315035 187) rotate(0 108.5 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">importVectors()</text></g><g stroke-linecap="round"><g transform="translate(587.9773433315036 225.5) rotate(0 1 16)"><path d="M-0.23 0.37 C0.22 5.61, 2.02 26.35, 2.42 31.58 M0.66 0.09 C1.09 5.37, 2 26.7, 2.2 32.06" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(587.9773433315036 225.5) rotate(0 1 16)"><path d="M-3.9 17.23 C-1.78 21.63, -1.39 24.98, 2.2 32.06 M-3.9 17.23 C-2.35 21.22, -1.12 24.68, 2.2 32.06" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(587.9773433315036 225.5) rotate(0 1 16)"><path d="M7.06 16.78 C6.39 21.27, 3.99 24.74, 2.2 32.06 M7.06 16.78 C5.8 20.88, 4.24 24.46, 2.2 32.06" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g stroke-linecap="round"><g transform="translate(698.9773433315036 251.5) rotate(0 -0.5 -15)"><path d="M0.37 -0.13 C0.18 -5.3, -1.32 -25.42, -1.5 -30.47 M-0.1 -0.68 C-0.1 -5.56, -0.39 -25.11, -0.52 -30.01" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(698.9773433315036 251.5) rotate(0 -0.5 -15)"><path d="M4.89 -16.01 C3.37 -19.97, 1.63 -22.18, -0.52 -30.01 M4.89 -16.01 C3.7 -19.24, 2.47 -21.8, -0.52 -30.01" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(698.9773433315036 251.5) rotate(0 -0.5 -15)"><path d="M-5.37 -15.81 C-4.48 -19.85, -3.79 -22.1, -0.52 -30.01 M-5.37 -15.81 C-4.33 -19.08, -3.32 -21.69, -0.52 -30.01" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g transform="translate(512.4773433315036 231) rotate(0 55.5 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">next()</text></g><g stroke-linecap="round"><g transform="translate(589.0408020581285 589.7060741470522) rotate(0 1 16)"><path d="M0.43 0.4 C0.62 5.7, 1.4 26.76, 1.58 32.06 M-0.02 0.14 C0.31 5.5, 2.17 27.61, 2.6 32.8" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(589.0408020581285 589.7060741470522) rotate(0 1 16)"><path d="M-4.11 18.24 C-0.98 23.04, 1.03 28.36, 2.6 32.8 M-4.11 18.24 C-2.16 23.48, 0.3 27.8, 2.6 32.8" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(589.0408020581285 589.7060741470522) rotate(0 1 16)"><path d="M6.81 17.33 C5.87 22.51, 3.8 28.17, 2.6 32.8 M6.81 17.33 C5.04 22.9, 3.78 27.53, 2.6 32.8" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g stroke-linecap="round"><g transform="translate(700.0408020581285 615.7060741470522) rotate(0 -0.5 -15)"><path d="M-0.42 0.06 C-0.74 -4.97, -1.35 -24.79, -1.5 -29.78 M0.37 -0.38 C0.17 -5.61, -0.43 -25.55, -0.53 -30.63" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(700.0408020581285 615.7060741470522) rotate(0 -0.5 -15)"><path d="M4.97 -16.66 C2.93 -22.64, 1.08 -27.71, -0.53 -30.63 M4.97 -16.66 C3.1 -21.58, 1.06 -25.58, -0.53 -30.63" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(700.0408020581285 615.7060741470522) rotate(0 -0.5 -15)"><path d="M-5.3 -16.39 C-3.46 -22.43, -1.44 -27.61, -0.53 -30.63 M-5.3 -16.39 C-3.78 -21.44, -2.42 -25.53, -0.53 -30.63" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g transform="translate(513.5408020581285 595.2060741470522) rotate(0 55.5 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">next()</text></g><g transform="translate(138.9773433315035 405.5) rotate(0 30 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">batch</text></g><g transform="translate(716.9773433315036 227) rotate(0 30 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">batch</text></g><g transform="translate(717.9773433315036 591) rotate(0 30 12.5)"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">batch</text></g><g stroke-linecap="round" transform="translate(858.9773433315036 93) rotate(0 130 64.5)"><path d="M32 0 C75.17 4.43, 117.81 1.58, 228 0 C251 1.2, 262.38 8.65, 260 32 C259.54 47.96, 260.03 59.6, 260 97 C259.99 117.69, 251.14 127.09, 228 129 C159.98 128.63, 98.52 122.93, 32 129 C10.58 129.33, -2.46 115.31, 0 97 C1.82 82.98, -1.07 63.57, 0 32 C2.58 12.32, 12.16 2.92, 32 0" stroke="none" stroke-width="0" fill="#eaddd7"></path><path d="M32 0 C75.47 1.35, 122.17 -0.82, 228 0 M32 0 C102.81 0.46, 174.58 -0.27, 228 0 M228 0 C247.33 0.47, 261.62 12.54, 260 32 M228 0 C248.61 -2.06, 262 8.4, 260 32 M260 32 C259.44 48.27, 261.74 69.04, 260 97 M260 32 C260.22 52.81, 259.85 72.59, 260 97 M260 97 C260.3 119.73, 250.3 129.88, 228 129 M260 97 C261.04 118.09, 247.15 129.41, 228 129 M228 129 C179.31 130.86, 132.15 127.94, 32 129 M228 129 C160.35 127.96, 93.01 126.99, 32 129 M32 129 C10.13 128.37, 0.89 120.31, 0 97 M32 129 C12.36 128.4, -1.42 119.17, 0 97 M0 97 C0.07 73.43, -1.65 51.18, 0 32 M0 97 C-0.12 80.83, -0.25 63.21, 0 32 M0 32 C1.75 10.68, 9.96 1.03, 32 0 M0 32 C1.53 10.34, 9.55 -1.79, 32 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(928.5773433315035 98) rotate(0 60.39999999999998 12.5)"><text x="60.400000000000006" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="middle" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">Shuffle Files</text></g><g stroke-linecap="round" transform="translate(899.9773433315036 143.5) rotate(0 95 22.5)"><path d="M11.25 0 C72.55 1.89, 132.91 -1.33, 178.75 0 C183.48 1.31, 189.32 2.86, 190 11.25 C189.95 18.27, 191.76 24.66, 190 33.75 C191.16 42.03, 183.19 42.1, 178.75 45 C116.16 42.75, 51.29 39.4, 11.25 45 C1.59 41.85, 3.39 42.04, 0 33.75 C2.82 27.66, 1.73 21.2, 0 11.25 C-2.16 4.52, 5.26 1.14, 11.25 0" stroke="none" stroke-width="0" fill="#ffec99"></path><path d="M11.25 0 C74.79 -0.9, 135.12 -0.49, 178.75 0 M11.25 0 C57.63 1.74, 106.83 2.45, 178.75 0 M178.75 0 C185.62 -1.79, 191.74 1.78, 190 11.25 M178.75 0 C185.64 1.32, 190.11 2.67, 190 11.25 M190 11.25 C190.34 14.69, 190.83 22.86, 190 33.75 M190 11.25 C190.23 20.25, 190.57 28.3, 190 33.75 M190 33.75 C190.9 41.04, 184.35 45.36, 178.75 45 M190 33.75 C188.83 39.96, 187.34 45.13, 178.75 45 M178.75 45 C121.53 45.23, 60.87 42.87, 11.25 45 M178.75 45 C118.22 44.06, 58.66 45.36, 11.25 45 M11.25 45 C5.22 44.48, -1.24 41.98, 0 33.75 M11.25 45 C4.82 46.62, -0.79 41.86, 0 33.75 M0 33.75 C-0.7 28.55, 1.24 22.59, 0 11.25 M0 33.75 C0.9 25.65, -0.32 18.06, 0 11.25 M0 11.25 C1.33 3.47, 2.78 -1.56, 11.25 0 M0 11.25 C-1.9 5.18, 2.18 0.33, 11.25 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(910.3773448573825 153.5) rotate(0 84.5999984741211 12.5)"><text x="84.5999984741211" y="17.619999999999997" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="middle" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">Arrow IPC Batch</text></g><g stroke-linecap="round"><g transform="translate(760.9773433315036 171.5) rotate(0 48.5 -1)"><path d="M1.08 -0.5 C17.12 -0.65, 80.43 -1.26, 96.61 -1.49 M0.19 -1.81 C16.01 -2.26, 79.15 -3.56, 95.46 -3.35" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(760.9773433315036 171.5) rotate(0 48.5 -1)"><path d="M72.02 5.35 C79 1.61, 88.45 1.37, 95.46 -3.35 M72.02 5.35 C80.27 2.68, 87.05 0.1, 95.46 -3.35" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(760.9773433315036 171.5) rotate(0 48.5 -1)"><path d="M71.92 -11.75 C78.84 -9.82, 88.33 -4.4, 95.46 -3.35 M71.92 -11.75 C80.2 -9.12, 87.01 -6.4, 95.46 -3.35" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask></svg>
\ No newline at end of file
diff --git a/docs/source/contributor-guide/plugin_overview.md b/docs/source/contributor-guide/plugin_overview.md
index a211ca6b55..3e7c24f55a 100644
--- a/docs/source/contributor-guide/plugin_overview.md
+++ b/docs/source/contributor-guide/plugin_overview.md
@@ -28,11 +28,21 @@ following setting to the Spark configuration when launching `spark-shell` or `sp
 --conf spark.plugins=org.apache.spark.CometPlugin
 ```
 
+This class is loaded by Spark's plugin framework. It will be instantiated in the Spark driver only. Comet does not
+provide any executor plugins.
+
+The plugin will update the current `SparkConf` with the extra configuration provided by Comet, such as executor memory
+configuration.
+
+The plugin also registers `CometSparkSessionExtensions` with Spark's extension API.
+
+## CometSparkSessionExtensions
+
 On initialization, this class registers two physical plan optimization rules with Spark: `CometScanRule`
 and `CometExecRule`. These rules run whenever a query stage is being planned during Adaptive Query Execution, and
 run once for the entire plan when Adaptive Query Execution is disabled.
 
-## CometScanRule
+### CometScanRule
 
 `CometScanRule` replaces any Parquet scans with Comet operators. There are different paths for Spark v1 and v2 data sources.
 
@@ -43,13 +53,13 @@ Parquet data source but leverages native code for decoding Parquet row groups di
 
 Comet only supports a subset of data types and will fall back to Spark's scan if unsupported types
 exist. Comet can still accelerate the rest of the query execution in this case because `CometSparkToColumnarExec` will
-convert the output from Spark's can to Arrow arrays. Note that both `spark.comet.exec.enabled=true` and
+convert the output from Spark's scan to Arrow arrays. Note that both `spark.comet.exec.enabled=true` and
 `spark.comet.convert.parquet.enabled=true` must be set to enable this conversion.
 
 Refer to the [Supported Spark Data Types](https://datafusion.apache.org/comet/user-guide/datatypes.html) section
 in the contributor guide to see a list of currently supported data types.
 
-## CometExecRule
+### CometExecRule
 
 This rule traverses bottom-up from the original Spark plan and attempts to replace each operator with a Comet equivalent.
 For example, a `ProjectExec` will be replaced by `CometProjectExec`.
@@ -64,25 +74,52 @@ of this could outweigh the benefits of running parts of the query stage natively
 
 ## Query Execution
 
-Once the plan has been transformed, any consecutive Comet operators are combined into a `CometNativeExec` which contains
-a serialized version of the plan (the serialization code can be found in `QueryPlanSerde`). When this operator is
-executed, the serialized plan is passed to the native code when calling `Native.createPlan`.
+Once the plan has been transformed, any consecutive native Comet operators are combined into a `CometNativeExec` which contains
+a protocol buffer serialized version of the plan (the serialization code can be found in `QueryPlanSerde`).
 
-In the native code there is a `PhysicalPlanner` struct (in `planner.rs`) which converts the serialized plan into an
+Spark serializes the physical plan and sends it to the executors when executing tasks. The executors deserialize the
+plan and invoke it.
+
+When `CometNativeExec` is invoked, it will pass the serialized protobuf plan into
+`Native.createPlan`, which invokes the native code via JNI, where the plan is then deserialized.
+
+In the native code there is a `PhysicalPlanner` struct (in `planner.rs`) which converts the deserialized plan into an
 Apache DataFusion `ExecutionPlan`. In some cases, Comet provides specialized physical operators and expressions to
 override the DataFusion versions to ensure compatibility with Apache Spark.
 
-`CometExecIterator` will invoke `Native.executePlan` to pull the next batch from the native plan. This is repeated
-until no more batches are available (meaning that all data has been processed by the native plan).
+The leaf nodes in the physical plan are always `ScanExec` and each of these operators will make a JNI call to 
+`CometBatchIterator.next()` to fetch the next input batch. The input could be a Comet native Parquet scan,
+a Spark exchange, or another native plan.
+
+`CometNativeExec` creates a `CometExecIterator` and applies this iterator to the input RDD
+partitions. Each call to `CometExecIterator.next()` will invoke `Native.executePlan`. Once the plan finishes
+executing, the resulting Arrow batches are imported into the JVM using Arrow FFI.
+
+## Arrow
+
+Due to the hybrid execution model, it is necessary to pass batches of data between the JVM and native code.
+
+Comet uses a combination of Arrow FFI and Arrow IPC to achieve this.
+
+### Arrow FFI
+
+The foundation for Arrow FFI is the [Arrow C Data Interface], which provides a stable ABI-compatible interface for 
+accessing Arrow data structures from multiple languages.
+
+[Arrow C Data Interface]: https://arrow.apache.org/docs/format/CDataInterface.html
+
+- `CometExecIterator` invokes native plans and uses Arrow FFI to read the output batches
+- Native `ScanExec` operators call `CometBatchIterator` via JNI to fetch input batches from the JVM
+
+### Arrow IPC
 
-The leaf nodes in the physical plan are always `ScanExec` and these operators consume batches of Arrow data that were
-prepared before the plan is executed. When `CometExecIterator` invokes `Native.executePlan` it passes the memory
-addresses of these Arrow arrays to the native code.
+Comet native shuffle uses Arrow IPC to write batches to the shuffle files.
 
-![Diagram of Comet Native Execution](../../_static/images/CometOverviewDetailed.drawio.svg)
+- `CometShuffleWriteProcessor` invokes a native plan to fetch batches and then passes them to native `ShuffleWriterExec`
+- `CometBlockStoreShuffleReader` reads batches from shuffle files
 
 ## End to End Flow
 
-The following diagram shows the end-to-end flow.
+The following diagram shows an example of the end-to-end flow for a query stage.
 
-![Diagram of Comet Native Parquet Scan](../../_static/images/CometNativeParquetReader.drawio.svg)
+![Diagram of Comet Data Flow](../../_static/images/comet-dataflow.svg)

From 2671e0cafbd6fe96c9af852ad7f34592e299a62a Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Tue, 3 Dec 2024 17:40:54 -0700
Subject: [PATCH 22/47] Stop passing Java config map into native createPlan
 (#1101)

---
 native/core/src/execution/jni_api.rs          | 69 +++++--------------
 .../org/apache/comet/CometExecIterator.scala  | 32 ++-------
 .../main/scala/org/apache/comet/Native.scala  | 10 +--
 3 files changed, 28 insertions(+), 83 deletions(-)

diff --git a/native/core/src/execution/jni_api.rs b/native/core/src/execution/jni_api.rs
index 083744f0a4..8afe134cd3 100644
--- a/native/core/src/execution/jni_api.rs
+++ b/native/core/src/execution/jni_api.rs
@@ -31,8 +31,8 @@ use futures::poll;
 use jni::{
     errors::Result as JNIResult,
     objects::{
-        JByteArray, JClass, JIntArray, JLongArray, JMap, JObject, JObjectArray, JPrimitiveArray,
-        JString, ReleaseMode,
+        JByteArray, JClass, JIntArray, JLongArray, JObject, JObjectArray, JPrimitiveArray, JString,
+        ReleaseMode,
     },
     sys::{jbyteArray, jint, jlong, jlongArray},
     JNIEnv,
@@ -77,8 +77,6 @@ struct ExecutionContext {
     pub input_sources: Vec<Arc<GlobalRef>>,
     /// The record batch stream to pull results from
     pub stream: Option<SendableRecordBatchStream>,
-    /// Configurations for DF execution
-    pub conf: HashMap<String, String>,
     /// The Tokio runtime used for async.
     pub runtime: Runtime,
     /// Native metrics
@@ -103,11 +101,15 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
     e: JNIEnv,
     _class: JClass,
     id: jlong,
-    config_object: JObject,
     iterators: jobjectArray,
     serialized_query: jbyteArray,
     metrics_node: JObject,
     comet_task_memory_manager_obj: JObject,
+    batch_size: jint,
+    debug_native: jboolean,
+    explain_native: jboolean,
+    worker_threads: jint,
+    blocking_threads: jint,
 ) -> jlong {
     try_unwrap_or_throw(&e, |mut env| {
         // Init JVM classes
@@ -121,36 +123,10 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
         // Deserialize query plan
         let spark_plan = serde::deserialize_op(bytes.as_slice())?;
 
-        // Sets up context
-        let mut configs = HashMap::new();
-
-        let config_map = JMap::from_env(&mut env, &config_object)?;
-        let mut map_iter = config_map.iter(&mut env)?;
-        while let Some((key, value)) = map_iter.next(&mut env)? {
-            let key: String = env.get_string(&JString::from(key)).unwrap().into();
-            let value: String = env.get_string(&JString::from(value)).unwrap().into();
-            configs.insert(key, value);
-        }
-
-        // Whether we've enabled additional debugging on the native side
-        let debug_native = parse_bool(&configs, "debug_native")?;
-        let explain_native = parse_bool(&configs, "explain_native")?;
-
-        let worker_threads = configs
-            .get("worker_threads")
-            .map(String::as_str)
-            .unwrap_or("4")
-            .parse::<usize>()?;
-        let blocking_threads = configs
-            .get("blocking_threads")
-            .map(String::as_str)
-            .unwrap_or("10")
-            .parse::<usize>()?;
-
         // Use multi-threaded tokio runtime to prevent blocking spawned tasks if any
         let runtime = tokio::runtime::Builder::new_multi_thread()
-            .worker_threads(worker_threads)
-            .max_blocking_threads(blocking_threads)
+            .worker_threads(worker_threads as usize)
+            .max_blocking_threads(blocking_threads as usize)
             .enable_all()
             .build()?;
 
@@ -171,7 +147,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
         // We need to keep the session context alive. Some session state like temporary
         // dictionaries are stored in session context. If it is dropped, the temporary
         // dictionaries will be dropped as well.
-        let session = prepare_datafusion_session_context(&configs, task_memory_manager)?;
+        let session = prepare_datafusion_session_context(batch_size as usize, task_memory_manager)?;
 
         let plan_creation_time = start.elapsed();
 
@@ -182,13 +158,12 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
             scans: vec![],
             input_sources,
             stream: None,
-            conf: configs,
             runtime,
             metrics,
             plan_creation_time,
             session_ctx: Arc::new(session),
-            debug_native,
-            explain_native,
+            debug_native: debug_native == 1,
+            explain_native: explain_native == 1,
             metrics_jstrings: HashMap::new(),
         });
 
@@ -196,19 +171,11 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
     })
 }
 
-/// Parse Comet configs and configure DataFusion session context.
+/// Configure DataFusion session context.
 fn prepare_datafusion_session_context(
-    conf: &HashMap<String, String>,
+    batch_size: usize,
     comet_task_memory_manager: Arc<GlobalRef>,
 ) -> CometResult<SessionContext> {
-    // Get the batch size from Comet JVM side
-    let batch_size = conf
-        .get("batch_size")
-        .ok_or(CometError::Internal(
-            "Config 'batch_size' is not specified from Comet JVM side".to_string(),
-        ))?
-        .parse::<usize>()?;
-
     let mut rt_config = RuntimeConfig::new().with_disk_manager(DiskManagerConfig::NewOs);
 
     // Set Comet memory pool for native
@@ -218,7 +185,7 @@ fn prepare_datafusion_session_context(
     // Get Datafusion configuration from Spark Execution context
     // can be configured in Comet Spark JVM using Spark --conf parameters
     // e.g: spark-shell --conf spark.datafusion.sql_parser.parse_float_as_decimal=true
-    let mut session_config = SessionConfig::new()
+    let session_config = SessionConfig::new()
         .with_batch_size(batch_size)
         // DataFusion partial aggregates can emit duplicate rows so we disable the
         // skip partial aggregation feature because this is not compatible with Spark's
@@ -231,11 +198,7 @@ fn prepare_datafusion_session_context(
             &ScalarValue::Float64(Some(1.1)),
         );
 
-    for (key, value) in conf.iter().filter(|(k, _)| k.starts_with("datafusion.")) {
-        session_config = session_config.set_str(key, value);
-    }
-
-    let runtime = RuntimeEnv::try_new(rt_config).unwrap();
+    let runtime = RuntimeEnv::try_new(rt_config)?;
 
     let mut session_ctx = SessionContext::new_with_config_rt(session_config, Arc::new(runtime));
 
diff --git a/spark/src/main/scala/org/apache/comet/CometExecIterator.scala b/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
index bff3e79256..d57e9e2b87 100644
--- a/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
+++ b/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
@@ -60,43 +60,23 @@ class CometExecIterator(
     new CometBatchIterator(iterator, nativeUtil)
   }.toArray
   private val plan = {
-    val configs = createNativeConf
     nativeLib.createPlan(
       id,
-      configs,
       cometBatchIterators,
       protobufQueryPlan,
       nativeMetrics,
-      new CometTaskMemoryManager(id))
+      new CometTaskMemoryManager(id),
+      batchSize = COMET_BATCH_SIZE.get(),
+      debug = COMET_DEBUG_ENABLED.get(),
+      explain = COMET_EXPLAIN_NATIVE_ENABLED.get(),
+      workerThreads = COMET_WORKER_THREADS.get(),
+      blockingThreads = COMET_BLOCKING_THREADS.get())
   }
 
   private var nextBatch: Option[ColumnarBatch] = None
   private var currentBatch: ColumnarBatch = null
   private var closed: Boolean = false
 
-  /**
-   * Creates a new configuration map to be passed to the native side.
-   */
-  private def createNativeConf: java.util.HashMap[String, String] = {
-    val result = new java.util.HashMap[String, String]()
-    val conf = SparkEnv.get.conf
-
-    result.put("batch_size", String.valueOf(COMET_BATCH_SIZE.get()))
-    result.put("debug_native", String.valueOf(COMET_DEBUG_ENABLED.get()))
-    result.put("explain_native", String.valueOf(COMET_EXPLAIN_NATIVE_ENABLED.get()))
-    result.put("worker_threads", String.valueOf(COMET_WORKER_THREADS.get()))
-    result.put("blocking_threads", String.valueOf(COMET_BLOCKING_THREADS.get()))
-
-    // Strip mandatory prefix spark. which is not required for DataFusion session params
-    conf.getAll.foreach {
-      case (k, v) if k.startsWith("spark.datafusion") =>
-        result.put(k.replaceFirst("spark\\.", ""), v)
-      case _ =>
-    }
-
-    result
-  }
-
   def getNextBatch(): Option[ColumnarBatch] = {
     assert(partitionIndex >= 0 && partitionIndex < numParts)
 
diff --git a/spark/src/main/scala/org/apache/comet/Native.scala b/spark/src/main/scala/org/apache/comet/Native.scala
index 52063419df..64ada91adc 100644
--- a/spark/src/main/scala/org/apache/comet/Native.scala
+++ b/spark/src/main/scala/org/apache/comet/Native.scala
@@ -19,8 +19,6 @@
 
 package org.apache.comet
 
-import java.util.Map
-
 import org.apache.spark.CometTaskMemoryManager
 import org.apache.spark.sql.comet.CometMetricNode
 
@@ -47,11 +45,15 @@ class Native extends NativeBase {
    */
   @native def createPlan(
       id: Long,
-      configMap: Map[String, String],
       iterators: Array[CometBatchIterator],
       plan: Array[Byte],
       metrics: CometMetricNode,
-      taskMemoryManager: CometTaskMemoryManager): Long
+      taskMemoryManager: CometTaskMemoryManager,
+      batchSize: Int,
+      debug: Boolean,
+      explain: Boolean,
+      workerThreads: Int,
+      blockingThreads: Int): Long
 
   /**
    * Execute a native query plan based on given input Arrow arrays.

From 8d7bcb84beab70f46321eb4feeb21ebdd6b55709 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 5 Dec 2024 17:01:50 -0700
Subject: [PATCH 23/47] feat: Improve ScanExec native metrics (#1133)

* save

* remove shuffle jvm metric and update tuning guide

* docs

* add source for all ScanExecs

* address feedback

* address feedback
---
 docs/source/user-guide/tuning.md              | 21 ++++++---
 .../execution/datafusion/shuffle_writer.rs    | 26 +++--------
 native/core/src/execution/operators/scan.rs   | 44 ++++++++++++++++---
 native/core/src/jvm_bridge/batch_iterator.rs  |  4 ++
 .../org/apache/comet/CometBatchIterator.java  | 28 +++++++++---
 .../apache/comet/serde/QueryPlanSerde.scala   |  7 ++-
 .../spark/sql/comet/CometExecUtils.scala      |  4 +-
 .../shuffle/CometShuffleExchangeExec.scala    | 14 +-----
 8 files changed, 97 insertions(+), 51 deletions(-)

diff --git a/docs/source/user-guide/tuning.md b/docs/source/user-guide/tuning.md
index e0d7c1bc93..af722494f9 100644
--- a/docs/source/user-guide/tuning.md
+++ b/docs/source/user-guide/tuning.md
@@ -103,7 +103,9 @@ native shuffle currently only supports `HashPartitioning` and `SinglePartitionin
 To enable native shuffle, set `spark.comet.exec.shuffle.mode` to `native`. If this mode is explicitly set,
 then any shuffle operations that cannot be supported in this mode will fall back to Spark.
 
-## Metrics
+##  Metrics
+
+### Spark SQL Metrics
 
 Some Comet metrics are not directly comparable to Spark metrics in some cases:
 
@@ -111,10 +113,17 @@ Some Comet metrics are not directly comparable to Spark metrics in some cases:
   milliseconds _per batch_ which can result in a large loss of precision, making it difficult to compare scan times
   between Spark and Comet.
 
-Comet also adds some custom metrics:
+### Native Metrics
+
+Setting `spark.comet.explain.native.enabled=true` will cause native plans to be logged in each executor. Metrics are
+logged for each native plan (and there is one plan per task, so this is very verbose).
+
+Here is a guide to some of the native metrics.
 
-### ShuffleWriterExec
+### ScanExec
 
-| Metric           | Description                                                                                                                                                                       |
-| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `jvm_fetch_time` | Measure the time it takes for `ShuffleWriterExec` to fetch batches from the JVM. Note that this does not include the execution time of the query that produced the input batches. |
+| Metric            | Description                                                                                         |
+| ----------------- | --------------------------------------------------------------------------------------------------- |
+| `elapsed_compute` | Total time spent in this operator, fetching batches from a JVM iterator.                            |
+| `jvm_fetch_time`  | Time spent in the JVM fetching input batches to be read by this `ScanExec` instance.                |
+| `arrow_ffi_time`  | Time spent using Arrow FFI to create Arrow batches from the memory addresses returned from the JVM. |
diff --git a/native/core/src/execution/datafusion/shuffle_writer.rs b/native/core/src/execution/datafusion/shuffle_writer.rs
index c79eeeb4a0..7587ff06dc 100644
--- a/native/core/src/execution/datafusion/shuffle_writer.rs
+++ b/native/core/src/execution/datafusion/shuffle_writer.rs
@@ -139,7 +139,6 @@ impl ExecutionPlan for ShuffleWriterExec {
     ) -> Result<SendableRecordBatchStream> {
         let input = self.input.execute(partition, Arc::clone(&context))?;
         let metrics = ShuffleRepartitionerMetrics::new(&self.metrics, 0);
-        let jvm_fetch_time = MetricBuilder::new(&self.metrics).subset_time("jvm_fetch_time", 0);
 
         Ok(Box::pin(RecordBatchStreamAdapter::new(
             self.schema(),
@@ -152,7 +151,6 @@ impl ExecutionPlan for ShuffleWriterExec {
                     self.partitioning.clone(),
                     metrics,
                     context,
-                    jvm_fetch_time,
                 )
                 .map_err(|e| ArrowError::ExternalError(Box::new(e))),
             )
@@ -1085,7 +1083,6 @@ impl Debug for ShuffleRepartitioner {
     }
 }
 
-#[allow(clippy::too_many_arguments)]
 async fn external_shuffle(
     mut input: SendableRecordBatchStream,
     partition_id: usize,
@@ -1094,7 +1091,6 @@ async fn external_shuffle(
     partitioning: Partitioning,
     metrics: ShuffleRepartitionerMetrics,
     context: Arc<TaskContext>,
-    jvm_fetch_time: Time,
 ) -> Result<SendableRecordBatchStream> {
     let schema = input.schema();
     let mut repartitioner = ShuffleRepartitioner::new(
@@ -1108,23 +1104,13 @@ async fn external_shuffle(
         context.session_config().batch_size(),
     );
 
-    loop {
-        let mut timer = jvm_fetch_time.timer();
-        let b = input.next().await;
-        timer.stop();
-
-        match b {
-            Some(batch_result) => {
-                // Block on the repartitioner to insert the batch and shuffle the rows
-                // into the corresponding partition buffer.
-                // Otherwise, pull the next batch from the input stream might overwrite the
-                // current batch in the repartitioner.
-                block_on(repartitioner.insert_batch(batch_result?))?;
-            }
-            _ => break,
-        }
+    while let Some(batch) = input.next().await {
+        // Block on the repartitioner to insert the batch and shuffle the rows
+        // into the corresponding partition buffer.
+        // Otherwise, pull the next batch from the input stream might overwrite the
+        // current batch in the repartitioner.
+        block_on(repartitioner.insert_batch(batch?))?;
     }
-
     repartitioner.shuffle_write().await
 }
 
diff --git a/native/core/src/execution/operators/scan.rs b/native/core/src/execution/operators/scan.rs
index 2cb8a84d94..a97caf0db1 100644
--- a/native/core/src/execution/operators/scan.rs
+++ b/native/core/src/execution/operators/scan.rs
@@ -77,6 +77,10 @@ pub struct ScanExec {
     metrics: ExecutionPlanMetricsSet,
     /// Baseline metrics
     baseline_metrics: BaselineMetrics,
+    /// Time waiting for JVM input plan to execute and return batches
+    jvm_fetch_time: Time,
+    /// Time spent in FFI
+    arrow_ffi_time: Time,
 }
 
 impl ScanExec {
@@ -88,6 +92,8 @@ impl ScanExec {
     ) -> Result<Self, CometError> {
         let metrics_set = ExecutionPlanMetricsSet::default();
         let baseline_metrics = BaselineMetrics::new(&metrics_set, 0);
+        let arrow_ffi_time = MetricBuilder::new(&metrics_set).subset_time("arrow_ffi_time", 0);
+        let jvm_fetch_time = MetricBuilder::new(&metrics_set).subset_time("jvm_fetch_time", 0);
 
         // Scan's schema is determined by the input batch, so we need to set it before execution.
         // Note that we determine if arrays are dictionary-encoded based on the
@@ -97,8 +103,13 @@ impl ScanExec {
         // Dictionary-encoded primitive arrays are always unpacked.
         let first_batch = if let Some(input_source) = input_source.as_ref() {
             let mut timer = baseline_metrics.elapsed_compute().timer();
-            let batch =
-                ScanExec::get_next(exec_context_id, input_source.as_obj(), data_types.len())?;
+            let batch = ScanExec::get_next(
+                exec_context_id,
+                input_source.as_obj(),
+                data_types.len(),
+                &jvm_fetch_time,
+                &arrow_ffi_time,
+            )?;
             timer.stop();
             batch
         } else {
@@ -124,6 +135,8 @@ impl ScanExec {
             cache,
             metrics: metrics_set,
             baseline_metrics,
+            jvm_fetch_time,
+            arrow_ffi_time,
             schema,
         })
     }
@@ -171,6 +184,8 @@ impl ScanExec {
                 self.exec_context_id,
                 self.input_source.as_ref().unwrap().as_obj(),
                 self.data_types.len(),
+                &self.jvm_fetch_time,
+                &self.arrow_ffi_time,
             )?;
             *current_batch = Some(next_batch);
         }
@@ -185,6 +200,8 @@ impl ScanExec {
         exec_context_id: i64,
         iter: &JObject,
         num_cols: usize,
+        jvm_fetch_time: &Time,
+        arrow_ffi_time: &Time,
     ) -> Result<InputBatch, CometError> {
         if exec_context_id == TEST_EXEC_CONTEXT_ID {
             // This is a unit test. We don't need to call JNI.
@@ -200,6 +217,21 @@ impl ScanExec {
 
         let mut env = JVMClasses::get_env()?;
 
+        let mut timer = jvm_fetch_time.timer();
+
+        let num_rows: i32 = unsafe {
+            jni_call!(&mut env,
+        comet_batch_iterator(iter).has_next() -> i32)?
+        };
+
+        timer.stop();
+
+        if num_rows == -1 {
+            return Ok(InputBatch::EOF);
+        }
+
+        let mut timer = arrow_ffi_time.timer();
+
         let mut array_addrs = Vec::with_capacity(num_cols);
         let mut schema_addrs = Vec::with_capacity(num_cols);
 
@@ -233,9 +265,9 @@ impl ScanExec {
         comet_batch_iterator(iter).next(array_obj, schema_obj) -> i32)?
         };
 
-        if num_rows == -1 {
-            return Ok(InputBatch::EOF);
-        }
+        // we already checked for end of results on call to has_next() so should always
+        // have a valid row count when calling next()
+        assert!(num_rows != -1);
 
         let mut inputs: Vec<ArrayRef> = Vec::with_capacity(num_cols);
 
@@ -255,6 +287,8 @@ impl ScanExec {
             }
         }
 
+        timer.stop();
+
         Ok(InputBatch::new(inputs, Some(num_rows as usize)))
     }
 }
diff --git a/native/core/src/jvm_bridge/batch_iterator.rs b/native/core/src/jvm_bridge/batch_iterator.rs
index 4870624d2b..45b10cf208 100644
--- a/native/core/src/jvm_bridge/batch_iterator.rs
+++ b/native/core/src/jvm_bridge/batch_iterator.rs
@@ -26,6 +26,8 @@ use jni::{
 /// A struct that holds all the JNI methods and fields for JVM `CometBatchIterator` class.
 pub struct CometBatchIterator<'a> {
     pub class: JClass<'a>,
+    pub method_has_next: JMethodID,
+    pub method_has_next_ret: ReturnType,
     pub method_next: JMethodID,
     pub method_next_ret: ReturnType,
 }
@@ -38,6 +40,8 @@ impl<'a> CometBatchIterator<'a> {
 
         Ok(CometBatchIterator {
             class,
+            method_has_next: env.get_method_id(Self::JVM_CLASS, "hasNext", "()I")?,
+            method_has_next_ret: ReturnType::Primitive(Primitive::Int),
             method_next: env.get_method_id(Self::JVM_CLASS, "next", "([J[J)I")?,
             method_next_ret: ReturnType::Primitive(Primitive::Int),
         })
diff --git a/spark/src/main/java/org/apache/comet/CometBatchIterator.java b/spark/src/main/java/org/apache/comet/CometBatchIterator.java
index accd57c208..e05bea1dff 100644
--- a/spark/src/main/java/org/apache/comet/CometBatchIterator.java
+++ b/spark/src/main/java/org/apache/comet/CometBatchIterator.java
@@ -33,12 +33,31 @@
 public class CometBatchIterator {
   final Iterator<ColumnarBatch> input;
   final NativeUtil nativeUtil;
+  private ColumnarBatch currentBatch = null;
 
   CometBatchIterator(Iterator<ColumnarBatch> input, NativeUtil nativeUtil) {
     this.input = input;
     this.nativeUtil = nativeUtil;
   }
 
+  /**
+   * Fetch the next input batch.
+   *
+   * @return Number of rows in next batch or -1 if no batches left.
+   */
+  public int hasNext() {
+    if (currentBatch == null) {
+      if (input.hasNext()) {
+        currentBatch = input.next();
+      }
+    }
+    if (currentBatch == null) {
+      return -1;
+    } else {
+      return currentBatch.numRows();
+    }
+  }
+
   /**
    * Get the next batches of Arrow arrays.
    *
@@ -47,12 +66,11 @@ public class CometBatchIterator {
    * @return the number of rows of the current batch. -1 if there is no more batch.
    */
   public int next(long[] arrayAddrs, long[] schemaAddrs) {
-    boolean hasBatch = input.hasNext();
-
-    if (!hasBatch) {
+    if (currentBatch == null) {
       return -1;
     }
-
-    return nativeUtil.exportBatch(arrayAddrs, schemaAddrs, input.next());
+    int numRows = nativeUtil.exportBatch(arrayAddrs, schemaAddrs, currentBatch);
+    currentBatch = null;
+    return numRows;
   }
 }
diff --git a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
index 2bb467af58..b33f6b5a6b 100644
--- a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
+++ b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
@@ -2909,7 +2909,12 @@ object QueryPlanSerde extends Logging with ShimQueryPlanSerde with CometExprShim
       case op if isCometSink(op) && op.output.forall(a => supportedDataType(a.dataType, true)) =>
         // These operators are source of Comet native execution chain
         val scanBuilder = OperatorOuterClass.Scan.newBuilder()
-        scanBuilder.setSource(op.simpleStringWithNodeId())
+        val source = op.simpleStringWithNodeId()
+        if (source.isEmpty) {
+          scanBuilder.setSource(op.getClass.getSimpleName)
+        } else {
+          scanBuilder.setSource(source)
+        }
 
         val scanTypes = op.output.flatten { attr =>
           serializeDataType(attr.dataType)
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/CometExecUtils.scala b/spark/src/main/scala/org/apache/spark/sql/comet/CometExecUtils.scala
index 9698dc98b8..2fc73bb7c5 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/CometExecUtils.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/CometExecUtils.scala
@@ -88,7 +88,7 @@ object CometExecUtils {
    * child partition
    */
   def getLimitNativePlan(outputAttributes: Seq[Attribute], limit: Int): Option[Operator] = {
-    val scanBuilder = OperatorOuterClass.Scan.newBuilder()
+    val scanBuilder = OperatorOuterClass.Scan.newBuilder().setSource("LimitInput")
     val scanOpBuilder = OperatorOuterClass.Operator.newBuilder()
 
     val scanTypes = outputAttributes.flatten { attr =>
@@ -118,7 +118,7 @@ object CometExecUtils {
       sortOrder: Seq[SortOrder],
       child: SparkPlan,
       limit: Int): Option[Operator] = {
-    val scanBuilder = OperatorOuterClass.Scan.newBuilder()
+    val scanBuilder = OperatorOuterClass.Scan.newBuilder().setSource("TopKInput")
     val scanOpBuilder = OperatorOuterClass.Operator.newBuilder()
 
     val scanTypes = outputAttributes.flatten { attr =>
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
index a7a33c40d6..b1dd9ac836 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
@@ -77,9 +77,6 @@ case class CometShuffleExchangeExec(
     SQLShuffleReadMetricsReporter.createShuffleReadMetrics(sparkContext)
   override lazy val metrics: Map[String, SQLMetric] = Map(
     "dataSize" -> SQLMetrics.createSizeMetric(sparkContext, "data size"),
-    "jvm_fetch_time" -> SQLMetrics.createNanoTimingMetric(
-      sparkContext,
-      "time fetching batches from JVM"),
     "numPartitions" -> SQLMetrics.createMetric(
       sparkContext,
       "number of partitions")) ++ readMetrics ++ writeMetrics
@@ -485,14 +482,7 @@ class CometShuffleWriteProcessor(
       "output_rows" -> metrics(SQLShuffleWriteMetricsReporter.SHUFFLE_RECORDS_WRITTEN),
       "data_size" -> metrics("dataSize"),
       "elapsed_compute" -> metrics(SQLShuffleWriteMetricsReporter.SHUFFLE_WRITE_TIME))
-
-    val nativeMetrics = if (metrics.contains("jvm_fetch_time")) {
-      CometMetricNode(
-        nativeSQLMetrics ++ Map("jvm_fetch_time" ->
-          metrics("jvm_fetch_time")))
-    } else {
-      CometMetricNode(nativeSQLMetrics)
-    }
+    val nativeMetrics = CometMetricNode(nativeSQLMetrics)
 
     // Getting rid of the fake partitionId
     val newInputs = inputs.asInstanceOf[Iterator[_ <: Product2[Any, Any]]].map(_._2)
@@ -538,7 +528,7 @@ class CometShuffleWriteProcessor(
   }
 
   def getNativePlan(dataFile: String, indexFile: String): Operator = {
-    val scanBuilder = OperatorOuterClass.Scan.newBuilder()
+    val scanBuilder = OperatorOuterClass.Scan.newBuilder().setSource("ShuffleWriterInput")
     val opBuilder = OperatorOuterClass.Operator.newBuilder()
 
     val scanTypes = outputAttributes.flatten { attr =>

From 587c29bfb10e699070d6ea2ca27cda767bc31e51 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 5 Dec 2024 18:02:18 -0700
Subject: [PATCH 24/47] chore: Remove unused StringView struct (#1143)

* Remove unused StringView struct

* remove more dead code
---
 native/core/src/common/mod.rs |  18 ---
 native/core/src/data_type.rs  | 241 ----------------------------------
 native/core/src/lib.rs        |   3 -
 3 files changed, 262 deletions(-)
 delete mode 100644 native/core/src/data_type.rs

diff --git a/native/core/src/common/mod.rs b/native/core/src/common/mod.rs
index 1b7dfad287..dc539879fa 100644
--- a/native/core/src/common/mod.rs
+++ b/native/core/src/common/mod.rs
@@ -17,23 +17,5 @@
 
 #[macro_use]
 pub mod bit;
-
-use crate::TypeTrait;
-
-/// Getter APIs for Comet vectors.
-trait ValueGetter<T: TypeTrait> {
-    /// Gets the non-null value at `idx`.
-    ///
-    /// Note that null check needs to be done before the call, to ensure the value at `idx` is
-    /// not null.
-    fn value(&self, idx: usize) -> T::Native;
-}
-
-/// Setter APIs for Comet mutable vectors.
-trait ValueSetter<T: TypeTrait> {
-    /// Appends a non-null value `v` to the end of this vector.
-    fn append_value(&mut self, v: &T::Native);
-}
-
 mod buffer;
 pub use buffer::*;
diff --git a/native/core/src/data_type.rs b/native/core/src/data_type.rs
deleted file mode 100644
index b275de1c65..0000000000
--- a/native/core/src/data_type.rs
+++ /dev/null
@@ -1,241 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-use arrow::datatypes::DataType as ArrowDataType;
-use arrow_schema::TimeUnit;
-use std::{cmp, fmt::Debug};
-
-#[derive(Debug, PartialEq)]
-pub enum DataType {
-    Boolean,
-    Byte,
-    Short,
-    Integer,
-    Long,
-    Float,
-    Double,
-    Decimal(u8, i8),
-    String,
-    Binary,
-    Timestamp,
-    Date,
-}
-
-impl From<&ArrowDataType> for DataType {
-    fn from(dt: &ArrowDataType) -> Self {
-        match dt {
-            ArrowDataType::Boolean => DataType::Boolean,
-            ArrowDataType::Int8 => DataType::Byte,
-            ArrowDataType::Int16 => DataType::Short,
-            ArrowDataType::Int32 => DataType::Integer,
-            ArrowDataType::Int64 => DataType::Long,
-            ArrowDataType::Float32 => DataType::Float,
-            ArrowDataType::Float64 => DataType::Double,
-            ArrowDataType::Decimal128(precision, scale) => DataType::Decimal(*precision, *scale),
-            ArrowDataType::Utf8 => DataType::String,
-            ArrowDataType::Binary => DataType::Binary,
-            // Spark always store timestamp in micro seconds
-            ArrowDataType::Timestamp(TimeUnit::Microsecond, _) => DataType::Timestamp,
-            ArrowDataType::Date32 => DataType::Date,
-            ArrowDataType::Dictionary(key_dt, value_dt) if is_valid_key_type(key_dt) => {
-                Self::from(value_dt.as_ref())
-            }
-            dt => panic!("unsupported Arrow data type: {:?}", dt),
-        }
-    }
-}
-
-impl DataType {
-    pub fn kind(&self) -> TypeKind {
-        match self {
-            DataType::Boolean => TypeKind::Boolean,
-            DataType::Byte => TypeKind::Byte,
-            DataType::Short => TypeKind::Short,
-            DataType::Integer => TypeKind::Integer,
-            DataType::Long => TypeKind::Long,
-            DataType::Float => TypeKind::Float,
-            DataType::Double => TypeKind::Double,
-            DataType::Decimal(_, _) => TypeKind::Decimal,
-            DataType::String => TypeKind::String,
-            DataType::Binary => TypeKind::Binary,
-            DataType::Timestamp => TypeKind::Timestamp,
-            DataType::Date => TypeKind::Date,
-        }
-    }
-}
-
-/// Comet only use i32 as dictionary key
-fn is_valid_key_type(dt: &ArrowDataType) -> bool {
-    matches!(dt, ArrowDataType::Int32)
-}
-
-/// Unlike [`DataType`], [`TypeKind`] doesn't carry extra information about the type itself, such as
-/// decimal precision & scale. Instead, it is merely a token that is used to do runtime case
-/// analysis depending on the actual type. It can be obtained from a `TypeTrait` generic parameter.
-#[derive(Debug, PartialEq)]
-pub enum TypeKind {
-    Boolean,
-    Byte,
-    Short,
-    Integer,
-    Long,
-    Float,
-    Double,
-    Decimal,
-    String,
-    Binary,
-    Timestamp,
-    Date,
-}
-
-pub const BITS_PER_BYTE: usize = 8;
-
-impl TypeKind {
-    /// Returns the size of this type, in number of bits.
-    pub fn type_size(&self) -> usize {
-        match self {
-            TypeKind::Boolean => 1,
-            TypeKind::Byte => BITS_PER_BYTE,
-            TypeKind::Short => BITS_PER_BYTE * 2,
-            TypeKind::Integer | TypeKind::Float => BITS_PER_BYTE * 4,
-            TypeKind::Long | TypeKind::Double => BITS_PER_BYTE * 8,
-            TypeKind::Decimal => BITS_PER_BYTE * 16,
-            TypeKind::String | TypeKind::Binary => BITS_PER_BYTE * 16,
-            TypeKind::Timestamp => BITS_PER_BYTE * 8,
-            TypeKind::Date => BITS_PER_BYTE * 4,
-        }
-    }
-}
-
-pub const STRING_VIEW_LEN: usize = 16; // StringView is stored using 16 bytes
-pub const STRING_VIEW_PREFIX_LEN: usize = 4; // String prefix in StringView is stored using 4 bytes
-
-#[repr(C, align(16))]
-#[derive(Clone, Copy, Debug)]
-pub struct StringView {
-    pub len: u32,
-    pub prefix: [u8; STRING_VIEW_PREFIX_LEN],
-    pub ptr: usize,
-}
-
-impl StringView {
-    pub fn as_utf8_str(&self) -> &str {
-        unsafe {
-            let slice = std::slice::from_raw_parts(self.ptr as *const u8, self.len as usize);
-            std::str::from_utf8_unchecked(slice)
-        }
-    }
-}
-
-impl Default for StringView {
-    fn default() -> Self {
-        Self {
-            len: 0,
-            prefix: [0; STRING_VIEW_PREFIX_LEN],
-            ptr: 0,
-        }
-    }
-}
-
-impl PartialEq for StringView {
-    fn eq(&self, other: &Self) -> bool {
-        if self.len != other.len {
-            return false;
-        }
-        if self.prefix != other.prefix {
-            return false;
-        }
-        self.as_utf8_str() == other.as_utf8_str()
-    }
-}
-
-pub trait NativeEqual {
-    fn is_equal(&self, other: &Self) -> bool;
-}
-
-macro_rules! make_native_equal {
-    ($native_ty:ty) => {
-        impl NativeEqual for $native_ty {
-            fn is_equal(&self, other: &Self) -> bool {
-                self == other
-            }
-        }
-    };
-}
-
-make_native_equal!(bool);
-make_native_equal!(i8);
-make_native_equal!(i16);
-make_native_equal!(i32);
-make_native_equal!(i64);
-make_native_equal!(i128);
-make_native_equal!(StringView);
-
-impl NativeEqual for f32 {
-    fn is_equal(&self, other: &Self) -> bool {
-        self.total_cmp(other) == cmp::Ordering::Equal
-    }
-}
-
-impl NativeEqual for f64 {
-    fn is_equal(&self, other: &Self) -> bool {
-        self.total_cmp(other) == cmp::Ordering::Equal
-    }
-}
-pub trait NativeType: Debug + Default + Copy + NativeEqual {}
-
-impl NativeType for bool {}
-impl NativeType for i8 {}
-impl NativeType for i16 {}
-impl NativeType for i32 {}
-impl NativeType for i64 {}
-impl NativeType for i128 {}
-impl NativeType for f32 {}
-impl NativeType for f64 {}
-impl NativeType for StringView {}
-
-/// A trait for Comet data type. This should only be used as generic parameter during method
-/// invocations.
-pub trait TypeTrait: 'static {
-    type Native: NativeType;
-    fn type_kind() -> TypeKind;
-}
-
-macro_rules! make_type_trait {
-    ($name:ident, $native_ty:ty, $kind:path) => {
-        pub struct $name {}
-        impl TypeTrait for $name {
-            type Native = $native_ty;
-            fn type_kind() -> TypeKind {
-                $kind
-            }
-        }
-    };
-}
-
-make_type_trait!(BoolType, bool, TypeKind::Boolean);
-make_type_trait!(ByteType, i8, TypeKind::Byte);
-make_type_trait!(ShortType, i16, TypeKind::Short);
-make_type_trait!(IntegerType, i32, TypeKind::Integer);
-make_type_trait!(LongType, i64, TypeKind::Long);
-make_type_trait!(FloatType, f32, TypeKind::Float);
-make_type_trait!(DoubleType, f64, TypeKind::Double);
-make_type_trait!(DecimalType, i128, TypeKind::Decimal);
-make_type_trait!(StringType, StringView, TypeKind::String);
-make_type_trait!(BinaryType, StringView, TypeKind::Binary);
-make_type_trait!(TimestampType, i64, TypeKind::Timestamp);
-make_type_trait!(DateType, i32, TypeKind::Date);
diff --git a/native/core/src/lib.rs b/native/core/src/lib.rs
index 36e63e39c9..c6a7a4143d 100644
--- a/native/core/src/lib.rs
+++ b/native/core/src/lib.rs
@@ -40,15 +40,12 @@ use log4rs::{
 use mimalloc::MiMalloc;
 use once_cell::sync::OnceCell;
 
-pub use data_type::*;
-
 use errors::{try_unwrap_or_throw, CometError, CometResult};
 
 #[macro_use]
 mod errors;
 #[macro_use]
 pub mod common;
-mod data_type;
 pub mod execution;
 mod jvm_bridge;
 pub mod parquet;

From b95dc1d84554b7cd5728ed53a24463a2e111ba44 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Fri, 6 Dec 2024 13:04:51 -0700
Subject: [PATCH 25/47] docs: Add some documentation explaining how shuffle
 works (#1148)

* add some notes on shuffle

* reads

* improve docs
---
 .../contributor-guide/plugin_overview.md      | 59 +++++++++++++------
 1 file changed, 42 insertions(+), 17 deletions(-)

diff --git a/docs/source/contributor-guide/plugin_overview.md b/docs/source/contributor-guide/plugin_overview.md
index 3e7c24f55a..add4172d5c 100644
--- a/docs/source/contributor-guide/plugin_overview.md
+++ b/docs/source/contributor-guide/plugin_overview.md
@@ -19,17 +19,26 @@ under the License.
 
 # Comet Plugin Architecture
 
+## Overview
+
+The Comet plugin enhances Spark SQL by introducing optimized query execution and shuffle mechanisms leveraging
+native code. It integrates with Spark's plugin framework and extension API to replace or extend Spark's
+default behavior.
+
+---
+
+# Plugin Components
+
 ## Comet SQL Plugin
 
-The entry point to Comet is the `org.apache.spark.CometPlugin` class, which can be registered with Spark by adding the
-following setting to the Spark configuration when launching `spark-shell` or `spark-submit`:
+The entry point to Comet is the org.apache.spark.CometPlugin class, which is registered in Spark using the following 
+configuration:
 
 ```
 --conf spark.plugins=org.apache.spark.CometPlugin
 ```
 
-This class is loaded by Spark's plugin framework. It will be instantiated in the Spark driver only. Comet does not
-provide any executor plugins.
+The plugin is loaded on the Spark driver and does not provide executor-side plugins.
 
 The plugin will update the current `SparkConf` with the extra configuration provided by Comet, such as executor memory
 configuration.
@@ -87,7 +96,7 @@ In the native code there is a `PhysicalPlanner` struct (in `planner.rs`) which c
 Apache DataFusion `ExecutionPlan`. In some cases, Comet provides specialized physical operators and expressions to
 override the DataFusion versions to ensure compatibility with Apache Spark.
 
-The leaf nodes in the physical plan are always `ScanExec` and each of these operators will make a JNI call to 
+The leaf nodes in the physical plan are always `ScanExec` and each of these operators will make a JNI call to
 `CometBatchIterator.next()` to fetch the next input batch. The input could be a Comet native Parquet scan,
 a Spark exchange, or another native plan.
 
@@ -95,15 +104,38 @@ a Spark exchange, or another native plan.
 partitions. Each call to `CometExecIterator.next()` will invoke `Native.executePlan`. Once the plan finishes
 executing, the resulting Arrow batches are imported into the JVM using Arrow FFI.
 
-## Arrow
+## Shuffle
 
-Due to the hybrid execution model, it is necessary to pass batches of data between the JVM and native code.
+Comet integrates with Spark's shuffle mechanism, optimizing both shuffle writes and reads. Comet's shuffle manager 
+must be registered with Spark using the following configuration:
+
+```
+--conf spark.shuffle.manager=org.apache.spark.sql.comet.execution.shuffle.CometShuffleManager
+```
+
+### Shuffle Writes
 
-Comet uses a combination of Arrow FFI and Arrow IPC to achieve this.
+For shuffle writes, a `ShuffleMapTask` runs in the executors. This task contains a `ShuffleDependency` that is
+broadcast to all of the executors. It then passes the input RDD to `ShuffleWriteProcessor.write()` which
+requests a `ShuffleWriter` from the shuffle manager, and this is where it gets a Comet shuffle writer.
 
-### Arrow FFI
+`ShuffleWriteProcessor` then invokes the dependency RDD and fetches rows/batches and passes them to Comet's 
+shuffle writer, which writes batches to disk in Arrow IPC format.
 
-The foundation for Arrow FFI is the [Arrow C Data Interface], which provides a stable ABI-compatible interface for 
+As a result, we cannot avoid having one native plan to produce the shuffle input and another native plan for
+writing the batches to the shuffle file.
+
+### Shuffle Reads
+
+For shuffle reads a `ShuffledRDD` requests a `ShuffleReader` from the shuffle manager. Comet provides a 
+`CometBlockStoreShuffleReader` which is implemented in JVM and fetches blocks from Spark and then creates an 
+`ArrowReaderIterator` to process the blocks using Arrow's `StreamReader` for decoding IPC batches.
+
+## Arrow FFI
+
+Due to the hybrid execution model, it is necessary to pass batches of data between the JVM and native code.
+
+The foundation for Arrow FFI is the [Arrow C Data Interface], which provides a stable ABI-compatible interface for
 accessing Arrow data structures from multiple languages.
 
 [Arrow C Data Interface]: https://arrow.apache.org/docs/format/CDataInterface.html
@@ -111,13 +143,6 @@ accessing Arrow data structures from multiple languages.
 - `CometExecIterator` invokes native plans and uses Arrow FFI to read the output batches
 - Native `ScanExec` operators call `CometBatchIterator` via JNI to fetch input batches from the JVM
 
-### Arrow IPC
-
-Comet native shuffle uses Arrow IPC to write batches to the shuffle files.
-
-- `CometShuffleWriteProcessor` invokes a native plan to fetch batches and then passes them to native `ShuffleWriterExec`
-- `CometBlockStoreShuffleReader` reads batches from shuffle files
-
 ## End to End Flow
 
 The following diagram shows an example of the end-to-end flow for a query stage.

From 1c6c7a93ae1a04e82255768ef46e401ed57453d2 Mon Sep 17 00:00:00 2001
From: KAZUYUKI TANIMURA <ktanimura@apple.com>
Date: Fri, 6 Dec 2024 12:55:05 -0800
Subject: [PATCH 26/47] test: enable more Spark 4.0 tests (#1145)

## Which issue does this PR close?

Part of https://github.com/apache/datafusion-comet/issues/372 and https://github.com/apache/datafusion-comet/issues/551

## Rationale for this change

To be ready for Spark 4.0

## What changes are included in this PR?

This PR enables more Spark 4.0 tests that were fixed by recent changes

## How are these changes tested?

tests enabled
---
 dev/diffs/4.0.0-preview1.diff | 476 +---------------------------------
 1 file changed, 4 insertions(+), 472 deletions(-)

diff --git a/dev/diffs/4.0.0-preview1.diff b/dev/diffs/4.0.0-preview1.diff
index 335aa01d1e..1a6810a7ab 100644
--- a/dev/diffs/4.0.0-preview1.diff
+++ b/dev/diffs/4.0.0-preview1.diff
@@ -1,5 +1,5 @@
 diff --git a/pom.xml b/pom.xml
-index a4b1b2c3c9f..db50bdb0d3b 100644
+index a4b1b2c3c9f..6a532749978 100644
 --- a/pom.xml
 +++ b/pom.xml
 @@ -147,6 +147,8 @@
@@ -38,7 +38,7 @@ index a4b1b2c3c9f..db50bdb0d3b 100644
        <dependency>
          <groupId>org.apache.datasketches</groupId>
 diff --git a/sql/core/pom.xml b/sql/core/pom.xml
-index 19f6303be36..31e1d27700f 100644
+index 19f6303be36..6c0e77882e6 100644
 --- a/sql/core/pom.xml
 +++ b/sql/core/pom.xml
 @@ -77,6 +77,10 @@
@@ -146,133 +146,6 @@ index 698ca009b4f..57d774a3617 100644
  
  -- Test tables
  CREATE table  explain_temp1 (key int, val int) USING PARQUET;
-diff --git a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/aggregates_part1.sql b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/aggregates_part1.sql
-index 1152d77da0c..f77493f690b 100644
---- a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/aggregates_part1.sql
-+++ b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/aggregates_part1.sql
-@@ -7,6 +7,9 @@
- 
- -- avoid bit-exact output here because operations may not be bit-exact.
- -- SET extra_float_digits = 0;
-+-- Disable Comet exec due to floating point precision difference
-+--SET spark.comet.exec.enabled = false
-+
- 
- -- Test aggregate operator with codegen on and off.
- --CONFIG_DIM1 spark.sql.codegen.wholeStage=true
-diff --git a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/aggregates_part3.sql b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/aggregates_part3.sql
-index 41fd4de2a09..44cd244d3b0 100644
---- a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/aggregates_part3.sql
-+++ b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/aggregates_part3.sql
-@@ -5,6 +5,9 @@
- -- AGGREGATES [Part 3]
- -- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/aggregates.sql#L352-L605
- 
-+-- Disable Comet exec due to floating point precision difference
-+--SET spark.comet.exec.enabled = false
-+
- -- Test aggregate operator with codegen on and off.
- --CONFIG_DIM1 spark.sql.codegen.wholeStage=true
- --CONFIG_DIM1 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=CODEGEN_ONLY
-diff --git a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/float8.sql b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/float8.sql
-index 932cdb95fcf..bbafaadb960 100644
---- a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/float8.sql
-+++ b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/float8.sql
-@@ -5,6 +5,9 @@
- -- FLOAT8
- -- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/float8.sql
- 
-+-- TODO: https://github.com/apache/datafusion-comet/issues/551
-+--SET spark.comet.enabled = false
-+
- CREATE TABLE FLOAT8_TBL(f1 double) USING parquet;
- 
- -- PostgreSQL implicitly casts string literals to data with floating point types, but
-diff --git a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/groupingsets.sql b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/groupingsets.sql
-index f06b0276b00..1f39a1b3da8 100644
---- a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/groupingsets.sql
-+++ b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/groupingsets.sql
-@@ -5,6 +5,9 @@
- 
- -- test data sources
- 
-+-- TODO: https://github.com/apache/datafusion-comet/issues/551
-+--SET spark.comet.enabled = false
-+
- create temp view gstest1(a,b,v)
-   as values (1,1,10),(1,1,11),(1,2,12),(1,2,13),(1,3,14),
-             (2,3,15),
-diff --git a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int4.sql b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int4.sql
-index 3a409eea348..26e9aaf215c 100644
---- a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int4.sql
-+++ b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int4.sql
-@@ -6,6 +6,9 @@
- -- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/int4.sql
- --
- 
-+-- TODO: https://github.com/apache/datafusion-comet/issues/551
-+--SET spark.comet.enabled = false
-+
- CREATE TABLE INT4_TBL(f1 int) USING parquet;
- 
- -- [SPARK-28023] Trim the string when cast string type to other types
-diff --git a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int8.sql b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int8.sql
-index fac23b4a26f..2b73732c33f 100644
---- a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int8.sql
-+++ b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int8.sql
-@@ -1,6 +1,10 @@
- --
- -- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
- --
-+
-+-- Disable Comet exec due to floating point precision difference
-+--SET spark.comet.exec.enabled = false
-+
- --
- -- INT8
- -- Test int8 64-bit integers.
-diff --git a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/select_having.sql b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/select_having.sql
-index 0efe0877e9b..423d3b3d76d 100644
---- a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/select_having.sql
-+++ b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/select_having.sql
-@@ -1,6 +1,10 @@
- --
- -- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
- --
-+
-+-- Disable Comet exec due to floating point precision difference
-+--SET spark.comet.exec.enabled = false
-+
- --
- -- SELECT_HAVING
- -- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/select_having.sql
-diff --git a/sql/core/src/test/resources/sql-tests/inputs/view-schema-binding-config.sql b/sql/core/src/test/resources/sql-tests/inputs/view-schema-binding-config.sql
-index e803254ea64..74db78aee38 100644
---- a/sql/core/src/test/resources/sql-tests/inputs/view-schema-binding-config.sql
-+++ b/sql/core/src/test/resources/sql-tests/inputs/view-schema-binding-config.sql
-@@ -1,6 +1,9 @@
- -- This test suits check the spark.sql.viewSchemaBindingMode configuration.
- -- It can be DISABLED and COMPENSATION
- 
-+-- TODO: https://github.com/apache/datafusion-comet/issues/551
-+--SET spark.comet.enabled = false
-+
- -- Verify the default binding is true
- SET spark.sql.legacy.viewSchemaBindingMode;
- 
-diff --git a/sql/core/src/test/resources/sql-tests/inputs/view-schema-compensation.sql b/sql/core/src/test/resources/sql-tests/inputs/view-schema-compensation.sql
-index 21a3ce1e122..316788b2989 100644
---- a/sql/core/src/test/resources/sql-tests/inputs/view-schema-compensation.sql
-+++ b/sql/core/src/test/resources/sql-tests/inputs/view-schema-compensation.sql
-@@ -1,4 +1,8 @@
- -- This test suite checks the WITH SCHEMA COMPENSATION clause
-+
-+-- TODO: https://github.com/apache/datafusion-comet/issues/551
-+--SET spark.comet.enabled = false
-+
- -- Disable ANSI mode to ensure we are forcing it explicitly in the CASTS
- SET spark.sql.ansi.enabled = false;
- 
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/CachedTableSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/CachedTableSuite.scala
 index d023fb82185..0f4f03bda6c 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/CachedTableSuite.scala
@@ -348,7 +221,7 @@ index f6fd6b501d7..11870c85d82 100644
            spark.range(100).write.saveAsTable(s"$dbName.$table2Name")
  
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/DataFrameSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/DataFrameSuite.scala
-index 760ee802608..ebd4a34b08d 100644
+index 760ee802608..b77133ffd37 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/DataFrameSuite.scala
 +++ b/sql/core/src/test/scala/org/apache/spark/sql/DataFrameSuite.scala
 @@ -36,11 +36,12 @@ import org.apache.spark.sql.catalyst.expressions.{Attribute, AttributeReference,
@@ -407,16 +280,6 @@ index 760ee802608..ebd4a34b08d 100644
      }
      assert(exchanges.size == 2)
    }
-@@ -2299,7 +2302,8 @@ class DataFrameSuite extends QueryTest
-     assert(df2.isLocal)
-   }
- 
--  test("SPARK-35886: PromotePrecision should be subexpr replaced") {
-+  test("SPARK-35886: PromotePrecision should be subexpr replaced",
-+    IgnoreComet("TODO: fix Comet for this test")) {
-     withTable("tbl") {
-       sql(
-         """
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/DatasetSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/DatasetSuite.scala
 index 16a493b5290..3f0b70e2d59 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/DatasetSuite.scala
@@ -1054,7 +917,7 @@ index 34c6c49bc49..f5dea07a213 100644
    protected val baseResourcePath = {
      // use the same way as `SQLQueryTestSuite` to get the resource path
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala
-index 56c364e2084..fc3abd7cdc4 100644
+index 56c364e2084..a00a50e020a 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala
 +++ b/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala
 @@ -1510,7 +1510,8 @@ class SQLQuerySuite extends QueryTest with SharedSparkSession with AdaptiveSpark
@@ -1067,36 +930,6 @@ index 56c364e2084..fc3abd7cdc4 100644
      AccumulatorSuite.verifyPeakExecutionMemorySet(sparkContext, "external sort") {
        sql("SELECT * FROM testData2 ORDER BY a ASC, b ASC").collect()
      }
-@@ -4454,7 +4455,8 @@ class SQLQuerySuite extends QueryTest with SharedSparkSession with AdaptiveSpark
-   }
- 
-   test("SPARK-39166: Query context of binary arithmetic should be serialized to executors" +
--    " when WSCG is off") {
-+    " when WSCG is off",
-+    IgnoreComet("TODO: https://github.com/apache/datafusion-comet/issues/551")) {
-     withSQLConf(SQLConf.WHOLESTAGE_CODEGEN_ENABLED.key -> "false",
-       SQLConf.ANSI_ENABLED.key -> "true") {
-       withTable("t") {
-@@ -4475,7 +4477,8 @@ class SQLQuerySuite extends QueryTest with SharedSparkSession with AdaptiveSpark
-   }
- 
-   test("SPARK-39175: Query context of Cast should be serialized to executors" +
--    " when WSCG is off") {
-+    " when WSCG is off",
-+    IgnoreComet("TODO: https://github.com/apache/datafusion-comet/issues/551")) {
-     withSQLConf(SQLConf.WHOLESTAGE_CODEGEN_ENABLED.key -> "false",
-       SQLConf.ANSI_ENABLED.key -> "true") {
-       withTable("t") {
-@@ -4502,7 +4505,8 @@ class SQLQuerySuite extends QueryTest with SharedSparkSession with AdaptiveSpark
-   }
- 
-   test("SPARK-39190,SPARK-39208,SPARK-39210: Query context of decimal overflow error should " +
--    "be serialized to executors when WSCG is off") {
-+    "be serialized to executors when WSCG is off",
-+    IgnoreComet("TODO: https://github.com/apache/datafusion-comet/issues/551")) {
-     withSQLConf(SQLConf.WHOLESTAGE_CODEGEN_ENABLED.key -> "false",
-       SQLConf.ANSI_ENABLED.key -> "true") {
-       withTable("t") {
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/SubquerySuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/SubquerySuite.scala
 index 68f14f13bbd..174636cefb5 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/SubquerySuite.scala
@@ -2145,29 +1978,6 @@ index a7efd0aa75e..baae0967a2a 100644
          }.isEmpty)
          assert(collect(initialExecutedPlan) {
            case i: InMemoryTableScanLike => i
-diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/FileSourceCustomMetadataStructSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/FileSourceCustomMetadataStructSuite.scala
-index 05872d41131..0dd83608bbd 100644
---- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/FileSourceCustomMetadataStructSuite.scala
-+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/FileSourceCustomMetadataStructSuite.scala
-@@ -21,7 +21,7 @@ import java.io.File
- 
- import org.apache.hadoop.fs.{FileStatus, Path}
- 
--import org.apache.spark.sql.{DataFrame, Dataset, QueryTest, Row}
-+import org.apache.spark.sql.{DataFrame, Dataset, IgnoreComet, QueryTest, Row}
- import org.apache.spark.sql.catalyst.InternalRow
- import org.apache.spark.sql.catalyst.expressions.{Expression, FileSourceConstantMetadataStructField, FileSourceGeneratedMetadataStructField, Literal}
- import org.apache.spark.sql.execution.datasources.parquet.ParquetFileFormat
-@@ -134,7 +134,8 @@ class FileSourceCustomMetadataStructSuite extends QueryTest with SharedSparkSess
-     }
-   }
- 
--  test("[SPARK-43226] extra constant metadata fields with extractors") {
-+  test("[SPARK-43226] extra constant metadata fields with extractors",
-+    IgnoreComet("TODO: https://github.com/apache/datafusion-comet/issues/551")) {
-     withTempData("parquet", FILE_SCHEMA) { (_, f0, f1) =>
-       val format = new TestFileFormat(extraConstantMetadataFields) {
-         val extractPartitionNumber = { pf: PartitionedFile =>
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/SchemaPruningSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/SchemaPruningSuite.scala
 index 0a0b23d1e60..5685926250f 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/SchemaPruningSuite.scala
@@ -2541,35 +2351,6 @@ index 4bd35e0789b..6544d86dbe0 100644
      )
    }
    test(s"parquet widening conversion $fromType -> $toType") {
-diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/state/StateDataSourceReadSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/state/StateDataSourceReadSuite.scala
-index c800168b507..991d52a1a75 100644
---- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/state/StateDataSourceReadSuite.scala
-+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/state/StateDataSourceReadSuite.scala
-@@ -22,7 +22,7 @@ import org.scalatest.Assertions
- 
- import org.apache.spark.SparkUnsupportedOperationException
- import org.apache.spark.io.CompressionCodec
--import org.apache.spark.sql.{AnalysisException, DataFrame, Encoders, Row}
-+import org.apache.spark.sql.{AnalysisException, DataFrame, Encoders, IgnoreComet, Row}
- import org.apache.spark.sql.catalyst.expressions.{BoundReference, GenericInternalRow}
- import org.apache.spark.sql.catalyst.plans.physical.HashPartitioning
- import org.apache.spark.sql.execution.datasources.v2.state.utils.SchemaUtil
-@@ -525,11 +525,13 @@ abstract class StateDataSourceReadSuite extends StateDataSourceTestBase with Ass
-     }
-   }
- 
--  test("flatMapGroupsWithState, state ver 1") {
-+  test("flatMapGroupsWithState, state ver 1",
-+    IgnoreComet("Ignored if Comet is enabled due to SPARK-49070.")) {
-     testFlatMapGroupsWithState(1)
-   }
- 
--  test("flatMapGroupsWithState, state ver 2") {
-+  test("flatMapGroupsWithState, state ver 2",
-+    IgnoreComet("Ignored if Comet is enabled due to SPARK-49070.")) {
-     testFlatMapGroupsWithState(2)
-   }
- 
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/debug/DebuggingSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/debug/DebuggingSuite.scala
 index b8f3ea3c6f3..bbd44221288 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/execution/debug/DebuggingSuite.scala
@@ -2900,94 +2681,6 @@ index 04193d5189a..d83d03f8e0d 100644
        }.headOption.getOrElse {
          fail(s"No FileScan in query\n${df.queryExecution}")
        }
-diff --git a/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateDistributionSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateDistributionSuite.scala
-index b597a244710..b2e8be41065 100644
---- a/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateDistributionSuite.scala
-+++ b/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateDistributionSuite.scala
-@@ -21,6 +21,7 @@ import java.io.File
- 
- import org.apache.commons.io.FileUtils
- 
-+import org.apache.spark.sql.IgnoreComet
- import org.apache.spark.sql.catalyst.streaming.InternalOutputModes.Update
- import org.apache.spark.sql.execution.streaming.{FlatMapGroupsWithStateExec, MemoryStream}
- import org.apache.spark.sql.internal.SQLConf
-@@ -91,7 +92,7 @@ class FlatMapGroupsWithStateDistributionSuite extends StreamTest
-   }
- 
-   test("SPARK-38204: flatMapGroupsWithState should require StatefulOpClusteredDistribution " +
--    "from children - without initial state") {
-+    "from children - without initial state", IgnoreComet("TODO: fix Comet for this test")) {
-     // function will return -1 on timeout and returns count of the state otherwise
-     val stateFunc =
-       (key: (String, String), values: Iterator[(String, String, Long)],
-@@ -243,7 +244,8 @@ class FlatMapGroupsWithStateDistributionSuite extends StreamTest
-   }
- 
-   test("SPARK-38204: flatMapGroupsWithState should require ClusteredDistribution " +
--    "from children if the query starts from checkpoint in 3.2.x - without initial state") {
-+    "from children if the query starts from checkpoint in 3.2.x - without initial state",
-+    IgnoreComet("TODO: fix Comet for this test")) {
-     // function will return -1 on timeout and returns count of the state otherwise
-     val stateFunc =
-       (key: (String, String), values: Iterator[(String, String, Long)],
-@@ -335,7 +337,8 @@ class FlatMapGroupsWithStateDistributionSuite extends StreamTest
-   }
- 
-   test("SPARK-38204: flatMapGroupsWithState should require ClusteredDistribution " +
--    "from children if the query starts from checkpoint in prior to 3.2") {
-+    "from children if the query starts from checkpoint in prior to 3.2",
-+    IgnoreComet("TODO: fix Comet for this test")) {
-     // function will return -1 on timeout and returns count of the state otherwise
-     val stateFunc =
-       (key: (String, String), values: Iterator[(String, String, Long)],
-diff --git a/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateSuite.scala
-index b35e996106f..326f72235e0 100644
---- a/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateSuite.scala
-+++ b/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateSuite.scala
-@@ -25,7 +25,7 @@ import org.scalatest.exceptions.TestFailedException
- 
- import org.apache.spark.SparkException
- import org.apache.spark.api.java.function.FlatMapGroupsWithStateFunction
--import org.apache.spark.sql.{DataFrame, Encoder}
-+import org.apache.spark.sql.{DataFrame, Encoder, IgnoreCometSuite}
- import org.apache.spark.sql.catalyst.InternalRow
- import org.apache.spark.sql.catalyst.expressions.{GenericInternalRow, UnsafeProjection, UnsafeRow}
- import org.apache.spark.sql.catalyst.plans.logical.FlatMapGroupsWithState
-@@ -46,8 +46,9 @@ case class RunningCount(count: Long)
- 
- case class Result(key: Long, count: Int)
- 
-+// TODO: fix Comet to enable this suite
- @SlowSQLTest
--class FlatMapGroupsWithStateSuite extends StateStoreMetricsTest {
-+class FlatMapGroupsWithStateSuite extends StateStoreMetricsTest with IgnoreCometSuite {
- 
-   import testImplicits._
- 
-diff --git a/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateWithInitialStateSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateWithInitialStateSuite.scala
-index 2a2a83d35e1..e3b7b290b3e 100644
---- a/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateWithInitialStateSuite.scala
-+++ b/sql/core/src/test/scala/org/apache/spark/sql/streaming/FlatMapGroupsWithStateWithInitialStateSuite.scala
-@@ -18,7 +18,7 @@
- package org.apache.spark.sql.streaming
- 
- import org.apache.spark.SparkException
--import org.apache.spark.sql.{AnalysisException, Dataset, KeyValueGroupedDataset}
-+import org.apache.spark.sql.{AnalysisException, Dataset, IgnoreComet, KeyValueGroupedDataset}
- import org.apache.spark.sql.catalyst.streaming.InternalOutputModes.Update
- import org.apache.spark.sql.execution.streaming.MemoryStream
- import org.apache.spark.sql.execution.streaming.state.FlatMapGroupsWithStateExecHelper
-@@ -253,7 +253,8 @@ class FlatMapGroupsWithStateWithInitialStateSuite extends StateStoreMetricsTest
-     assert(e.message.contains(expectedError))
-   }
- 
--  test("flatMapGroupsWithState - initial state - initial state has flatMapGroupsWithState") {
-+  test("flatMapGroupsWithState - initial state - initial state has flatMapGroupsWithState",
-+    IgnoreComet("TODO: fix Comet for this test")) {
-     val initialStateDS = Seq(("keyInStateAndData", new RunningCount(1))).toDS()
-     val initialState: KeyValueGroupedDataset[String, RunningCount] =
-       initialStateDS.groupByKey(_._1).mapValues(_._2)
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/streaming/StreamSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/streaming/StreamSuite.scala
 index 1fce992126b..6d3ea74e0fc 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/streaming/StreamSuite.scala
@@ -3102,153 +2795,6 @@ index e05cb4d3c35..dc65a4fe18e 100644
        })
    }
  
-diff --git a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithListStateSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithListStateSuite.scala
-index dea16e52989..55cdf47c4d5 100644
---- a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithListStateSuite.scala
-+++ b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithListStateSuite.scala
-@@ -18,7 +18,7 @@
- package org.apache.spark.sql.streaming
- 
- import org.apache.spark.SparkIllegalArgumentException
--import org.apache.spark.sql.Encoders
-+import org.apache.spark.sql.{Encoders, IgnoreCometSuite}
- import org.apache.spark.sql.execution.streaming.MemoryStream
- import org.apache.spark.sql.execution.streaming.state.{AlsoTestWithChangelogCheckpointingEnabled, RocksDBStateStoreProvider}
- import org.apache.spark.sql.internal.SQLConf
-@@ -128,7 +128,7 @@ class ToggleSaveAndEmitProcessor
- }
- 
- class TransformWithListStateSuite extends StreamTest
--  with AlsoTestWithChangelogCheckpointingEnabled {
-+  with AlsoTestWithChangelogCheckpointingEnabled with IgnoreCometSuite {
-   import testImplicits._
- 
-   test("test appending null value in list state throw exception") {
-diff --git a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithListStateTTLSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithListStateTTLSuite.scala
-index 299a3346b2e..2213f3c52a6 100644
---- a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithListStateTTLSuite.scala
-+++ b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithListStateTTLSuite.scala
-@@ -19,7 +19,7 @@ package org.apache.spark.sql.streaming
- 
- import java.time.Duration
- 
--import org.apache.spark.sql.Encoders
-+import org.apache.spark.sql.{Encoders, IgnoreCometSuite}
- import org.apache.spark.sql.execution.streaming.{ListStateImplWithTTL, MemoryStream}
- import org.apache.spark.sql.execution.streaming.state.RocksDBStateStoreProvider
- import org.apache.spark.sql.internal.SQLConf
-@@ -95,7 +95,7 @@ class ListStateTTLProcessor(ttlConfig: TTLConfig)
-  * Test suite for testing list state with TTL.
-  * We use the base TTL suite with a list state processor.
-  */
--class TransformWithListStateTTLSuite extends TransformWithStateTTLTest {
-+class TransformWithListStateTTLSuite extends TransformWithStateTTLTest with IgnoreCometSuite {
- 
-   import testImplicits._
- 
-diff --git a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithMapStateTTLSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithMapStateTTLSuite.scala
-index bf46c802fde..623c3003430 100644
---- a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithMapStateTTLSuite.scala
-+++ b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithMapStateTTLSuite.scala
-@@ -19,7 +19,7 @@ package org.apache.spark.sql.streaming
- 
- import java.time.Duration
- 
--import org.apache.spark.sql.Encoders
-+import org.apache.spark.sql.{Encoders, IgnoreCometSuite}
- import org.apache.spark.sql.execution.streaming.{MapStateImplWithTTL, MemoryStream}
- import org.apache.spark.sql.execution.streaming.state.RocksDBStateStoreProvider
- import org.apache.spark.sql.internal.SQLConf
-@@ -174,7 +174,7 @@ class MapStateTTLProcessor(ttlConfig: TTLConfig)
-   }
- }
- 
--class TransformWithMapStateTTLSuite extends TransformWithStateTTLTest {
-+class TransformWithMapStateTTLSuite extends TransformWithStateTTLTest with IgnoreCometSuite {
- 
-   import testImplicits._
-   override def getProcessor(ttlConfig: TTLConfig):
-diff --git a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithStateChainingSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithStateChainingSuite.scala
-index 5388d6f1fb6..8aa11c5b875 100644
---- a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithStateChainingSuite.scala
-+++ b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithStateChainingSuite.scala
-@@ -21,7 +21,7 @@ import java.sql.Timestamp
- import java.time.{Instant, LocalDateTime, ZoneId}
- 
- import org.apache.spark.{SparkRuntimeException, SparkThrowable}
--import org.apache.spark.sql.AnalysisException
-+import org.apache.spark.sql.{AnalysisException, IgnoreCometSuite}
- import org.apache.spark.sql.catalyst.ExtendedAnalysisException
- import org.apache.spark.sql.execution.streaming.{MemoryStream, StreamExecution}
- import org.apache.spark.sql.execution.streaming.state.RocksDBStateStoreProvider
-@@ -106,7 +106,8 @@ case class AggEventRow(
-     window: Window,
-     count: Long)
- 
--class TransformWithStateChainingSuite extends StreamTest {
-+class TransformWithStateChainingSuite extends StreamTest
-+  with IgnoreCometSuite {
-   import testImplicits._
- 
-   test("watermark is propagated correctly for next stateful operator" +
-diff --git a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithStateSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithStateSuite.scala
-index 0057af44d3e..51975748309 100644
---- a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithStateSuite.scala
-+++ b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithStateSuite.scala
-@@ -22,7 +22,7 @@ import java.util.UUID
- 
- import org.apache.spark.SparkRuntimeException
- import org.apache.spark.internal.Logging
--import org.apache.spark.sql.{Dataset, Encoders}
-+import org.apache.spark.sql.{Dataset, Encoders, IgnoreCometSuite}
- import org.apache.spark.sql.catalyst.util.stringToFile
- import org.apache.spark.sql.execution.streaming._
- import org.apache.spark.sql.execution.streaming.state.{AlsoTestWithChangelogCheckpointingEnabled, RocksDBStateStoreProvider, StatefulProcessorCannotPerformOperationWithInvalidHandleState, StateStoreMultipleColumnFamiliesNotSupportedException}
-@@ -307,9 +307,11 @@ class RunningCountStatefulProcessorWithError extends RunningCountStatefulProcess
- 
- /**
-  * Class that adds tests for transformWithState stateful streaming operator
-+ *
-+ * Ignored if Comet is enabled due to SPARK-49070.
-  */
- class TransformWithStateSuite extends StateStoreMetricsTest
--  with AlsoTestWithChangelogCheckpointingEnabled {
-+  with AlsoTestWithChangelogCheckpointingEnabled with IgnoreCometSuite {
- 
-   import testImplicits._
- 
-@@ -786,7 +788,7 @@ class TransformWithStateSuite extends StateStoreMetricsTest
-   }
- }
- 
--class TransformWithStateValidationSuite extends StateStoreMetricsTest {
-+class TransformWithStateValidationSuite extends StateStoreMetricsTest with IgnoreCometSuite {
-   import testImplicits._
- 
-   test("transformWithState - streaming with hdfsStateStoreProvider should fail") {
-diff --git a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithValueStateTTLSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithValueStateTTLSuite.scala
-index 54004b419f7..4e5b35aa0da 100644
---- a/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithValueStateTTLSuite.scala
-+++ b/sql/core/src/test/scala/org/apache/spark/sql/streaming/TransformWithValueStateTTLSuite.scala
-@@ -20,7 +20,7 @@ package org.apache.spark.sql.streaming
- import java.time.Duration
- 
- import org.apache.spark.internal.Logging
--import org.apache.spark.sql.Encoders
-+import org.apache.spark.sql.{Encoders, IgnoreCometSuite}
- import org.apache.spark.sql.execution.streaming.{MemoryStream, ValueStateImpl, ValueStateImplWithTTL}
- import org.apache.spark.sql.execution.streaming.state.RocksDBStateStoreProvider
- import org.apache.spark.sql.internal.SQLConf
-@@ -160,7 +160,8 @@ case class MultipleValueStatesTTLProcessor(
-   }
- }
- 
--class TransformWithValueStateTTLSuite extends TransformWithStateTTLTest {
-+class TransformWithValueStateTTLSuite extends TransformWithStateTTLTest
-+  with IgnoreCometSuite{
- 
-   import testImplicits._
- 
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/streaming/test/DataStreamTableAPISuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/streaming/test/DataStreamTableAPISuite.scala
 index af07aceaed1..ed0b5e6d9be 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/streaming/test/DataStreamTableAPISuite.scala
@@ -3423,20 +2969,6 @@ index 52abd248f3a..7a199931a08 100644
        case h: HiveTableScanExec => h.partitionPruningPred.collect {
          case d: DynamicPruningExpression => d.child
        }
-diff --git a/sql/hive/src/test/scala/org/apache/spark/sql/hive/execution/AggregationQuerySuite.scala b/sql/hive/src/test/scala/org/apache/spark/sql/hive/execution/AggregationQuerySuite.scala
-index 4b000fff0eb..e867b6c0d9b 100644
---- a/sql/hive/src/test/scala/org/apache/spark/sql/hive/execution/AggregationQuerySuite.scala
-+++ b/sql/hive/src/test/scala/org/apache/spark/sql/hive/execution/AggregationQuerySuite.scala
-@@ -660,7 +660,8 @@ abstract class AggregationQuerySuite extends QueryTest with SQLTestUtils with Te
-         Row(3, 4, 4, 3, null) :: Nil)
-   }
- 
--  test("single distinct multiple columns set") {
-+  test("single distinct multiple columns set",
-+    IgnoreComet("TODO: fix Comet for this test")) {
-     checkAnswer(
-       spark.sql(
-         """
 diff --git a/sql/hive/src/test/scala/org/apache/spark/sql/hive/test/TestHive.scala b/sql/hive/src/test/scala/org/apache/spark/sql/hive/test/TestHive.scala
 index 3f8de93b330..fc06e81f41a 100644
 --- a/sql/hive/src/test/scala/org/apache/spark/sql/hive/test/TestHive.scala

From 8d83cc15c87a14b93ebbec12d6fe4dce5283f4a2 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Fri, 6 Dec 2024 15:16:39 -0700
Subject: [PATCH 27/47] chore: Refactor cast to use SparkCastOptions param
 (#1146)

* Refactor cast to use SparkCastOptions param

* update tests

* update benches

* update benches

* update benches
---
 .../core/src/execution/datafusion/planner.rs  |  23 +--
 native/spark-expr/benches/cast_from_string.rs |  30 +---
 native/spark-expr/benches/cast_numeric.rs     |  22 +--
 native/spark-expr/src/cast.rs                 | 157 +++++++-----------
 native/spark-expr/src/lib.rs                  |   4 +-
 native/spark-expr/src/to_json.rs              |   5 +-
 6 files changed, 83 insertions(+), 158 deletions(-)

diff --git a/native/core/src/execution/datafusion/planner.rs b/native/core/src/execution/datafusion/planner.rs
index 83f86dbee8..33c4924cbd 100644
--- a/native/core/src/execution/datafusion/planner.rs
+++ b/native/core/src/execution/datafusion/planner.rs
@@ -100,7 +100,8 @@ use datafusion_comet_proto::{
 };
 use datafusion_comet_spark_expr::{
     ArrayInsert, Cast, CreateNamedStruct, DateTruncExpr, GetArrayStructFields, GetStructField,
-    HourExpr, IfExpr, ListExtract, MinuteExpr, RLike, SecondExpr, TimestampTruncExpr, ToJson,
+    HourExpr, IfExpr, ListExtract, MinuteExpr, RLike, SecondExpr, SparkCastOptions,
+    TimestampTruncExpr, ToJson,
 };
 use datafusion_common::scalar::ScalarStructBuilder;
 use datafusion_common::{
@@ -388,14 +389,11 @@ impl PhysicalPlanner {
             ExprStruct::Cast(expr) => {
                 let child = self.create_expr(expr.child.as_ref().unwrap(), input_schema)?;
                 let datatype = to_arrow_datatype(expr.datatype.as_ref().unwrap());
-                let timezone = expr.timezone.clone();
                 let eval_mode = from_protobuf_eval_mode(expr.eval_mode)?;
                 Ok(Arc::new(Cast::new(
                     child,
                     datatype,
-                    eval_mode,
-                    timezone,
-                    expr.allow_incompat,
+                    SparkCastOptions::new(eval_mode, &expr.timezone, expr.allow_incompat),
                 )))
             }
             ExprStruct::Hour(expr) => {
@@ -806,24 +804,21 @@ impl PhysicalPlanner {
                 let data_type = return_type.map(to_arrow_datatype).unwrap();
                 // For some Decimal128 operations, we need wider internal digits.
                 // Cast left and right to Decimal256 and cast the result back to Decimal128
-                let left = Arc::new(Cast::new_without_timezone(
+                let left = Arc::new(Cast::new(
                     left,
                     DataType::Decimal256(p1, s1),
-                    EvalMode::Legacy,
-                    false,
+                    SparkCastOptions::new_without_timezone(EvalMode::Legacy, false),
                 ));
-                let right = Arc::new(Cast::new_without_timezone(
+                let right = Arc::new(Cast::new(
                     right,
                     DataType::Decimal256(p2, s2),
-                    EvalMode::Legacy,
-                    false,
+                    SparkCastOptions::new_without_timezone(EvalMode::Legacy, false),
                 ));
                 let child = Arc::new(BinaryExpr::new(left, op, right));
-                Ok(Arc::new(Cast::new_without_timezone(
+                Ok(Arc::new(Cast::new(
                     child,
                     data_type,
-                    EvalMode::Legacy,
-                    false,
+                    SparkCastOptions::new_without_timezone(EvalMode::Legacy, false),
                 )))
             }
             (
diff --git a/native/spark-expr/benches/cast_from_string.rs b/native/spark-expr/benches/cast_from_string.rs
index 056ada2eb7..c6b0bcf397 100644
--- a/native/spark-expr/benches/cast_from_string.rs
+++ b/native/spark-expr/benches/cast_from_string.rs
@@ -18,36 +18,18 @@
 use arrow_array::{builder::StringBuilder, RecordBatch};
 use arrow_schema::{DataType, Field, Schema};
 use criterion::{criterion_group, criterion_main, Criterion};
-use datafusion_comet_spark_expr::{Cast, EvalMode};
+use datafusion_comet_spark_expr::{Cast, EvalMode, SparkCastOptions};
 use datafusion_physical_expr::{expressions::Column, PhysicalExpr};
 use std::sync::Arc;
 
 fn criterion_benchmark(c: &mut Criterion) {
     let batch = create_utf8_batch();
     let expr = Arc::new(Column::new("a", 0));
-    let timezone = "".to_string();
-    let cast_string_to_i8 = Cast::new(
-        expr.clone(),
-        DataType::Int8,
-        EvalMode::Legacy,
-        timezone.clone(),
-        false,
-    );
-    let cast_string_to_i16 = Cast::new(
-        expr.clone(),
-        DataType::Int16,
-        EvalMode::Legacy,
-        timezone.clone(),
-        false,
-    );
-    let cast_string_to_i32 = Cast::new(
-        expr.clone(),
-        DataType::Int32,
-        EvalMode::Legacy,
-        timezone.clone(),
-        false,
-    );
-    let cast_string_to_i64 = Cast::new(expr, DataType::Int64, EvalMode::Legacy, timezone, false);
+    let spark_cast_options = SparkCastOptions::new(EvalMode::Legacy, "", false);
+    let cast_string_to_i8 = Cast::new(expr.clone(), DataType::Int8, spark_cast_options.clone());
+    let cast_string_to_i16 = Cast::new(expr.clone(), DataType::Int16, spark_cast_options.clone());
+    let cast_string_to_i32 = Cast::new(expr.clone(), DataType::Int32, spark_cast_options.clone());
+    let cast_string_to_i64 = Cast::new(expr, DataType::Int64, spark_cast_options);
 
     let mut group = c.benchmark_group("cast_string_to_int");
     group.bench_function("cast_string_to_i8", |b| {
diff --git a/native/spark-expr/benches/cast_numeric.rs b/native/spark-expr/benches/cast_numeric.rs
index 15ef1a5a27..8ec8b2f891 100644
--- a/native/spark-expr/benches/cast_numeric.rs
+++ b/native/spark-expr/benches/cast_numeric.rs
@@ -18,29 +18,17 @@
 use arrow_array::{builder::Int32Builder, RecordBatch};
 use arrow_schema::{DataType, Field, Schema};
 use criterion::{criterion_group, criterion_main, Criterion};
-use datafusion_comet_spark_expr::{Cast, EvalMode};
+use datafusion_comet_spark_expr::{Cast, EvalMode, SparkCastOptions};
 use datafusion_physical_expr::{expressions::Column, PhysicalExpr};
 use std::sync::Arc;
 
 fn criterion_benchmark(c: &mut Criterion) {
     let batch = create_int32_batch();
     let expr = Arc::new(Column::new("a", 0));
-    let timezone = "".to_string();
-    let cast_i32_to_i8 = Cast::new(
-        expr.clone(),
-        DataType::Int8,
-        EvalMode::Legacy,
-        timezone.clone(),
-        false,
-    );
-    let cast_i32_to_i16 = Cast::new(
-        expr.clone(),
-        DataType::Int16,
-        EvalMode::Legacy,
-        timezone.clone(),
-        false,
-    );
-    let cast_i32_to_i64 = Cast::new(expr, DataType::Int64, EvalMode::Legacy, timezone, false);
+    let spark_cast_options = SparkCastOptions::new_without_timezone(EvalMode::Legacy, false);
+    let cast_i32_to_i8 = Cast::new(expr.clone(), DataType::Int8, spark_cast_options.clone());
+    let cast_i32_to_i16 = Cast::new(expr.clone(), DataType::Int16, spark_cast_options.clone());
+    let cast_i32_to_i64 = Cast::new(expr, DataType::Int64, spark_cast_options);
 
     let mut group = c.benchmark_group("cast_int_to_int");
     group.bench_function("cast_i32_to_i8", |b| {
diff --git a/native/spark-expr/src/cast.rs b/native/spark-expr/src/cast.rs
index 13263a5954..f62d0220c9 100644
--- a/native/spark-expr/src/cast.rs
+++ b/native/spark-expr/src/cast.rs
@@ -138,14 +138,7 @@ impl TimeStampInfo {
 pub struct Cast {
     pub child: Arc<dyn PhysicalExpr>,
     pub data_type: DataType,
-    pub eval_mode: EvalMode,
-
-    /// When cast from/to timezone related types, we need timezone, which will be resolved with
-    /// session local timezone by an analyzer in Spark.
-    pub timezone: String,
-
-    /// Whether to allow casts that are known to be incompatible with Spark
-    pub allow_incompat: bool,
+    pub cast_options: SparkCastOptions,
 }
 
 macro_rules! cast_utf8_to_int {
@@ -547,30 +540,41 @@ impl Cast {
     pub fn new(
         child: Arc<dyn PhysicalExpr>,
         data_type: DataType,
-        eval_mode: EvalMode,
-        timezone: String,
-        allow_incompat: bool,
+        cast_options: SparkCastOptions,
     ) -> Self {
         Self {
             child,
             data_type,
-            timezone,
+            cast_options,
+        }
+    }
+}
+
+/// Spark cast options
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub struct SparkCastOptions {
+    /// Spark evaluation mode
+    pub eval_mode: EvalMode,
+    /// When cast from/to timezone related types, we need timezone, which will be resolved with
+    /// session local timezone by an analyzer in Spark.
+    pub timezone: String,
+    /// Allow casts that are supported but not guaranteed to be 100% compatible
+    pub allow_incompat: bool,
+}
+
+impl SparkCastOptions {
+    pub fn new(eval_mode: EvalMode, timezone: &str, allow_incompat: bool) -> Self {
+        Self {
             eval_mode,
+            timezone: timezone.to_string(),
             allow_incompat,
         }
     }
 
-    pub fn new_without_timezone(
-        child: Arc<dyn PhysicalExpr>,
-        data_type: DataType,
-        eval_mode: EvalMode,
-        allow_incompat: bool,
-    ) -> Self {
+    pub fn new_without_timezone(eval_mode: EvalMode, allow_incompat: bool) -> Self {
         Self {
-            child,
-            data_type,
-            timezone: "".to_string(),
             eval_mode,
+            timezone: "".to_string(),
             allow_incompat,
         }
     }
@@ -582,33 +586,21 @@ impl Cast {
 pub fn spark_cast(
     arg: ColumnarValue,
     data_type: &DataType,
-    eval_mode: EvalMode,
-    timezone: &str,
-    allow_incompat: bool,
+    cast_options: &SparkCastOptions,
 ) -> DataFusionResult<ColumnarValue> {
     match arg {
         ColumnarValue::Array(array) => Ok(ColumnarValue::Array(cast_array(
             array,
             data_type,
-            eval_mode,
-            timezone.to_owned(),
-            allow_incompat,
+            cast_options,
         )?)),
         ColumnarValue::Scalar(scalar) => {
             // Note that normally CAST(scalar) should be fold in Spark JVM side. However, for
             // some cases e.g., scalar subquery, Spark will not fold it, so we need to handle it
             // here.
             let array = scalar.to_array()?;
-            let scalar = ScalarValue::try_from_array(
-                &cast_array(
-                    array,
-                    data_type,
-                    eval_mode,
-                    timezone.to_owned(),
-                    allow_incompat,
-                )?,
-                0,
-            )?;
+            let scalar =
+                ScalarValue::try_from_array(&cast_array(array, data_type, cast_options)?, 0)?;
             Ok(ColumnarValue::Scalar(scalar))
         }
     }
@@ -617,12 +609,11 @@ pub fn spark_cast(
 fn cast_array(
     array: ArrayRef,
     to_type: &DataType,
-    eval_mode: EvalMode,
-    timezone: String,
-    allow_incompat: bool,
+    cast_options: &SparkCastOptions,
 ) -> DataFusionResult<ArrayRef> {
-    let array = array_with_timezone(array, timezone.clone(), Some(to_type))?;
+    let array = array_with_timezone(array, cast_options.timezone.clone(), Some(to_type))?;
     let from_type = array.data_type().clone();
+
     let array = match &from_type {
         DataType::Dictionary(key_type, value_type)
             if key_type.as_ref() == &DataType::Int32
@@ -636,13 +627,7 @@ fn cast_array(
 
             let casted_dictionary = DictionaryArray::<Int32Type>::new(
                 dict_array.keys().clone(),
-                cast_array(
-                    Arc::clone(dict_array.values()),
-                    to_type,
-                    eval_mode,
-                    timezone,
-                    allow_incompat,
-                )?,
+                cast_array(Arc::clone(dict_array.values()), to_type, cast_options)?,
             );
 
             let casted_result = match to_type {
@@ -654,6 +639,7 @@ fn cast_array(
         _ => array,
     };
     let from_type = array.data_type();
+    let eval_mode = cast_options.eval_mode;
 
     let cast_result = match (from_type, to_type) {
         (DataType::Utf8, DataType::Boolean) => spark_cast_utf8_to_boolean::<i32>(&array, eval_mode),
@@ -661,7 +647,7 @@ fn cast_array(
             spark_cast_utf8_to_boolean::<i64>(&array, eval_mode)
         }
         (DataType::Utf8, DataType::Timestamp(_, _)) => {
-            cast_string_to_timestamp(&array, to_type, eval_mode, &timezone)
+            cast_string_to_timestamp(&array, to_type, eval_mode, &cast_options.timezone)
         }
         (DataType::Utf8, DataType::Date32) => cast_string_to_date(&array, to_type, eval_mode),
         (DataType::Int64, DataType::Int32)
@@ -712,17 +698,15 @@ fn cast_array(
             spark_cast_nonintegral_numeric_to_integral(&array, eval_mode, from_type, to_type)
         }
         (DataType::Struct(_), DataType::Utf8) => {
-            Ok(casts_struct_to_string(array.as_struct(), &timezone)?)
+            Ok(casts_struct_to_string(array.as_struct(), cast_options)?)
         }
         (DataType::Struct(_), DataType::Struct(_)) => Ok(cast_struct_to_struct(
             array.as_struct(),
             from_type,
             to_type,
-            eval_mode,
-            timezone,
-            allow_incompat,
+            cast_options,
         )?),
-        _ if is_datafusion_spark_compatible(from_type, to_type, allow_incompat) => {
+        _ if is_datafusion_spark_compatible(from_type, to_type, cast_options.allow_incompat) => {
             // use DataFusion cast only when we know that it is compatible with Spark
             Ok(cast_with_options(&array, to_type, &CAST_OPTIONS)?)
         }
@@ -825,9 +809,7 @@ fn cast_struct_to_struct(
     array: &StructArray,
     from_type: &DataType,
     to_type: &DataType,
-    eval_mode: EvalMode,
-    timezone: String,
-    allow_incompat: bool,
+    cast_options: &SparkCastOptions,
 ) -> DataFusionResult<ArrayRef> {
     match (from_type, to_type) {
         (DataType::Struct(_), DataType::Struct(to_fields)) => {
@@ -836,9 +818,7 @@ fn cast_struct_to_struct(
                 let cast_field = cast_array(
                     Arc::clone(array.column(i)),
                     to_fields[i].data_type(),
-                    eval_mode,
-                    timezone.clone(),
-                    allow_incompat,
+                    cast_options,
                 )?;
                 cast_fields.push((Arc::clone(&to_fields[i]), cast_field));
             }
@@ -848,7 +828,10 @@ fn cast_struct_to_struct(
     }
 }
 
-fn casts_struct_to_string(array: &StructArray, timezone: &str) -> DataFusionResult<ArrayRef> {
+fn casts_struct_to_string(
+    array: &StructArray,
+    spark_cast_options: &SparkCastOptions,
+) -> DataFusionResult<ArrayRef> {
     // cast each field to a string
     let string_arrays: Vec<ArrayRef> = array
         .columns()
@@ -857,9 +840,7 @@ fn casts_struct_to_string(array: &StructArray, timezone: &str) -> DataFusionResu
             spark_cast(
                 ColumnarValue::Array(Arc::clone(arr)),
                 &DataType::Utf8,
-                EvalMode::Legacy,
-                timezone,
-                true,
+                spark_cast_options,
             )
             .and_then(|cv| cv.into_array(arr.len()))
         })
@@ -1464,7 +1445,7 @@ impl Display for Cast {
         write!(
             f,
             "Cast [data_type: {}, timezone: {}, child: {}, eval_mode: {:?}]",
-            self.data_type, self.timezone, self.child, &self.eval_mode
+            self.data_type, self.cast_options.timezone, self.child, &self.cast_options.eval_mode
         )
     }
 }
@@ -1475,9 +1456,8 @@ impl PartialEq<dyn Any> for Cast {
             .downcast_ref::<Self>()
             .map(|x| {
                 self.child.eq(&x.child)
-                    && self.timezone.eq(&x.timezone)
+                    && self.cast_options.eq(&x.cast_options)
                     && self.data_type.eq(&x.data_type)
-                    && self.eval_mode.eq(&x.eval_mode)
             })
             .unwrap_or(false)
     }
@@ -1498,13 +1478,7 @@ impl PhysicalExpr for Cast {
 
     fn evaluate(&self, batch: &RecordBatch) -> DataFusionResult<ColumnarValue> {
         let arg = self.child.evaluate(batch)?;
-        spark_cast(
-            arg,
-            &self.data_type,
-            self.eval_mode,
-            &self.timezone,
-            self.allow_incompat,
-        )
+        spark_cast(arg, &self.data_type, &self.cast_options)
     }
 
     fn children(&self) -> Vec<&Arc<dyn PhysicalExpr>> {
@@ -1519,9 +1493,7 @@ impl PhysicalExpr for Cast {
             1 => Ok(Arc::new(Cast::new(
                 Arc::clone(&children[0]),
                 self.data_type.clone(),
-                self.eval_mode,
-                self.timezone.clone(),
-                self.allow_incompat,
+                self.cast_options.clone(),
             ))),
             _ => internal_err!("Cast should have exactly one child"),
         }
@@ -1531,9 +1503,7 @@ impl PhysicalExpr for Cast {
         let mut s = state;
         self.child.hash(&mut s);
         self.data_type.hash(&mut s);
-        self.timezone.hash(&mut s);
-        self.eval_mode.hash(&mut s);
-        self.allow_incompat.hash(&mut s);
+        self.cast_options.hash(&mut s);
         self.hash(&mut s);
     }
 }
@@ -2110,12 +2080,11 @@ mod tests {
 
         let timezone = "UTC".to_string();
         // test casting string dictionary array to timestamp array
+        let cast_options = SparkCastOptions::new(EvalMode::Legacy, &timezone, false);
         let result = cast_array(
             dict_array,
             &DataType::Timestamp(TimeUnit::Microsecond, Some(timezone.clone().into())),
-            EvalMode::Legacy,
-            timezone.clone(),
-            false,
+            &cast_options,
         )?;
         assert_eq!(
             *result.data_type(),
@@ -2320,12 +2289,11 @@ mod tests {
     fn test_cast_unsupported_timestamp_to_date() {
         // Since datafusion uses chrono::Datetime internally not all dates representable by TimestampMicrosecondType are supported
         let timestamps: PrimitiveArray<TimestampMicrosecondType> = vec![i64::MAX].into();
+        let cast_options = SparkCastOptions::new(EvalMode::Legacy, "UTC", false);
         let result = cast_array(
             Arc::new(timestamps.with_timezone("Europe/Copenhagen")),
             &DataType::Date32,
-            EvalMode::Legacy,
-            "UTC".to_owned(),
-            false,
+            &cast_options,
         );
         assert!(result.is_err())
     }
@@ -2333,12 +2301,11 @@ mod tests {
     #[test]
     fn test_cast_invalid_timezone() {
         let timestamps: PrimitiveArray<TimestampMicrosecondType> = vec![i64::MAX].into();
+        let cast_options = SparkCastOptions::new(EvalMode::Legacy, "Not a valid timezone", false);
         let result = cast_array(
             Arc::new(timestamps.with_timezone("Europe/Copenhagen")),
             &DataType::Date32,
-            EvalMode::Legacy,
-            "Not a valid timezone".to_owned(),
-            false,
+            &cast_options,
         );
         assert!(result.is_err())
     }
@@ -2360,9 +2327,7 @@ mod tests {
         let string_array = cast_array(
             c,
             &DataType::Utf8,
-            EvalMode::Legacy,
-            "UTC".to_owned(),
-            false,
+            &SparkCastOptions::new(EvalMode::Legacy, "UTC", false),
         )
         .unwrap();
         let string_array = string_array.as_string::<i32>();
@@ -2396,9 +2361,7 @@ mod tests {
         let cast_array = spark_cast(
             ColumnarValue::Array(c),
             &DataType::Struct(fields),
-            EvalMode::Legacy,
-            "UTC",
-            false,
+            &SparkCastOptions::new(EvalMode::Legacy, "UTC", false),
         )
         .unwrap();
         if let ColumnarValue::Array(cast_array) = cast_array {
@@ -2429,9 +2392,7 @@ mod tests {
         let cast_array = spark_cast(
             ColumnarValue::Array(c),
             &DataType::Struct(fields),
-            EvalMode::Legacy,
-            "UTC",
-            false,
+            &SparkCastOptions::new(EvalMode::Legacy, "UTC", false),
         )
         .unwrap();
         if let ColumnarValue::Array(cast_array) = cast_array {
diff --git a/native/spark-expr/src/lib.rs b/native/spark-expr/src/lib.rs
index 3ec2e886b5..c227b3a025 100644
--- a/native/spark-expr/src/lib.rs
+++ b/native/spark-expr/src/lib.rs
@@ -34,7 +34,7 @@ pub mod timezone;
 mod to_json;
 pub mod utils;
 
-pub use cast::{spark_cast, Cast};
+pub use cast::{spark_cast, Cast, SparkCastOptions};
 pub use error::{SparkError, SparkResult};
 pub use if_expr::IfExpr;
 pub use list::{ArrayInsert, GetArrayStructFields, ListExtract};
@@ -47,7 +47,7 @@ pub use to_json::ToJson;
 /// the behavior when processing input values that are invalid or would result in an
 /// error, such as divide by zero errors, and also affects behavior when converting
 /// between types.
-#[derive(Debug, Hash, PartialEq, Clone, Copy)]
+#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 pub enum EvalMode {
     /// Legacy is the default behavior in Spark prior to Spark 4.0. This mode silently ignores
     /// or replaces errors during SQL operations. Operations resulting in errors (like
diff --git a/native/spark-expr/src/to_json.rs b/native/spark-expr/src/to_json.rs
index 7d38cbf1b6..1f68eb8606 100644
--- a/native/spark-expr/src/to_json.rs
+++ b/native/spark-expr/src/to_json.rs
@@ -19,6 +19,7 @@
 // of the Spark-specific compatibility features that we need (including
 // being able to specify Spark-compatible cast from all types to string)
 
+use crate::cast::SparkCastOptions;
 use crate::{spark_cast, EvalMode};
 use arrow_array::builder::StringBuilder;
 use arrow_array::{Array, ArrayRef, RecordBatch, StringArray, StructArray};
@@ -117,9 +118,7 @@ fn array_to_json_string(arr: &Arc<dyn Array>, timezone: &str) -> Result<ArrayRef
         spark_cast(
             ColumnarValue::Array(Arc::clone(arr)),
             &DataType::Utf8,
-            EvalMode::Legacy,
-            timezone,
-            false,
+            &SparkCastOptions::new(EvalMode::Legacy, timezone, false),
         )?
         .into_array(arr.len())
     }

From 21503ca26f4d1a7b1b0eb1583158bbcddd695909 Mon Sep 17 00:00:00 2001
From: Matt Butrovich <mbutrovich@users.noreply.github.com>
Date: Sat, 7 Dec 2024 13:40:43 -0500
Subject: [PATCH 28/47] Enable more scenarios in CometExecBenchmark. (#1151)

---
 .../sql/benchmark/CometExecBenchmark.scala    | 34 +++++++++----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/spark/src/test/scala/org/apache/spark/sql/benchmark/CometExecBenchmark.scala b/spark/src/test/scala/org/apache/spark/sql/benchmark/CometExecBenchmark.scala
index 3dd930f671..3ee37bd668 100644
--- a/spark/src/test/scala/org/apache/spark/sql/benchmark/CometExecBenchmark.scala
+++ b/spark/src/test/scala/org/apache/spark/sql/benchmark/CometExecBenchmark.scala
@@ -274,23 +274,23 @@ object CometExecBenchmark extends CometBenchmarkBase {
   }
 
   override def runCometBenchmark(mainArgs: Array[String]): Unit = {
-//    runBenchmarkWithTable("Subquery", 1024 * 1024 * 10) { v =>
-//      subqueryExecBenchmark(v)
-//    }
-//
-//    runBenchmarkWithTable("Expand", 1024 * 1024 * 10) { v =>
-//      expandExecBenchmark(v)
-//    }
-//
-//    runBenchmarkWithTable("Project + Filter", 1024 * 1024 * 10) { v =>
-//      for (fractionOfZeros <- List(0.0, 0.50, 0.95)) {
-//        numericFilterExecBenchmark(v, fractionOfZeros)
-//      }
-//    }
-//
-//    runBenchmarkWithTable("Sort", 1024 * 1024 * 10) { v =>
-//      sortExecBenchmark(v)
-//    }
+    runBenchmarkWithTable("Subquery", 1024 * 1024 * 10) { v =>
+      subqueryExecBenchmark(v)
+    }
+
+    runBenchmarkWithTable("Expand", 1024 * 1024 * 10) { v =>
+      expandExecBenchmark(v)
+    }
+
+    runBenchmarkWithTable("Project + Filter", 1024 * 1024 * 10) { v =>
+      for (fractionOfZeros <- List(0.0, 0.50, 0.95)) {
+        numericFilterExecBenchmark(v, fractionOfZeros)
+      }
+    }
+
+    runBenchmarkWithTable("Sort", 1024 * 1024 * 10) { v =>
+      sortExecBenchmark(v)
+    }
 
     runBenchmarkWithTable("BloomFilterAggregate", 1024 * 1024 * 10) { v =>
       for (card <- List(100, 1024, 1024 * 1024)) {

From 73f14051adc3bfa513adc54a9af157928472ee0b Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Mon, 9 Dec 2024 11:45:12 -0700
Subject: [PATCH 29/47] chore: Move more expressions from core crate to
 spark-expr crate (#1152)

* move aggregate expressions to spark-expr crate

* move more expressions

* move benchmark

* normalize_nan

* bitwise not

* comet scalar funcs

* update bench imports
---
 native/Cargo.lock                             |  2 +
 native/Cargo.toml                             |  1 +
 native/core/Cargo.toml                        |  7 +---
 native/core/src/common/bit.rs                 |  6 +--
 .../datafusion/expressions/checkoverflow.rs   | 15 +------
 .../execution/datafusion/expressions/mod.rs   | 11 ------
 .../core/src/execution/datafusion/planner.rs  | 18 +++------
 native/core/src/lib.rs                        | 27 -------------
 native/core/src/parquet/read/levels.rs        |  7 ++--
 native/core/src/parquet/read/values.rs        |  2 +-
 native/spark-expr/Cargo.toml                  |  8 ++++
 .../{core => spark-expr}/benches/aggregate.rs |  6 +--
 .../expressions => spark-expr/src}/avg.rs     |  0
 .../src}/avg_decimal.rs                       |  2 +-
 .../src}/bitwise_not.rs                       | 18 +--------
 .../src}/comet_scalar_funcs.rs                |  6 +--
 .../src}/correlation.rs                       |  5 +--
 .../src}/covariance.rs                        |  0
 native/spark-expr/src/lib.rs                  | 20 ++++++++++
 .../src}/normalize_nan.rs                     |  0
 .../expressions => spark-expr/src}/stddev.rs  |  2 +-
 .../src}/sum_decimal.rs                       | 10 ++---
 native/spark-expr/src/utils.rs                | 39 ++++++++++++++++++-
 .../src}/variance.rs                          |  0
 24 files changed, 96 insertions(+), 116 deletions(-)
 rename native/{core => spark-expr}/benches/aggregate.rs (97%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/avg.rs (100%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/avg_decimal.rs (99%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/bitwise_not.rs (88%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/comet_scalar_funcs.rs (98%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/correlation.rs (98%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/covariance.rs (100%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/normalize_nan.rs (100%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/stddev.rs (98%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/sum_decimal.rs (98%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/variance.rs (100%)

diff --git a/native/Cargo.lock b/native/Cargo.lock
index a7f8359d87..67d041a399 100644
--- a/native/Cargo.lock
+++ b/native/Cargo.lock
@@ -942,10 +942,12 @@ dependencies = [
  "datafusion-common",
  "datafusion-expr",
  "datafusion-physical-expr",
+ "futures",
  "num",
  "rand",
  "regex",
  "thiserror",
+ "tokio",
  "twox-hash 2.0.1",
 ]
 
diff --git a/native/Cargo.toml b/native/Cargo.toml
index 85c46a6d02..4ac85479f2 100644
--- a/native/Cargo.toml
+++ b/native/Cargo.toml
@@ -51,6 +51,7 @@ datafusion-comet-spark-expr = { path = "spark-expr", version = "0.5.0" }
 datafusion-comet-proto = { path = "proto", version = "0.5.0" }
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 chrono-tz = { version = "0.8" }
+futures = "0.3.28"
 num = "0.4"
 rand = "0.8"
 regex = "1.9.6"
diff --git a/native/core/Cargo.toml b/native/core/Cargo.toml
index daa0837c82..4b9753ec51 100644
--- a/native/core/Cargo.toml
+++ b/native/core/Cargo.toml
@@ -42,7 +42,7 @@ arrow-data = { workspace = true }
 arrow-schema = { workspace = true }
 parquet = { workspace = true, default-features = false, features = ["experimental"] }
 half = { version = "2.4.1", default-features = false }
-futures = "0.3.28"
+futures = { workspace = true }
 mimalloc = { version = "*", default-features = false, optional = true }
 tokio = { version = "1", features = ["rt-multi-thread"] }
 async-trait = "0.1"
@@ -88,7 +88,6 @@ hex = "0.4.3"
 
 [features]
 default = []
-nightly = []
 
 [lib]
 name = "comet"
@@ -123,10 +122,6 @@ harness = false
 name = "filter"
 harness = false
 
-[[bench]]
-name = "aggregate"
-harness = false
-
 [[bench]]
 name = "bloom_filter_agg"
 harness = false
diff --git a/native/core/src/common/bit.rs b/native/core/src/common/bit.rs
index 871786bb15..72d7729d93 100644
--- a/native/core/src/common/bit.rs
+++ b/native/core/src/common/bit.rs
@@ -17,14 +17,12 @@
 
 use std::{cmp::min, mem::size_of};
 
-use arrow::buffer::Buffer;
-
 use crate::{
     errors::CometResult as Result,
-    likely,
     parquet::{data_type::AsBytes, util::bit_packing::unpack32},
-    unlikely,
 };
+use arrow::buffer::Buffer;
+use datafusion_comet_spark_expr::utils::{likely, unlikely};
 
 #[inline]
 pub fn from_ne_slice<T: FromBytes>(bs: &[u8]) -> T {
diff --git a/native/core/src/execution/datafusion/expressions/checkoverflow.rs b/native/core/src/execution/datafusion/expressions/checkoverflow.rs
index ed03ab667f..e922171bd2 100644
--- a/native/core/src/execution/datafusion/expressions/checkoverflow.rs
+++ b/native/core/src/execution/datafusion/expressions/checkoverflow.rs
@@ -27,8 +27,7 @@ use arrow::{
     datatypes::{Decimal128Type, DecimalType},
     record_batch::RecordBatch,
 };
-use arrow_data::decimal::{MAX_DECIMAL_FOR_EACH_PRECISION, MIN_DECIMAL_FOR_EACH_PRECISION};
-use arrow_schema::{DataType, Schema, DECIMAL128_MAX_PRECISION};
+use arrow_schema::{DataType, Schema};
 use datafusion::logical_expr::ColumnarValue;
 use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{DataFusionError, ScalarValue};
@@ -172,15 +171,3 @@ impl PhysicalExpr for CheckOverflow {
         self.hash(&mut s);
     }
 }
-
-/// Adapted from arrow-rs `validate_decimal_precision` but returns bool
-/// instead of Err to avoid the cost of formatting the error strings and is
-/// optimized to remove a memcpy that exists in the original function
-/// we can remove this code once we upgrade to a version of arrow-rs that
-/// includes https://github.com/apache/arrow-rs/pull/6419
-#[inline]
-pub fn is_valid_decimal_precision(value: i128, precision: u8) -> bool {
-    precision <= DECIMAL128_MAX_PRECISION
-        && value >= MIN_DECIMAL_FOR_EACH_PRECISION[precision as usize - 1]
-        && value <= MAX_DECIMAL_FOR_EACH_PRECISION[precision as usize - 1]
-}
diff --git a/native/core/src/execution/datafusion/expressions/mod.rs b/native/core/src/execution/datafusion/expressions/mod.rs
index 48b80384b0..2bb14df36e 100644
--- a/native/core/src/execution/datafusion/expressions/mod.rs
+++ b/native/core/src/execution/datafusion/expressions/mod.rs
@@ -17,26 +17,15 @@
 
 //! Native DataFusion expressions
 
-pub mod bitwise_not;
 pub mod checkoverflow;
-mod normalize_nan;
-pub use normalize_nan::NormalizeNaNAndZero;
 
 use crate::errors::CometError;
-pub mod avg;
-pub mod avg_decimal;
 pub mod bloom_filter_agg;
 pub mod bloom_filter_might_contain;
-pub mod comet_scalar_funcs;
-pub mod correlation;
-pub mod covariance;
 pub mod negative;
-pub mod stddev;
 pub mod strings;
 pub mod subquery;
-pub mod sum_decimal;
 pub mod unbound;
-pub mod variance;
 
 pub use datafusion_comet_spark_expr::{EvalMode, SparkError};
 
diff --git a/native/core/src/execution/datafusion/planner.rs b/native/core/src/execution/datafusion/planner.rs
index 33c4924cbd..a83dba5d63 100644
--- a/native/core/src/execution/datafusion/planner.rs
+++ b/native/core/src/execution/datafusion/planner.rs
@@ -18,29 +18,19 @@
 //! Converts Spark physical plan to DataFusion physical plan
 
 use super::expressions::EvalMode;
-use crate::execution::datafusion::expressions::comet_scalar_funcs::create_comet_physical_fun;
 use crate::execution::operators::{CopyMode, FilterExec};
 use crate::{
     errors::ExpressionError,
     execution::{
         datafusion::{
             expressions::{
-                avg::Avg,
-                avg_decimal::AvgDecimal,
-                bitwise_not::BitwiseNotExpr,
                 bloom_filter_agg::BloomFilterAgg,
                 bloom_filter_might_contain::BloomFilterMightContain,
                 checkoverflow::CheckOverflow,
-                correlation::Correlation,
-                covariance::Covariance,
                 negative,
-                stddev::Stddev,
                 strings::{Contains, EndsWith, Like, StartsWith, StringSpaceExpr, SubstringExpr},
                 subquery::Subquery,
-                sum_decimal::SumDecimal,
                 unbound::UnboundColumn,
-                variance::Variance,
-                NormalizeNaNAndZero,
             },
             operators::expand::CometExpandExec,
             shuffle_writer::ShuffleWriterExec,
@@ -82,6 +72,7 @@ use datafusion::{
     },
     prelude::SessionContext,
 };
+use datafusion_comet_spark_expr::create_comet_physical_fun;
 use datafusion_functions_nested::concat::ArrayAppend;
 use datafusion_physical_expr::aggregate::{AggregateExprBuilder, AggregateFunctionExpr};
 
@@ -99,9 +90,10 @@ use datafusion_comet_proto::{
     spark_partitioning::{partitioning::PartitioningStruct, Partitioning as SparkPartitioning},
 };
 use datafusion_comet_spark_expr::{
-    ArrayInsert, Cast, CreateNamedStruct, DateTruncExpr, GetArrayStructFields, GetStructField,
-    HourExpr, IfExpr, ListExtract, MinuteExpr, RLike, SecondExpr, SparkCastOptions,
-    TimestampTruncExpr, ToJson,
+    ArrayInsert, Avg, AvgDecimal, BitwiseNotExpr, Cast, Correlation, Covariance, CreateNamedStruct,
+    DateTruncExpr, GetArrayStructFields, GetStructField, HourExpr, IfExpr, ListExtract, MinuteExpr,
+    NormalizeNaNAndZero, RLike, SecondExpr, SparkCastOptions, Stddev, SumDecimal,
+    TimestampTruncExpr, ToJson, Variance,
 };
 use datafusion_common::scalar::ScalarStructBuilder;
 use datafusion_common::{
diff --git a/native/core/src/lib.rs b/native/core/src/lib.rs
index c6a7a4143d..68c8ae7299 100644
--- a/native/core/src/lib.rs
+++ b/native/core/src/lib.rs
@@ -104,30 +104,3 @@ fn default_logger_config() -> CometResult<Config> {
         .build(root)
         .map_err(|err| CometError::Config(err.to_string()))
 }
-
-// These are borrowed from hashbrown crate:
-//   https://github.com/rust-lang/hashbrown/blob/master/src/raw/mod.rs
-
-// On stable we can use #[cold] to get a equivalent effect: this attributes
-// suggests that the function is unlikely to be called
-#[cfg(not(feature = "nightly"))]
-#[inline]
-#[cold]
-fn cold() {}
-
-#[cfg(not(feature = "nightly"))]
-#[inline]
-fn likely(b: bool) -> bool {
-    if !b {
-        cold();
-    }
-    b
-}
-#[cfg(not(feature = "nightly"))]
-#[inline]
-fn unlikely(b: bool) -> bool {
-    if b {
-        cold();
-    }
-    b
-}
diff --git a/native/core/src/parquet/read/levels.rs b/native/core/src/parquet/read/levels.rs
index 3d74b277cc..9077c0e485 100644
--- a/native/core/src/parquet/read/levels.rs
+++ b/native/core/src/parquet/read/levels.rs
@@ -17,15 +17,14 @@
 
 use std::mem;
 
-use arrow::buffer::Buffer;
-use parquet::schema::types::ColumnDescPtr;
-
 use super::values::Decoder;
 use crate::{
     common::bit::{self, read_u32, BitReader},
     parquet::ParquetMutableVector,
-    unlikely,
 };
+use arrow::buffer::Buffer;
+use datafusion_comet_spark_expr::utils::unlikely;
+use parquet::schema::types::ColumnDescPtr;
 
 const INITIAL_BUF_LEN: usize = 16;
 
diff --git a/native/core/src/parquet/read/values.rs b/native/core/src/parquet/read/values.rs
index b439e29e6a..71cd035d2e 100644
--- a/native/core/src/parquet/read/values.rs
+++ b/native/core/src/parquet/read/values.rs
@@ -28,9 +28,9 @@ use crate::write_val_or_null;
 use crate::{
     common::bit::{self, BitReader},
     parquet::{data_type::*, ParquetMutableVector},
-    unlikely,
 };
 use arrow::datatypes::DataType as ArrowDataType;
+use datafusion_comet_spark_expr::utils::unlikely;
 
 pub fn get_decoder<T: DataType>(
     value_data: Buffer,
diff --git a/native/spark-expr/Cargo.toml b/native/spark-expr/Cargo.toml
index 532bf74375..65517431d2 100644
--- a/native/spark-expr/Cargo.toml
+++ b/native/spark-expr/Cargo.toml
@@ -29,6 +29,7 @@ edition = { workspace = true }
 [dependencies]
 arrow = { workspace = true }
 arrow-array = { workspace = true }
+arrow-data = { workspace = true }
 arrow-schema = { workspace = true }
 chrono = { workspace = true }
 datafusion = { workspace = true }
@@ -39,12 +40,14 @@ chrono-tz = { workspace = true }
 num = { workspace = true }
 regex = { workspace = true }
 thiserror = { workspace = true }
+futures = { workspace = true }
 twox-hash = "2.0.0"
 
 [dev-dependencies]
 arrow-data = {workspace = true}
 criterion = "0.5.1"
 rand = { workspace = true}
+tokio = { version = "1", features = ["rt-multi-thread"] }
 
 
 [lib]
@@ -66,3 +69,8 @@ harness = false
 [[bench]]
 name = "decimal_div"
 harness = false
+
+[[bench]]
+name = "aggregate"
+harness = false
+
diff --git a/native/core/benches/aggregate.rs b/native/spark-expr/benches/aggregate.rs
similarity index 97%
rename from native/core/benches/aggregate.rs
rename to native/spark-expr/benches/aggregate.rs
index c6209406fd..43194fdda2 100644
--- a/native/core/benches/aggregate.rs
+++ b/native/spark-expr/benches/aggregate.rs
@@ -19,16 +19,16 @@ use arrow::datatypes::{DataType, Field, Schema};
 use arrow_array::builder::{Decimal128Builder, StringBuilder};
 use arrow_array::{ArrayRef, RecordBatch};
 use arrow_schema::SchemaRef;
-use comet::execution::datafusion::expressions::avg_decimal::AvgDecimal;
-use comet::execution::datafusion::expressions::sum_decimal::SumDecimal;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use datafusion::execution::TaskContext;
 use datafusion::functions_aggregate::average::avg_udaf;
 use datafusion::functions_aggregate::sum::sum_udaf;
 use datafusion::physical_expr::PhysicalExpr;
 use datafusion::physical_plan::aggregates::{AggregateExec, AggregateMode, PhysicalGroupBy};
 use datafusion::physical_plan::memory::MemoryExec;
 use datafusion::physical_plan::ExecutionPlan;
-use datafusion_execution::TaskContext;
+use datafusion_comet_spark_expr::AvgDecimal;
+use datafusion_comet_spark_expr::SumDecimal;
 use datafusion_expr::AggregateUDF;
 use datafusion_physical_expr::aggregate::AggregateExprBuilder;
 use datafusion_physical_expr::expressions::Column;
diff --git a/native/core/src/execution/datafusion/expressions/avg.rs b/native/spark-expr/src/avg.rs
similarity index 100%
rename from native/core/src/execution/datafusion/expressions/avg.rs
rename to native/spark-expr/src/avg.rs
diff --git a/native/core/src/execution/datafusion/expressions/avg_decimal.rs b/native/spark-expr/src/avg_decimal.rs
similarity index 99%
rename from native/core/src/execution/datafusion/expressions/avg_decimal.rs
rename to native/spark-expr/src/avg_decimal.rs
index a265fdc29e..163e1560b6 100644
--- a/native/core/src/execution/datafusion/expressions/avg_decimal.rs
+++ b/native/spark-expr/src/avg_decimal.rs
@@ -28,7 +28,7 @@ use datafusion_common::{not_impl_err, Result, ScalarValue};
 use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 use std::{any::Any, sync::Arc};
 
-use crate::execution::datafusion::expressions::checkoverflow::is_valid_decimal_precision;
+use crate::utils::is_valid_decimal_precision;
 use arrow_array::ArrowNativeTypeOp;
 use arrow_data::decimal::{MAX_DECIMAL_FOR_EACH_PRECISION, MIN_DECIMAL_FOR_EACH_PRECISION};
 use datafusion::logical_expr::Volatility::Immutable;
diff --git a/native/core/src/execution/datafusion/expressions/bitwise_not.rs b/native/spark-expr/src/bitwise_not.rs
similarity index 88%
rename from native/core/src/execution/datafusion/expressions/bitwise_not.rs
rename to native/spark-expr/src/bitwise_not.rs
index a2b9ebe5b5..36234935e1 100644
--- a/native/core/src/execution/datafusion/expressions/bitwise_not.rs
+++ b/native/spark-expr/src/bitwise_not.rs
@@ -28,7 +28,7 @@ use arrow::{
 };
 use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion::{error::DataFusionError, logical_expr::ColumnarValue};
-use datafusion_common::{Result, ScalarValue};
+use datafusion_common::Result;
 use datafusion_physical_expr::PhysicalExpr;
 
 macro_rules! compute_op {
@@ -135,22 +135,6 @@ pub fn bitwise_not(arg: Arc<dyn PhysicalExpr>) -> Result<Arc<dyn PhysicalExpr>>
     Ok(Arc::new(BitwiseNotExpr::new(arg)))
 }
 
-fn scalar_bitwise_not(scalar: ScalarValue) -> Result<ScalarValue> {
-    match scalar {
-        ScalarValue::Int8(None)
-        | ScalarValue::Int16(None)
-        | ScalarValue::Int32(None)
-        | ScalarValue::Int64(None) => Ok(scalar),
-        ScalarValue::Int8(Some(v)) => Ok(ScalarValue::Int8(Some(!v))),
-        ScalarValue::Int16(Some(v)) => Ok(ScalarValue::Int16(Some(!v))),
-        ScalarValue::Int32(Some(v)) => Ok(ScalarValue::Int32(Some(!v))),
-        ScalarValue::Int64(Some(v)) => Ok(ScalarValue::Int64(Some(!v))),
-        value => Err(DataFusionError::Internal(format!(
-            "Can not run ! on scalar value {value:?}"
-        ))),
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use arrow::datatypes::*;
diff --git a/native/core/src/execution/datafusion/expressions/comet_scalar_funcs.rs b/native/spark-expr/src/comet_scalar_funcs.rs
similarity index 98%
rename from native/core/src/execution/datafusion/expressions/comet_scalar_funcs.rs
rename to native/spark-expr/src/comet_scalar_funcs.rs
index 06717aabeb..71ff0e9dcc 100644
--- a/native/core/src/execution/datafusion/expressions/comet_scalar_funcs.rs
+++ b/native/spark-expr/src/comet_scalar_funcs.rs
@@ -15,15 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow_schema::DataType;
-use datafusion_comet_spark_expr::scalar_funcs::hash_expressions::{
+use crate::scalar_funcs::hash_expressions::{
     spark_sha224, spark_sha256, spark_sha384, spark_sha512,
 };
-use datafusion_comet_spark_expr::scalar_funcs::{
+use crate::scalar_funcs::{
     spark_ceil, spark_date_add, spark_date_sub, spark_decimal_div, spark_floor, spark_hex,
     spark_isnan, spark_make_decimal, spark_murmur3_hash, spark_read_side_padding, spark_round,
     spark_unhex, spark_unscaled_value, spark_xxhash64, SparkChrFunc,
 };
+use arrow_schema::DataType;
 use datafusion_common::{DataFusionError, Result as DataFusionResult};
 use datafusion_expr::registry::FunctionRegistry;
 use datafusion_expr::{
diff --git a/native/core/src/execution/datafusion/expressions/correlation.rs b/native/spark-expr/src/correlation.rs
similarity index 98%
rename from native/core/src/execution/datafusion/expressions/correlation.rs
rename to native/spark-expr/src/correlation.rs
index 6bf35e7115..e5f36c6f95 100644
--- a/native/core/src/execution/datafusion/expressions/correlation.rs
+++ b/native/spark-expr/src/correlation.rs
@@ -19,9 +19,8 @@ use arrow::compute::{and, filter, is_not_null};
 
 use std::{any::Any, sync::Arc};
 
-use crate::execution::datafusion::expressions::{
-    covariance::CovarianceAccumulator, stddev::StddevAccumulator,
-};
+use crate::covariance::CovarianceAccumulator;
+use crate::stddev::StddevAccumulator;
 use arrow::{
     array::ArrayRef,
     datatypes::{DataType, Field},
diff --git a/native/core/src/execution/datafusion/expressions/covariance.rs b/native/spark-expr/src/covariance.rs
similarity index 100%
rename from native/core/src/execution/datafusion/expressions/covariance.rs
rename to native/spark-expr/src/covariance.rs
diff --git a/native/spark-expr/src/lib.rs b/native/spark-expr/src/lib.rs
index c227b3a025..15f446ef35 100644
--- a/native/spark-expr/src/lib.rs
+++ b/native/spark-expr/src/lib.rs
@@ -23,18 +23,38 @@ mod cast;
 mod error;
 mod if_expr;
 
+mod avg;
+pub use avg::Avg;
+mod bitwise_not;
+pub use bitwise_not::{bitwise_not, BitwiseNotExpr};
+mod avg_decimal;
+pub use avg_decimal::AvgDecimal;
+mod correlation;
+pub use correlation::Correlation;
+mod covariance;
+pub use covariance::Covariance;
 mod kernels;
 mod list;
 mod regexp;
 pub mod scalar_funcs;
 pub mod spark_hash;
+mod stddev;
+pub use stddev::Stddev;
 mod structs;
+mod sum_decimal;
+pub use sum_decimal::SumDecimal;
+mod normalize_nan;
 mod temporal;
 pub mod timezone;
 mod to_json;
 pub mod utils;
+pub use normalize_nan::NormalizeNaNAndZero;
 
+mod variance;
+pub use variance::Variance;
+mod comet_scalar_funcs;
 pub use cast::{spark_cast, Cast, SparkCastOptions};
+pub use comet_scalar_funcs::create_comet_physical_fun;
 pub use error::{SparkError, SparkResult};
 pub use if_expr::IfExpr;
 pub use list::{ArrayInsert, GetArrayStructFields, ListExtract};
diff --git a/native/core/src/execution/datafusion/expressions/normalize_nan.rs b/native/spark-expr/src/normalize_nan.rs
similarity index 100%
rename from native/core/src/execution/datafusion/expressions/normalize_nan.rs
rename to native/spark-expr/src/normalize_nan.rs
diff --git a/native/core/src/execution/datafusion/expressions/stddev.rs b/native/spark-expr/src/stddev.rs
similarity index 98%
rename from native/core/src/execution/datafusion/expressions/stddev.rs
rename to native/spark-expr/src/stddev.rs
index 1ba495e215..3cf604da0b 100644
--- a/native/core/src/execution/datafusion/expressions/stddev.rs
+++ b/native/spark-expr/src/stddev.rs
@@ -17,7 +17,7 @@
 
 use std::{any::Any, sync::Arc};
 
-use crate::execution::datafusion::expressions::variance::VarianceAccumulator;
+use crate::variance::VarianceAccumulator;
 use arrow::{
     array::ArrayRef,
     datatypes::{DataType, Field},
diff --git a/native/core/src/execution/datafusion/expressions/sum_decimal.rs b/native/spark-expr/src/sum_decimal.rs
similarity index 98%
rename from native/core/src/execution/datafusion/expressions/sum_decimal.rs
rename to native/spark-expr/src/sum_decimal.rs
index d885ff90b6..ab142aee69 100644
--- a/native/core/src/execution/datafusion/expressions/sum_decimal.rs
+++ b/native/spark-expr/src/sum_decimal.rs
@@ -15,8 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::execution::datafusion::expressions::checkoverflow::is_valid_decimal_precision;
-use crate::unlikely;
+use crate::utils::{is_valid_decimal_precision, unlikely};
 use arrow::{
     array::BooleanBufferBuilder,
     buffer::{BooleanBuffer, NullBuffer},
@@ -113,7 +112,6 @@ impl AggregateUDFImpl for SumDecimal {
         Ok(Box::new(SumDecimalGroupsAccumulator::new(
             self.result_type.clone(),
             self.precision,
-            self.scale,
         )))
     }
 
@@ -286,18 +284,16 @@ struct SumDecimalGroupsAccumulator {
     sum: Vec<i128>,
     result_type: DataType,
     precision: u8,
-    scale: i8,
 }
 
 impl SumDecimalGroupsAccumulator {
-    fn new(result_type: DataType, precision: u8, scale: i8) -> Self {
+    fn new(result_type: DataType, precision: u8) -> Self {
         Self {
             is_not_null: BooleanBufferBuilder::new(0),
             is_empty: BooleanBufferBuilder::new(0),
             sum: Vec::new(),
             result_type,
             precision,
-            scale,
         }
     }
 
@@ -488,11 +484,11 @@ mod tests {
     use arrow::datatypes::*;
     use arrow_array::builder::{Decimal128Builder, StringBuilder};
     use arrow_array::RecordBatch;
+    use datafusion::execution::TaskContext;
     use datafusion::physical_plan::aggregates::{AggregateExec, AggregateMode, PhysicalGroupBy};
     use datafusion::physical_plan::memory::MemoryExec;
     use datafusion::physical_plan::ExecutionPlan;
     use datafusion_common::Result;
-    use datafusion_execution::TaskContext;
     use datafusion_expr::AggregateUDF;
     use datafusion_physical_expr::aggregate::AggregateExprBuilder;
     use datafusion_physical_expr::expressions::{Column, Literal};
diff --git a/native/spark-expr/src/utils.rs b/native/spark-expr/src/utils.rs
index db4ad1956a..18a2314fb1 100644
--- a/native/spark-expr/src/utils.rs
+++ b/native/spark-expr/src/utils.rs
@@ -19,7 +19,7 @@ use arrow_array::{
     cast::as_primitive_array,
     types::{Int32Type, TimestampMicrosecondType},
 };
-use arrow_schema::{ArrowError, DataType};
+use arrow_schema::{ArrowError, DataType, DECIMAL128_MAX_PRECISION};
 use std::sync::Arc;
 
 use crate::timezone::Tz;
@@ -27,6 +27,7 @@ use arrow::{
     array::{as_dictionary_array, Array, ArrayRef, PrimitiveArray},
     temporal_conversions::as_datetime,
 };
+use arrow_data::decimal::{MAX_DECIMAL_FOR_EACH_PRECISION, MIN_DECIMAL_FOR_EACH_PRECISION};
 use chrono::{DateTime, Offset, TimeZone};
 
 /// Preprocesses input arrays to add timezone information from Spark to Arrow array datatype or
@@ -176,3 +177,39 @@ fn pre_timestamp_cast(array: ArrayRef, timezone: String) -> Result<ArrayRef, Arr
         _ => Ok(array),
     }
 }
+
+/// Adapted from arrow-rs `validate_decimal_precision` but returns bool
+/// instead of Err to avoid the cost of formatting the error strings and is
+/// optimized to remove a memcpy that exists in the original function
+/// we can remove this code once we upgrade to a version of arrow-rs that
+/// includes https://github.com/apache/arrow-rs/pull/6419
+#[inline]
+pub fn is_valid_decimal_precision(value: i128, precision: u8) -> bool {
+    precision <= DECIMAL128_MAX_PRECISION
+        && value >= MIN_DECIMAL_FOR_EACH_PRECISION[precision as usize - 1]
+        && value <= MAX_DECIMAL_FOR_EACH_PRECISION[precision as usize - 1]
+}
+
+// These are borrowed from hashbrown crate:
+//   https://github.com/rust-lang/hashbrown/blob/master/src/raw/mod.rs
+
+// On stable we can use #[cold] to get a equivalent effect: this attributes
+// suggests that the function is unlikely to be called
+#[inline]
+#[cold]
+pub fn cold() {}
+
+#[inline]
+pub fn likely(b: bool) -> bool {
+    if !b {
+        cold();
+    }
+    b
+}
+#[inline]
+pub fn unlikely(b: bool) -> bool {
+    if b {
+        cold();
+    }
+    b
+}
diff --git a/native/core/src/execution/datafusion/expressions/variance.rs b/native/spark-expr/src/variance.rs
similarity index 100%
rename from native/core/src/execution/datafusion/expressions/variance.rs
rename to native/spark-expr/src/variance.rs

From 5c45fdc9e311da07a0f3510d9b8aec673081861a Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Mon, 9 Dec 2024 17:45:27 -0700
Subject: [PATCH 30/47] remove dead code (#1155)

---
 native/core/benches/bloom_filter_agg.rs       |   2 -
 native/core/benches/parquet_read.rs           |   5 +-
 native/core/src/errors.rs                     |  44 +------
 .../expressions/bloom_filter_agg.rs           |   6 -
 .../core/src/execution/datafusion/planner.rs  |   3 -
 .../datafusion/util/spark_bit_array.rs        |   1 +
 native/core/src/execution/jni_api.rs          |   8 --
 native/core/src/execution/kernels/strings.rs  | 117 +-----------------
 native/core/src/execution/operators/scan.rs   |   8 --
 native/core/src/execution/shuffle/list.rs     |   4 +-
 native/core/src/execution/shuffle/map.rs      |  17 +--
 native/core/src/execution/shuffle/row.rs      |   5 +-
 native/core/src/execution/utils.rs            |  18 ---
 native/core/src/jvm_bridge/batch_iterator.rs  |   1 +
 .../core/src/jvm_bridge/comet_metric_node.rs  |   1 +
 .../jvm_bridge/comet_task_memory_manager.rs   |   1 +
 native/core/src/jvm_bridge/mod.rs             |   1 +
 native/core/src/lib.rs                        |   1 -
 native/core/src/parquet/mod.rs                |   2 -
 native/core/src/parquet/mutable_vector.rs     |   8 --
 native/core/src/parquet/read/column.rs        |  14 +--
 native/core/src/parquet/read/mod.rs           |   3 -
 native/core/src/parquet/read/values.rs        |  26 +---
 .../src/parquet/util/test_common/page_util.rs |  12 +-
 24 files changed, 27 insertions(+), 281 deletions(-)

diff --git a/native/core/benches/bloom_filter_agg.rs b/native/core/benches/bloom_filter_agg.rs
index af3eb919ee..25d27d174e 100644
--- a/native/core/benches/bloom_filter_agg.rs
+++ b/native/core/benches/bloom_filter_agg.rs
@@ -61,10 +61,8 @@ fn criterion_benchmark(c: &mut Criterion) {
         group.bench_function(agg_mode.0, |b| {
             let comet_bloom_filter_agg =
                 Arc::new(AggregateUDF::new_from_impl(BloomFilterAgg::new(
-                    Arc::clone(&c0),
                     Arc::clone(&num_items),
                     Arc::clone(&num_bits),
-                    "bloom_filter_agg",
                     DataType::Binary,
                 )));
             b.to_async(&rt).iter(|| {
diff --git a/native/core/benches/parquet_read.rs b/native/core/benches/parquet_read.rs
index 1f8178cd22..ae511ade51 100644
--- a/native/core/benches/parquet_read.rs
+++ b/native/core/benches/parquet_read.rs
@@ -44,7 +44,7 @@ fn bench(c: &mut Criterion) {
     let mut group = c.benchmark_group("comet_parquet_read");
     let schema = build_test_schema();
 
-    let pages = build_plain_int32_pages(schema.clone(), schema.column(0), 0.0);
+    let pages = build_plain_int32_pages(schema.column(0), 0.0);
     group.bench_function("INT/PLAIN/NOT_NULL", |b| {
         let t = TypePtr::new(
             PrimitiveTypeBuilder::new("f", PhysicalType::INT32)
@@ -107,7 +107,6 @@ const VALUES_PER_PAGE: usize = 10_000;
 const BATCH_SIZE: usize = 4096;
 
 fn build_plain_int32_pages(
-    schema: SchemaDescPtr,
     column_desc: ColumnDescPtr,
     null_density: f32,
 ) -> impl PageIterator + Clone {
@@ -143,7 +142,7 @@ fn build_plain_int32_pages(
 
     // Since `InMemoryPageReader` is not exposed from parquet crate, here we use
     // `InMemoryPageIterator` instead which is a Iter<Iter<Page>>.
-    InMemoryPageIterator::new(schema, column_desc, vec![pages])
+    InMemoryPageIterator::new(vec![pages])
 }
 
 struct TestColumnReader {
diff --git a/native/core/src/errors.rs b/native/core/src/errors.rs
index 92799bcf6f..4d623d976f 100644
--- a/native/core/src/errors.rs
+++ b/native/core/src/errors.rs
@@ -485,23 +485,6 @@ where
     || f(t)
 }
 
-// This is a duplicate of `try_unwrap_or_throw`, which is used to work around Arrow's lack of
-// `UnwindSafe` handling.
-pub fn try_assert_unwind_safe_or_throw<T, F>(env: &JNIEnv, f: F) -> T
-where
-    T: JNIDefault,
-    F: FnOnce(JNIEnv) -> Result<T, CometError>,
-{
-    let mut env1 = unsafe { JNIEnv::from_raw(env.get_raw()).unwrap() };
-    let env2 = unsafe { JNIEnv::from_raw(env.get_raw()).unwrap() };
-    unwrap_or_throw_default(
-        &mut env1,
-        flatten(
-            catch_unwind(std::panic::AssertUnwindSafe(curry(f, env2))).map_err(CometError::from),
-        ),
-    )
-}
-
 // It is currently undefined behavior to unwind from Rust code into foreign code, so we can wrap
 // our JNI functions and turn these panics into a `RuntimeException`.
 pub fn try_unwrap_or_throw<T, F>(env: &JNIEnv, f: F) -> T
@@ -534,10 +517,7 @@ mod tests {
         AttachGuard, InitArgsBuilder, JNIEnv, JNIVersion, JavaVM,
     };
 
-    use assertables::{
-        assert_contains, assert_contains_as_result, assert_starts_with,
-        assert_starts_with_as_result,
-    };
+    use assertables::{assert_starts_with, assert_starts_with_as_result};
 
     pub fn jvm() -> &'static Arc<JavaVM> {
         static mut JVM: Option<Arc<JavaVM>> = None;
@@ -890,26 +870,4 @@ mod tests {
         // first line.
         assert_starts_with!(msg_rust, expected_message);
     }
-
-    // Asserts that exception's message matches `expected_message`.
-    fn assert_exception_message_with_stacktrace(
-        env: &mut JNIEnv,
-        exception: JThrowable,
-        expected_message: &str,
-        stacktrace_contains: &str,
-    ) {
-        let message = env
-            .call_method(exception, "getMessage", "()Ljava/lang/String;", &[])
-            .unwrap()
-            .l()
-            .unwrap();
-        let message_string = message.into();
-        let msg_rust: String = env.get_string(&message_string).unwrap().into();
-        // Since panics result in multi-line messages which include the backtrace, just use the
-        // first line.
-        assert_starts_with!(msg_rust, expected_message);
-
-        // Check that the stacktrace is included by checking for a specific element
-        assert_contains!(msg_rust, stacktrace_contains);
-    }
 }
diff --git a/native/core/src/execution/datafusion/expressions/bloom_filter_agg.rs b/native/core/src/execution/datafusion/expressions/bloom_filter_agg.rs
index e6528a5633..1300e08c22 100644
--- a/native/core/src/execution/datafusion/expressions/bloom_filter_agg.rs
+++ b/native/core/src/execution/datafusion/expressions/bloom_filter_agg.rs
@@ -34,9 +34,7 @@ use datafusion_physical_expr::expressions::Literal;
 
 #[derive(Debug, Clone)]
 pub struct BloomFilterAgg {
-    name: String,
     signature: Signature,
-    expr: Arc<dyn PhysicalExpr>,
     num_items: i32,
     num_bits: i32,
 }
@@ -53,15 +51,12 @@ fn extract_i32_from_literal(expr: Arc<dyn PhysicalExpr>) -> i32 {
 
 impl BloomFilterAgg {
     pub fn new(
-        expr: Arc<dyn PhysicalExpr>,
         num_items: Arc<dyn PhysicalExpr>,
         num_bits: Arc<dyn PhysicalExpr>,
-        name: impl Into<String>,
         data_type: DataType,
     ) -> Self {
         assert!(matches!(data_type, DataType::Binary));
         Self {
-            name: name.into(),
             signature: Signature::uniform(
                 1,
                 vec![
@@ -73,7 +68,6 @@ impl BloomFilterAgg {
                 ],
                 Volatility::Immutable,
             ),
-            expr,
             num_items: extract_i32_from_literal(num_items),
             num_bits: extract_i32_from_literal(num_bits),
         }
diff --git a/native/core/src/execution/datafusion/planner.rs b/native/core/src/execution/datafusion/planner.rs
index a83dba5d63..5e77b3f653 100644
--- a/native/core/src/execution/datafusion/planner.rs
+++ b/native/core/src/execution/datafusion/planner.rs
@@ -115,7 +115,6 @@ use std::cmp::max;
 use std::{collections::HashMap, sync::Arc};
 
 // For clippy error on type_complexity.
-type ExecResult<T> = Result<T, ExecutionError>;
 type PhyAggResult = Result<Vec<AggregateFunctionExpr>, ExecutionError>;
 type PhyExprResult = Result<Vec<(Arc<dyn PhysicalExpr>, String)>, ExecutionError>;
 type PartitionPhyExprResult = Result<Vec<Arc<dyn PhysicalExpr>>, ExecutionError>;
@@ -1758,10 +1757,8 @@ impl PhysicalPlanner {
                     self.create_expr(expr.num_bits.as_ref().unwrap(), Arc::clone(&schema))?;
                 let datatype = to_arrow_datatype(expr.datatype.as_ref().unwrap());
                 let func = AggregateUDF::new_from_impl(BloomFilterAgg::new(
-                    Arc::clone(&child),
                     Arc::clone(&num_items),
                     Arc::clone(&num_bits),
-                    "bloom_filter_agg",
                     datatype,
                 ));
                 Self::create_aggr_func_expr("bloom_filter_agg", schema, vec![child], func)
diff --git a/native/core/src/execution/datafusion/util/spark_bit_array.rs b/native/core/src/execution/datafusion/util/spark_bit_array.rs
index 68b97d6608..6cfecc1bfb 100644
--- a/native/core/src/execution/datafusion/util/spark_bit_array.rs
+++ b/native/core/src/execution/datafusion/util/spark_bit_array.rs
@@ -70,6 +70,7 @@ impl SparkBitArray {
         self.data.len()
     }
 
+    #[allow(dead_code)] // this is only called from tests
     pub fn cardinality(&self) -> usize {
         self.bit_count
     }
diff --git a/native/core/src/execution/jni_api.rs b/native/core/src/execution/jni_api.rs
index 8afe134cd3..5103f5ce4a 100644
--- a/native/core/src/execution/jni_api.rs
+++ b/native/core/src/execution/jni_api.rs
@@ -207,14 +207,6 @@ fn prepare_datafusion_session_context(
     Ok(session_ctx)
 }
 
-fn parse_bool(conf: &HashMap<String, String>, name: &str) -> CometResult<bool> {
-    conf.get(name)
-        .map(String::as_str)
-        .unwrap_or("false")
-        .parse::<bool>()
-        .map_err(|e| CometError::Config(format!("Failed to parse boolean config {name}: {e}")))
-}
-
 /// Prepares arrow arrays for output.
 fn prepare_output(
     env: &mut JNIEnv,
diff --git a/native/core/src/execution/kernels/strings.rs b/native/core/src/execution/kernels/strings.rs
index 2e5e67b67f..d63b2c4778 100644
--- a/native/core/src/execution/kernels/strings.rs
+++ b/native/core/src/execution/kernels/strings.rs
@@ -21,7 +21,7 @@ use std::sync::Arc;
 
 use arrow::{
     array::*,
-    buffer::{Buffer, MutableBuffer},
+    buffer::MutableBuffer,
     compute::kernels::substring::{substring as arrow_substring, substring_by_char},
     datatypes::{DataType, Int32Type},
 };
@@ -87,43 +87,6 @@ pub fn substring(array: &dyn Array, start: i64, length: u64) -> Result<ArrayRef,
     }
 }
 
-/// Returns an ArrayRef with a substring starting from `start` and length.
-///
-/// # Preconditions
-///
-/// - `start` can be negative, in which case the start counts from the end of the string.
-/// - `array` must  be either [`StringArray`] or [`LargeStringArray`].
-///
-/// Note: this is different from arrow-rs `substring` kernel in that both `start` and `length` are
-/// `Int32Array` here.
-pub fn substring_with_array(
-    array: &dyn Array,
-    start: &Int32Array,
-    length: &Int32Array,
-) -> ArrayRef {
-    match array.data_type() {
-        DataType::LargeUtf8 => generic_substring(
-            array
-                .as_any()
-                .downcast_ref::<LargeStringArray>()
-                .expect("A large string is expected"),
-            start,
-            length,
-            |i| i as i64,
-        ),
-        DataType::Utf8 => generic_substring(
-            array
-                .as_any()
-                .downcast_ref::<StringArray>()
-                .expect("A string is expected"),
-            start,
-            length,
-            |i| i,
-        ),
-        _ => panic!("substring does not support type {:?}", array.data_type()),
-    }
-}
-
 fn generic_string_space<OffsetSize: OffsetSizeTrait>(length: &Int32Array) -> ArrayRef {
     let array_len = length.len();
     let mut offsets = MutableBuffer::new((array_len + 1) * std::mem::size_of::<OffsetSize>());
@@ -163,81 +126,3 @@ fn generic_string_space<OffsetSize: OffsetSizeTrait>(length: &Int32Array) -> Arr
     };
     make_array(data)
 }
-
-fn generic_substring<OffsetSize: OffsetSizeTrait, F>(
-    array: &GenericStringArray<OffsetSize>,
-    start: &Int32Array,
-    length: &Int32Array,
-    f: F,
-) -> ArrayRef
-where
-    F: Fn(i32) -> OffsetSize,
-{
-    assert_eq!(array.len(), start.len());
-    assert_eq!(array.len(), length.len());
-
-    // compute current offsets
-    let offsets = array.to_data().buffers()[0].clone();
-    let offsets: &[OffsetSize] = offsets.typed_data::<OffsetSize>();
-
-    // compute null bitmap (copy)
-    let null_bit_buffer = array.to_data().nulls().map(|b| b.buffer().clone());
-
-    // Gets slices of start and length arrays to access them directly for performance.
-    let start_data = start.to_data();
-    let length_data = length.to_data();
-    let starts = start_data.buffers()[0].typed_data::<i32>();
-    let lengths = length_data.buffers()[0].typed_data::<i32>();
-
-    // compute values
-    let array_data = array.to_data();
-    let values = &array_data.buffers()[1];
-    let data = values.as_slice();
-
-    // we have no way to estimate how much this will be.
-    let mut new_values = MutableBuffer::new(0);
-    let mut new_offsets: Vec<OffsetSize> = Vec::with_capacity(array.len() + 1);
-
-    let mut length_so_far = OffsetSize::zero();
-    new_offsets.push(length_so_far);
-    (0..array.len()).for_each(|i| {
-        // the length of this entry
-        let length_i: OffsetSize = offsets[i + 1] - offsets[i];
-        // compute where we should start slicing this entry
-        let start_pos: OffsetSize = f(starts[i]);
-
-        let start = offsets[i]
-            + if start_pos >= OffsetSize::zero() {
-                start_pos
-            } else {
-                length_i + start_pos
-            };
-
-        let start = start.clamp(offsets[i], offsets[i + 1]);
-        // compute the length of the slice
-        let slice_length: OffsetSize = f(lengths[i].max(0)).min(offsets[i + 1] - start);
-
-        length_so_far += slice_length;
-
-        new_offsets.push(length_so_far);
-
-        // we need usize for ranges
-        let start = start.to_usize().unwrap();
-        let slice_length = slice_length.to_usize().unwrap();
-
-        new_values.extend_from_slice(&data[start..start + slice_length]);
-    });
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            GenericStringArray::<OffsetSize>::DATA_TYPE,
-            array.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![Buffer::from_slice_ref(&new_offsets), new_values.into()],
-            vec![],
-        )
-    };
-    make_array(data)
-}
diff --git a/native/core/src/execution/operators/scan.rs b/native/core/src/execution/operators/scan.rs
index a97caf0db1..0d35859dfb 100644
--- a/native/core/src/execution/operators/scan.rs
+++ b/native/core/src/execution/operators/scan.rs
@@ -525,12 +525,4 @@ impl InputBatch {
 
         InputBatch::Batch(columns, num_rows)
     }
-
-    /// Get the number of rows in this batch
-    fn num_rows(&self) -> usize {
-        match self {
-            Self::EOF => 0,
-            Self::Batch(_, num_rows) => *num_rows,
-        }
-    }
 }
diff --git a/native/core/src/execution/shuffle/list.rs b/native/core/src/execution/shuffle/list.rs
index d8bdcb197b..0f7f3e8cb3 100644
--- a/native/core/src/execution/shuffle/list.rs
+++ b/native/core/src/execution/shuffle/list.rs
@@ -28,7 +28,6 @@ use arrow_schema::{DataType, TimeUnit};
 
 pub struct SparkUnsafeArray {
     row_addr: i64,
-    row_size: i32,
     num_elements: usize,
     element_offset: i64,
 }
@@ -45,7 +44,7 @@ impl SparkUnsafeObject for SparkUnsafeArray {
 
 impl SparkUnsafeArray {
     /// Creates a `SparkUnsafeArray` which points to the given address and size in bytes.
-    pub fn new(addr: i64, size: i32) -> Self {
+    pub fn new(addr: i64) -> Self {
         // Read the number of elements from the first 8 bytes.
         let slice: &[u8] = unsafe { std::slice::from_raw_parts(addr as *const u8, 8) };
         let num_elements = i64::from_le_bytes(slice.try_into().unwrap());
@@ -60,7 +59,6 @@ impl SparkUnsafeArray {
 
         Self {
             row_addr: addr,
-            row_size: size,
             num_elements: num_elements as usize,
             element_offset: addr + Self::get_header_portion_in_bytes(num_elements),
         }
diff --git a/native/core/src/execution/shuffle/map.rs b/native/core/src/execution/shuffle/map.rs
index 014695293a..0969168f8e 100644
--- a/native/core/src/execution/shuffle/map.rs
+++ b/native/core/src/execution/shuffle/map.rs
@@ -30,8 +30,6 @@ use arrow_array::builder::{
 use arrow_schema::{DataType, FieldRef, Fields, TimeUnit};
 
 pub struct SparkUnsafeMap {
-    row_addr: i64,
-    row_size: i32,
     pub(crate) keys: SparkUnsafeArray,
     pub(crate) values: SparkUnsafeArray,
 }
@@ -59,8 +57,8 @@ impl SparkUnsafeMap {
             panic!("Negative value size in bytes of map: {}", value_array_size);
         }
 
-        let keys = SparkUnsafeArray::new(addr + 8, key_array_size as i32);
-        let values = SparkUnsafeArray::new(addr + 8 + key_array_size, value_array_size);
+        let keys = SparkUnsafeArray::new(addr + 8);
+        let values = SparkUnsafeArray::new(addr + 8 + key_array_size);
 
         if keys.get_num_elements() != values.get_num_elements() {
             panic!(
@@ -70,16 +68,7 @@ impl SparkUnsafeMap {
             );
         }
 
-        Self {
-            row_addr: addr,
-            row_size: size,
-            keys,
-            values,
-        }
-    }
-
-    pub(crate) fn get_num_elements(&self) -> usize {
-        self.keys.get_num_elements()
+        Self { keys, values }
     }
 }
 
diff --git a/native/core/src/execution/shuffle/row.rs b/native/core/src/execution/shuffle/row.rs
index 2aeb488154..17b180e9d0 100644
--- a/native/core/src/execution/shuffle/row.rs
+++ b/native/core/src/execution/shuffle/row.rs
@@ -48,7 +48,6 @@ use std::{
     sync::Arc,
 };
 
-const WORD_SIZE: i64 = 8;
 const MAX_LONG_DIGITS: u8 = 18;
 const NESTED_TYPE_BUILDER_CAPACITY: usize = 100;
 
@@ -170,8 +169,8 @@ pub trait SparkUnsafeObject {
 
     /// Returns array value at the given index of the object.
     fn get_array(&self, index: usize) -> SparkUnsafeArray {
-        let (offset, len) = self.get_offset_and_len(index);
-        SparkUnsafeArray::new(self.get_row_addr() + offset as i64, len)
+        let (offset, _) = self.get_offset_and_len(index);
+        SparkUnsafeArray::new(self.get_row_addr() + offset as i64)
     }
 
     fn get_map(&self, index: usize) -> SparkUnsafeMap {
diff --git a/native/core/src/execution/utils.rs b/native/core/src/execution/utils.rs
index 553d426062..4992b7ba94 100644
--- a/native/core/src/execution/utils.rs
+++ b/native/core/src/execution/utils.rs
@@ -15,8 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::sync::Arc;
-
 use arrow::{
     array::ArrayData,
     error::ArrowError,
@@ -52,10 +50,6 @@ pub trait SparkArrowConvert {
     where
         Self: Sized;
 
-    /// Convert Arrow Arrays to C data interface.
-    /// It returns a tuple (ArrowArray address, ArrowSchema address).
-    fn to_spark(&self) -> Result<(i64, i64), ExecutionError>;
-
     /// Move Arrow Arrays to C data interface.
     fn move_to_spark(&self, array: i64, schema: i64) -> Result<(), ExecutionError>;
 }
@@ -88,18 +82,6 @@ impl SparkArrowConvert for ArrayData {
         Ok(ffi_array)
     }
 
-    /// Converts this ArrowData to pointers of Arrow C data interface.
-    /// Returned pointers are Arc-ed and should be freed manually.
-    #[allow(clippy::arc_with_non_send_sync)]
-    fn to_spark(&self) -> Result<(i64, i64), ExecutionError> {
-        let arrow_array = Arc::new(FFI_ArrowArray::new(self));
-        let arrow_schema = Arc::new(FFI_ArrowSchema::try_from(self.data_type())?);
-
-        let (array, schema) = (Arc::into_raw(arrow_array), Arc::into_raw(arrow_schema));
-
-        Ok((array as i64, schema as i64))
-    }
-
     /// Move this ArrowData to pointers of Arrow C data interface.
     fn move_to_spark(&self, array: i64, schema: i64) -> Result<(), ExecutionError> {
         let array_ptr = array as *mut FFI_ArrowArray;
diff --git a/native/core/src/jvm_bridge/batch_iterator.rs b/native/core/src/jvm_bridge/batch_iterator.rs
index 45b10cf208..998e540c73 100644
--- a/native/core/src/jvm_bridge/batch_iterator.rs
+++ b/native/core/src/jvm_bridge/batch_iterator.rs
@@ -24,6 +24,7 @@ use jni::{
 };
 
 /// A struct that holds all the JNI methods and fields for JVM `CometBatchIterator` class.
+#[allow(dead_code)] // we need to keep references to Java items to prevent GC
 pub struct CometBatchIterator<'a> {
     pub class: JClass<'a>,
     pub method_has_next: JMethodID,
diff --git a/native/core/src/jvm_bridge/comet_metric_node.rs b/native/core/src/jvm_bridge/comet_metric_node.rs
index 8647e071a2..85386d9b0d 100644
--- a/native/core/src/jvm_bridge/comet_metric_node.rs
+++ b/native/core/src/jvm_bridge/comet_metric_node.rs
@@ -23,6 +23,7 @@ use jni::{
 };
 
 /// A struct that holds all the JNI methods and fields for JVM CometMetricNode class.
+#[allow(dead_code)] // we need to keep references to Java items to prevent GC
 pub struct CometMetricNode<'a> {
     pub class: JClass<'a>,
     pub method_get_child_node: JMethodID,
diff --git a/native/core/src/jvm_bridge/comet_task_memory_manager.rs b/native/core/src/jvm_bridge/comet_task_memory_manager.rs
index 97d1bf3a73..22c3332c61 100644
--- a/native/core/src/jvm_bridge/comet_task_memory_manager.rs
+++ b/native/core/src/jvm_bridge/comet_task_memory_manager.rs
@@ -25,6 +25,7 @@ use jni::{
 /// A wrapper which delegate acquire/release memory calls to the
 /// JVM side `CometTaskMemoryManager`.
 #[derive(Debug)]
+#[allow(dead_code)] // we need to keep references to Java items to prevent GC
 pub struct CometTaskMemoryManager<'a> {
     pub class: JClass<'a>,
     pub method_acquire_memory: JMethodID,
diff --git a/native/core/src/jvm_bridge/mod.rs b/native/core/src/jvm_bridge/mod.rs
index 4936b1c5bf..5fc0a55e3e 100644
--- a/native/core/src/jvm_bridge/mod.rs
+++ b/native/core/src/jvm_bridge/mod.rs
@@ -189,6 +189,7 @@ pub use comet_metric_node::*;
 pub use comet_task_memory_manager::*;
 
 /// The JVM classes that are used in the JNI calls.
+#[allow(dead_code)] // we need to keep references to Java items to prevent GC
 pub struct JVMClasses<'a> {
     /// Cached JClass for "java.lang.Object"
     java_lang_object: JClass<'a>,
diff --git a/native/core/src/lib.rs b/native/core/src/lib.rs
index 68c8ae7299..cab511faff 100644
--- a/native/core/src/lib.rs
+++ b/native/core/src/lib.rs
@@ -17,7 +17,6 @@
 
 #![allow(incomplete_features)]
 #![allow(non_camel_case_types)]
-#![allow(dead_code)]
 #![allow(clippy::upper_case_acronyms)]
 // For prost generated struct
 #![allow(clippy::derive_partial_eq_without_eq)]
diff --git a/native/core/src/parquet/mod.rs b/native/core/src/parquet/mod.rs
index 455f19929f..d2a6f4804b 100644
--- a/native/core/src/parquet/mod.rs
+++ b/native/core/src/parquet/mod.rs
@@ -47,8 +47,6 @@ use util::jni::{convert_column_descriptor, convert_encoding};
 
 use self::util::jni::TypePromotionInfo;
 
-const STR_CLASS_NAME: &str = "java/lang/String";
-
 /// Parquet read context maintained across multiple JNI calls.
 struct Context {
     pub column_reader: ColumnReader,
diff --git a/native/core/src/parquet/mutable_vector.rs b/native/core/src/parquet/mutable_vector.rs
index 7f30d7d877..d19ea32fad 100644
--- a/native/core/src/parquet/mutable_vector.rs
+++ b/native/core/src/parquet/mutable_vector.rs
@@ -40,12 +40,6 @@ pub struct ParquetMutableVector {
     /// The number of null elements in this vector, must <= `num_values`.
     pub(crate) num_nulls: usize,
 
-    /// The capacity of the vector
-    pub(crate) capacity: usize,
-
-    /// How many bits are required to store a single value
-    pub(crate) bit_width: usize,
-
     /// The validity buffer of this Arrow vector. A bit set at position `i` indicates the `i`th
     /// element is not null. Otherwise, an unset bit at position `i` indicates the `i`th element is
     /// null.
@@ -109,8 +103,6 @@ impl ParquetMutableVector {
             arrow_type,
             num_values: 0,
             num_nulls: 0,
-            capacity,
-            bit_width,
             validity_buffer,
             value_buffer,
             children,
diff --git a/native/core/src/parquet/read/column.rs b/native/core/src/parquet/read/column.rs
index 73f8df9560..05a0bf7b5b 100644
--- a/native/core/src/parquet/read/column.rs
+++ b/native/core/src/parquet/read/column.rs
@@ -770,7 +770,7 @@ impl<T: DataType> TypedColumnReader<T> {
         // Create a new vector for dictionary values
         let mut value_vector = ParquetMutableVector::new(page_value_count, &self.arrow_type);
 
-        let mut dictionary = self.get_decoder(page_data, page_value_count, encoding);
+        let mut dictionary = self.get_decoder(page_data, encoding);
         dictionary.read_batch(&mut value_vector, page_value_count);
         value_vector.num_values = page_value_count;
 
@@ -812,7 +812,7 @@ impl<T: DataType> TypedColumnReader<T> {
         self.def_level_decoder = Some(dl_decoder);
         page_buffer = page_buffer.slice(offset);
 
-        let value_decoder = self.get_decoder(page_buffer, page_value_count, encoding);
+        let value_decoder = self.get_decoder(page_buffer, encoding);
         self.value_decoder = Some(value_decoder);
     }
 
@@ -838,7 +838,7 @@ impl<T: DataType> TypedColumnReader<T> {
         dl_decoder.set_data(page_value_count, &def_level_data);
         self.def_level_decoder = Some(dl_decoder);
 
-        let value_decoder = self.get_decoder(value_data, page_value_count, encoding);
+        let value_decoder = self.get_decoder(value_data, encoding);
         self.value_decoder = Some(value_decoder);
     }
 
@@ -977,15 +977,9 @@ impl<T: DataType> TypedColumnReader<T> {
         }
     }
 
-    fn get_decoder(
-        &self,
-        value_data: Buffer,
-        page_value_count: usize,
-        encoding: Encoding,
-    ) -> Box<dyn Decoder> {
+    fn get_decoder(&self, value_data: Buffer, encoding: Encoding) -> Box<dyn Decoder> {
         get_decoder::<T>(
             value_data,
-            page_value_count,
             encoding,
             Arc::clone(&self.desc),
             self.read_options,
diff --git a/native/core/src/parquet/read/mod.rs b/native/core/src/parquet/read/mod.rs
index 4d057a06c9..5a55f21170 100644
--- a/native/core/src/parquet/read/mod.rs
+++ b/native/core/src/parquet/read/mod.rs
@@ -44,9 +44,6 @@ pub struct PlainDecoderInner {
     /// The current offset in `data`, in bytes.
     offset: usize,
 
-    /// The number of total values in `data`
-    value_count: usize,
-
     /// Reads `data` bit by bit, used if `T` is [`BoolType`].
     bit_reader: BitReader,
 
diff --git a/native/core/src/parquet/read/values.rs b/native/core/src/parquet/read/values.rs
index 71cd035d2e..e28d695ecd 100644
--- a/native/core/src/parquet/read/values.rs
+++ b/native/core/src/parquet/read/values.rs
@@ -34,20 +34,16 @@ use datafusion_comet_spark_expr::utils::unlikely;
 
 pub fn get_decoder<T: DataType>(
     value_data: Buffer,
-    num_values: usize,
     encoding: Encoding,
     desc: ColumnDescPtr,
     read_options: ReadOptions,
 ) -> Box<dyn Decoder> {
     let decoder: Box<dyn Decoder> = match encoding {
-        Encoding::PLAIN | Encoding::PLAIN_DICTIONARY => Box::new(PlainDecoder::<T>::new(
-            value_data,
-            num_values,
-            desc,
-            read_options,
-        )),
+        Encoding::PLAIN | Encoding::PLAIN_DICTIONARY => {
+            Box::new(PlainDecoder::<T>::new(value_data, desc, read_options))
+        }
         // This is for dictionary indices
-        Encoding::RLE_DICTIONARY => Box::new(DictDecoder::new(value_data, num_values)),
+        Encoding::RLE_DICTIONARY => Box::new(DictDecoder::new(value_data)),
         _ => panic!("Unsupported encoding: {}", encoding),
     };
     decoder
@@ -108,17 +104,11 @@ pub struct PlainDecoder<T: DataType> {
 }
 
 impl<T: DataType> PlainDecoder<T> {
-    pub fn new(
-        value_data: Buffer,
-        num_values: usize,
-        desc: ColumnDescPtr,
-        read_options: ReadOptions,
-    ) -> Self {
+    pub fn new(value_data: Buffer, desc: ColumnDescPtr, read_options: ReadOptions) -> Self {
         let len = value_data.len();
         let inner = PlainDecoderInner {
             data: value_data.clone(),
             offset: 0,
-            value_count: num_values,
             bit_reader: BitReader::new(value_data, len),
             read_options,
             desc,
@@ -938,9 +928,6 @@ pub struct DictDecoder {
     /// Number of bits used to represent dictionary indices. Must be between `[0, 64]`.
     bit_width: usize,
 
-    /// The number of total values in `data`
-    value_count: usize,
-
     /// Bit reader
     bit_reader: BitReader,
 
@@ -955,12 +942,11 @@ pub struct DictDecoder {
 }
 
 impl DictDecoder {
-    pub fn new(buf: Buffer, num_values: usize) -> Self {
+    pub fn new(buf: Buffer) -> Self {
         let bit_width = buf.as_bytes()[0] as usize;
 
         Self {
             bit_width,
-            value_count: num_values,
             bit_reader: BitReader::new_all(buf.slice(1)),
             rle_left: 0,
             bit_packed_left: 0,
diff --git a/native/core/src/parquet/util/test_common/page_util.rs b/native/core/src/parquet/util/test_common/page_util.rs
index e20cc30cff..333298bc37 100644
--- a/native/core/src/parquet/util/test_common/page_util.rs
+++ b/native/core/src/parquet/util/test_common/page_util.rs
@@ -28,7 +28,7 @@ use parquet::{
         levels::{max_buffer_size, LevelEncoder},
     },
     errors::Result,
-    schema::types::{ColumnDescPtr, SchemaDescPtr},
+    schema::types::ColumnDescPtr,
 };
 
 use super::random_numbers_range;
@@ -201,20 +201,12 @@ impl<P: Iterator<Item = Page> + Send> Iterator for InMemoryPageReader<P> {
 /// A utility page iterator which stores page readers in memory, used for tests.
 #[derive(Clone)]
 pub struct InMemoryPageIterator<I: Iterator<Item = Vec<Page>>> {
-    schema: SchemaDescPtr,
-    column_desc: ColumnDescPtr,
     page_reader_iter: I,
 }
 
 impl<I: Iterator<Item = Vec<Page>>> InMemoryPageIterator<I> {
-    pub fn new(
-        schema: SchemaDescPtr,
-        column_desc: ColumnDescPtr,
-        pages: impl IntoIterator<Item = Vec<Page>, IntoIter = I>,
-    ) -> Self {
+    pub fn new(pages: impl IntoIterator<Item = Vec<Page>, IntoIter = I>) -> Self {
         Self {
-            schema,
-            column_desc,
             page_reader_iter: pages.into_iter(),
         }
     }

From 2c1a6b9c576042f2e0a73cf76a3ad93db46b6a0b Mon Sep 17 00:00:00 2001
From: KAZUYUKI TANIMURA <ktanimura@apple.com>
Date: Wed, 11 Dec 2024 09:44:12 -0800
Subject: [PATCH 31/47] fix: Spark 4.0-preview1 SPARK-47120 (#1156)

## Which issue does this PR close?

Part of https://github.com/apache/datafusion-comet/issues/372 and https://github.com/apache/datafusion-comet/issues/551

## Rationale for this change

To be ready for Spark 4.0

## What changes are included in this PR?

This PR fixes the new test SPARK-47120 added in Spark 4.0

## How are these changes tested?

tests enabled
---
 dev/diffs/4.0.0-preview1.diff                    | 16 +++-------------
 docs/source/user-guide/source.md                 |  2 +-
 .../apache/comet/parquet/ParquetFilters.scala    | 10 ++++++----
 3 files changed, 10 insertions(+), 18 deletions(-)

diff --git a/dev/diffs/4.0.0-preview1.diff b/dev/diffs/4.0.0-preview1.diff
index 1a6810a7ab..ba68d2a7bd 100644
--- a/dev/diffs/4.0.0-preview1.diff
+++ b/dev/diffs/4.0.0-preview1.diff
@@ -2088,7 +2088,7 @@ index cd6f41b4ef4..4b6a17344bc 100644
        ParquetOutputFormat.WRITER_VERSION -> ParquetProperties.WriterVersion.PARQUET_2_0.toString
      )
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/parquet/ParquetFilterSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/parquet/ParquetFilterSuite.scala
-index 795e9f46a8d..6285a1e388b 100644
+index 795e9f46a8d..5306c94a686 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/parquet/ParquetFilterSuite.scala
 +++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/parquet/ParquetFilterSuite.scala
 @@ -1100,7 +1100,11 @@ abstract class ParquetFilterSuite extends QueryTest with ParquetTest with Shared
@@ -2150,17 +2150,7 @@ index 795e9f46a8d..6285a1e388b 100644
      // block 1:
      //                      null count  min                                       max
      // page-0                         0  0                                         99
-@@ -2211,7 +2225,8 @@ abstract class ParquetFilterSuite extends QueryTest with ParquetTest with Shared
-     }
-   }
- 
--  test("SPARK-47120: subquery literal filter pushdown") {
-+  test("SPARK-47120: subquery literal filter pushdown",
-+    IgnoreComet("TODO: https://github.com/apache/datafusion-comet/issues/551")) {
-     withTable("t1", "t2") {
-       sql("create table t1(d date) using parquet")
-       sql("create table t2(d date) using parquet")
-@@ -2301,7 +2316,11 @@ class ParquetV1FilterSuite extends ParquetFilterSuite {
+@@ -2301,7 +2315,11 @@ class ParquetV1FilterSuite extends ParquetFilterSuite {
            assert(pushedParquetFilters.exists(_.getClass === filterClass),
              s"${pushedParquetFilters.map(_.getClass).toList} did not contain ${filterClass}.")
  
@@ -2173,7 +2163,7 @@ index 795e9f46a8d..6285a1e388b 100644
          } else {
            assert(selectedFilters.isEmpty, "There is filter pushed down")
          }
-@@ -2362,7 +2381,11 @@ class ParquetV2FilterSuite extends ParquetFilterSuite {
+@@ -2362,7 +2380,11 @@ class ParquetV2FilterSuite extends ParquetFilterSuite {
            assert(pushedParquetFilters.exists(_.getClass === filterClass),
              s"${pushedParquetFilters.map(_.getClass).toList} did not contain ${filterClass}.")
  
diff --git a/docs/source/user-guide/source.md b/docs/source/user-guide/source.md
index 71c9060cb5..5f5d03d906 100644
--- a/docs/source/user-guide/source.md
+++ b/docs/source/user-guide/source.md
@@ -27,7 +27,7 @@ Official source releases can be downloaded from https://dist.apache.org/repos/di
 
 ```console
 # Pick the latest version
-export COMET_VERSION=0.3.0
+export COMET_VERSION=0.4.0
 # Download the tarball
 curl -O "https://dist.apache.org/repos/dist/release/datafusion/datafusion-comet-$COMET_VERSION/apache-datafusion-comet-$COMET_VERSION.tar.gz"
 # Unpack
diff --git a/spark/src/main/scala/org/apache/comet/parquet/ParquetFilters.scala b/spark/src/main/scala/org/apache/comet/parquet/ParquetFilters.scala
index 17844aba82..bcb23986f3 100644
--- a/spark/src/main/scala/org/apache/comet/parquet/ParquetFilters.scala
+++ b/spark/src/main/scala/org/apache/comet/parquet/ParquetFilters.scala
@@ -723,20 +723,22 @@ class ParquetFilters(
           .lift(nameToParquetField(name).fieldType)
           .map(_(nameToParquetField(name).fieldNames, value))
 
-      case sources.LessThan(name, value) if canMakeFilterOn(name, value) =>
+      case sources.LessThan(name, value) if (value != null) && canMakeFilterOn(name, value) =>
         makeLt
           .lift(nameToParquetField(name).fieldType)
           .map(_(nameToParquetField(name).fieldNames, value))
-      case sources.LessThanOrEqual(name, value) if canMakeFilterOn(name, value) =>
+      case sources.LessThanOrEqual(name, value)
+          if (value != null) && canMakeFilterOn(name, value) =>
         makeLtEq
           .lift(nameToParquetField(name).fieldType)
           .map(_(nameToParquetField(name).fieldNames, value))
 
-      case sources.GreaterThan(name, value) if canMakeFilterOn(name, value) =>
+      case sources.GreaterThan(name, value) if (value != null) && canMakeFilterOn(name, value) =>
         makeGt
           .lift(nameToParquetField(name).fieldType)
           .map(_(nameToParquetField(name).fieldNames, value))
-      case sources.GreaterThanOrEqual(name, value) if canMakeFilterOn(name, value) =>
+      case sources.GreaterThanOrEqual(name, value)
+          if (value != null) && canMakeFilterOn(name, value) =>
         makeGtEq
           .lift(nameToParquetField(name).fieldType)
           .map(_(nameToParquetField(name).fieldNames, value))

From 49cf0d7f32813b6cb5bd3999378c960bd1171fca Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 12 Dec 2024 07:45:06 -0700
Subject: [PATCH 32/47] chore: Move string kernels and expressions to
 spark-expr crate (#1164)

* Move string kernels and expressions to spark-expr crate

* remove unused hash kernel

* remove unused dependencies
---
 native/Cargo.lock                             |   2 -
 native/core/Cargo.toml                        |   6 -
 native/core/benches/hash.rs                   | 137 -------------
 .../execution/datafusion/expressions/mod.rs   |   1 -
 .../core/src/execution/datafusion/planner.rs  |  15 +-
 native/core/src/execution/kernels/hash.rs     | 187 ------------------
 native/core/src/execution/kernels/mod.rs      |  23 ---
 native/core/src/execution/mod.rs              |   3 -
 native/spark-expr/src/kernels/mod.rs          |   1 +
 .../src}/kernels/strings.rs                   |   7 +-
 native/spark-expr/src/lib.rs                  |   2 +
 .../expressions => spark-expr/src}/strings.rs |   2 +-
 12 files changed, 13 insertions(+), 373 deletions(-)
 delete mode 100644 native/core/benches/hash.rs
 delete mode 100644 native/core/src/execution/kernels/hash.rs
 delete mode 100644 native/core/src/execution/kernels/mod.rs
 rename native/{core/src/execution => spark-expr/src}/kernels/strings.rs (96%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/strings.rs (99%)

diff --git a/native/Cargo.lock b/native/Cargo.lock
index 67d041a399..9a8eab83e6 100644
--- a/native/Cargo.lock
+++ b/native/Cargo.lock
@@ -871,7 +871,6 @@ dependencies = [
 name = "datafusion-comet"
 version = "0.5.0"
 dependencies = [
- "ahash",
  "arrow",
  "arrow-array",
  "arrow-buffer",
@@ -893,7 +892,6 @@ dependencies = [
  "datafusion-physical-expr",
  "flate2",
  "futures",
- "half",
  "hex",
  "itertools 0.11.0",
  "jni",
diff --git a/native/core/Cargo.toml b/native/core/Cargo.toml
index 4b9753ec51..489da46d47 100644
--- a/native/core/Cargo.toml
+++ b/native/core/Cargo.toml
@@ -41,7 +41,6 @@ arrow-buffer = { workspace = true }
 arrow-data = { workspace = true }
 arrow-schema = { workspace = true }
 parquet = { workspace = true, default-features = false, features = ["experimental"] }
-half = { version = "2.4.1", default-features = false }
 futures = { workspace = true }
 mimalloc = { version = "*", default-features = false, optional = true }
 tokio = { version = "1", features = ["rt-multi-thread"] }
@@ -62,7 +61,6 @@ rand = { workspace = true}
 num = { workspace = true }
 bytes = "1.5.0"
 tempfile = "3.8.0"
-ahash = { version = "0.8", default-features = false }
 itertools = "0.11.0"
 paste = "1.0.14"
 datafusion-common = { workspace = true }
@@ -102,10 +100,6 @@ harness = false
 name = "bit_util"
 harness = false
 
-[[bench]]
-name = "hash"
-harness = false
-
 [[bench]]
 name = "row_columnar"
 harness = false
diff --git a/native/core/benches/hash.rs b/native/core/benches/hash.rs
deleted file mode 100644
index 039a6d5d8e..0000000000
--- a/native/core/benches/hash.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#[path = "common.rs"]
-mod common;
-
-use arrow_array::ArrayRef;
-use comet::execution::kernels::hash;
-use common::*;
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use datafusion_comet_spark_expr::scalar_funcs::{spark_murmur3_hash, spark_xxhash64};
-use datafusion_common::ScalarValue;
-use datafusion_expr::ColumnarValue;
-use std::sync::Arc;
-
-const BATCH_SIZE: usize = 1024 * 8;
-const NUM_ITER: usize = 10;
-const NULL_FRACTION: f32 = 0.1;
-
-fn criterion_benchmark(c: &mut Criterion) {
-    let mut group = c.benchmark_group("hash");
-
-    let a1: ArrayRef = Arc::new(create_int64_array(BATCH_SIZE, 0.0, 0, BATCH_SIZE as i64));
-    let a2: ArrayRef = Arc::new(create_int64_array(BATCH_SIZE, 0.0, 0, BATCH_SIZE as i64));
-    let a3: ArrayRef = Arc::new(create_int64_array(
-        BATCH_SIZE,
-        NULL_FRACTION,
-        0,
-        BATCH_SIZE as i64,
-    ));
-    let a4: ArrayRef = Arc::new(create_int64_array(
-        BATCH_SIZE,
-        NULL_FRACTION,
-        0,
-        BATCH_SIZE as i64,
-    ));
-
-    group.bench_function(
-        BenchmarkId::new("hash_i64_single_nonnull", BATCH_SIZE),
-        |b| {
-            let input = vec![a1.clone()];
-            let mut dst = vec![0; BATCH_SIZE];
-
-            b.iter(|| {
-                for _ in 0..NUM_ITER {
-                    hash(&input, &mut dst);
-                }
-            });
-        },
-    );
-    group.bench_function(BenchmarkId::new("hash_i64_single_null", BATCH_SIZE), |b| {
-        let input = vec![a3.clone()];
-        let mut dst = vec![0; BATCH_SIZE];
-
-        b.iter(|| {
-            for _ in 0..NUM_ITER {
-                hash(&input, &mut dst);
-            }
-        });
-    });
-    group.bench_function(
-        BenchmarkId::new("hash_i64_multiple_nonnull", BATCH_SIZE),
-        |b| {
-            let input = vec![a1.clone(), a2.clone()];
-            let mut dst = vec![0; BATCH_SIZE];
-
-            b.iter(|| {
-                for _ in 0..NUM_ITER {
-                    hash(&input, &mut dst);
-                }
-            });
-        },
-    );
-    group.bench_function(
-        BenchmarkId::new("hash_i64_multiple_null", BATCH_SIZE),
-        |b| {
-            let input = vec![a3.clone(), a4.clone()];
-            let mut dst = vec![0; BATCH_SIZE];
-
-            b.iter(|| {
-                for _ in 0..NUM_ITER {
-                    hash(&input, &mut dst);
-                }
-            });
-        },
-    );
-    group.bench_function(BenchmarkId::new("xxhash64", BATCH_SIZE), |b| {
-        let inputs = &[
-            ColumnarValue::Array(a3.clone()),
-            ColumnarValue::Array(a4.clone()),
-            ColumnarValue::Scalar(ScalarValue::Int64(Some(42i64))),
-        ];
-
-        b.iter(|| {
-            for _ in 0..NUM_ITER {
-                spark_xxhash64(inputs).unwrap();
-            }
-        });
-    });
-    group.bench_function(BenchmarkId::new("murmur3", BATCH_SIZE), |b| {
-        let inputs = &[
-            ColumnarValue::Array(a3.clone()),
-            ColumnarValue::Array(a4.clone()),
-            ColumnarValue::Scalar(ScalarValue::Int32(Some(42))),
-        ];
-        b.iter(|| {
-            for _ in 0..NUM_ITER {
-                spark_murmur3_hash(inputs).unwrap();
-            }
-        });
-    });
-}
-
-fn config() -> Criterion {
-    Criterion::default()
-}
-
-criterion_group! {
-    name = benches;
-    config = config();
-    targets = criterion_benchmark
-}
-criterion_main!(benches);
diff --git a/native/core/src/execution/datafusion/expressions/mod.rs b/native/core/src/execution/datafusion/expressions/mod.rs
index 2bb14df36e..5f9f322b2e 100644
--- a/native/core/src/execution/datafusion/expressions/mod.rs
+++ b/native/core/src/execution/datafusion/expressions/mod.rs
@@ -23,7 +23,6 @@ use crate::errors::CometError;
 pub mod bloom_filter_agg;
 pub mod bloom_filter_might_contain;
 pub mod negative;
-pub mod strings;
 pub mod subquery;
 pub mod unbound;
 
diff --git a/native/core/src/execution/datafusion/planner.rs b/native/core/src/execution/datafusion/planner.rs
index 5e77b3f653..0e64ed6afa 100644
--- a/native/core/src/execution/datafusion/planner.rs
+++ b/native/core/src/execution/datafusion/planner.rs
@@ -25,12 +25,8 @@ use crate::{
         datafusion::{
             expressions::{
                 bloom_filter_agg::BloomFilterAgg,
-                bloom_filter_might_contain::BloomFilterMightContain,
-                checkoverflow::CheckOverflow,
-                negative,
-                strings::{Contains, EndsWith, Like, StartsWith, StringSpaceExpr, SubstringExpr},
-                subquery::Subquery,
-                unbound::UnboundColumn,
+                bloom_filter_might_contain::BloomFilterMightContain, checkoverflow::CheckOverflow,
+                negative, subquery::Subquery, unbound::UnboundColumn,
             },
             operators::expand::CometExpandExec,
             shuffle_writer::ShuffleWriterExec,
@@ -90,9 +86,10 @@ use datafusion_comet_proto::{
     spark_partitioning::{partitioning::PartitioningStruct, Partitioning as SparkPartitioning},
 };
 use datafusion_comet_spark_expr::{
-    ArrayInsert, Avg, AvgDecimal, BitwiseNotExpr, Cast, Correlation, Covariance, CreateNamedStruct,
-    DateTruncExpr, GetArrayStructFields, GetStructField, HourExpr, IfExpr, ListExtract, MinuteExpr,
-    NormalizeNaNAndZero, RLike, SecondExpr, SparkCastOptions, Stddev, SumDecimal,
+    ArrayInsert, Avg, AvgDecimal, BitwiseNotExpr, Cast, Contains, Correlation, Covariance,
+    CreateNamedStruct, DateTruncExpr, EndsWith, GetArrayStructFields, GetStructField, HourExpr,
+    IfExpr, Like, ListExtract, MinuteExpr, NormalizeNaNAndZero, RLike, SecondExpr,
+    SparkCastOptions, StartsWith, Stddev, StringSpaceExpr, SubstringExpr, SumDecimal,
     TimestampTruncExpr, ToJson, Variance,
 };
 use datafusion_common::scalar::ScalarStructBuilder;
diff --git a/native/core/src/execution/kernels/hash.rs b/native/core/src/execution/kernels/hash.rs
deleted file mode 100644
index b39fd62243..0000000000
--- a/native/core/src/execution/kernels/hash.rs
+++ /dev/null
@@ -1,187 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-use crate::common::bit;
-use ahash::RandomState;
-use arrow::datatypes::{i256, ArrowNativeType};
-use arrow_array::{
-    downcast_dictionary_array, downcast_primitive_array, Array, ArrayAccessor, ArrayRef,
-    ArrowPrimitiveType, PrimitiveArray,
-};
-use arrow_buffer::{IntervalDayTime, IntervalMonthDayNano};
-use std::fmt::Debug;
-
-pub fn hash(src: &[ArrayRef], dst: &mut [u64]) {
-    let state = RandomState::with_seed(42);
-    src.iter().enumerate().for_each(|(idx, v)| {
-        downcast_dictionary_array!(
-            v => {
-                let keys = v.keys();
-                let values = v.values();
-                downcast_primitive_array!(
-                    values => hash_dict_typed(&state, idx > 0, keys, values, dst),
-                    dt => panic!("Expected only primitive type but found {}", dt)
-                )
-            },
-            dt => {
-                downcast_primitive_array!(
-                    v => hash_typed(&state, idx > 0, v, dst),
-                    _ => panic!("Expected only primitive type but found {}", dt)
-                )
-            }
-        )
-    });
-}
-
-fn hash_typed<T>(state: &RandomState, mix: bool, array: T, dst: &mut [u64])
-where
-    T: ArrayAccessor,
-    T::Item: Hashable + Debug,
-{
-    let nullable = array.null_count() > 0;
-    let num_values = array.len();
-    if nullable {
-        for i in 0..num_values {
-            if !array.is_null(i) {
-                unsafe {
-                    let value = array.value_unchecked(i);
-                    hash1(state, mix, i, value, dst);
-                }
-            }
-        }
-    } else {
-        for i in 0..num_values {
-            unsafe {
-                let value = array.value_unchecked(i);
-                hash1(state, mix, i, value, dst);
-            }
-        }
-    }
-}
-
-fn hash_dict_typed<K, V>(
-    state: &RandomState,
-    mix: bool,
-    keys: &PrimitiveArray<K>,
-    values: V,
-    dst: &mut [u64],
-) where
-    K: ArrowPrimitiveType,
-    V: ArrayAccessor,
-    V::Item: Hashable + Debug,
-{
-    let nullable = keys.null_count() > 0;
-    let num_keys = keys.len();
-    let mut value_hashes = vec![0; values.len()];
-
-    for (i, value_hash) in value_hashes.iter_mut().enumerate() {
-        unsafe {
-            *value_hash = values.value_unchecked(i).create_hash(state);
-        }
-    }
-
-    if nullable {
-        for i in 0..num_keys {
-            if !keys.is_null(i) {
-                unsafe {
-                    let idx = keys.value_unchecked(i);
-                    let hash = value_hashes[idx.as_usize()];
-                    hash1_helper(mix, i, hash, dst);
-                }
-            }
-        }
-    } else {
-        for i in 0..num_keys {
-            unsafe {
-                let idx = keys.value_unchecked(i);
-                let hash = value_hashes[idx.as_usize()];
-                hash1_helper(mix, i, hash, dst);
-            }
-        }
-    }
-}
-
-#[inline(always)]
-fn hash1<T: Hashable>(state: &RandomState, mix: bool, i: usize, value: T, dst: &mut [u64]) {
-    let hash = value.create_hash(state);
-    hash1_helper(mix, i, hash, dst);
-}
-
-#[inline(always)]
-fn hash1_helper(mix: bool, i: usize, hash: u64, dst: &mut [u64]) {
-    dst[i] = if mix {
-        bit::mix_hash(dst[i], hash)
-    } else {
-        hash
-    }
-}
-
-pub(crate) trait Hashable {
-    fn create_hash(&self, state: &RandomState) -> u64;
-}
-
-macro_rules! impl_hashable {
-    ($($t:ty),+) => {
-        $(impl Hashable for $t {
-            #[inline]
-            fn create_hash(&self, state: &RandomState) -> u64 {
-                state.hash_one(self)
-            }
-        })+
-    };
-}
-
-impl_hashable!(i8, i16, i32, u8, u16, u32, u64, i128, i256);
-
-impl Hashable for i64 {
-    fn create_hash(&self, state: &RandomState) -> u64 {
-        state.hash_one(self)
-    }
-}
-
-impl Hashable for half::f16 {
-    fn create_hash(&self, _: &RandomState) -> u64 {
-        unimplemented!("hashing on f16 is not supported")
-    }
-}
-
-impl Hashable for f32 {
-    fn create_hash(&self, state: &RandomState) -> u64 {
-        state.hash_one(u32::from_ne_bytes(self.to_ne_bytes()))
-    }
-}
-
-impl Hashable for f64 {
-    fn create_hash(&self, state: &RandomState) -> u64 {
-        state.hash_one(u64::from_ne_bytes(self.to_ne_bytes()))
-    }
-}
-
-impl Hashable for IntervalDayTime {
-    fn create_hash(&self, state: &RandomState) -> u64 {
-        state.hash_one(self.days);
-        state.hash_one(self.milliseconds)
-    }
-}
-
-impl Hashable for IntervalMonthDayNano {
-    fn create_hash(&self, state: &RandomState) -> u64 {
-        state.hash_one(self.months);
-        state.hash_one(self.days);
-        state.hash_one(self.nanoseconds)
-    }
-}
diff --git a/native/core/src/execution/kernels/mod.rs b/native/core/src/execution/kernels/mod.rs
deleted file mode 100644
index 675dcd4893..0000000000
--- a/native/core/src/execution/kernels/mod.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-//! Kernels
-
-mod hash;
-pub use hash::hash;
-
-pub(crate) mod strings;
diff --git a/native/core/src/execution/mod.rs b/native/core/src/execution/mod.rs
index f17935702c..3dba747f2d 100644
--- a/native/core/src/execution/mod.rs
+++ b/native/core/src/execution/mod.rs
@@ -18,9 +18,6 @@
 //! PoC of vectorization execution through JNI to Rust.
 pub mod datafusion;
 pub mod jni_api;
-
-pub mod kernels; // for benchmarking
-
 mod metrics;
 pub mod operators;
 pub mod serde;
diff --git a/native/spark-expr/src/kernels/mod.rs b/native/spark-expr/src/kernels/mod.rs
index 88aa34b1a3..3669ff13ad 100644
--- a/native/spark-expr/src/kernels/mod.rs
+++ b/native/spark-expr/src/kernels/mod.rs
@@ -17,4 +17,5 @@
 
 //! Kernels
 
+pub mod strings;
 pub(crate) mod temporal;
diff --git a/native/core/src/execution/kernels/strings.rs b/native/spark-expr/src/kernels/strings.rs
similarity index 96%
rename from native/core/src/execution/kernels/strings.rs
rename to native/spark-expr/src/kernels/strings.rs
index d63b2c4778..bb275fbb9f 100644
--- a/native/core/src/execution/kernels/strings.rs
+++ b/native/spark-expr/src/kernels/strings.rs
@@ -25,15 +25,14 @@ use arrow::{
     compute::kernels::substring::{substring as arrow_substring, substring_by_char},
     datatypes::{DataType, Int32Type},
 };
-
-use crate::errors::ExpressionError;
+use datafusion_common::DataFusionError;
 
 /// Returns an ArrayRef with a string consisting of `length` spaces.
 ///
 /// # Preconditions
 ///
 /// - elements in `length` must not be negative
-pub fn string_space(length: &dyn Array) -> Result<ArrayRef, ExpressionError> {
+pub fn string_space(length: &dyn Array) -> Result<ArrayRef, DataFusionError> {
     match length.data_type() {
         DataType::Int32 => {
             let array = length.as_any().downcast_ref::<Int32Array>().unwrap();
@@ -52,7 +51,7 @@ pub fn string_space(length: &dyn Array) -> Result<ArrayRef, ExpressionError> {
     }
 }
 
-pub fn substring(array: &dyn Array, start: i64, length: u64) -> Result<ArrayRef, ExpressionError> {
+pub fn substring(array: &dyn Array, start: i64, length: u64) -> Result<ArrayRef, DataFusionError> {
     match array.data_type() {
         DataType::LargeUtf8 => substring_by_char(
             array
diff --git a/native/spark-expr/src/lib.rs b/native/spark-expr/src/lib.rs
index 15f446ef35..5dff6e0b8f 100644
--- a/native/spark-expr/src/lib.rs
+++ b/native/spark-expr/src/lib.rs
@@ -33,6 +33,8 @@ mod correlation;
 pub use correlation::Correlation;
 mod covariance;
 pub use covariance::Covariance;
+mod strings;
+pub use strings::{Contains, EndsWith, Like, StartsWith, StringSpaceExpr, SubstringExpr};
 mod kernels;
 mod list;
 mod regexp;
diff --git a/native/core/src/execution/datafusion/expressions/strings.rs b/native/spark-expr/src/strings.rs
similarity index 99%
rename from native/core/src/execution/datafusion/expressions/strings.rs
rename to native/spark-expr/src/strings.rs
index 200b4ec5a3..a8aab6aee9 100644
--- a/native/core/src/execution/datafusion/expressions/strings.rs
+++ b/native/spark-expr/src/strings.rs
@@ -17,7 +17,7 @@
 
 #![allow(deprecated)]
 
-use crate::execution::kernels::strings::{string_space, substring};
+use crate::kernels::strings::{string_space, substring};
 use arrow::{
     compute::{
         contains_dyn, contains_utf8_scalar_dyn, ends_with_dyn, ends_with_utf8_scalar_dyn, like_dyn,

From 7db9aa67ed0049bb25e783bc4ba991e53df34bbf Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 12 Dec 2024 14:51:19 -0700
Subject: [PATCH 33/47] chore: Move remaining expressions to spark-expr crate +
 some minor refactoring (#1165)

* move CheckOverflow to spark-expr crate

* move NegativeExpr to spark-expr crate

* move UnboundColumn to spark-expr crate

* move ExpandExec from execution::datafusion::operators to execution::operators

* refactoring to remove datafusion subpackage

* update imports in benches

* fix

* fix
---
 native/Cargo.lock                             |  1 +
 native/core/benches/bloom_filter_agg.rs       |  2 +-
 native/core/benches/shuffle_writer.rs         |  2 +-
 .../execution/datafusion/expressions/mod.rs   | 35 -------------------
 .../src/execution/datafusion/operators/mod.rs | 18 ----------
 .../expressions/bloom_filter_agg.rs           |  4 +--
 .../expressions/bloom_filter_might_contain.rs |  4 +--
 .../{datafusion => expressions}/mod.rs        | 13 ++++---
 .../{datafusion => }/expressions/subquery.rs  |  0
 native/core/src/execution/jni_api.rs          |  6 ++--
 native/core/src/execution/metrics/utils.rs    |  2 +-
 native/core/src/execution/mod.rs              |  5 ++-
 .../{datafusion => }/operators/expand.rs      | 10 +++---
 native/core/src/execution/operators/mod.rs    |  2 ++
 native/core/src/execution/operators/scan.rs   |  3 +-
 .../src/execution/{datafusion => }/planner.rs | 32 ++++++++---------
 native/core/src/execution/shuffle/mod.rs      |  2 ++
 native/core/src/execution/shuffle/row.rs      |  2 +-
 .../{datafusion => shuffle}/shuffle_writer.rs |  0
 .../execution/{datafusion => }/spark_plan.rs  |  0
 .../execution/{datafusion => }/util/mod.rs    |  0
 .../{datafusion => }/util/spark_bit_array.rs  |  0
 .../util/spark_bloom_filter.rs                |  4 +--
 native/spark-expr/Cargo.toml                  |  1 +
 .../src}/checkoverflow.rs                     |  0
 native/spark-expr/src/lib.rs                  | 12 +++++++
 .../src}/negative.rs                          |  7 ++--
 .../expressions => spark-expr/src}/unbound.rs |  0
 28 files changed, 63 insertions(+), 104 deletions(-)
 delete mode 100644 native/core/src/execution/datafusion/expressions/mod.rs
 delete mode 100644 native/core/src/execution/datafusion/operators/mod.rs
 rename native/core/src/execution/{datafusion => }/expressions/bloom_filter_agg.rs (97%)
 rename native/core/src/execution/{datafusion => }/expressions/bloom_filter_might_contain.rs (97%)
 rename native/core/src/execution/{datafusion => expressions}/mod.rs (83%)
 rename native/core/src/execution/{datafusion => }/expressions/subquery.rs (100%)
 rename native/core/src/execution/{datafusion => }/operators/expand.rs (97%)
 rename native/core/src/execution/{datafusion => }/planner.rs (98%)
 rename native/core/src/execution/{datafusion => shuffle}/shuffle_writer.rs (100%)
 rename native/core/src/execution/{datafusion => }/spark_plan.rs (100%)
 rename native/core/src/execution/{datafusion => }/util/mod.rs (100%)
 rename native/core/src/execution/{datafusion => }/util/spark_bit_array.rs (100%)
 rename native/core/src/execution/{datafusion => }/util/spark_bloom_filter.rs (98%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/checkoverflow.rs (100%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/negative.rs (98%)
 rename native/{core/src/execution/datafusion/expressions => spark-expr/src}/unbound.rs (100%)

diff --git a/native/Cargo.lock b/native/Cargo.lock
index 9a8eab83e6..7966bb80bb 100644
--- a/native/Cargo.lock
+++ b/native/Cargo.lock
@@ -931,6 +931,7 @@ version = "0.5.0"
 dependencies = [
  "arrow",
  "arrow-array",
+ "arrow-buffer",
  "arrow-data",
  "arrow-schema",
  "chrono",
diff --git a/native/core/benches/bloom_filter_agg.rs b/native/core/benches/bloom_filter_agg.rs
index 25d27d174e..b83ff3fad1 100644
--- a/native/core/benches/bloom_filter_agg.rs
+++ b/native/core/benches/bloom_filter_agg.rs
@@ -19,7 +19,7 @@ use arrow::datatypes::{DataType, Field, Schema};
 use arrow_array::builder::Int64Builder;
 use arrow_array::{ArrayRef, RecordBatch};
 use arrow_schema::SchemaRef;
-use comet::execution::datafusion::expressions::bloom_filter_agg::BloomFilterAgg;
+use comet::execution::expressions::bloom_filter_agg::BloomFilterAgg;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use datafusion::physical_expr::PhysicalExpr;
 use datafusion::physical_plan::aggregates::{AggregateExec, AggregateMode, PhysicalGroupBy};
diff --git a/native/core/benches/shuffle_writer.rs b/native/core/benches/shuffle_writer.rs
index 6f28718618..272887238e 100644
--- a/native/core/benches/shuffle_writer.rs
+++ b/native/core/benches/shuffle_writer.rs
@@ -17,7 +17,7 @@
 
 use arrow_array::{builder::StringBuilder, RecordBatch};
 use arrow_schema::{DataType, Field, Schema};
-use comet::execution::datafusion::shuffle_writer::ShuffleWriterExec;
+use comet::execution::shuffle::ShuffleWriterExec;
 use criterion::{criterion_group, criterion_main, Criterion};
 use datafusion::{
     physical_plan::{common::collect, memory::MemoryExec, ExecutionPlan},
diff --git a/native/core/src/execution/datafusion/expressions/mod.rs b/native/core/src/execution/datafusion/expressions/mod.rs
deleted file mode 100644
index 5f9f322b2e..0000000000
--- a/native/core/src/execution/datafusion/expressions/mod.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-//! Native DataFusion expressions
-
-pub mod checkoverflow;
-
-use crate::errors::CometError;
-pub mod bloom_filter_agg;
-pub mod bloom_filter_might_contain;
-pub mod negative;
-pub mod subquery;
-pub mod unbound;
-
-pub use datafusion_comet_spark_expr::{EvalMode, SparkError};
-
-fn arithmetic_overflow_error(from_type: &str) -> CometError {
-    CometError::Spark(SparkError::ArithmeticOverflow {
-        from_type: from_type.to_string(),
-    })
-}
diff --git a/native/core/src/execution/datafusion/operators/mod.rs b/native/core/src/execution/datafusion/operators/mod.rs
deleted file mode 100644
index 3d28a266a6..0000000000
--- a/native/core/src/execution/datafusion/operators/mod.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-pub mod expand;
diff --git a/native/core/src/execution/datafusion/expressions/bloom_filter_agg.rs b/native/core/src/execution/expressions/bloom_filter_agg.rs
similarity index 97%
rename from native/core/src/execution/datafusion/expressions/bloom_filter_agg.rs
rename to native/core/src/execution/expressions/bloom_filter_agg.rs
index 1300e08c22..ea8bb3647f 100644
--- a/native/core/src/execution/datafusion/expressions/bloom_filter_agg.rs
+++ b/native/core/src/execution/expressions/bloom_filter_agg.rs
@@ -19,8 +19,8 @@ use arrow_schema::Field;
 use datafusion::{arrow::datatypes::DataType, logical_expr::Volatility};
 use std::{any::Any, sync::Arc};
 
-use crate::execution::datafusion::util::spark_bloom_filter;
-use crate::execution::datafusion::util::spark_bloom_filter::SparkBloomFilter;
+use crate::execution::util::spark_bloom_filter;
+use crate::execution::util::spark_bloom_filter::SparkBloomFilter;
 use arrow::array::ArrayRef;
 use arrow_array::BinaryArray;
 use datafusion::error::Result;
diff --git a/native/core/src/execution/datafusion/expressions/bloom_filter_might_contain.rs b/native/core/src/execution/expressions/bloom_filter_might_contain.rs
similarity index 97%
rename from native/core/src/execution/datafusion/expressions/bloom_filter_might_contain.rs
rename to native/core/src/execution/expressions/bloom_filter_might_contain.rs
index de922d8312..af6a5a47a3 100644
--- a/native/core/src/execution/datafusion/expressions/bloom_filter_might_contain.rs
+++ b/native/core/src/execution/expressions/bloom_filter_might_contain.rs
@@ -15,9 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::{
-    execution::datafusion::util::spark_bloom_filter::SparkBloomFilter, parquet::data_type::AsBytes,
-};
+use crate::{execution::util::spark_bloom_filter::SparkBloomFilter, parquet::data_type::AsBytes};
 use arrow::record_batch::RecordBatch;
 use arrow_array::cast::as_primitive_array;
 use arrow_schema::{DataType, Schema};
diff --git a/native/core/src/execution/datafusion/mod.rs b/native/core/src/execution/expressions/mod.rs
similarity index 83%
rename from native/core/src/execution/datafusion/mod.rs
rename to native/core/src/execution/expressions/mod.rs
index ca41fa0aa0..e2f811fa2e 100644
--- a/native/core/src/execution/datafusion/mod.rs
+++ b/native/core/src/execution/expressions/mod.rs
@@ -15,11 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Native execution through DataFusion
+//! Native DataFusion expressions
 
-pub mod expressions;
-mod operators;
-pub mod planner;
-pub mod shuffle_writer;
-pub(crate) mod spark_plan;
-mod util;
+pub mod bloom_filter_agg;
+pub mod bloom_filter_might_contain;
+pub mod subquery;
+
+pub use datafusion_comet_spark_expr::EvalMode;
diff --git a/native/core/src/execution/datafusion/expressions/subquery.rs b/native/core/src/execution/expressions/subquery.rs
similarity index 100%
rename from native/core/src/execution/datafusion/expressions/subquery.rs
rename to native/core/src/execution/expressions/subquery.rs
diff --git a/native/core/src/execution/jni_api.rs b/native/core/src/execution/jni_api.rs
index 5103f5ce4a..491b389c99 100644
--- a/native/core/src/execution/jni_api.rs
+++ b/native/core/src/execution/jni_api.rs
@@ -45,8 +45,8 @@ use super::{serde, utils::SparkArrowConvert, CometMemoryPool};
 use crate::{
     errors::{try_unwrap_or_throw, CometError, CometResult},
     execution::{
-        datafusion::planner::PhysicalPlanner, metrics::utils::update_comet_metric,
-        serde::to_arrow_datatype, shuffle::row::process_sorted_row_partition, sort::RdxSort,
+        metrics::utils::update_comet_metric, planner::PhysicalPlanner, serde::to_arrow_datatype,
+        shuffle::row::process_sorted_row_partition, sort::RdxSort,
     },
     jvm_bridge::{jni_new_global_ref, JVMClasses},
 };
@@ -59,8 +59,8 @@ use jni::{
 };
 use tokio::runtime::Runtime;
 
-use crate::execution::datafusion::spark_plan::SparkPlan;
 use crate::execution::operators::ScanExec;
+use crate::execution::spark_plan::SparkPlan;
 use log::info;
 
 /// Comet native execution context. Kept alive across JNI calls.
diff --git a/native/core/src/execution/metrics/utils.rs b/native/core/src/execution/metrics/utils.rs
index 4bb1c4474c..0eb4b631dd 100644
--- a/native/core/src/execution/metrics/utils.rs
+++ b/native/core/src/execution/metrics/utils.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::execution::datafusion::spark_plan::SparkPlan;
+use crate::execution::spark_plan::SparkPlan;
 use crate::jvm_bridge::jni_new_global_ref;
 use crate::{
     errors::CometError,
diff --git a/native/core/src/execution/mod.rs b/native/core/src/execution/mod.rs
index 3dba747f2d..a74ec3017e 100644
--- a/native/core/src/execution/mod.rs
+++ b/native/core/src/execution/mod.rs
@@ -16,13 +16,16 @@
 // under the License.
 
 //! PoC of vectorization execution through JNI to Rust.
-pub mod datafusion;
+pub mod expressions;
 pub mod jni_api;
 mod metrics;
 pub mod operators;
+pub(crate) mod planner;
 pub mod serde;
 pub mod shuffle;
 pub(crate) mod sort;
+pub(crate) mod spark_plan;
+pub(crate) mod util;
 pub use datafusion_comet_spark_expr::timezone;
 pub(crate) mod utils;
 
diff --git a/native/core/src/execution/datafusion/operators/expand.rs b/native/core/src/execution/operators/expand.rs
similarity index 97%
rename from native/core/src/execution/datafusion/operators/expand.rs
rename to native/core/src/execution/operators/expand.rs
index a3dd06507e..fb43a6e49f 100644
--- a/native/core/src/execution/datafusion/operators/expand.rs
+++ b/native/core/src/execution/operators/expand.rs
@@ -37,14 +37,14 @@ use std::{
 /// A Comet native operator that expands a single row into multiple rows. This behaves as same as
 /// Spark Expand operator.
 #[derive(Debug)]
-pub struct CometExpandExec {
+pub struct ExpandExec {
     projections: Vec<Vec<Arc<dyn PhysicalExpr>>>,
     child: Arc<dyn ExecutionPlan>,
     schema: SchemaRef,
     cache: PlanProperties,
 }
 
-impl CometExpandExec {
+impl ExpandExec {
     /// Create a new ExpandExec
     pub fn new(
         projections: Vec<Vec<Arc<dyn PhysicalExpr>>>,
@@ -66,7 +66,7 @@ impl CometExpandExec {
     }
 }
 
-impl DisplayAs for CometExpandExec {
+impl DisplayAs for ExpandExec {
     fn fmt_as(&self, t: DisplayFormatType, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match t {
             DisplayFormatType::Default | DisplayFormatType::Verbose => {
@@ -87,7 +87,7 @@ impl DisplayAs for CometExpandExec {
     }
 }
 
-impl ExecutionPlan for CometExpandExec {
+impl ExecutionPlan for ExpandExec {
     fn as_any(&self) -> &dyn Any {
         self
     }
@@ -104,7 +104,7 @@ impl ExecutionPlan for CometExpandExec {
         self: Arc<Self>,
         children: Vec<Arc<dyn ExecutionPlan>>,
     ) -> datafusion_common::Result<Arc<dyn ExecutionPlan>> {
-        let new_expand = CometExpandExec::new(
+        let new_expand = ExpandExec::new(
             self.projections.clone(),
             Arc::clone(&children[0]),
             Arc::clone(&self.schema),
diff --git a/native/core/src/execution/operators/mod.rs b/native/core/src/execution/operators/mod.rs
index bdc233e942..4e15e4341a 100644
--- a/native/core/src/execution/operators/mod.rs
+++ b/native/core/src/execution/operators/mod.rs
@@ -27,6 +27,8 @@ pub use filter::FilterExec;
 pub use scan::*;
 
 mod copy;
+mod expand;
+pub use expand::ExpandExec;
 mod filter;
 mod scan;
 
diff --git a/native/core/src/execution/operators/scan.rs b/native/core/src/execution/operators/scan.rs
index 0d35859dfb..a297f87c1f 100644
--- a/native/core/src/execution/operators/scan.rs
+++ b/native/core/src/execution/operators/scan.rs
@@ -18,8 +18,7 @@
 use crate::{
     errors::CometError,
     execution::{
-        datafusion::planner::TEST_EXEC_CONTEXT_ID, operators::ExecutionError,
-        utils::SparkArrowConvert,
+        operators::ExecutionError, planner::TEST_EXEC_CONTEXT_ID, utils::SparkArrowConvert,
     },
     jvm_bridge::{jni_call, JVMClasses},
 };
diff --git a/native/core/src/execution/datafusion/planner.rs b/native/core/src/execution/planner.rs
similarity index 98%
rename from native/core/src/execution/datafusion/planner.rs
rename to native/core/src/execution/planner.rs
index 0e64ed6afa..3ac830c04e 100644
--- a/native/core/src/execution/datafusion/planner.rs
+++ b/native/core/src/execution/planner.rs
@@ -22,17 +22,13 @@ use crate::execution::operators::{CopyMode, FilterExec};
 use crate::{
     errors::ExpressionError,
     execution::{
-        datafusion::{
-            expressions::{
-                bloom_filter_agg::BloomFilterAgg,
-                bloom_filter_might_contain::BloomFilterMightContain, checkoverflow::CheckOverflow,
-                negative, subquery::Subquery, unbound::UnboundColumn,
-            },
-            operators::expand::CometExpandExec,
-            shuffle_writer::ShuffleWriterExec,
+        expressions::{
+            bloom_filter_agg::BloomFilterAgg, bloom_filter_might_contain::BloomFilterMightContain,
+            subquery::Subquery,
         },
-        operators::{CopyExec, ExecutionError, ScanExec},
+        operators::{CopyExec, ExecutionError, ExpandExec, ScanExec},
         serde::to_arrow_datatype,
+        shuffle::ShuffleWriterExec,
     },
 };
 use arrow::compute::CastOptions;
@@ -68,11 +64,11 @@ use datafusion::{
     },
     prelude::SessionContext,
 };
-use datafusion_comet_spark_expr::create_comet_physical_fun;
+use datafusion_comet_spark_expr::{create_comet_physical_fun, create_negate_expr};
 use datafusion_functions_nested::concat::ArrayAppend;
 use datafusion_physical_expr::aggregate::{AggregateExprBuilder, AggregateFunctionExpr};
 
-use crate::execution::datafusion::spark_plan::SparkPlan;
+use crate::execution::spark_plan::SparkPlan;
 use datafusion_comet_proto::{
     spark_expression::{
         self, agg_expr::ExprStruct as AggExprStruct, expr::ExprStruct, literal::Value, AggExpr,
@@ -86,11 +82,11 @@ use datafusion_comet_proto::{
     spark_partitioning::{partitioning::PartitioningStruct, Partitioning as SparkPartitioning},
 };
 use datafusion_comet_spark_expr::{
-    ArrayInsert, Avg, AvgDecimal, BitwiseNotExpr, Cast, Contains, Correlation, Covariance,
-    CreateNamedStruct, DateTruncExpr, EndsWith, GetArrayStructFields, GetStructField, HourExpr,
-    IfExpr, Like, ListExtract, MinuteExpr, NormalizeNaNAndZero, RLike, SecondExpr,
+    ArrayInsert, Avg, AvgDecimal, BitwiseNotExpr, Cast, CheckOverflow, Contains, Correlation,
+    Covariance, CreateNamedStruct, DateTruncExpr, EndsWith, GetArrayStructFields, GetStructField,
+    HourExpr, IfExpr, Like, ListExtract, MinuteExpr, NormalizeNaNAndZero, RLike, SecondExpr,
     SparkCastOptions, StartsWith, Stddev, StringSpaceExpr, SubstringExpr, SumDecimal,
-    TimestampTruncExpr, ToJson, Variance,
+    TimestampTruncExpr, ToJson, UnboundColumn, Variance,
 };
 use datafusion_common::scalar::ScalarStructBuilder;
 use datafusion_common::{
@@ -611,7 +607,7 @@ impl PhysicalPlanner {
             ExprStruct::UnaryMinus(expr) => {
                 let child: Arc<dyn PhysicalExpr> =
                     self.create_expr(expr.child.as_ref().unwrap(), Arc::clone(&input_schema))?;
-                let result = negative::create_negate_expr(child, expr.fail_on_error);
+                let result = create_negate_expr(child, expr.fail_on_error);
                 result.map_err(|e| ExecutionError::GeneralError(e.to_string()))
             }
             ExprStruct::NormalizeNanAndZero(expr) => {
@@ -1118,7 +1114,7 @@ impl PhysicalPlanner {
                 } else {
                     Arc::clone(&child.native_plan)
                 };
-                let expand = Arc::new(CometExpandExec::new(projections, input, schema));
+                let expand = Arc::new(ExpandExec::new(projections, input, schema));
                 Ok((
                     scans,
                     Arc::new(SparkPlan::new(spark_plan.plan_id, expand, vec![child])),
@@ -2270,7 +2266,7 @@ mod tests {
     use datafusion::{physical_plan::common::collect, prelude::SessionContext};
     use tokio::sync::mpsc;
 
-    use crate::execution::{datafusion::planner::PhysicalPlanner, operators::InputBatch};
+    use crate::execution::{operators::InputBatch, planner::PhysicalPlanner};
 
     use crate::execution::operators::ExecutionError;
     use datafusion_comet_proto::{
diff --git a/native/core/src/execution/shuffle/mod.rs b/native/core/src/execution/shuffle/mod.rs
index b052df29b3..8721ead74b 100644
--- a/native/core/src/execution/shuffle/mod.rs
+++ b/native/core/src/execution/shuffle/mod.rs
@@ -18,3 +18,5 @@
 mod list;
 mod map;
 pub mod row;
+mod shuffle_writer;
+pub use shuffle_writer::ShuffleWriterExec;
diff --git a/native/core/src/execution/shuffle/row.rs b/native/core/src/execution/shuffle/row.rs
index 17b180e9d0..ce752e68af 100644
--- a/native/core/src/execution/shuffle/row.rs
+++ b/native/core/src/execution/shuffle/row.rs
@@ -20,10 +20,10 @@
 use crate::{
     errors::CometError,
     execution::{
-        datafusion::shuffle_writer::{write_ipc_compressed, Checksum},
         shuffle::{
             list::{append_list_element, SparkUnsafeArray},
             map::{append_map_elements, get_map_key_value_dt, SparkUnsafeMap},
+            shuffle_writer::{write_ipc_compressed, Checksum},
         },
         utils::bytes_to_i128,
     },
diff --git a/native/core/src/execution/datafusion/shuffle_writer.rs b/native/core/src/execution/shuffle/shuffle_writer.rs
similarity index 100%
rename from native/core/src/execution/datafusion/shuffle_writer.rs
rename to native/core/src/execution/shuffle/shuffle_writer.rs
diff --git a/native/core/src/execution/datafusion/spark_plan.rs b/native/core/src/execution/spark_plan.rs
similarity index 100%
rename from native/core/src/execution/datafusion/spark_plan.rs
rename to native/core/src/execution/spark_plan.rs
diff --git a/native/core/src/execution/datafusion/util/mod.rs b/native/core/src/execution/util/mod.rs
similarity index 100%
rename from native/core/src/execution/datafusion/util/mod.rs
rename to native/core/src/execution/util/mod.rs
diff --git a/native/core/src/execution/datafusion/util/spark_bit_array.rs b/native/core/src/execution/util/spark_bit_array.rs
similarity index 100%
rename from native/core/src/execution/datafusion/util/spark_bit_array.rs
rename to native/core/src/execution/util/spark_bit_array.rs
diff --git a/native/core/src/execution/datafusion/util/spark_bloom_filter.rs b/native/core/src/execution/util/spark_bloom_filter.rs
similarity index 98%
rename from native/core/src/execution/datafusion/util/spark_bloom_filter.rs
rename to native/core/src/execution/util/spark_bloom_filter.rs
index 35fa23b460..2c3af16916 100644
--- a/native/core/src/execution/datafusion/util/spark_bloom_filter.rs
+++ b/native/core/src/execution/util/spark_bloom_filter.rs
@@ -15,8 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::execution::datafusion::util::spark_bit_array;
-use crate::execution::datafusion::util::spark_bit_array::SparkBitArray;
+use crate::execution::util::spark_bit_array;
+use crate::execution::util::spark_bit_array::SparkBitArray;
 use arrow_array::{ArrowNativeTypeOp, BooleanArray, Int64Array};
 use arrow_buffer::ToByteSlice;
 use datafusion_comet_spark_expr::spark_hash::spark_compatible_murmur3_hash;
diff --git a/native/spark-expr/Cargo.toml b/native/spark-expr/Cargo.toml
index 65517431d2..d0bc2fd9dd 100644
--- a/native/spark-expr/Cargo.toml
+++ b/native/spark-expr/Cargo.toml
@@ -29,6 +29,7 @@ edition = { workspace = true }
 [dependencies]
 arrow = { workspace = true }
 arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
 arrow-data = { workspace = true }
 arrow-schema = { workspace = true }
 chrono = { workspace = true }
diff --git a/native/core/src/execution/datafusion/expressions/checkoverflow.rs b/native/spark-expr/src/checkoverflow.rs
similarity index 100%
rename from native/core/src/execution/datafusion/expressions/checkoverflow.rs
rename to native/spark-expr/src/checkoverflow.rs
diff --git a/native/spark-expr/src/lib.rs b/native/spark-expr/src/lib.rs
index 5dff6e0b8f..8a57480587 100644
--- a/native/spark-expr/src/lib.rs
+++ b/native/spark-expr/src/lib.rs
@@ -29,6 +29,8 @@ mod bitwise_not;
 pub use bitwise_not::{bitwise_not, BitwiseNotExpr};
 mod avg_decimal;
 pub use avg_decimal::AvgDecimal;
+mod checkoverflow;
+pub use checkoverflow::CheckOverflow;
 mod correlation;
 pub use correlation::Correlation;
 mod covariance;
@@ -45,10 +47,14 @@ pub use stddev::Stddev;
 mod structs;
 mod sum_decimal;
 pub use sum_decimal::SumDecimal;
+mod negative;
+pub use negative::{create_negate_expr, NegativeExpr};
 mod normalize_nan;
 mod temporal;
 pub mod timezone;
 mod to_json;
+mod unbound;
+pub use unbound::UnboundColumn;
 pub mod utils;
 pub use normalize_nan::NormalizeNaNAndZero;
 
@@ -83,3 +89,9 @@ pub enum EvalMode {
     /// failing the entire query.
     Try,
 }
+
+pub(crate) fn arithmetic_overflow_error(from_type: &str) -> SparkError {
+    SparkError::ArithmeticOverflow {
+        from_type: from_type.to_string(),
+    }
+}
diff --git a/native/core/src/execution/datafusion/expressions/negative.rs b/native/spark-expr/src/negative.rs
similarity index 98%
rename from native/core/src/execution/datafusion/expressions/negative.rs
rename to native/spark-expr/src/negative.rs
index 8dfe717422..3d9063e783 100644
--- a/native/core/src/execution/datafusion/expressions/negative.rs
+++ b/native/spark-expr/src/negative.rs
@@ -16,7 +16,7 @@
 // under the License.
 
 use super::arithmetic_overflow_error;
-use crate::errors::CometError;
+use crate::SparkError;
 use arrow::{compute::kernels::numeric::neg_wrapping, datatypes::IntervalDayTimeType};
 use arrow_array::RecordBatch;
 use arrow_buffer::IntervalDayTime;
@@ -26,8 +26,7 @@ use datafusion::{
     logical_expr::{interval_arithmetic::Interval, ColumnarValue},
     physical_expr::PhysicalExpr,
 };
-use datafusion_comet_spark_expr::SparkError;
-use datafusion_common::{Result, ScalarValue};
+use datafusion_common::{DataFusionError, Result, ScalarValue};
 use datafusion_expr::sort_properties::ExprProperties;
 use std::{
     any::Any,
@@ -38,7 +37,7 @@ use std::{
 pub fn create_negate_expr(
     expr: Arc<dyn PhysicalExpr>,
     fail_on_error: bool,
-) -> Result<Arc<dyn PhysicalExpr>, CometError> {
+) -> Result<Arc<dyn PhysicalExpr>, DataFusionError> {
     Ok(Arc::new(NegativeExpr::new(expr, fail_on_error)))
 }
 
diff --git a/native/core/src/execution/datafusion/expressions/unbound.rs b/native/spark-expr/src/unbound.rs
similarity index 100%
rename from native/core/src/execution/datafusion/expressions/unbound.rs
rename to native/spark-expr/src/unbound.rs

From f1d08791e0603e5543702fa952365d4e61f8df4c Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 12 Dec 2024 16:41:12 -0700
Subject: [PATCH 34/47] chore: Add ignored tests for reading complex types from
 Parquet (#1167)

* Add ignored tests for reading structs from Parquet

* add basic map test

* add tests for Map and Array
---
 .../apache/comet/CometExpressionSuite.scala   | 127 ++++++++++++++++++
 1 file changed, 127 insertions(+)

diff --git a/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala b/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
index 35f374bf0f..cce7cb20a1 100644
--- a/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
@@ -2195,6 +2195,133 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
     }
   }
 
+  ignore("get_struct_field - select primitive fields") {
+    withTempPath { dir =>
+      // create input file with Comet disabled
+      withSQLConf(CometConf.COMET_ENABLED.key -> "false") {
+        val df = spark
+          .range(5)
+          // Add both a null struct and null inner value
+          .select(when(col("id") > 1, struct(when(col("id") > 2, col("id")).alias("id")))
+            .alias("nested1"))
+
+        df.write.parquet(dir.toString())
+      }
+
+      Seq("", "parquet").foreach { v1List =>
+        withSQLConf(SQLConf.USE_V1_SOURCE_LIST.key -> v1List) {
+          val df = spark.read.parquet(dir.toString())
+          checkSparkAnswerAndOperator(df.select("nested1.id"))
+        }
+      }
+    }
+  }
+
+  ignore("get_struct_field - select subset of struct") {
+    withTempPath { dir =>
+      // create input file with Comet disabled
+      withSQLConf(CometConf.COMET_ENABLED.key -> "false") {
+        val df = spark
+          .range(5)
+          // Add both a null struct and null inner value
+          .select(
+            when(
+              col("id") > 1,
+              struct(
+                when(col("id") > 2, col("id")).alias("id"),
+                when(col("id") > 2, struct(when(col("id") > 3, col("id")).alias("id")))
+                  .as("nested2")))
+              .alias("nested1"))
+
+        df.write.parquet(dir.toString())
+      }
+
+      Seq("", "parquet").foreach { v1List =>
+        withSQLConf(SQLConf.USE_V1_SOURCE_LIST.key -> v1List) {
+          val df = spark.read.parquet(dir.toString())
+          checkSparkAnswerAndOperator(df.select("nested1.id"))
+          checkSparkAnswerAndOperator(df.select("nested1.nested2"))
+          checkSparkAnswerAndOperator(df.select("nested1.nested2.id"))
+          checkSparkAnswerAndOperator(df.select("nested1.id", "nested1.nested2.id"))
+        }
+      }
+    }
+  }
+
+  ignore("get_struct_field - read entire struct") {
+    withTempPath { dir =>
+      // create input file with Comet disabled
+      withSQLConf(CometConf.COMET_ENABLED.key -> "false") {
+        val df = spark
+          .range(5)
+          // Add both a null struct and null inner value
+          .select(
+            when(
+              col("id") > 1,
+              struct(
+                when(col("id") > 2, col("id")).alias("id"),
+                when(col("id") > 2, struct(when(col("id") > 3, col("id")).alias("id")))
+                  .as("nested2")))
+              .alias("nested1"))
+
+        df.write.parquet(dir.toString())
+      }
+
+      Seq("", "parquet").foreach { v1List =>
+        withSQLConf(SQLConf.USE_V1_SOURCE_LIST.key -> v1List) {
+          val df = spark.read.parquet(dir.toString())
+          checkSparkAnswerAndOperator(df.select("nested1"))
+        }
+      }
+    }
+  }
+
+  ignore("read map[int, int] from parquet") {
+    withTempPath { dir =>
+      // create input file with Comet disabled
+      withSQLConf(CometConf.COMET_ENABLED.key -> "false") {
+        val df = spark
+          .range(5)
+          // Spark does not allow null as a key but does allow null as a
+          // value, and the entire map be null
+          .select(
+            when(col("id") > 1, map(col("id"), when(col("id") > 2, col("id")))).alias("map1"))
+        df.write.parquet(dir.toString())
+      }
+
+      Seq("", "parquet").foreach { v1List =>
+        withSQLConf(SQLConf.USE_V1_SOURCE_LIST.key -> v1List) {
+          val df = spark.read.parquet(dir.toString())
+          checkSparkAnswerAndOperator(df.select("map1"))
+          checkSparkAnswerAndOperator(df.select(map_keys(col("map1"))))
+          checkSparkAnswerAndOperator(df.select(map_values(col("map1"))))
+        }
+      }
+    }
+  }
+
+  ignore("read array[int] from parquet") {
+    withTempPath { dir =>
+      // create input file with Comet disabled
+      withSQLConf(CometConf.COMET_ENABLED.key -> "false") {
+        val df = spark
+          .range(5)
+          // Spark does not allow null as a key but does allow null as a
+          // value, and the entire map be null
+          .select(when(col("id") > 1, sequence(lit(0), col("id") * 2)).alias("array1"))
+        df.write.parquet(dir.toString())
+      }
+
+      Seq("", "parquet").foreach { v1List =>
+        withSQLConf(SQLConf.USE_V1_SOURCE_LIST.key -> v1List) {
+          val df = spark.read.parquet(dir.toString())
+          checkSparkAnswerAndOperator(df.select("array1"))
+          checkSparkAnswerAndOperator(df.select(element_at(col("array1"), lit(1))))
+        }
+      }
+    }
+  }
+
   test("CreateArray") {
     Seq(true, false).foreach { dictionaryEnabled =>
       withTempDir { dir =>

From b9ac78beffe8b71388ceb8d7e842fd6a07395829 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Tue, 17 Dec 2024 16:35:54 -0700
Subject: [PATCH 35/47] feat: Add Spark-compatible implementation of
 SchemaAdapterFactory (#1169)

* Add Spark-compatible SchemaAdapterFactory implementation

* remove prototype code

* fix

* refactor

* implement more cast logic

* implement more cast logic

* add basic test

* improve test

* cleanup

* fmt

* add support for casting unsigned int to signed int

* clippy

* address feedback

* fix test
---
 native/Cargo.lock                             |  67 +++-
 native/Cargo.toml                             |   2 +-
 .../core/src/parquet/util/test_common/mod.rs  |   3 +-
 native/spark-expr/Cargo.toml                  |   4 +-
 native/spark-expr/src/cast.rs                 | 353 +++++++++++++---
 native/spark-expr/src/lib.rs                  |   5 +
 native/spark-expr/src/schema_adapter.rs       | 376 ++++++++++++++++++
 .../src}/test_common/file_util.rs             |   0
 native/spark-expr/src/test_common/mod.rs      |  17 +
 9 files changed, 758 insertions(+), 69 deletions(-)
 create mode 100644 native/spark-expr/src/schema_adapter.rs
 rename native/{core/src/parquet/util => spark-expr/src}/test_common/file_util.rs (100%)
 create mode 100644 native/spark-expr/src/test_common/mod.rs

diff --git a/native/Cargo.lock b/native/Cargo.lock
index 7966bb80bb..538c40ee23 100644
--- a/native/Cargo.lock
+++ b/native/Cargo.lock
@@ -436,7 +436,18 @@ checksum = "d640d25bc63c50fb1f0b545ffd80207d2e10a4c965530809b40ba3386825c391"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
- "brotli-decompressor",
+ "brotli-decompressor 2.5.1",
+]
+
+[[package]]
+name = "brotli"
+version = "7.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc97b8f16f944bba54f0433f07e30be199b6dc2bd25937444bbad560bcea29bd"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor 4.0.1",
 ]
 
 [[package]]
@@ -449,6 +460,16 @@ dependencies = [
  "alloc-stdlib",
 ]
 
+[[package]]
+name = "brotli-decompressor"
+version = "4.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a45bd2e4095a8b518033b128020dd4a55aab1c0a381ba4404a472630f4bc362"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.16.0"
@@ -842,6 +863,7 @@ dependencies = [
  "num_cpus",
  "object_store",
  "parking_lot",
+ "parquet",
  "paste",
  "pin-project-lite",
  "rand",
@@ -878,7 +900,7 @@ dependencies = [
  "arrow-schema",
  "assertables",
  "async-trait",
- "brotli",
+ "brotli 3.5.0",
  "bytes",
  "crc32fast",
  "criterion",
@@ -914,7 +936,7 @@ dependencies = [
  "tempfile",
  "thiserror",
  "tokio",
- "zstd",
+ "zstd 0.11.2+zstd.1.5.2",
 ]
 
 [[package]]
@@ -943,6 +965,7 @@ dependencies = [
  "datafusion-physical-expr",
  "futures",
  "num",
+ "parquet",
  "rand",
  "regex",
  "thiserror",
@@ -969,6 +992,7 @@ dependencies = [
  "libc",
  "num_cpus",
  "object_store",
+ "parquet",
  "paste",
  "sqlparser",
  "tokio",
@@ -2350,16 +2374,33 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dea02606ba6f5e856561d8d507dba8bac060aefca2a6c0f1aa1d361fed91ff3e"
 dependencies = [
  "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-schema",
+ "arrow-select",
+ "base64",
+ "brotli 7.0.0",
  "bytes",
  "chrono",
+ "flate2",
+ "futures",
  "half",
  "hashbrown 0.14.5",
+ "lz4_flex",
  "num",
  "num-bigint",
+ "object_store",
  "paste",
  "seq-macro",
+ "snap",
  "thrift",
+ "tokio",
  "twox-hash 1.6.3",
+ "zstd 0.13.2",
+ "zstd-sys",
 ]
 
 [[package]]
@@ -3652,7 +3693,16 @@ version = "0.11.2+zstd.1.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4"
 dependencies = [
- "zstd-safe",
+ "zstd-safe 5.0.2+zstd.1.5.2",
+]
+
+[[package]]
+name = "zstd"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcf2b778a664581e31e389454a7072dab1647606d44f7feea22cd5abb9c9f3f9"
+dependencies = [
+ "zstd-safe 7.2.1",
 ]
 
 [[package]]
@@ -3665,6 +3715,15 @@ dependencies = [
  "zstd-sys",
 ]
 
+[[package]]
+name = "zstd-safe"
+version = "7.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54a3ab4db68cea366acc5c897c7b4d4d1b8994a9cd6e6f841f8964566a419059"
+dependencies = [
+ "zstd-sys",
+]
+
 [[package]]
 name = "zstd-sys"
 version = "2.0.13+zstd.1.5.6"
diff --git a/native/Cargo.toml b/native/Cargo.toml
index 4ac85479f2..bd46cf0c9f 100644
--- a/native/Cargo.toml
+++ b/native/Cargo.toml
@@ -39,8 +39,8 @@ arrow-buffer = { version = "53.2.0" }
 arrow-data = { version = "53.2.0" }
 arrow-schema = { version = "53.2.0" }
 parquet = { version = "53.2.0", default-features = false, features = ["experimental"] }
-datafusion-common = { version = "43.0.0" }
 datafusion = { version = "43.0.0", default-features = false, features = ["unicode_expressions", "crypto_expressions"] }
+datafusion-common = { version = "43.0.0" }
 datafusion-functions = { version = "43.0.0", features = ["crypto_expressions"] }
 datafusion-functions-nested = { version = "43.0.0", default-features = false }
 datafusion-expr = { version = "43.0.0", default-features = false }
diff --git a/native/core/src/parquet/util/test_common/mod.rs b/native/core/src/parquet/util/test_common/mod.rs
index e46d732239..d92544608e 100644
--- a/native/core/src/parquet/util/test_common/mod.rs
+++ b/native/core/src/parquet/util/test_common/mod.rs
@@ -15,10 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-pub mod file_util;
 pub mod page_util;
 pub mod rand_gen;
 
 pub use self::rand_gen::{random_bools, random_bytes, random_numbers, random_numbers_range};
 
-pub use self::file_util::{get_temp_file, get_temp_filename};
+pub use datafusion_comet_spark_expr::test_common::file_util::{get_temp_file, get_temp_filename};
diff --git a/native/spark-expr/Cargo.toml b/native/spark-expr/Cargo.toml
index d0bc2fd9dd..27367d83e1 100644
--- a/native/spark-expr/Cargo.toml
+++ b/native/spark-expr/Cargo.toml
@@ -33,7 +33,7 @@ arrow-buffer = { workspace = true }
 arrow-data = { workspace = true }
 arrow-schema = { workspace = true }
 chrono = { workspace = true }
-datafusion = { workspace = true }
+datafusion = { workspace = true, features = ["parquet"] }
 datafusion-common = { workspace = true }
 datafusion-expr = { workspace = true }
 datafusion-physical-expr = { workspace = true }
@@ -43,9 +43,11 @@ regex = { workspace = true }
 thiserror = { workspace = true }
 futures = { workspace = true }
 twox-hash = "2.0.0"
+rand = { workspace = true }
 
 [dev-dependencies]
 arrow-data = {workspace = true}
+parquet = { workspace = true, features = ["arrow"] }
 criterion = "0.5.1"
 rand = { workspace = true}
 tokio = { version = "1", features = ["rt-multi-thread"] }
diff --git a/native/spark-expr/src/cast.rs b/native/spark-expr/src/cast.rs
index f62d0220c9..d96bcbbdb6 100644
--- a/native/spark-expr/src/cast.rs
+++ b/native/spark-expr/src/cast.rs
@@ -15,6 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::timezone;
+use crate::utils::array_with_timezone;
+use crate::{EvalMode, SparkError, SparkResult};
 use arrow::{
     array::{
         cast::AsArray,
@@ -35,11 +38,18 @@ use arrow::{
 use arrow_array::builder::StringBuilder;
 use arrow_array::{DictionaryArray, StringArray, StructArray};
 use arrow_schema::{DataType, Field, Schema};
+use chrono::{NaiveDate, NaiveDateTime, TimeZone, Timelike};
+use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{
     cast::as_generic_string_array, internal_err, Result as DataFusionResult, ScalarValue,
 };
 use datafusion_expr::ColumnarValue;
 use datafusion_physical_expr::PhysicalExpr;
+use num::{
+    cast::AsPrimitive, integer::div_floor, traits::CheckedNeg, CheckedSub, Integer, Num,
+    ToPrimitive,
+};
+use regex::Regex;
 use std::str::FromStr;
 use std::{
     any::Any,
@@ -49,19 +59,6 @@ use std::{
     sync::Arc,
 };
 
-use chrono::{NaiveDate, NaiveDateTime, TimeZone, Timelike};
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
-use num::{
-    cast::AsPrimitive, integer::div_floor, traits::CheckedNeg, CheckedSub, Integer, Num,
-    ToPrimitive,
-};
-use regex::Regex;
-
-use crate::timezone;
-use crate::utils::array_with_timezone;
-
-use crate::{EvalMode, SparkError, SparkResult};
-
 static TIMESTAMP_FORMAT: Option<&str> = Some("%Y-%m-%d %H:%M:%S%.f");
 
 const MICROS_PER_SECOND: i64 = 1000000;
@@ -141,6 +138,240 @@ pub struct Cast {
     pub cast_options: SparkCastOptions,
 }
 
+/// Determine if Comet supports a cast, taking options such as EvalMode and Timezone into account.
+pub fn cast_supported(
+    from_type: &DataType,
+    to_type: &DataType,
+    options: &SparkCastOptions,
+) -> bool {
+    use DataType::*;
+
+    let from_type = if let Dictionary(_, dt) = from_type {
+        dt
+    } else {
+        from_type
+    };
+
+    let to_type = if let Dictionary(_, dt) = to_type {
+        dt
+    } else {
+        to_type
+    };
+
+    if from_type == to_type {
+        return true;
+    }
+
+    match (from_type, to_type) {
+        (Boolean, _) => can_cast_from_boolean(to_type, options),
+        (UInt8 | UInt16 | UInt32 | UInt64, Int8 | Int16 | Int32 | Int64)
+            if options.allow_cast_unsigned_ints =>
+        {
+            true
+        }
+        (Int8, _) => can_cast_from_byte(to_type, options),
+        (Int16, _) => can_cast_from_short(to_type, options),
+        (Int32, _) => can_cast_from_int(to_type, options),
+        (Int64, _) => can_cast_from_long(to_type, options),
+        (Float32, _) => can_cast_from_float(to_type, options),
+        (Float64, _) => can_cast_from_double(to_type, options),
+        (Decimal128(p, s), _) => can_cast_from_decimal(p, s, to_type, options),
+        (Timestamp(_, None), _) => can_cast_from_timestamp_ntz(to_type, options),
+        (Timestamp(_, Some(_)), _) => can_cast_from_timestamp(to_type, options),
+        (Utf8 | LargeUtf8, _) => can_cast_from_string(to_type, options),
+        (_, Utf8 | LargeUtf8) => can_cast_to_string(from_type, options),
+        (Struct(from_fields), Struct(to_fields)) => from_fields
+            .iter()
+            .zip(to_fields.iter())
+            .all(|(a, b)| cast_supported(a.data_type(), b.data_type(), options)),
+        _ => false,
+    }
+}
+
+fn can_cast_from_string(to_type: &DataType, options: &SparkCastOptions) -> bool {
+    use DataType::*;
+    match to_type {
+        Boolean | Int8 | Int16 | Int32 | Int64 | Binary => true,
+        Float32 | Float64 => {
+            // https://github.com/apache/datafusion-comet/issues/326
+            // Does not support inputs ending with 'd' or 'f'. Does not support 'inf'.
+            // Does not support ANSI mode.
+            options.allow_incompat
+        }
+        Decimal128(_, _) => {
+            // https://github.com/apache/datafusion-comet/issues/325
+            // Does not support inputs ending with 'd' or 'f'. Does not support 'inf'.
+            // Does not support ANSI mode. Returns 0.0 instead of null if input contains no digits
+
+            options.allow_incompat
+        }
+        Date32 | Date64 => {
+            // https://github.com/apache/datafusion-comet/issues/327
+            // Only supports years between 262143 BC and 262142 AD
+            options.allow_incompat
+        }
+        Timestamp(_, _) if options.eval_mode == EvalMode::Ansi => {
+            // ANSI mode not supported
+            false
+        }
+        Timestamp(_, Some(tz)) if tz.as_ref() != "UTC" => {
+            // Cast will use UTC instead of $timeZoneId
+            options.allow_incompat
+        }
+        Timestamp(_, _) => {
+            // https://github.com/apache/datafusion-comet/issues/328
+            // Not all valid formats are supported
+            options.allow_incompat
+        }
+        _ => false,
+    }
+}
+
+fn can_cast_to_string(from_type: &DataType, options: &SparkCastOptions) -> bool {
+    use DataType::*;
+    match from_type {
+        Boolean | Int8 | Int16 | Int32 | Int64 | Date32 | Date64 | Timestamp(_, _) => true,
+        Float32 | Float64 => {
+            // There can be differences in precision.
+            // For example, the input \"1.4E-45\" will produce 1.0E-45 " +
+            // instead of 1.4E-45"))
+            true
+        }
+        Decimal128(_, _) => {
+            // https://github.com/apache/datafusion-comet/issues/1068
+            // There can be formatting differences in some case due to Spark using
+            // scientific notation where Comet does not
+            true
+        }
+        Binary => {
+            // https://github.com/apache/datafusion-comet/issues/377
+            // Only works for binary data representing valid UTF-8 strings
+            options.allow_incompat
+        }
+        Struct(fields) => fields
+            .iter()
+            .all(|f| can_cast_to_string(f.data_type(), options)),
+        _ => false,
+    }
+}
+
+fn can_cast_from_timestamp_ntz(to_type: &DataType, options: &SparkCastOptions) -> bool {
+    use DataType::*;
+    match to_type {
+        Timestamp(_, _) | Date32 | Date64 | Utf8 => {
+            // incompatible
+            options.allow_incompat
+        }
+        _ => {
+            // unsupported
+            false
+        }
+    }
+}
+
+fn can_cast_from_timestamp(to_type: &DataType, _options: &SparkCastOptions) -> bool {
+    use DataType::*;
+    match to_type {
+        Boolean | Int8 | Int16 => {
+            // https://github.com/apache/datafusion-comet/issues/352
+            // this seems like an edge case that isn't important for us to support
+            false
+        }
+        Int64 => {
+            // https://github.com/apache/datafusion-comet/issues/352
+            true
+        }
+        Date32 | Date64 | Utf8 | Decimal128(_, _) => true,
+        _ => {
+            // unsupported
+            false
+        }
+    }
+}
+
+fn can_cast_from_boolean(to_type: &DataType, _: &SparkCastOptions) -> bool {
+    use DataType::*;
+    matches!(to_type, Int8 | Int16 | Int32 | Int64 | Float32 | Float64)
+}
+
+fn can_cast_from_byte(to_type: &DataType, _: &SparkCastOptions) -> bool {
+    use DataType::*;
+    matches!(
+        to_type,
+        Boolean | Int8 | Int16 | Int32 | Int64 | Float32 | Float64 | Decimal128(_, _)
+    )
+}
+
+fn can_cast_from_short(to_type: &DataType, _: &SparkCastOptions) -> bool {
+    use DataType::*;
+    matches!(
+        to_type,
+        Boolean | Int8 | Int16 | Int32 | Int64 | Float32 | Float64 | Decimal128(_, _)
+    )
+}
+
+fn can_cast_from_int(to_type: &DataType, options: &SparkCastOptions) -> bool {
+    use DataType::*;
+    match to_type {
+        Boolean | Int8 | Int16 | Int32 | Int64 | Float32 | Float64 | Utf8 => true,
+        Decimal128(_, _) => {
+            // incompatible: no overflow check
+            options.allow_incompat
+        }
+        _ => false,
+    }
+}
+
+fn can_cast_from_long(to_type: &DataType, options: &SparkCastOptions) -> bool {
+    use DataType::*;
+    match to_type {
+        Boolean | Int8 | Int16 | Int32 | Int64 | Float32 | Float64 => true,
+        Decimal128(_, _) => {
+            // incompatible: no overflow check
+            options.allow_incompat
+        }
+        _ => false,
+    }
+}
+
+fn can_cast_from_float(to_type: &DataType, _: &SparkCastOptions) -> bool {
+    use DataType::*;
+    matches!(
+        to_type,
+        Boolean | Int8 | Int16 | Int32 | Int64 | Float64 | Decimal128(_, _)
+    )
+}
+
+fn can_cast_from_double(to_type: &DataType, _: &SparkCastOptions) -> bool {
+    use DataType::*;
+    matches!(
+        to_type,
+        Boolean | Int8 | Int16 | Int32 | Int64 | Float32 | Decimal128(_, _)
+    )
+}
+
+fn can_cast_from_decimal(
+    p1: &u8,
+    _s1: &i8,
+    to_type: &DataType,
+    options: &SparkCastOptions,
+) -> bool {
+    use DataType::*;
+    match to_type {
+        Int8 | Int16 | Int32 | Int64 | Float32 | Float64 => true,
+        Decimal128(p2, _) => {
+            if p2 < p1 {
+                // https://github.com/apache/datafusion/issues/13492
+                // Incompatible(Some("Casting to smaller precision is not supported"))
+                options.allow_incompat
+            } else {
+                true
+            }
+        }
+        _ => false,
+    }
+}
+
 macro_rules! cast_utf8_to_int {
     ($array:expr, $eval_mode:expr, $array_type:ty, $cast_method:ident) => {{
         let len = $array.len();
@@ -560,6 +791,8 @@ pub struct SparkCastOptions {
     pub timezone: String,
     /// Allow casts that are supported but not guaranteed to be 100% compatible
     pub allow_incompat: bool,
+    /// Support casting unsigned ints to signed ints (used by Parquet SchemaAdapter)
+    pub allow_cast_unsigned_ints: bool,
 }
 
 impl SparkCastOptions {
@@ -568,6 +801,7 @@ impl SparkCastOptions {
             eval_mode,
             timezone: timezone.to_string(),
             allow_incompat,
+            allow_cast_unsigned_ints: false,
         }
     }
 
@@ -576,6 +810,7 @@ impl SparkCastOptions {
             eval_mode,
             timezone: "".to_string(),
             allow_incompat,
+            allow_cast_unsigned_ints: false,
         }
     }
 }
@@ -611,14 +846,14 @@ fn cast_array(
     to_type: &DataType,
     cast_options: &SparkCastOptions,
 ) -> DataFusionResult<ArrayRef> {
+    use DataType::*;
     let array = array_with_timezone(array, cast_options.timezone.clone(), Some(to_type))?;
     let from_type = array.data_type().clone();
 
     let array = match &from_type {
-        DataType::Dictionary(key_type, value_type)
-            if key_type.as_ref() == &DataType::Int32
-                && (value_type.as_ref() == &DataType::Utf8
-                    || value_type.as_ref() == &DataType::LargeUtf8) =>
+        Dictionary(key_type, value_type)
+            if key_type.as_ref() == &Int32
+                && (value_type.as_ref() == &Utf8 || value_type.as_ref() == &LargeUtf8) =>
         {
             let dict_array = array
                 .as_any()
@@ -631,7 +866,7 @@ fn cast_array(
             );
 
             let casted_result = match to_type {
-                DataType::Dictionary(_, _) => Arc::new(casted_dictionary.clone()),
+                Dictionary(_, _) => Arc::new(casted_dictionary.clone()),
                 _ => take(casted_dictionary.values().as_ref(), dict_array.keys(), None)?,
             };
             return Ok(spark_cast_postprocess(casted_result, &from_type, to_type));
@@ -642,70 +877,66 @@ fn cast_array(
     let eval_mode = cast_options.eval_mode;
 
     let cast_result = match (from_type, to_type) {
-        (DataType::Utf8, DataType::Boolean) => spark_cast_utf8_to_boolean::<i32>(&array, eval_mode),
-        (DataType::LargeUtf8, DataType::Boolean) => {
-            spark_cast_utf8_to_boolean::<i64>(&array, eval_mode)
-        }
-        (DataType::Utf8, DataType::Timestamp(_, _)) => {
+        (Utf8, Boolean) => spark_cast_utf8_to_boolean::<i32>(&array, eval_mode),
+        (LargeUtf8, Boolean) => spark_cast_utf8_to_boolean::<i64>(&array, eval_mode),
+        (Utf8, Timestamp(_, _)) => {
             cast_string_to_timestamp(&array, to_type, eval_mode, &cast_options.timezone)
         }
-        (DataType::Utf8, DataType::Date32) => cast_string_to_date(&array, to_type, eval_mode),
-        (DataType::Int64, DataType::Int32)
-        | (DataType::Int64, DataType::Int16)
-        | (DataType::Int64, DataType::Int8)
-        | (DataType::Int32, DataType::Int16)
-        | (DataType::Int32, DataType::Int8)
-        | (DataType::Int16, DataType::Int8)
+        (Utf8, Date32) => cast_string_to_date(&array, to_type, eval_mode),
+        (Int64, Int32)
+        | (Int64, Int16)
+        | (Int64, Int8)
+        | (Int32, Int16)
+        | (Int32, Int8)
+        | (Int16, Int8)
             if eval_mode != EvalMode::Try =>
         {
             spark_cast_int_to_int(&array, eval_mode, from_type, to_type)
         }
-        (DataType::Utf8, DataType::Int8 | DataType::Int16 | DataType::Int32 | DataType::Int64) => {
+        (Utf8, Int8 | Int16 | Int32 | Int64) => {
             cast_string_to_int::<i32>(to_type, &array, eval_mode)
         }
-        (
-            DataType::LargeUtf8,
-            DataType::Int8 | DataType::Int16 | DataType::Int32 | DataType::Int64,
-        ) => cast_string_to_int::<i64>(to_type, &array, eval_mode),
-        (DataType::Float64, DataType::Utf8) => spark_cast_float64_to_utf8::<i32>(&array, eval_mode),
-        (DataType::Float64, DataType::LargeUtf8) => {
-            spark_cast_float64_to_utf8::<i64>(&array, eval_mode)
-        }
-        (DataType::Float32, DataType::Utf8) => spark_cast_float32_to_utf8::<i32>(&array, eval_mode),
-        (DataType::Float32, DataType::LargeUtf8) => {
-            spark_cast_float32_to_utf8::<i64>(&array, eval_mode)
-        }
-        (DataType::Float32, DataType::Decimal128(precision, scale)) => {
+        (LargeUtf8, Int8 | Int16 | Int32 | Int64) => {
+            cast_string_to_int::<i64>(to_type, &array, eval_mode)
+        }
+        (Float64, Utf8) => spark_cast_float64_to_utf8::<i32>(&array, eval_mode),
+        (Float64, LargeUtf8) => spark_cast_float64_to_utf8::<i64>(&array, eval_mode),
+        (Float32, Utf8) => spark_cast_float32_to_utf8::<i32>(&array, eval_mode),
+        (Float32, LargeUtf8) => spark_cast_float32_to_utf8::<i64>(&array, eval_mode),
+        (Float32, Decimal128(precision, scale)) => {
             cast_float32_to_decimal128(&array, *precision, *scale, eval_mode)
         }
-        (DataType::Float64, DataType::Decimal128(precision, scale)) => {
+        (Float64, Decimal128(precision, scale)) => {
             cast_float64_to_decimal128(&array, *precision, *scale, eval_mode)
         }
-        (DataType::Float32, DataType::Int8)
-        | (DataType::Float32, DataType::Int16)
-        | (DataType::Float32, DataType::Int32)
-        | (DataType::Float32, DataType::Int64)
-        | (DataType::Float64, DataType::Int8)
-        | (DataType::Float64, DataType::Int16)
-        | (DataType::Float64, DataType::Int32)
-        | (DataType::Float64, DataType::Int64)
-        | (DataType::Decimal128(_, _), DataType::Int8)
-        | (DataType::Decimal128(_, _), DataType::Int16)
-        | (DataType::Decimal128(_, _), DataType::Int32)
-        | (DataType::Decimal128(_, _), DataType::Int64)
+        (Float32, Int8)
+        | (Float32, Int16)
+        | (Float32, Int32)
+        | (Float32, Int64)
+        | (Float64, Int8)
+        | (Float64, Int16)
+        | (Float64, Int32)
+        | (Float64, Int64)
+        | (Decimal128(_, _), Int8)
+        | (Decimal128(_, _), Int16)
+        | (Decimal128(_, _), Int32)
+        | (Decimal128(_, _), Int64)
             if eval_mode != EvalMode::Try =>
         {
             spark_cast_nonintegral_numeric_to_integral(&array, eval_mode, from_type, to_type)
         }
-        (DataType::Struct(_), DataType::Utf8) => {
-            Ok(casts_struct_to_string(array.as_struct(), cast_options)?)
-        }
-        (DataType::Struct(_), DataType::Struct(_)) => Ok(cast_struct_to_struct(
+        (Struct(_), Utf8) => Ok(casts_struct_to_string(array.as_struct(), cast_options)?),
+        (Struct(_), Struct(_)) => Ok(cast_struct_to_struct(
             array.as_struct(),
             from_type,
             to_type,
             cast_options,
         )?),
+        (UInt8 | UInt16 | UInt32 | UInt64, Int8 | Int16 | Int32 | Int64)
+            if cast_options.allow_cast_unsigned_ints =>
+        {
+            Ok(cast_with_options(&array, to_type, &CAST_OPTIONS)?)
+        }
         _ if is_datafusion_spark_compatible(from_type, to_type, cast_options.allow_incompat) => {
             // use DataFusion cast only when we know that it is compatible with Spark
             Ok(cast_with_options(&array, to_type, &CAST_OPTIONS)?)
diff --git a/native/spark-expr/src/lib.rs b/native/spark-expr/src/lib.rs
index 8a57480587..f358731004 100644
--- a/native/spark-expr/src/lib.rs
+++ b/native/spark-expr/src/lib.rs
@@ -41,6 +41,9 @@ mod kernels;
 mod list;
 mod regexp;
 pub mod scalar_funcs;
+mod schema_adapter;
+pub use schema_adapter::SparkSchemaAdapterFactory;
+
 pub mod spark_hash;
 mod stddev;
 pub use stddev::Stddev;
@@ -51,6 +54,8 @@ mod negative;
 pub use negative::{create_negate_expr, NegativeExpr};
 mod normalize_nan;
 mod temporal;
+
+pub mod test_common;
 pub mod timezone;
 mod to_json;
 mod unbound;
diff --git a/native/spark-expr/src/schema_adapter.rs b/native/spark-expr/src/schema_adapter.rs
new file mode 100644
index 0000000000..161ad6f164
--- /dev/null
+++ b/native/spark-expr/src/schema_adapter.rs
@@ -0,0 +1,376 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Custom schema adapter that uses Spark-compatible casts
+
+use crate::cast::cast_supported;
+use crate::{spark_cast, SparkCastOptions};
+use arrow_array::{new_null_array, Array, RecordBatch, RecordBatchOptions};
+use arrow_schema::{Schema, SchemaRef};
+use datafusion::datasource::schema_adapter::{SchemaAdapter, SchemaAdapterFactory, SchemaMapper};
+use datafusion_common::plan_err;
+use datafusion_expr::ColumnarValue;
+use std::sync::Arc;
+
+/// An implementation of DataFusion's `SchemaAdapterFactory` that uses a Spark-compatible
+/// `cast` implementation.
+#[derive(Clone, Debug)]
+pub struct SparkSchemaAdapterFactory {
+    /// Spark cast options
+    cast_options: SparkCastOptions,
+}
+
+impl SparkSchemaAdapterFactory {
+    pub fn new(options: SparkCastOptions) -> Self {
+        Self {
+            cast_options: options,
+        }
+    }
+}
+
+impl SchemaAdapterFactory for SparkSchemaAdapterFactory {
+    /// Create a new factory for mapping batches from a file schema to a table
+    /// schema.
+    ///
+    /// This is a convenience for [`DefaultSchemaAdapterFactory::create`] with
+    /// the same schema for both the projected table schema and the table
+    /// schema.
+    fn create(
+        &self,
+        required_schema: SchemaRef,
+        table_schema: SchemaRef,
+    ) -> Box<dyn SchemaAdapter> {
+        Box::new(SparkSchemaAdapter {
+            required_schema,
+            table_schema,
+            cast_options: self.cast_options.clone(),
+        })
+    }
+}
+
+/// This SchemaAdapter requires both the table schema and the projected table
+/// schema. See  [`SchemaMapping`] for more details
+#[derive(Clone, Debug)]
+pub struct SparkSchemaAdapter {
+    /// The schema for the table, projected to include only the fields being output (projected) by the
+    /// associated ParquetExec
+    required_schema: SchemaRef,
+    /// The entire table schema for the table we're using this to adapt.
+    ///
+    /// This is used to evaluate any filters pushed down into the scan
+    /// which may refer to columns that are not referred to anywhere
+    /// else in the plan.
+    table_schema: SchemaRef,
+    /// Spark cast options
+    cast_options: SparkCastOptions,
+}
+
+impl SchemaAdapter for SparkSchemaAdapter {
+    /// Map a column index in the table schema to a column index in a particular
+    /// file schema
+    ///
+    /// Panics if index is not in range for the table schema
+    fn map_column_index(&self, index: usize, file_schema: &Schema) -> Option<usize> {
+        let field = self.required_schema.field(index);
+        Some(file_schema.fields.find(field.name())?.0)
+    }
+
+    /// Creates a `SchemaMapping` for casting or mapping the columns from the
+    /// file schema to the table schema.
+    ///
+    /// If the provided `file_schema` contains columns of a different type to
+    /// the expected `table_schema`, the method will attempt to cast the array
+    /// data from the file schema to the table schema where possible.
+    ///
+    /// Returns a [`SchemaMapping`] that can be applied to the output batch
+    /// along with an ordered list of columns to project from the file
+    fn map_schema(
+        &self,
+        file_schema: &Schema,
+    ) -> datafusion_common::Result<(Arc<dyn SchemaMapper>, Vec<usize>)> {
+        let mut projection = Vec::with_capacity(file_schema.fields().len());
+        let mut field_mappings = vec![None; self.required_schema.fields().len()];
+
+        for (file_idx, file_field) in file_schema.fields.iter().enumerate() {
+            if let Some((table_idx, table_field)) =
+                self.required_schema.fields().find(file_field.name())
+            {
+                if cast_supported(
+                    file_field.data_type(),
+                    table_field.data_type(),
+                    &self.cast_options,
+                ) {
+                    field_mappings[table_idx] = Some(projection.len());
+                    projection.push(file_idx);
+                } else {
+                    return plan_err!(
+                        "Cannot cast file schema field {} of type {:?} to required schema field of type {:?}",
+                        file_field.name(),
+                        file_field.data_type(),
+                        table_field.data_type()
+                    );
+                }
+            }
+        }
+
+        Ok((
+            Arc::new(SchemaMapping {
+                required_schema: Arc::<Schema>::clone(&self.required_schema),
+                field_mappings,
+                table_schema: Arc::<Schema>::clone(&self.table_schema),
+                cast_options: self.cast_options.clone(),
+            }),
+            projection,
+        ))
+    }
+}
+
+// TODO SchemaMapping is mostly copied from DataFusion but calls spark_cast
+// instead of arrow cast - can we reduce the amount of code copied here and make
+// the DataFusion version more extensible?
+
+/// The SchemaMapping struct holds a mapping from the file schema to the table
+/// schema and any necessary type conversions.
+///
+/// Note, because `map_batch` and `map_partial_batch` functions have different
+/// needs, this struct holds two schemas:
+///
+/// 1. The projected **table** schema
+/// 2. The full table schema
+///
+/// [`map_batch`] is used by the ParquetOpener to produce a RecordBatch which
+/// has the projected schema, since that's the schema which is supposed to come
+/// out of the execution of this query. Thus `map_batch` uses
+/// `projected_table_schema` as it can only operate on the projected fields.
+///
+/// [`map_partial_batch`]  is used to create a RecordBatch with a schema that
+/// can be used for Parquet predicate pushdown, meaning that it may contain
+/// fields which are not in the projected schema (as the fields that parquet
+/// pushdown filters operate can be completely distinct from the fields that are
+/// projected (output) out of the ParquetExec). `map_partial_batch` thus uses
+/// `table_schema` to create the resulting RecordBatch (as it could be operating
+/// on any fields in the schema).
+///
+/// [`map_batch`]: Self::map_batch
+/// [`map_partial_batch`]: Self::map_partial_batch
+#[derive(Debug)]
+pub struct SchemaMapping {
+    /// The schema of the table. This is the expected schema after conversion
+    /// and it should match the schema of the query result.
+    required_schema: SchemaRef,
+    /// Mapping from field index in `projected_table_schema` to index in
+    /// projected file_schema.
+    ///
+    /// They are Options instead of just plain `usize`s because the table could
+    /// have fields that don't exist in the file.
+    field_mappings: Vec<Option<usize>>,
+    /// The entire table schema, as opposed to the projected_table_schema (which
+    /// only contains the columns that we are projecting out of this query).
+    /// This contains all fields in the table, regardless of if they will be
+    /// projected out or not.
+    table_schema: SchemaRef,
+    /// Spark cast options
+    cast_options: SparkCastOptions,
+}
+
+impl SchemaMapper for SchemaMapping {
+    /// Adapts a `RecordBatch` to match the `projected_table_schema` using the stored mapping and
+    /// conversions. The produced RecordBatch has a schema that contains only the projected
+    /// columns, so if one needs a RecordBatch with a schema that references columns which are not
+    /// in the projected, it would be better to use `map_partial_batch`
+    fn map_batch(&self, batch: RecordBatch) -> datafusion_common::Result<RecordBatch> {
+        let batch_rows = batch.num_rows();
+        let batch_cols = batch.columns().to_vec();
+
+        let cols = self
+            .required_schema
+            // go through each field in the projected schema
+            .fields()
+            .iter()
+            // and zip it with the index that maps fields from the projected table schema to the
+            // projected file schema in `batch`
+            .zip(&self.field_mappings)
+            // and for each one...
+            .map(|(field, file_idx)| {
+                file_idx.map_or_else(
+                    // If this field only exists in the table, and not in the file, then we know
+                    // that it's null, so just return that.
+                    || Ok(new_null_array(field.data_type(), batch_rows)),
+                    // However, if it does exist in both, then try to cast it to the correct output
+                    // type
+                    |batch_idx| {
+                        spark_cast(
+                            ColumnarValue::Array(Arc::clone(&batch_cols[batch_idx])),
+                            field.data_type(),
+                            &self.cast_options,
+                        )?
+                        .into_array(batch_rows)
+                    },
+                )
+            })
+            .collect::<datafusion_common::Result<Vec<_>, _>>()?;
+
+        // Necessary to handle empty batches
+        let options = RecordBatchOptions::new().with_row_count(Some(batch.num_rows()));
+
+        let schema = Arc::<Schema>::clone(&self.required_schema);
+        let record_batch = RecordBatch::try_new_with_options(schema, cols, &options)?;
+        Ok(record_batch)
+    }
+
+    /// Adapts a [`RecordBatch`]'s schema into one that has all the correct output types and only
+    /// contains the fields that exist in both the file schema and table schema.
+    ///
+    /// Unlike `map_batch` this method also preserves the columns that
+    /// may not appear in the final output (`projected_table_schema`) but may
+    /// appear in push down predicates
+    fn map_partial_batch(&self, batch: RecordBatch) -> datafusion_common::Result<RecordBatch> {
+        let batch_cols = batch.columns().to_vec();
+        let schema = batch.schema();
+
+        // for each field in the batch's schema (which is based on a file, not a table)...
+        let (cols, fields) = schema
+            .fields()
+            .iter()
+            .zip(batch_cols.iter())
+            .flat_map(|(field, batch_col)| {
+                self.table_schema
+                    // try to get the same field from the table schema that we have stored in self
+                    .field_with_name(field.name())
+                    // and if we don't have it, that's fine, ignore it. This may occur when we've
+                    // created an external table whose fields are a subset of the fields in this
+                    // file, then tried to read data from the file into this table. If that is the
+                    // case here, it's fine to ignore because we don't care about this field
+                    // anyways
+                    .ok()
+                    // but if we do have it,
+                    .map(|table_field| {
+                        // try to cast it into the correct output type. we don't want to ignore this
+                        // error, though, so it's propagated.
+                        spark_cast(
+                            ColumnarValue::Array(Arc::clone(batch_col)),
+                            table_field.data_type(),
+                            &self.cast_options,
+                        )?
+                        .into_array(batch_col.len())
+                        // and if that works, return the field and column.
+                        .map(|new_col| (new_col, table_field.clone()))
+                    })
+            })
+            .collect::<Result<Vec<_>, _>>()?
+            .into_iter()
+            .unzip::<_, _, Vec<_>, Vec<_>>();
+
+        // Necessary to handle empty batches
+        let options = RecordBatchOptions::new().with_row_count(Some(batch.num_rows()));
+
+        let schema = Arc::new(Schema::new_with_metadata(fields, schema.metadata().clone()));
+        let record_batch = RecordBatch::try_new_with_options(schema, cols, &options)?;
+        Ok(record_batch)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::test_common::file_util::get_temp_filename;
+    use crate::{EvalMode, SparkCastOptions, SparkSchemaAdapterFactory};
+    use arrow::array::{Int32Array, StringArray};
+    use arrow::datatypes::{DataType, Field, Schema};
+    use arrow::record_batch::RecordBatch;
+    use arrow_array::UInt32Array;
+    use arrow_schema::SchemaRef;
+    use datafusion::datasource::listing::PartitionedFile;
+    use datafusion::datasource::physical_plan::{FileScanConfig, ParquetExec};
+    use datafusion::execution::object_store::ObjectStoreUrl;
+    use datafusion::execution::TaskContext;
+    use datafusion::physical_plan::ExecutionPlan;
+    use datafusion_common::DataFusionError;
+    use futures::StreamExt;
+    use parquet::arrow::ArrowWriter;
+    use std::fs::File;
+    use std::sync::Arc;
+
+    #[tokio::test]
+    async fn parquet_roundtrip_int_as_string() -> Result<(), DataFusionError> {
+        let file_schema = Arc::new(Schema::new(vec![
+            Field::new("id", DataType::Int32, false),
+            Field::new("name", DataType::Utf8, false),
+        ]));
+
+        let ids = Arc::new(Int32Array::from(vec![1, 2, 3])) as Arc<dyn arrow::array::Array>;
+        let names = Arc::new(StringArray::from(vec!["Alice", "Bob", "Charlie"]))
+            as Arc<dyn arrow::array::Array>;
+        let batch = RecordBatch::try_new(Arc::clone(&file_schema), vec![ids, names])?;
+
+        let required_schema = Arc::new(Schema::new(vec![
+            Field::new("id", DataType::Utf8, false),
+            Field::new("name", DataType::Utf8, false),
+        ]));
+
+        let _ = roundtrip(&batch, required_schema).await?;
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn parquet_roundtrip_unsigned_int() -> Result<(), DataFusionError> {
+        let file_schema = Arc::new(Schema::new(vec![Field::new("id", DataType::UInt32, false)]));
+
+        let ids = Arc::new(UInt32Array::from(vec![1, 2, 3])) as Arc<dyn arrow::array::Array>;
+        let batch = RecordBatch::try_new(Arc::clone(&file_schema), vec![ids])?;
+
+        let required_schema = Arc::new(Schema::new(vec![Field::new("id", DataType::Int32, false)]));
+
+        let _ = roundtrip(&batch, required_schema).await?;
+
+        Ok(())
+    }
+
+    /// Create a Parquet file containing a single batch and then read the batch back using
+    /// the specified required_schema. This will cause the SchemaAdapter code to be used.
+    async fn roundtrip(
+        batch: &RecordBatch,
+        required_schema: SchemaRef,
+    ) -> Result<RecordBatch, DataFusionError> {
+        let filename = get_temp_filename();
+        let filename = filename.as_path().as_os_str().to_str().unwrap().to_string();
+        let file = File::create(&filename)?;
+        let mut writer = ArrowWriter::try_new(file, Arc::clone(&batch.schema()), None)?;
+        writer.write(batch)?;
+        writer.close()?;
+
+        let object_store_url = ObjectStoreUrl::local_filesystem();
+        let file_scan_config = FileScanConfig::new(object_store_url, required_schema)
+            .with_file_groups(vec![vec![PartitionedFile::from_path(
+                filename.to_string(),
+            )?]]);
+
+        let mut spark_cast_options = SparkCastOptions::new(EvalMode::Legacy, "UTC", false);
+        spark_cast_options.allow_cast_unsigned_ints = true;
+
+        let parquet_exec = ParquetExec::builder(file_scan_config)
+            .with_schema_adapter_factory(Arc::new(SparkSchemaAdapterFactory::new(
+                spark_cast_options,
+            )))
+            .build();
+
+        let mut stream = parquet_exec
+            .execute(0, Arc::new(TaskContext::default()))
+            .unwrap();
+        stream.next().await.unwrap()
+    }
+}
diff --git a/native/core/src/parquet/util/test_common/file_util.rs b/native/spark-expr/src/test_common/file_util.rs
similarity index 100%
rename from native/core/src/parquet/util/test_common/file_util.rs
rename to native/spark-expr/src/test_common/file_util.rs
diff --git a/native/spark-expr/src/test_common/mod.rs b/native/spark-expr/src/test_common/mod.rs
new file mode 100644
index 0000000000..efd25a4a2a
--- /dev/null
+++ b/native/spark-expr/src/test_common/mod.rs
@@ -0,0 +1,17 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+pub mod file_util;

From 46a28db5e5014fc7fabe8eafc7dbeb5027974c47 Mon Sep 17 00:00:00 2001
From: Parth Chandra <parthc@apache.org>
Date: Tue, 17 Dec 2024 15:50:36 -0800
Subject: [PATCH 36/47] fix: Document enabling comet explain plan usage in
 Spark (4.0) (#1176)

---
 docs/source/user-guide/tuning.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/docs/source/user-guide/tuning.md b/docs/source/user-guide/tuning.md
index af722494f9..f10a0dde9e 100644
--- a/docs/source/user-guide/tuning.md
+++ b/docs/source/user-guide/tuning.md
@@ -127,3 +127,13 @@ Here is a guide to some of the native metrics.
 | `elapsed_compute` | Total time spent in this operator, fetching batches from a JVM iterator.                            |
 | `jvm_fetch_time`  | Time spent in the JVM fetching input batches to be read by this `ScanExec` instance.                |
 | `arrow_ffi_time`  | Time spent using Arrow FFI to create Arrow batches from the memory addresses returned from the JVM. |
+
+## Explain Plan
+### Extended Explain
+With Spark 4.0.0 and newer, Comet can provide extended explain plan information in the Spark UI. Currently this lists
+reasons why Comet may not have been enabled for specific operations.
+To enable this, in the Spark configuration, set the following:
+```shell
+-c spark.sql.extendedExplainProviders=org.apache.comet.ExtendedExplainInfo
+```
+This will add a section to the detailed plan displayed in the Spark SQL UI page.
\ No newline at end of file

From 655081b66808d8f70abebd4d85af7c401c579a3a Mon Sep 17 00:00:00 2001
From: KAZUYUKI TANIMURA <ktanimura@apple.com>
Date: Wed, 18 Dec 2024 09:10:34 -0800
Subject: [PATCH 37/47] test: enabling Spark tests with offHeap requirement
 (#1177)

## Which issue does this PR close?

## Rationale for this change

After https://github.com/apache/datafusion-comet/pull/1062 We have not running Spark tests for native execution

## What changes are included in this PR?

Removed the off heap requirement for testing

## How are these changes tested?

Bringing back Spark tests for native execution
---
 dev/diffs/4.0.0-preview1.diff                 | 103 +++++++++++++++++-
 native/core/src/execution/jni_api.rs          |  26 ++++-
 .../org/apache/comet/CometExecIterator.scala  |   9 +-
 .../comet/CometSparkSessionExtensions.scala   |  10 +-
 .../main/scala/org/apache/comet/Native.scala  |   5 +
 5 files changed, 142 insertions(+), 11 deletions(-)

diff --git a/dev/diffs/4.0.0-preview1.diff b/dev/diffs/4.0.0-preview1.diff
index ba68d2a7bd..db62ed607e 100644
--- a/dev/diffs/4.0.0-preview1.diff
+++ b/dev/diffs/4.0.0-preview1.diff
@@ -146,6 +146,77 @@ index 698ca009b4f..57d774a3617 100644
  
  -- Test tables
  CREATE table  explain_temp1 (key int, val int) USING PARQUET;
+diff --git a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int4.sql b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int4.sql
+index 3a409eea348..26e9aaf215c 100644
+--- a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int4.sql
++++ b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int4.sql
+@@ -6,6 +6,9 @@
+ -- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/int4.sql
+ --
+ 
++-- TODO: https://github.com/apache/datafusion-comet/issues/551
++--SET spark.comet.enabled = false
++
+ CREATE TABLE INT4_TBL(f1 int) USING parquet;
+ 
+ -- [SPARK-28023] Trim the string when cast string type to other types
+diff --git a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int8.sql b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int8.sql
+index fac23b4a26f..98b12ae5ccc 100644
+--- a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int8.sql
++++ b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/int8.sql
+@@ -6,6 +6,10 @@
+ -- Test int8 64-bit integers.
+ -- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/int8.sql
+ --
++
++-- TODO: https://github.com/apache/datafusion-comet/issues/551
++--SET spark.comet.enabled = false
++
+ CREATE TABLE INT8_TBL(q1 bigint, q2 bigint) USING parquet;
+ 
+ -- PostgreSQL implicitly casts string literals to data with integral types, but
+diff --git a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/select_having.sql b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/select_having.sql
+index 0efe0877e9b..f9df0400c99 100644
+--- a/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/select_having.sql
++++ b/sql/core/src/test/resources/sql-tests/inputs/postgreSQL/select_having.sql
+@@ -6,6 +6,9 @@
+ -- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/select_having.sql
+ --
+ 
++-- TODO: https://github.com/apache/datafusion-comet/issues/551
++--SET spark.comet.enabled = false
++
+ -- load test data
+ CREATE TABLE test_having (a int, b int, c string, d string) USING parquet;
+ INSERT INTO test_having VALUES (0, 1, 'XXXX', 'A');
+diff --git a/sql/core/src/test/resources/sql-tests/inputs/view-schema-binding-config.sql b/sql/core/src/test/resources/sql-tests/inputs/view-schema-binding-config.sql
+index e803254ea64..74db78aee38 100644
+--- a/sql/core/src/test/resources/sql-tests/inputs/view-schema-binding-config.sql
++++ b/sql/core/src/test/resources/sql-tests/inputs/view-schema-binding-config.sql
+@@ -1,6 +1,9 @@
+ -- This test suits check the spark.sql.viewSchemaBindingMode configuration.
+ -- It can be DISABLED and COMPENSATION
+ 
++-- TODO: https://github.com/apache/datafusion-comet/issues/551
++--SET spark.comet.enabled = false
++
+ -- Verify the default binding is true
+ SET spark.sql.legacy.viewSchemaBindingMode;
+ 
+diff --git a/sql/core/src/test/resources/sql-tests/inputs/view-schema-compensation.sql b/sql/core/src/test/resources/sql-tests/inputs/view-schema-compensation.sql
+index 21a3ce1e122..f4762ab98f0 100644
+--- a/sql/core/src/test/resources/sql-tests/inputs/view-schema-compensation.sql
++++ b/sql/core/src/test/resources/sql-tests/inputs/view-schema-compensation.sql
+@@ -1,5 +1,9 @@
+ -- This test suite checks the WITH SCHEMA COMPENSATION clause
+ -- Disable ANSI mode to ensure we are forcing it explicitly in the CASTS
++
++-- TODO: https://github.com/apache/datafusion-comet/issues/551
++--SET spark.comet.enabled = false
++
+ SET spark.sql.ansi.enabled = false;
+ 
+ -- In COMPENSATION views get invalidated if the type can't cast
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/CachedTableSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/CachedTableSuite.scala
 index d023fb82185..0f4f03bda6c 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/CachedTableSuite.scala
@@ -917,7 +988,7 @@ index 34c6c49bc49..f5dea07a213 100644
    protected val baseResourcePath = {
      // use the same way as `SQLQueryTestSuite` to get the resource path
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala
-index 56c364e2084..a00a50e020a 100644
+index 56c364e2084..fc3abd7cdc4 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala
 +++ b/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala
 @@ -1510,7 +1510,8 @@ class SQLQuerySuite extends QueryTest with SharedSparkSession with AdaptiveSpark
@@ -930,6 +1001,36 @@ index 56c364e2084..a00a50e020a 100644
      AccumulatorSuite.verifyPeakExecutionMemorySet(sparkContext, "external sort") {
        sql("SELECT * FROM testData2 ORDER BY a ASC, b ASC").collect()
      }
+@@ -4454,7 +4455,8 @@ class SQLQuerySuite extends QueryTest with SharedSparkSession with AdaptiveSpark
+   }
+ 
+   test("SPARK-39166: Query context of binary arithmetic should be serialized to executors" +
+-    " when WSCG is off") {
++    " when WSCG is off",
++    IgnoreComet("TODO: https://github.com/apache/datafusion-comet/issues/551")) {
+     withSQLConf(SQLConf.WHOLESTAGE_CODEGEN_ENABLED.key -> "false",
+       SQLConf.ANSI_ENABLED.key -> "true") {
+       withTable("t") {
+@@ -4475,7 +4477,8 @@ class SQLQuerySuite extends QueryTest with SharedSparkSession with AdaptiveSpark
+   }
+ 
+   test("SPARK-39175: Query context of Cast should be serialized to executors" +
+-    " when WSCG is off") {
++    " when WSCG is off",
++    IgnoreComet("TODO: https://github.com/apache/datafusion-comet/issues/551")) {
+     withSQLConf(SQLConf.WHOLESTAGE_CODEGEN_ENABLED.key -> "false",
+       SQLConf.ANSI_ENABLED.key -> "true") {
+       withTable("t") {
+@@ -4502,7 +4505,8 @@ class SQLQuerySuite extends QueryTest with SharedSparkSession with AdaptiveSpark
+   }
+ 
+   test("SPARK-39190,SPARK-39208,SPARK-39210: Query context of decimal overflow error should " +
+-    "be serialized to executors when WSCG is off") {
++    "be serialized to executors when WSCG is off",
++    IgnoreComet("TODO: https://github.com/apache/datafusion-comet/issues/551")) {
+     withSQLConf(SQLConf.WHOLESTAGE_CODEGEN_ENABLED.key -> "false",
+       SQLConf.ANSI_ENABLED.key -> "true") {
+       withTable("t") {
 diff --git a/sql/core/src/test/scala/org/apache/spark/sql/SubquerySuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/SubquerySuite.scala
 index 68f14f13bbd..174636cefb5 100644
 --- a/sql/core/src/test/scala/org/apache/spark/sql/SubquerySuite.scala
diff --git a/native/core/src/execution/jni_api.rs b/native/core/src/execution/jni_api.rs
index 491b389c99..eb73675b5b 100644
--- a/native/core/src/execution/jni_api.rs
+++ b/native/core/src/execution/jni_api.rs
@@ -106,6 +106,9 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
     metrics_node: JObject,
     comet_task_memory_manager_obj: JObject,
     batch_size: jint,
+    use_unified_memory_manager: jboolean,
+    memory_limit: jlong,
+    memory_fraction: jdouble,
     debug_native: jboolean,
     explain_native: jboolean,
     worker_threads: jint,
@@ -147,7 +150,13 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
         // We need to keep the session context alive. Some session state like temporary
         // dictionaries are stored in session context. If it is dropped, the temporary
         // dictionaries will be dropped as well.
-        let session = prepare_datafusion_session_context(batch_size as usize, task_memory_manager)?;
+        let session = prepare_datafusion_session_context(
+            batch_size as usize,
+            use_unified_memory_manager == 1,
+            memory_limit as usize,
+            memory_fraction,
+            task_memory_manager,
+        )?;
 
         let plan_creation_time = start.elapsed();
 
@@ -174,13 +183,22 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
 /// Configure DataFusion session context.
 fn prepare_datafusion_session_context(
     batch_size: usize,
+    use_unified_memory_manager: bool,
+    memory_limit: usize,
+    memory_fraction: f64,
     comet_task_memory_manager: Arc<GlobalRef>,
 ) -> CometResult<SessionContext> {
     let mut rt_config = RuntimeConfig::new().with_disk_manager(DiskManagerConfig::NewOs);
 
-    // Set Comet memory pool for native
-    let memory_pool = CometMemoryPool::new(comet_task_memory_manager);
-    rt_config = rt_config.with_memory_pool(Arc::new(memory_pool));
+    // Check if we are using unified memory manager integrated with Spark.
+    if use_unified_memory_manager {
+        // Set Comet memory pool for native
+        let memory_pool = CometMemoryPool::new(comet_task_memory_manager);
+        rt_config = rt_config.with_memory_pool(Arc::new(memory_pool));
+    } else {
+        // Use the memory pool from DF
+        rt_config = rt_config.with_memory_limit(memory_limit, memory_fraction)
+    }
 
     // Get Datafusion configuration from Spark Execution context
     // can be configured in Comet Spark JVM using Spark --conf parameters
diff --git a/spark/src/main/scala/org/apache/comet/CometExecIterator.scala b/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
index d57e9e2b87..04d9306951 100644
--- a/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
+++ b/spark/src/main/scala/org/apache/comet/CometExecIterator.scala
@@ -23,7 +23,7 @@ import org.apache.spark._
 import org.apache.spark.sql.comet.CometMetricNode
 import org.apache.spark.sql.vectorized._
 
-import org.apache.comet.CometConf.{COMET_BATCH_SIZE, COMET_BLOCKING_THREADS, COMET_DEBUG_ENABLED, COMET_EXPLAIN_NATIVE_ENABLED, COMET_WORKER_THREADS}
+import org.apache.comet.CometConf.{COMET_BATCH_SIZE, COMET_BLOCKING_THREADS, COMET_DEBUG_ENABLED, COMET_EXEC_MEMORY_FRACTION, COMET_EXPLAIN_NATIVE_ENABLED, COMET_WORKER_THREADS}
 import org.apache.comet.vector.NativeUtil
 
 /**
@@ -60,6 +60,10 @@ class CometExecIterator(
     new CometBatchIterator(iterator, nativeUtil)
   }.toArray
   private val plan = {
+    val conf = SparkEnv.get.conf
+    // Only enable unified memory manager when off-heap mode is enabled. Otherwise,
+    // we'll use the built-in memory pool from DF, and initializes with `memory_limit`
+    // and `memory_fraction` below.
     nativeLib.createPlan(
       id,
       cometBatchIterators,
@@ -67,6 +71,9 @@ class CometExecIterator(
       nativeMetrics,
       new CometTaskMemoryManager(id),
       batchSize = COMET_BATCH_SIZE.get(),
+      use_unified_memory_manager = conf.getBoolean("spark.memory.offHeap.enabled", false),
+      memory_limit = CometSparkSessionExtensions.getCometMemoryOverhead(conf),
+      memory_fraction = COMET_EXEC_MEMORY_FRACTION.get(),
       debug = COMET_DEBUG_ENABLED.get(),
       explain = COMET_EXPLAIN_NATIVE_ENABLED.get(),
       workerThreads = COMET_WORKER_THREADS.get(),
diff --git a/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala b/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
index 61c45daff0..8bff6b5fbd 100644
--- a/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
+++ b/spark/src/main/scala/org/apache/comet/CometSparkSessionExtensions.scala
@@ -53,7 +53,7 @@ import org.apache.spark.sql.types.{DoubleType, FloatType}
 
 import org.apache.comet.CometConf._
 import org.apache.comet.CometExplainInfo.getActualPlan
-import org.apache.comet.CometSparkSessionExtensions.{createMessage, getCometBroadcastNotEnabledReason, getCometShuffleNotEnabledReason, isANSIEnabled, isCometBroadCastForceEnabled, isCometEnabled, isCometExecEnabled, isCometJVMShuffleMode, isCometNativeShuffleMode, isCometScan, isCometScanEnabled, isCometShuffleEnabled, isSpark34Plus, isSpark40Plus, shouldApplySparkToColumnar, withInfo, withInfos}
+import org.apache.comet.CometSparkSessionExtensions.{createMessage, getCometBroadcastNotEnabledReason, getCometShuffleNotEnabledReason, isANSIEnabled, isCometBroadCastForceEnabled, isCometEnabled, isCometExecEnabled, isCometJVMShuffleMode, isCometNativeShuffleMode, isCometScan, isCometScanEnabled, isCometShuffleEnabled, isOffHeapEnabled, isSpark34Plus, isSpark40Plus, isTesting, shouldApplySparkToColumnar, withInfo, withInfos}
 import org.apache.comet.parquet.{CometParquetScan, SupportsComet}
 import org.apache.comet.rules.RewriteJoin
 import org.apache.comet.serde.OperatorOuterClass.Operator
@@ -921,8 +921,9 @@ class CometSparkSessionExtensions
     override def apply(plan: SparkPlan): SparkPlan = {
 
       // Comet required off-heap memory to be enabled
-      if ("true" != conf.getConfString("spark.memory.offHeap.enabled", "false")) {
-        logInfo("Comet extension disabled because spark.memory.offHeap.enabled=false")
+      if (!isOffHeapEnabled(conf) && !isTesting) {
+        logWarning("Comet native exec disabled because spark.memory.offHeap.enabled=false")
+        withInfo(plan, "Comet native exec disabled because spark.memory.offHeap.enabled=false")
         return plan
       }
 
@@ -1174,8 +1175,7 @@ object CometSparkSessionExtensions extends Logging {
   }
 
   private[comet] def isOffHeapEnabled(conf: SQLConf): Boolean =
-    conf.contains("spark.memory.offHeap.enabled") &&
-      conf.getConfString("spark.memory.offHeap.enabled").toBoolean
+    conf.getConfString("spark.memory.offHeap.enabled", "false").toBoolean
 
   // Copied from org.apache.spark.util.Utils which is private to Spark.
   private[comet] def isTesting: Boolean = {
diff --git a/spark/src/main/scala/org/apache/comet/Native.scala b/spark/src/main/scala/org/apache/comet/Native.scala
index 64ada91adc..083c0f2b50 100644
--- a/spark/src/main/scala/org/apache/comet/Native.scala
+++ b/spark/src/main/scala/org/apache/comet/Native.scala
@@ -43,6 +43,7 @@ class Native extends NativeBase {
    * @return
    *   the address to native query plan.
    */
+  // scalastyle:off
   @native def createPlan(
       id: Long,
       iterators: Array[CometBatchIterator],
@@ -50,10 +51,14 @@ class Native extends NativeBase {
       metrics: CometMetricNode,
       taskMemoryManager: CometTaskMemoryManager,
       batchSize: Int,
+      use_unified_memory_manager: Boolean,
+      memory_limit: Long,
+      memory_fraction: Double,
       debug: Boolean,
       explain: Boolean,
       workerThreads: Int,
       blockingThreads: Int): Long
+  // scalastyle:on
 
   /**
    * Execute a native query plan based on given input Arrow arrays.

From e297d23bd38bc306c90ed21a154d1495f985683e Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Wed, 18 Dec 2024 10:50:07 -0700
Subject: [PATCH 38/47] feat: Improve shuffle metrics (second attempt) (#1175)

* improve shuffle metrics

* docs

* more metrics

* refactor

* address feedback
---
 docs/source/index.rst                         |   1 +
 docs/source/user-guide/metrics.md             |  66 +++++
 docs/source/user-guide/tuning.md              |  25 --
 native/core/src/execution/shuffle/row.rs      |   6 +-
 .../src/execution/shuffle/shuffle_writer.rs   | 271 +++++++++++-------
 .../sql/comet/CometCollectLimitExec.scala     |   3 +-
 .../spark/sql/comet/CometMetricNode.scala     |  11 +
 .../CometTakeOrderedAndProjectExec.scala      |   3 +-
 .../shuffle/CometShuffleExchangeExec.scala    |  15 +-
 9 files changed, 261 insertions(+), 140 deletions(-)
 create mode 100644 docs/source/user-guide/metrics.md

diff --git a/docs/source/index.rst b/docs/source/index.rst
index 39ad27a57c..21ec36ca95 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -51,6 +51,7 @@ as a native runtime to achieve improvement in terms of query efficiency and quer
    Configuration Settings <user-guide/configs>
    Compatibility Guide <user-guide/compatibility>
    Tuning Guide <user-guide/tuning>
+   Metrics Guide <user-guide/metrics>
 
 .. _toc.contributor-guide-links:
 .. toctree::
diff --git a/docs/source/user-guide/metrics.md b/docs/source/user-guide/metrics.md
new file mode 100644
index 0000000000..509d0ae8c0
--- /dev/null
+++ b/docs/source/user-guide/metrics.md
@@ -0,0 +1,66 @@
+<!---
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Comet Metrics
+
+## Spark SQL Metrics
+
+Set `spark.comet.metrics.detailed=true` to see all available Comet metrics.
+
+### CometScanExec
+
+| Metric      | Description                                                                                                                                                                                                                                                                        |
+| ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `scan time` | Total time to scan a Parquet file. This is not comparable to the same metric in Spark because Comet's scan metric is more accurate. Although both Comet and Spark measure the time in nanoseconds, Spark rounds this time to the nearest millisecond per batch and Comet does not. |
+
+### Exchange
+
+Comet adds some additional metrics:
+
+| Metric                          | Description                                                   |
+| ------------------------------- | ------------------------------------------------------------- |
+| `native shuffle time`           | Total time in native code excluding any child operators.      |
+| `repartition time`              | Time to repartition batches.                                  |
+| `memory pool time`              | Time interacting with memory pool.                            |
+| `encoding and compression time` | Time to encode batches in IPC format and compress using ZSTD. |
+
+## Native Metrics
+
+Setting `spark.comet.explain.native.enabled=true` will cause native plans to be logged in each executor. Metrics are
+logged for each native plan (and there is one plan per task, so this is very verbose).
+
+Here is a guide to some of the native metrics.
+
+### ScanExec
+
+| Metric            | Description                                                                                         |
+| ----------------- | --------------------------------------------------------------------------------------------------- |
+| `elapsed_compute` | Total time spent in this operator, fetching batches from a JVM iterator.                            |
+| `jvm_fetch_time`  | Time spent in the JVM fetching input batches to be read by this `ScanExec` instance.                |
+| `arrow_ffi_time`  | Time spent using Arrow FFI to create Arrow batches from the memory addresses returned from the JVM. |
+
+### ShuffleWriterExec
+
+| Metric            | Description                                                   |
+| ----------------- | ------------------------------------------------------------- |
+| `elapsed_compute` | Total time excluding any child operators.                     |
+| `repart_time`     | Time to repartition batches.                                  |
+| `ipc_time`        | Time to encode batches in IPC format and compress using ZSTD. |
+| `mempool_time`    | Time interacting with memory pool.                            |
+| `write_time`      | Time spent writing bytes to disk.                             |
diff --git a/docs/source/user-guide/tuning.md b/docs/source/user-guide/tuning.md
index f10a0dde9e..d68481d172 100644
--- a/docs/source/user-guide/tuning.md
+++ b/docs/source/user-guide/tuning.md
@@ -103,31 +103,6 @@ native shuffle currently only supports `HashPartitioning` and `SinglePartitionin
 To enable native shuffle, set `spark.comet.exec.shuffle.mode` to `native`. If this mode is explicitly set,
 then any shuffle operations that cannot be supported in this mode will fall back to Spark.
 
-##  Metrics
-
-### Spark SQL Metrics
-
-Some Comet metrics are not directly comparable to Spark metrics in some cases:
-
-- `CometScanExec` uses nanoseconds for total scan time. Spark also measures scan time in nanoseconds but converts to
-  milliseconds _per batch_ which can result in a large loss of precision, making it difficult to compare scan times
-  between Spark and Comet.
-
-### Native Metrics
-
-Setting `spark.comet.explain.native.enabled=true` will cause native plans to be logged in each executor. Metrics are
-logged for each native plan (and there is one plan per task, so this is very verbose).
-
-Here is a guide to some of the native metrics.
-
-### ScanExec
-
-| Metric            | Description                                                                                         |
-| ----------------- | --------------------------------------------------------------------------------------------------- |
-| `elapsed_compute` | Total time spent in this operator, fetching batches from a JVM iterator.                            |
-| `jvm_fetch_time`  | Time spent in the JVM fetching input batches to be read by this `ScanExec` instance.                |
-| `arrow_ffi_time`  | Time spent using Arrow FFI to create Arrow batches from the memory addresses returned from the JVM. |
-
 ## Explain Plan
 ### Extended Explain
 With Spark 4.0.0 and newer, Comet can provide extended explain plan information in the Spark UI. Currently this lists
diff --git a/native/core/src/execution/shuffle/row.rs b/native/core/src/execution/shuffle/row.rs
index ce752e68af..ecab77d966 100644
--- a/native/core/src/execution/shuffle/row.rs
+++ b/native/core/src/execution/shuffle/row.rs
@@ -40,6 +40,7 @@ use arrow_array::{
     Array, ArrayRef, RecordBatch, RecordBatchOptions,
 };
 use arrow_schema::{ArrowError, DataType, Field, Schema, TimeUnit};
+use datafusion::physical_plan::metrics::Time;
 use jni::sys::{jint, jlong};
 use std::{
     fs::OpenOptions,
@@ -3354,7 +3355,10 @@ pub fn process_sorted_row_partition(
         let mut frozen: Vec<u8> = vec![];
         let mut cursor = Cursor::new(&mut frozen);
         cursor.seek(SeekFrom::End(0))?;
-        written += write_ipc_compressed(&batch, &mut cursor)?;
+
+        // we do not collect metrics in Native_writeSortedFileNative
+        let ipc_time = Time::default();
+        written += write_ipc_compressed(&batch, &mut cursor, &ipc_time)?;
 
         if let Some(checksum) = &mut current_checksum {
             checksum.update(&mut cursor)?;
diff --git a/native/core/src/execution/shuffle/shuffle_writer.rs b/native/core/src/execution/shuffle/shuffle_writer.rs
index 7587ff06dc..fcc8c51f60 100644
--- a/native/core/src/execution/shuffle/shuffle_writer.rs
+++ b/native/core/src/execution/shuffle/shuffle_writer.rs
@@ -17,22 +17,14 @@
 
 //! Defines the External shuffle repartition plan.
 
-use std::{
-    any::Any,
-    fmt,
-    fmt::{Debug, Formatter},
-    fs::{File, OpenOptions},
-    io::{BufReader, BufWriter, Cursor, Read, Seek, SeekFrom, Write},
-    path::Path,
-    sync::Arc,
-    task::{Context, Poll},
+use crate::{
+    common::bit::ceil,
+    errors::{CometError, CometResult},
 };
-
 use arrow::{datatypes::*, ipc::writer::StreamWriter};
 use async_trait::async_trait;
 use bytes::Buf;
 use crc32fast::Hasher;
-use datafusion::physical_plan::metrics::Time;
 use datafusion::{
     arrow::{
         array::*,
@@ -48,23 +40,32 @@ use datafusion::{
         runtime_env::RuntimeEnv,
     },
     physical_plan::{
-        metrics::{BaselineMetrics, Count, ExecutionPlanMetricsSet, MetricBuilder, MetricsSet},
+        metrics::{
+            BaselineMetrics, Count, ExecutionPlanMetricsSet, MetricBuilder, MetricsSet, Time,
+        },
         stream::RecordBatchStreamAdapter,
         DisplayAs, DisplayFormatType, ExecutionMode, ExecutionPlan, Partitioning, PlanProperties,
         RecordBatchStream, SendableRecordBatchStream, Statistics,
     },
 };
+use datafusion_comet_spark_expr::spark_hash::create_murmur3_hashes;
 use datafusion_physical_expr::EquivalenceProperties;
 use futures::executor::block_on;
 use futures::{lock::Mutex, Stream, StreamExt, TryFutureExt, TryStreamExt};
 use itertools::Itertools;
 use simd_adler32::Adler32;
-
-use crate::{
-    common::bit::ceil,
-    errors::{CometError, CometResult},
+use std::io::Error;
+use std::{
+    any::Any,
+    fmt,
+    fmt::{Debug, Formatter},
+    fs::{File, OpenOptions},
+    io::{BufReader, BufWriter, Cursor, Read, Seek, SeekFrom, Write},
+    path::Path,
+    sync::Arc,
+    task::{Context, Poll},
 };
-use datafusion_comet_spark_expr::spark_hash::create_murmur3_hashes;
+use tokio::time::Instant;
 
 /// The status of appending rows to a partition buffer.
 enum AppendRowStatus {
@@ -242,7 +243,7 @@ impl PartitionBuffer {
 
     /// Initializes active builders if necessary.
     /// Returns error if memory reservation fails.
-    fn init_active_if_necessary(&mut self) -> Result<isize> {
+    fn init_active_if_necessary(&mut self, metrics: &ShuffleRepartitionerMetrics) -> Result<isize> {
         let mut mem_diff = 0;
 
         if self.active.is_empty() {
@@ -256,9 +257,13 @@ impl PartitionBuffer {
                     .sum::<usize>();
             }
 
+            let mut mempool_timer = metrics.mempool_time.timer();
             self.reservation.try_grow(self.active_slots_mem_size)?;
+            mempool_timer.stop();
 
+            let mut repart_timer = metrics.repart_time.timer();
             self.active = new_array_builders(&self.schema, self.batch_size);
+            repart_timer.stop();
 
             mem_diff += self.active_slots_mem_size as isize;
         }
@@ -271,13 +276,13 @@ impl PartitionBuffer {
         columns: &[ArrayRef],
         indices: &[usize],
         start_index: usize,
-        time_metric: &Time,
+        metrics: &ShuffleRepartitionerMetrics,
     ) -> AppendRowStatus {
         let mut mem_diff = 0;
         let mut start = start_index;
 
         // lazy init because some partition may be empty
-        let init = self.init_active_if_necessary();
+        let init = self.init_active_if_necessary(metrics);
         if init.is_err() {
             return AppendRowStatus::StartIndex(start);
         }
@@ -285,6 +290,8 @@ impl PartitionBuffer {
 
         while start < indices.len() {
             let end = (start + self.batch_size).min(indices.len());
+
+            let mut repart_timer = metrics.repart_time.timer();
             self.active
                 .iter_mut()
                 .zip(columns)
@@ -292,16 +299,16 @@ impl PartitionBuffer {
                     append_columns(builder, column, &indices[start..end], column.data_type());
                 });
             self.num_active_rows += end - start;
+            repart_timer.stop();
+
             if self.num_active_rows >= self.batch_size {
-                let mut timer = time_metric.timer();
-                let flush = self.flush();
+                let flush = self.flush(&metrics.ipc_time);
                 if let Err(e) = flush {
                     return AppendRowStatus::MemDiff(Err(e));
                 }
                 mem_diff += flush.unwrap();
-                timer.stop();
 
-                let init = self.init_active_if_necessary();
+                let init = self.init_active_if_necessary(metrics);
                 if init.is_err() {
                     return AppendRowStatus::StartIndex(end);
                 }
@@ -313,7 +320,7 @@ impl PartitionBuffer {
     }
 
     /// flush active data into frozen bytes
-    fn flush(&mut self) -> Result<isize> {
+    fn flush(&mut self, ipc_time: &Time) -> Result<isize> {
         if self.num_active_rows == 0 {
             return Ok(0);
         }
@@ -330,7 +337,7 @@ impl PartitionBuffer {
         let frozen_capacity_old = self.frozen.capacity();
         let mut cursor = Cursor::new(&mut self.frozen);
         cursor.seek(SeekFrom::End(0))?;
-        write_ipc_compressed(&frozen_batch, &mut cursor)?;
+        write_ipc_compressed(&frozen_batch, &mut cursor, ipc_time)?;
 
         mem_diff += (self.frozen.capacity() - frozen_capacity_old) as isize;
         Ok(mem_diff)
@@ -628,6 +635,21 @@ struct ShuffleRepartitionerMetrics {
     /// metrics
     baseline: BaselineMetrics,
 
+    /// Time to perform repartitioning
+    repart_time: Time,
+
+    /// Time interacting with memory pool
+    mempool_time: Time,
+
+    /// Time encoding batches to IPC format
+    ipc_time: Time,
+
+    /// Time spent writing to disk. Maps to "shuffleWriteTime" in Spark SQL Metrics.
+    write_time: Time,
+
+    /// Number of input batches
+    input_batches: Count,
+
     /// count of spills during the execution of the operator
     spill_count: Count,
 
@@ -642,6 +664,11 @@ impl ShuffleRepartitionerMetrics {
     fn new(metrics: &ExecutionPlanMetricsSet, partition: usize) -> Self {
         Self {
             baseline: BaselineMetrics::new(metrics, partition),
+            repart_time: MetricBuilder::new(metrics).subset_time("repart_time", partition),
+            mempool_time: MetricBuilder::new(metrics).subset_time("mempool_time", partition),
+            ipc_time: MetricBuilder::new(metrics).subset_time("ipc_time", partition),
+            write_time: MetricBuilder::new(metrics).subset_time("write_time", partition),
+            input_batches: MetricBuilder::new(metrics).counter("input_batches", partition),
             spill_count: MetricBuilder::new(metrics).spill_count(partition),
             spilled_bytes: MetricBuilder::new(metrics).spilled_bytes(partition),
             data_size: MetricBuilder::new(metrics).counter("data_size", partition),
@@ -701,6 +728,7 @@ impl ShuffleRepartitioner {
     /// This function will slice input batch according to configured batch size and then
     /// shuffle rows into corresponding partition buffer.
     async fn insert_batch(&mut self, batch: RecordBatch) -> Result<()> {
+        let start_time = Instant::now();
         let mut start = 0;
         while start < batch.num_rows() {
             let end = (start + self.batch_size).min(batch.num_rows());
@@ -708,6 +736,11 @@ impl ShuffleRepartitioner {
             self.partitioning_batch(batch).await?;
             start = end;
         }
+        self.metrics.input_batches.add(1);
+        self.metrics
+            .baseline
+            .elapsed_compute()
+            .add_duration(start_time.elapsed());
         Ok(())
     }
 
@@ -738,53 +771,61 @@ impl ShuffleRepartitioner {
         let num_output_partitions = self.num_output_partitions;
         match &self.partitioning {
             Partitioning::Hash(exprs, _) => {
-                let arrays = exprs
-                    .iter()
-                    .map(|expr| expr.evaluate(&input)?.into_array(input.num_rows()))
-                    .collect::<Result<Vec<_>>>()?;
-
-                // use identical seed as spark hash partition
-                let hashes_buf = &mut self.hashes_buf[..arrays[0].len()];
-                hashes_buf.fill(42_u32);
-
-                // Hash arrays and compute buckets based on number of partitions
-                let partition_ids = &mut self.partition_ids[..arrays[0].len()];
-                create_murmur3_hashes(&arrays, hashes_buf)?
-                    .iter()
-                    .enumerate()
-                    .for_each(|(idx, hash)| {
-                        partition_ids[idx] = pmod(*hash, num_output_partitions) as u64
+                let (partition_starts, shuffled_partition_ids): (Vec<usize>, Vec<usize>) = {
+                    let mut timer = self.metrics.repart_time.timer();
+                    let arrays = exprs
+                        .iter()
+                        .map(|expr| expr.evaluate(&input)?.into_array(input.num_rows()))
+                        .collect::<Result<Vec<_>>>()?;
+
+                    // use identical seed as spark hash partition
+                    let hashes_buf = &mut self.hashes_buf[..arrays[0].len()];
+                    hashes_buf.fill(42_u32);
+
+                    // Hash arrays and compute buckets based on number of partitions
+                    let partition_ids = &mut self.partition_ids[..arrays[0].len()];
+                    create_murmur3_hashes(&arrays, hashes_buf)?
+                        .iter()
+                        .enumerate()
+                        .for_each(|(idx, hash)| {
+                            partition_ids[idx] = pmod(*hash, num_output_partitions) as u64
+                        });
+
+                    // count each partition size
+                    let mut partition_counters = vec![0usize; num_output_partitions];
+                    partition_ids
+                        .iter()
+                        .for_each(|partition_id| partition_counters[*partition_id as usize] += 1);
+
+                    // accumulate partition counters into partition ends
+                    // e.g. partition counter: [1, 3, 2, 1] => [1, 4, 6, 7]
+                    let mut partition_ends = partition_counters;
+                    let mut accum = 0;
+                    partition_ends.iter_mut().for_each(|v| {
+                        *v += accum;
+                        accum = *v;
                     });
 
-                // count each partition size
-                let mut partition_counters = vec![0usize; num_output_partitions];
-                partition_ids
-                    .iter()
-                    .for_each(|partition_id| partition_counters[*partition_id as usize] += 1);
-
-                // accumulate partition counters into partition ends
-                // e.g. partition counter: [1, 3, 2, 1] => [1, 4, 6, 7]
-                let mut partition_ends = partition_counters;
-                let mut accum = 0;
-                partition_ends.iter_mut().for_each(|v| {
-                    *v += accum;
-                    accum = *v;
-                });
-
-                // calculate shuffled partition ids
-                // e.g. partition ids: [3, 1, 1, 1, 2, 2, 0] => [6, 1, 2, 3, 4, 5, 0] which is the
-                // row indices for rows ordered by their partition id. For example, first partition
-                // 0 has one row index [6], partition 1 has row indices [1, 2, 3], etc.
-                let mut shuffled_partition_ids = vec![0usize; input.num_rows()];
-                for (index, partition_id) in partition_ids.iter().enumerate().rev() {
-                    partition_ends[*partition_id as usize] -= 1;
-                    let end = partition_ends[*partition_id as usize];
-                    shuffled_partition_ids[end] = index;
-                }
+                    // calculate shuffled partition ids
+                    // e.g. partition ids: [3, 1, 1, 1, 2, 2, 0] => [6, 1, 2, 3, 4, 5, 0] which is the
+                    // row indices for rows ordered by their partition id. For example, first partition
+                    // 0 has one row index [6], partition 1 has row indices [1, 2, 3], etc.
+                    let mut shuffled_partition_ids = vec![0usize; input.num_rows()];
+                    for (index, partition_id) in partition_ids.iter().enumerate().rev() {
+                        partition_ends[*partition_id as usize] -= 1;
+                        let end = partition_ends[*partition_id as usize];
+                        shuffled_partition_ids[end] = index;
+                    }
 
-                // after calculating, partition ends become partition starts
-                let mut partition_starts = partition_ends;
-                partition_starts.push(input.num_rows());
+                    // after calculating, partition ends become partition starts
+                    let mut partition_starts = partition_ends;
+                    partition_starts.push(input.num_rows());
+                    timer.stop();
+                    Ok::<(Vec<usize>, Vec<usize>), DataFusionError>((
+                        partition_starts,
+                        shuffled_partition_ids,
+                    ))
+                }?;
 
                 // For each interval of row indices of partition, taking rows from input batch and
                 // appending into output buffer.
@@ -804,11 +845,20 @@ impl ShuffleRepartitioner {
 
                     if mem_diff > 0 {
                         let mem_increase = mem_diff as usize;
-                        if self.reservation.try_grow(mem_increase).is_err() {
+
+                        let try_grow = {
+                            let mut mempool_timer = self.metrics.mempool_time.timer();
+                            let result = self.reservation.try_grow(mem_increase);
+                            mempool_timer.stop();
+                            result
+                        };
+
+                        if try_grow.is_err() {
                             self.spill().await?;
+                            let mut mempool_timer = self.metrics.mempool_time.timer();
                             self.reservation.free();
                             self.reservation.try_grow(mem_increase)?;
-
+                            mempool_timer.stop();
                             mem_diff = 0;
                         }
                     }
@@ -816,7 +866,9 @@ impl ShuffleRepartitioner {
                     if mem_diff < 0 {
                         let mem_used = self.reservation.size();
                         let mem_decrease = mem_used.min(-mem_diff as usize);
+                        let mut mempool_timer = self.metrics.mempool_time.timer();
                         self.reservation.shrink(mem_decrease);
+                        mempool_timer.stop();
                     }
                 }
             }
@@ -848,12 +900,13 @@ impl ShuffleRepartitioner {
 
     /// Writes buffered shuffled record batches into Arrow IPC bytes.
     async fn shuffle_write(&mut self) -> Result<SendableRecordBatchStream> {
+        let mut elapsed_compute = self.metrics.baseline.elapsed_compute().timer();
         let num_output_partitions = self.num_output_partitions;
         let buffered_partitions = &mut self.buffered_partitions;
         let mut output_batches: Vec<Vec<u8>> = vec![vec![]; num_output_partitions];
-
+        let mut offsets = vec![0; num_output_partitions + 1];
         for i in 0..num_output_partitions {
-            buffered_partitions[i].flush()?;
+            buffered_partitions[i].flush(&self.metrics.ipc_time)?;
             output_batches[i] = std::mem::take(&mut buffered_partitions[i].frozen);
         }
 
@@ -863,53 +916,38 @@ impl ShuffleRepartitioner {
         let data_file = self.output_data_file.clone();
         let index_file = self.output_index_file.clone();
 
-        let mut offsets = vec![0; num_output_partitions + 1];
-        let mut output_data = OpenOptions::new()
+        let mut write_time = self.metrics.write_time.timer();
+
+        let output_data = OpenOptions::new()
             .write(true)
             .create(true)
             .truncate(true)
             .open(data_file)
             .map_err(|e| DataFusionError::Execution(format!("shuffle write error: {:?}", e)))?;
 
-        for i in 0..num_output_partitions {
-            let mut timer = self.metrics.baseline.elapsed_compute().timer();
+        let mut output_data = BufWriter::new(output_data);
 
+        for i in 0..num_output_partitions {
             offsets[i] = output_data.stream_position()?;
             output_data.write_all(&output_batches[i])?;
-
-            timer.stop();
-
             output_batches[i].clear();
 
             // append partition in each spills
             for spill in &output_spills {
                 let length = spill.offsets[i + 1] - spill.offsets[i];
                 if length > 0 {
-                    let mut timer = self.metrics.baseline.elapsed_compute().timer();
-
                     let mut spill_file =
-                        BufReader::new(File::open(spill.file.path()).map_err(|e| {
-                            DataFusionError::Execution(format!("shuffle write error: {:?}", e))
-                        })?);
+                        BufReader::new(File::open(spill.file.path()).map_err(Self::to_df_err)?);
                     spill_file.seek(SeekFrom::Start(spill.offsets[i]))?;
-                    std::io::copy(&mut spill_file.take(length), &mut output_data).map_err(|e| {
-                        DataFusionError::Execution(format!("shuffle write error: {:?}", e))
-                    })?;
-
-                    timer.stop();
+                    std::io::copy(&mut spill_file.take(length), &mut output_data)
+                        .map_err(Self::to_df_err)?;
                 }
             }
         }
-        let mut timer = self.metrics.baseline.elapsed_compute().timer();
         output_data.flush()?;
-        timer.stop();
 
         // add one extra offset at last to ease partition length computation
-        offsets[num_output_partitions] = output_data
-            .stream_position()
-            .map_err(|e| DataFusionError::Execution(format!("shuffle write error: {:?}", e)))?;
-
-        let mut timer = self.metrics.baseline.elapsed_compute().timer();
+        offsets[num_output_partitions] = output_data.stream_position().map_err(Self::to_df_err)?;
 
         let mut output_index =
             BufWriter::new(File::create(index_file).map_err(|e| {
@@ -918,19 +956,27 @@ impl ShuffleRepartitioner {
         for offset in offsets {
             output_index
                 .write_all(&(offset as i64).to_le_bytes()[..])
-                .map_err(|e| DataFusionError::Execution(format!("shuffle write error: {:?}", e)))?;
+                .map_err(Self::to_df_err)?;
         }
         output_index.flush()?;
 
-        timer.stop();
+        write_time.stop();
 
+        let mut mempool_timer = self.metrics.mempool_time.timer();
         let used = self.reservation.size();
         self.reservation.shrink(used);
+        mempool_timer.stop();
+
+        elapsed_compute.stop();
 
         // shuffle writer always has empty output
         Ok(Box::pin(EmptyStream::try_new(Arc::clone(&self.schema))?))
     }
 
+    fn to_df_err(e: Error) -> DataFusionError {
+        DataFusionError::Execution(format!("shuffle write error: {:?}", e))
+    }
+
     fn used(&self) -> usize {
         self.reservation.size()
     }
@@ -959,7 +1005,7 @@ impl ShuffleRepartitioner {
             return Ok(0);
         }
 
-        let mut timer = self.metrics.baseline.elapsed_compute().timer();
+        let mut timer = self.metrics.write_time.timer();
 
         let spillfile = self
             .runtime
@@ -969,6 +1015,7 @@ impl ShuffleRepartitioner {
             &mut self.buffered_partitions,
             spillfile.path(),
             self.num_output_partitions,
+            &self.metrics.ipc_time,
         )?;
 
         timer.stop();
@@ -995,12 +1042,10 @@ impl ShuffleRepartitioner {
 
         let output = &mut self.buffered_partitions[partition_id];
 
-        let time_metric = self.metrics.baseline.elapsed_compute();
-
         // If the range of indices is not big enough, just appending the rows into
         // active array builders instead of directly adding them as a record batch.
         let mut start_index: usize = 0;
-        let mut output_ret = output.append_rows(columns, indices, start_index, time_metric);
+        let mut output_ret = output.append_rows(columns, indices, start_index, &self.metrics);
 
         loop {
             match output_ret {
@@ -1012,15 +1057,15 @@ impl ShuffleRepartitioner {
                     // Cannot allocate enough memory for the array builders in the partition,
                     // spill partitions and retry.
                     self.spill().await?;
-                    self.reservation.free();
 
+                    let mut mempool_timer = self.metrics.mempool_time.timer();
+                    self.reservation.free();
                     let output = &mut self.buffered_partitions[partition_id];
                     output.reservation.free();
-
-                    let time_metric = self.metrics.baseline.elapsed_compute();
+                    mempool_timer.stop();
 
                     start_index = new_start;
-                    output_ret = output.append_rows(columns, indices, start_index, time_metric);
+                    output_ret = output.append_rows(columns, indices, start_index, &self.metrics);
 
                     if let AppendRowStatus::StartIndex(new_start) = output_ret {
                         if new_start == start_index {
@@ -1045,11 +1090,12 @@ fn spill_into(
     buffered_partitions: &mut [PartitionBuffer],
     path: &Path,
     num_output_partitions: usize,
+    ipc_time: &Time,
 ) -> Result<Vec<u64>> {
     let mut output_batches: Vec<Vec<u8>> = vec![vec![]; num_output_partitions];
 
     for i in 0..num_output_partitions {
-        buffered_partitions[i].flush()?;
+        buffered_partitions[i].flush(ipc_time)?;
         output_batches[i] = std::mem::take(&mut buffered_partitions[i].frozen);
     }
     let path = path.to_owned();
@@ -1485,10 +1531,13 @@ impl Checksum {
 pub(crate) fn write_ipc_compressed<W: Write + Seek>(
     batch: &RecordBatch,
     output: &mut W,
+    ipc_time: &Time,
 ) -> Result<usize> {
     if batch.num_rows() == 0 {
         return Ok(0);
     }
+
+    let mut timer = ipc_time.timer();
     let start_pos = output.stream_position()?;
 
     // write ipc_length placeholder
@@ -1508,8 +1557,10 @@ pub(crate) fn write_ipc_compressed<W: Write + Seek>(
     // fill ipc length
     output.seek(SeekFrom::Start(start_pos))?;
     output.write_all(&ipc_length.to_le_bytes()[..])?;
-
     output.seek(SeekFrom::Start(end_pos))?;
+
+    timer.stop();
+
     Ok((end_pos - start_pos) as usize)
 }
 
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/CometCollectLimitExec.scala b/spark/src/main/scala/org/apache/spark/sql/comet/CometCollectLimitExec.scala
index 8ea0b17654..f75af5076b 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/CometCollectLimitExec.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/CometCollectLimitExec.scala
@@ -57,7 +57,8 @@ case class CometCollectLimitExec(
     "dataSize" -> SQLMetrics.createSizeMetric(sparkContext, "data size"),
     "numPartitions" -> SQLMetrics.createMetric(
       sparkContext,
-      "number of partitions")) ++ readMetrics ++ writeMetrics
+      "number of partitions")) ++ readMetrics ++ writeMetrics ++ CometMetricNode.shuffleMetrics(
+    sparkContext)
 
   private lazy val serializer: Serializer =
     new UnsafeRowSerializer(child.output.size, longMetric("dataSize"))
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/CometMetricNode.scala b/spark/src/main/scala/org/apache/spark/sql/comet/CometMetricNode.scala
index 47c89d9433..a26fa28c8b 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/CometMetricNode.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/CometMetricNode.scala
@@ -130,6 +130,17 @@ object CometMetricNode {
       "spilled_rows" -> SQLMetrics.createMetric(sc, "Total spilled rows"))
   }
 
+  def shuffleMetrics(sc: SparkContext): Map[String, SQLMetric] = {
+    Map(
+      "elapsed_compute" -> SQLMetrics.createNanoTimingMetric(sc, "native shuffle time"),
+      "mempool_time" -> SQLMetrics.createNanoTimingMetric(sc, "memory pool time"),
+      "repart_time" -> SQLMetrics.createNanoTimingMetric(sc, "repartition time"),
+      "ipc_time" -> SQLMetrics.createNanoTimingMetric(sc, "encoding and compression time"),
+      "spill_count" -> SQLMetrics.createMetric(sc, "number of spills"),
+      "spilled_bytes" -> SQLMetrics.createMetric(sc, "spilled bytes"),
+      "input_batches" -> SQLMetrics.createMetric(sc, "number of input batches"))
+  }
+
   /**
    * Creates a [[CometMetricNode]] from a [[CometPlan]].
    */
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/CometTakeOrderedAndProjectExec.scala b/spark/src/main/scala/org/apache/spark/sql/comet/CometTakeOrderedAndProjectExec.scala
index 5582f4d687..19586628a7 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/CometTakeOrderedAndProjectExec.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/CometTakeOrderedAndProjectExec.scala
@@ -57,7 +57,8 @@ case class CometTakeOrderedAndProjectExec(
     "dataSize" -> SQLMetrics.createSizeMetric(sparkContext, "data size"),
     "numPartitions" -> SQLMetrics.createMetric(
       sparkContext,
-      "number of partitions")) ++ readMetrics ++ writeMetrics
+      "number of partitions")) ++ readMetrics ++ writeMetrics ++ CometMetricNode.shuffleMetrics(
+    sparkContext)
 
   private lazy val serializer: Serializer =
     new UnsafeRowSerializer(child.output.size, longMetric("dataSize"))
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
index b1dd9ac836..0cd8a9ce67 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
@@ -79,7 +79,8 @@ case class CometShuffleExchangeExec(
     "dataSize" -> SQLMetrics.createSizeMetric(sparkContext, "data size"),
     "numPartitions" -> SQLMetrics.createMetric(
       sparkContext,
-      "number of partitions")) ++ readMetrics ++ writeMetrics
+      "number of partitions")) ++ readMetrics ++ writeMetrics ++ CometMetricNode.shuffleMetrics(
+    sparkContext)
 
   override def nodeName: String = if (shuffleType == CometNativeShuffle) {
     "CometExchange"
@@ -477,11 +478,21 @@ class CometShuffleWriteProcessor(
     // Call native shuffle write
     val nativePlan = getNativePlan(tempDataFilename, tempIndexFilename)
 
+    val detailedMetrics = Seq(
+      "elapsed_compute",
+      "ipc_time",
+      "repart_time",
+      "mempool_time",
+      "input_batches",
+      "spill_count",
+      "spilled_bytes")
+
     // Maps native metrics to SQL metrics
     val nativeSQLMetrics = Map(
       "output_rows" -> metrics(SQLShuffleWriteMetricsReporter.SHUFFLE_RECORDS_WRITTEN),
       "data_size" -> metrics("dataSize"),
-      "elapsed_compute" -> metrics(SQLShuffleWriteMetricsReporter.SHUFFLE_WRITE_TIME))
+      "write_time" -> metrics(SQLShuffleWriteMetricsReporter.SHUFFLE_WRITE_TIME)) ++
+      metrics.filterKeys(detailedMetrics.contains)
     val nativeMetrics = CometMetricNode(nativeSQLMetrics)
 
     // Getting rid of the fake partitionId

From 8f4a8a54a292d86a30fb66d3dac442bff46a1039 Mon Sep 17 00:00:00 2001
From: Liang-Chi Hsieh <viirya@gmail.com>
Date: Thu, 19 Dec 2024 13:06:56 -0800
Subject: [PATCH 39/47] fix: stddev_pop should not directly return 0.0 when
 count is 1.0 (#1184)

* add test

* fix

* fix

* fix
---
 native/spark-expr/src/variance.rs               |  6 ++----
 .../apache/comet/exec/CometAggregateSuite.scala | 17 +++++++++++++++++
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/native/spark-expr/src/variance.rs b/native/spark-expr/src/variance.rs
index 2f4d8091c2..4370d89ff4 100644
--- a/native/spark-expr/src/variance.rs
+++ b/native/spark-expr/src/variance.rs
@@ -245,10 +245,8 @@ impl Accumulator for VarianceAccumulator {
 
         Ok(ScalarValue::Float64(match self.count {
             count if count == 0.0 => None,
-            count if count == 1.0 => {
-                if let StatsType::Population = self.stats_type {
-                    Some(0.0)
-                } else if self.null_on_divide_by_zero {
+            count if count == 1.0 && StatsType::Sample == self.stats_type => {
+                if self.null_on_divide_by_zero {
                     None
                 } else {
                     Some(f64::NAN)
diff --git a/spark/src/test/scala/org/apache/comet/exec/CometAggregateSuite.scala b/spark/src/test/scala/org/apache/comet/exec/CometAggregateSuite.scala
index e337d36c48..9a642f12f7 100644
--- a/spark/src/test/scala/org/apache/comet/exec/CometAggregateSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/exec/CometAggregateSuite.scala
@@ -38,6 +38,23 @@ import org.apache.comet.CometSparkSessionExtensions.isSpark34Plus
 class CometAggregateSuite extends CometTestBase with AdaptiveSparkPlanHelper {
   import testImplicits._
 
+  test("stddev_pop should return NaN for some cases") {
+    withSQLConf(
+      CometConf.COMET_EXEC_SHUFFLE_ENABLED.key -> "true",
+      CometConf.COMET_EXPR_STDDEV_ENABLED.key -> "true") {
+      Seq(true, false).foreach { nullOnDivideByZero =>
+        withSQLConf("spark.sql.legacy.statisticalAggregate" -> nullOnDivideByZero.toString) {
+
+          val data: Seq[(Float, Int)] = Seq((Float.PositiveInfinity, 1))
+          withParquetTable(data, "tbl", false) {
+            val df = sql("SELECT stddev_pop(_1), stddev_pop(_2) FROM tbl")
+            checkSparkAnswer(df)
+          }
+        }
+      }
+    }
+  }
+
   test("count with aggregation filter") {
     withSQLConf(
       CometConf.COMET_ENABLED.key -> "true",

From ea6d20511e813a2698c47a964b3a0739e9543add Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Fri, 20 Dec 2024 11:11:14 -0700
Subject: [PATCH 40/47] feat: Make native shuffle compression configurable and
 respect `spark.shuffle.compress` (#1185)

* Make shuffle compression codec and level configurable

* remove lz4 references

* docs

* update comment

* clippy

* fix benches

* clippy

* clippy

* disable test for miri

* remove lz4 reference from proto
---
 .../scala/org/apache/comet/CometConf.scala    | 14 ++-
 .../shuffle/IpcInputStreamIterator.scala      |  6 +-
 .../execution/shuffle/ShuffleUtils.scala      | 31 ++++---
 docs/source/user-guide/configs.md             |  3 +-
 docs/source/user-guide/tuning.md              |  6 ++
 native/core/benches/shuffle_writer.rs         | 87 +++++++++++++-----
 native/core/src/execution/planner.rs          | 17 +++-
 native/core/src/execution/shuffle/mod.rs      |  2 +-
 native/core/src/execution/shuffle/row.rs      |  5 +-
 .../src/execution/shuffle/shuffle_writer.rs   | 90 +++++++++++++++----
 native/proto/src/proto/operator.proto         |  7 ++
 .../shuffle/CometShuffleExchangeExec.scala    | 14 ++-
 .../shuffle/CometShuffleManager.scala         |  2 +-
 13 files changed, 221 insertions(+), 63 deletions(-)

diff --git a/common/src/main/scala/org/apache/comet/CometConf.scala b/common/src/main/scala/org/apache/comet/CometConf.scala
index b602d7cf1c..8815ac4eb8 100644
--- a/common/src/main/scala/org/apache/comet/CometConf.scala
+++ b/common/src/main/scala/org/apache/comet/CometConf.scala
@@ -272,13 +272,21 @@ object CometConf extends ShimCometConf {
       .booleanConf
       .createWithDefault(false)
 
-  val COMET_EXEC_SHUFFLE_CODEC: ConfigEntry[String] = conf(
-    s"$COMET_EXEC_CONFIG_PREFIX.shuffle.codec")
+  val COMET_EXEC_SHUFFLE_COMPRESSION_CODEC: ConfigEntry[String] = conf(
+    s"$COMET_EXEC_CONFIG_PREFIX.shuffle.compression.codec")
     .doc(
-      "The codec of Comet native shuffle used to compress shuffle data. Only zstd is supported.")
+      "The codec of Comet native shuffle used to compress shuffle data. Only zstd is supported. " +
+        "Compression can be disabled by setting spark.shuffle.compress=false.")
     .stringConf
+    .checkValues(Set("zstd"))
     .createWithDefault("zstd")
 
+  val COMET_EXEC_SHUFFLE_COMPRESSION_LEVEL: ConfigEntry[Int] =
+    conf(s"$COMET_EXEC_CONFIG_PREFIX.shuffle.compression.level")
+      .doc("The compression level to use when compression shuffle files.")
+      .intConf
+      .createWithDefault(1)
+
   val COMET_COLUMNAR_SHUFFLE_ASYNC_ENABLED: ConfigEntry[Boolean] =
     conf("spark.comet.columnar.shuffle.async.enabled")
       .doc("Whether to enable asynchronous shuffle for Arrow-based shuffle.")
diff --git a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/IpcInputStreamIterator.scala b/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/IpcInputStreamIterator.scala
index 281c481083..d1d5af350f 100644
--- a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/IpcInputStreamIterator.scala
+++ b/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/IpcInputStreamIterator.scala
@@ -110,8 +110,10 @@ case class IpcInputStreamIterator(
     currentLimitedInputStream = is
 
     if (decompressingNeeded) {
-      val zs = ShuffleUtils.compressionCodecForShuffling.compressedInputStream(is)
-      Channels.newChannel(zs)
+      ShuffleUtils.compressionCodecForShuffling match {
+        case Some(codec) => Channels.newChannel(codec.compressedInputStream(is))
+        case _ => Channels.newChannel(is)
+      }
     } else {
       Channels.newChannel(is)
     }
diff --git a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ShuffleUtils.scala b/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ShuffleUtils.scala
index eea134ab5e..23b4a5ec23 100644
--- a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ShuffleUtils.scala
+++ b/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ShuffleUtils.scala
@@ -21,22 +21,33 @@ package org.apache.spark.sql.comet.execution.shuffle
 
 import org.apache.spark.SparkEnv
 import org.apache.spark.internal.Logging
-import org.apache.spark.internal.config.IO_COMPRESSION_CODEC
+import org.apache.spark.internal.config.{IO_COMPRESSION_CODEC, SHUFFLE_COMPRESS}
 import org.apache.spark.io.CompressionCodec
-import org.apache.spark.sql.internal.SQLConf
 
 import org.apache.comet.CometConf
 
 private[spark] object ShuffleUtils extends Logging {
-  lazy val compressionCodecForShuffling: CompressionCodec = {
+  // optional compression codec to use when compressing shuffle files
+  lazy val compressionCodecForShuffling: Option[CompressionCodec] = {
     val sparkConf = SparkEnv.get.conf
-    val codecName = CometConf.COMET_EXEC_SHUFFLE_CODEC.get(SQLConf.get)
-
-    // only zstd compression is supported at the moment
-    if (codecName != "zstd") {
-      logWarning(
-        s"Overriding config ${IO_COMPRESSION_CODEC}=${codecName} in shuffling, force using zstd")
+    val shuffleCompressionEnabled = sparkConf.getBoolean(SHUFFLE_COMPRESS.key, true)
+    val sparkShuffleCodec = sparkConf.get(IO_COMPRESSION_CODEC.key, "lz4")
+    val cometShuffleCodec = CometConf.COMET_EXEC_SHUFFLE_COMPRESSION_CODEC.get()
+    if (shuffleCompressionEnabled) {
+      if (sparkShuffleCodec != cometShuffleCodec) {
+        logWarning(
+          s"Overriding config $IO_COMPRESSION_CODEC=$sparkShuffleCodec in shuffling, " +
+            s"force using $cometShuffleCodec")
+      }
+      cometShuffleCodec match {
+        case "zstd" =>
+          Some(CompressionCodec.createCodec(sparkConf, "zstd"))
+        case other =>
+          throw new UnsupportedOperationException(
+            s"Unsupported shuffle compression codec: $other")
+      }
+    } else {
+      None
     }
-    CompressionCodec.createCodec(sparkConf, "zstd")
   }
 }
diff --git a/docs/source/user-guide/configs.md b/docs/source/user-guide/configs.md
index 69da792223..7881f07632 100644
--- a/docs/source/user-guide/configs.md
+++ b/docs/source/user-guide/configs.md
@@ -50,7 +50,8 @@ Comet provides the following configuration settings.
 | spark.comet.exec.memoryFraction | The fraction of memory from Comet memory overhead that the native memory manager can use for execution. The purpose of this config is to set aside memory for untracked data structures, as well as imprecise size estimation during memory acquisition. | 0.7 |
 | spark.comet.exec.project.enabled | Whether to enable project by default. | true |
 | spark.comet.exec.replaceSortMergeJoin | Experimental feature to force Spark to replace SortMergeJoin with ShuffledHashJoin for improved performance. This feature is not stable yet. For more information, refer to the Comet Tuning Guide (https://datafusion.apache.org/comet/user-guide/tuning.html). | false |
-| spark.comet.exec.shuffle.codec | The codec of Comet native shuffle used to compress shuffle data. Only zstd is supported. | zstd |
+| spark.comet.exec.shuffle.compression.codec | The codec of Comet native shuffle used to compress shuffle data. Only zstd is supported. Compression can be disabled by setting spark.shuffle.compress=false. | zstd |
+| spark.comet.exec.shuffle.compression.level | The compression level to use when compression shuffle files. | 1 |
 | spark.comet.exec.shuffle.enabled | Whether to enable Comet native shuffle. Note that this requires setting 'spark.shuffle.manager' to 'org.apache.spark.sql.comet.execution.shuffle.CometShuffleManager'. 'spark.shuffle.manager' must be set before starting the Spark application and cannot be changed during the application. | true |
 | spark.comet.exec.sort.enabled | Whether to enable sort by default. | true |
 | spark.comet.exec.sortMergeJoin.enabled | Whether to enable sortMergeJoin by default. | true |
diff --git a/docs/source/user-guide/tuning.md b/docs/source/user-guide/tuning.md
index d68481d172..e04e750b47 100644
--- a/docs/source/user-guide/tuning.md
+++ b/docs/source/user-guide/tuning.md
@@ -103,6 +103,12 @@ native shuffle currently only supports `HashPartitioning` and `SinglePartitionin
 To enable native shuffle, set `spark.comet.exec.shuffle.mode` to `native`. If this mode is explicitly set,
 then any shuffle operations that cannot be supported in this mode will fall back to Spark.
 
+### Shuffle Compression
+
+By default, Spark compresses shuffle files using LZ4 compression. Comet overrides this behavior with ZSTD compression.
+Compression can be disabled by setting `spark.shuffle.compress=false`, which may result in faster shuffle times in 
+certain environments, such as single-node setups with fast NVMe drives, at the expense of increased disk space usage.
+
 ## Explain Plan
 ### Extended Explain
 With Spark 4.0.0 and newer, Comet can provide extended explain plan information in the Spark UI. Currently this lists
diff --git a/native/core/benches/shuffle_writer.rs b/native/core/benches/shuffle_writer.rs
index 272887238e..865ca73b4a 100644
--- a/native/core/benches/shuffle_writer.rs
+++ b/native/core/benches/shuffle_writer.rs
@@ -15,36 +15,47 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use arrow_array::builder::Int32Builder;
 use arrow_array::{builder::StringBuilder, RecordBatch};
 use arrow_schema::{DataType, Field, Schema};
-use comet::execution::shuffle::ShuffleWriterExec;
+use comet::execution::shuffle::{write_ipc_compressed, CompressionCodec, ShuffleWriterExec};
 use criterion::{criterion_group, criterion_main, Criterion};
+use datafusion::physical_plan::metrics::Time;
 use datafusion::{
     physical_plan::{common::collect, memory::MemoryExec, ExecutionPlan},
     prelude::SessionContext,
 };
 use datafusion_physical_expr::{expressions::Column, Partitioning};
+use std::io::Cursor;
 use std::sync::Arc;
 use tokio::runtime::Runtime;
 
 fn criterion_benchmark(c: &mut Criterion) {
-    let batch = create_batch();
-    let mut batches = Vec::new();
-    for _ in 0..10 {
-        batches.push(batch.clone());
-    }
-    let partitions = &[batches];
-    let exec = ShuffleWriterExec::try_new(
-        Arc::new(MemoryExec::try_new(partitions, batch.schema(), None).unwrap()),
-        Partitioning::Hash(vec![Arc::new(Column::new("a", 0))], 16),
-        "/tmp/data.out".to_string(),
-        "/tmp/index.out".to_string(),
-    )
-    .unwrap();
-
     let mut group = c.benchmark_group("shuffle_writer");
-    group.bench_function("shuffle_writer", |b| {
+    group.bench_function("shuffle_writer: encode (no compression))", |b| {
+        let batch = create_batch(8192, true);
+        let mut buffer = vec![];
+        let mut cursor = Cursor::new(&mut buffer);
+        let ipc_time = Time::default();
+        b.iter(|| write_ipc_compressed(&batch, &mut cursor, &CompressionCodec::None, &ipc_time));
+    });
+    group.bench_function("shuffle_writer: encode and compress (zstd level 1)", |b| {
+        let batch = create_batch(8192, true);
+        let mut buffer = vec![];
+        let mut cursor = Cursor::new(&mut buffer);
+        let ipc_time = Time::default();
+        b.iter(|| write_ipc_compressed(&batch, &mut cursor, &CompressionCodec::Zstd(1), &ipc_time));
+    });
+    group.bench_function("shuffle_writer: encode and compress (zstd level 6)", |b| {
+        let batch = create_batch(8192, true);
+        let mut buffer = vec![];
+        let mut cursor = Cursor::new(&mut buffer);
+        let ipc_time = Time::default();
+        b.iter(|| write_ipc_compressed(&batch, &mut cursor, &CompressionCodec::Zstd(6), &ipc_time));
+    });
+    group.bench_function("shuffle_writer: end to end", |b| {
         let ctx = SessionContext::new();
+        let exec = create_shuffle_writer_exec(CompressionCodec::Zstd(1));
         b.iter(|| {
             let task_ctx = ctx.task_ctx();
             let stream = exec.execute(0, task_ctx).unwrap();
@@ -54,19 +65,47 @@ fn criterion_benchmark(c: &mut Criterion) {
     });
 }
 
-fn create_batch() -> RecordBatch {
-    let schema = Arc::new(Schema::new(vec![Field::new("a", DataType::Utf8, true)]));
+fn create_shuffle_writer_exec(compression_codec: CompressionCodec) -> ShuffleWriterExec {
+    let batches = create_batches(8192, 10);
+    let schema = batches[0].schema();
+    let partitions = &[batches];
+    ShuffleWriterExec::try_new(
+        Arc::new(MemoryExec::try_new(partitions, schema, None).unwrap()),
+        Partitioning::Hash(vec![Arc::new(Column::new("a", 0))], 16),
+        compression_codec,
+        "/tmp/data.out".to_string(),
+        "/tmp/index.out".to_string(),
+    )
+    .unwrap()
+}
+
+fn create_batches(size: usize, count: usize) -> Vec<RecordBatch> {
+    let batch = create_batch(size, true);
+    let mut batches = Vec::new();
+    for _ in 0..count {
+        batches.push(batch.clone());
+    }
+    batches
+}
+
+fn create_batch(num_rows: usize, allow_nulls: bool) -> RecordBatch {
+    let schema = Arc::new(Schema::new(vec![
+        Field::new("c0", DataType::Int32, true),
+        Field::new("c1", DataType::Utf8, true),
+    ]));
+    let mut a = Int32Builder::new();
     let mut b = StringBuilder::new();
-    for i in 0..8192 {
-        if i % 10 == 0 {
+    for i in 0..num_rows {
+        a.append_value(i as i32);
+        if allow_nulls && i % 10 == 0 {
             b.append_null();
         } else {
-            b.append_value(format!("{i}"));
+            b.append_value(format!("this is string number {i}"));
         }
     }
-    let array = b.finish();
-
-    RecordBatch::try_new(schema.clone(), vec![Arc::new(array)]).unwrap()
+    let a = a.finish();
+    let b = b.finish();
+    RecordBatch::try_new(schema.clone(), vec![Arc::new(a), Arc::new(b)]).unwrap()
 }
 
 fn config() -> Criterion {
diff --git a/native/core/src/execution/planner.rs b/native/core/src/execution/planner.rs
index 3ac830c04e..0a74933547 100644
--- a/native/core/src/execution/planner.rs
+++ b/native/core/src/execution/planner.rs
@@ -68,6 +68,7 @@ use datafusion_comet_spark_expr::{create_comet_physical_fun, create_negate_expr}
 use datafusion_functions_nested::concat::ArrayAppend;
 use datafusion_physical_expr::aggregate::{AggregateExprBuilder, AggregateFunctionExpr};
 
+use crate::execution::shuffle::CompressionCodec;
 use crate::execution::spark_plan::SparkPlan;
 use datafusion_comet_proto::{
     spark_expression::{
@@ -76,8 +77,8 @@ use datafusion_comet_proto::{
     },
     spark_operator::{
         self, lower_window_frame_bound::LowerFrameBoundStruct, operator::OpStruct,
-        upper_window_frame_bound::UpperFrameBoundStruct, BuildSide, JoinType, Operator,
-        WindowFrameType,
+        upper_window_frame_bound::UpperFrameBoundStruct, BuildSide,
+        CompressionCodec as SparkCompressionCodec, JoinType, Operator, WindowFrameType,
     },
     spark_partitioning::{partitioning::PartitioningStruct, Partitioning as SparkPartitioning},
 };
@@ -1049,9 +1050,21 @@ impl PhysicalPlanner {
                 let partitioning = self
                     .create_partitioning(writer.partitioning.as_ref().unwrap(), child.schema())?;
 
+                let codec = match writer.codec.try_into() {
+                    Ok(SparkCompressionCodec::None) => Ok(CompressionCodec::None),
+                    Ok(SparkCompressionCodec::Zstd) => {
+                        Ok(CompressionCodec::Zstd(writer.compression_level))
+                    }
+                    _ => Err(ExecutionError::GeneralError(format!(
+                        "Unsupported shuffle compression codec: {:?}",
+                        writer.codec
+                    ))),
+                }?;
+
                 let shuffle_writer = Arc::new(ShuffleWriterExec::try_new(
                     Arc::clone(&child.native_plan),
                     partitioning,
+                    codec,
                     writer.output_data_file.clone(),
                     writer.output_index_file.clone(),
                 )?);
diff --git a/native/core/src/execution/shuffle/mod.rs b/native/core/src/execution/shuffle/mod.rs
index 8721ead74b..8111f5eede 100644
--- a/native/core/src/execution/shuffle/mod.rs
+++ b/native/core/src/execution/shuffle/mod.rs
@@ -19,4 +19,4 @@ mod list;
 mod map;
 pub mod row;
 mod shuffle_writer;
-pub use shuffle_writer::ShuffleWriterExec;
+pub use shuffle_writer::{write_ipc_compressed, CompressionCodec, ShuffleWriterExec};
diff --git a/native/core/src/execution/shuffle/row.rs b/native/core/src/execution/shuffle/row.rs
index ecab77d966..405f642163 100644
--- a/native/core/src/execution/shuffle/row.rs
+++ b/native/core/src/execution/shuffle/row.rs
@@ -292,6 +292,7 @@ macro_rules! downcast_builder_ref {
 }
 
 // Expose the macro for other modules.
+use crate::execution::shuffle::shuffle_writer::CompressionCodec;
 pub(crate) use downcast_builder_ref;
 
 /// Appends field of row to the given struct builder. `dt` is the data type of the field.
@@ -3358,7 +3359,9 @@ pub fn process_sorted_row_partition(
 
         // we do not collect metrics in Native_writeSortedFileNative
         let ipc_time = Time::default();
-        written += write_ipc_compressed(&batch, &mut cursor, &ipc_time)?;
+        // compression codec is not configurable for CometBypassMergeSortShuffleWriter
+        let codec = CompressionCodec::Zstd(1);
+        written += write_ipc_compressed(&batch, &mut cursor, &codec, &ipc_time)?;
 
         if let Some(checksum) = &mut current_checksum {
             checksum.update(&mut cursor)?;
diff --git a/native/core/src/execution/shuffle/shuffle_writer.rs b/native/core/src/execution/shuffle/shuffle_writer.rs
index fcc8c51f60..01117199eb 100644
--- a/native/core/src/execution/shuffle/shuffle_writer.rs
+++ b/native/core/src/execution/shuffle/shuffle_writer.rs
@@ -90,6 +90,7 @@ pub struct ShuffleWriterExec {
     /// Metrics
     metrics: ExecutionPlanMetricsSet,
     cache: PlanProperties,
+    codec: CompressionCodec,
 }
 
 impl DisplayAs for ShuffleWriterExec {
@@ -126,6 +127,7 @@ impl ExecutionPlan for ShuffleWriterExec {
             1 => Ok(Arc::new(ShuffleWriterExec::try_new(
                 Arc::clone(&children[0]),
                 self.partitioning.clone(),
+                self.codec.clone(),
                 self.output_data_file.clone(),
                 self.output_index_file.clone(),
             )?)),
@@ -152,6 +154,7 @@ impl ExecutionPlan for ShuffleWriterExec {
                     self.partitioning.clone(),
                     metrics,
                     context,
+                    self.codec.clone(),
                 )
                 .map_err(|e| ArrowError::ExternalError(Box::new(e))),
             )
@@ -181,6 +184,7 @@ impl ShuffleWriterExec {
     pub fn try_new(
         input: Arc<dyn ExecutionPlan>,
         partitioning: Partitioning,
+        codec: CompressionCodec,
         output_data_file: String,
         output_index_file: String,
     ) -> Result<Self> {
@@ -197,6 +201,7 @@ impl ShuffleWriterExec {
             output_data_file,
             output_index_file,
             cache,
+            codec,
         })
     }
 }
@@ -217,6 +222,7 @@ struct PartitionBuffer {
     batch_size: usize,
     /// Memory reservation for this partition buffer.
     reservation: MemoryReservation,
+    codec: CompressionCodec,
 }
 
 impl PartitionBuffer {
@@ -225,6 +231,7 @@ impl PartitionBuffer {
         batch_size: usize,
         partition_id: usize,
         runtime: &Arc<RuntimeEnv>,
+        codec: CompressionCodec,
     ) -> Self {
         let reservation = MemoryConsumer::new(format!("PartitionBuffer[{}]", partition_id))
             .with_can_spill(true)
@@ -238,6 +245,7 @@ impl PartitionBuffer {
             num_active_rows: 0,
             batch_size,
             reservation,
+            codec,
         }
     }
 
@@ -337,7 +345,7 @@ impl PartitionBuffer {
         let frozen_capacity_old = self.frozen.capacity();
         let mut cursor = Cursor::new(&mut self.frozen);
         cursor.seek(SeekFrom::End(0))?;
-        write_ipc_compressed(&frozen_batch, &mut cursor, ipc_time)?;
+        write_ipc_compressed(&frozen_batch, &mut cursor, &self.codec, ipc_time)?;
 
         mem_diff += (self.frozen.capacity() - frozen_capacity_old) as isize;
         Ok(mem_diff)
@@ -687,6 +695,7 @@ impl ShuffleRepartitioner {
         metrics: ShuffleRepartitionerMetrics,
         runtime: Arc<RuntimeEnv>,
         batch_size: usize,
+        codec: CompressionCodec,
     ) -> Self {
         let num_output_partitions = partitioning.partition_count();
         let reservation = MemoryConsumer::new(format!("ShuffleRepartitioner[{}]", partition_id))
@@ -709,7 +718,13 @@ impl ShuffleRepartitioner {
             schema: Arc::clone(&schema),
             buffered_partitions: (0..num_output_partitions)
                 .map(|partition_id| {
-                    PartitionBuffer::new(Arc::clone(&schema), batch_size, partition_id, &runtime)
+                    PartitionBuffer::new(
+                        Arc::clone(&schema),
+                        batch_size,
+                        partition_id,
+                        &runtime,
+                        codec.clone(),
+                    )
                 })
                 .collect::<Vec<_>>(),
             spills: Mutex::new(vec![]),
@@ -1129,6 +1144,7 @@ impl Debug for ShuffleRepartitioner {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 async fn external_shuffle(
     mut input: SendableRecordBatchStream,
     partition_id: usize,
@@ -1137,6 +1153,7 @@ async fn external_shuffle(
     partitioning: Partitioning,
     metrics: ShuffleRepartitionerMetrics,
     context: Arc<TaskContext>,
+    codec: CompressionCodec,
 ) -> Result<SendableRecordBatchStream> {
     let schema = input.schema();
     let mut repartitioner = ShuffleRepartitioner::new(
@@ -1148,6 +1165,7 @@ async fn external_shuffle(
         metrics,
         context.runtime_env(),
         context.session_config().batch_size(),
+        codec,
     );
 
     while let Some(batch) = input.next().await {
@@ -1526,11 +1544,18 @@ impl Checksum {
     }
 }
 
+#[derive(Debug, Clone)]
+pub enum CompressionCodec {
+    None,
+    Zstd(i32),
+}
+
 /// Writes given record batch as Arrow IPC bytes into given writer.
 /// Returns number of bytes written.
-pub(crate) fn write_ipc_compressed<W: Write + Seek>(
+pub fn write_ipc_compressed<W: Write + Seek>(
     batch: &RecordBatch,
     output: &mut W,
+    codec: &CompressionCodec,
     ipc_time: &Time,
 ) -> Result<usize> {
     if batch.num_rows() == 0 {
@@ -1543,14 +1568,24 @@ pub(crate) fn write_ipc_compressed<W: Write + Seek>(
     // write ipc_length placeholder
     output.write_all(&[0u8; 8])?;
 
-    // write ipc data
-    // TODO: make compression level configurable
-    let mut arrow_writer = StreamWriter::try_new(zstd::Encoder::new(output, 1)?, &batch.schema())?;
-    arrow_writer.write(batch)?;
-    arrow_writer.finish()?;
+    let output = match codec {
+        CompressionCodec::None => {
+            let mut arrow_writer = StreamWriter::try_new(output, &batch.schema())?;
+            arrow_writer.write(batch)?;
+            arrow_writer.finish()?;
+            arrow_writer.into_inner()?
+        }
+        CompressionCodec::Zstd(level) => {
+            let encoder = zstd::Encoder::new(output, *level)?;
+            let mut arrow_writer = StreamWriter::try_new(encoder, &batch.schema())?;
+            arrow_writer.write(batch)?;
+            arrow_writer.finish()?;
+            let zstd_encoder = arrow_writer.into_inner()?;
+            zstd_encoder.finish()?
+        }
+    };
 
-    let zwriter = arrow_writer.into_inner()?;
-    let output = zwriter.finish()?;
+    // fill ipc length
     let end_pos = output.stream_position()?;
     let ipc_length = end_pos - start_pos - 8;
 
@@ -1611,6 +1646,22 @@ mod test {
     use datafusion_physical_expr::expressions::Column;
     use tokio::runtime::Runtime;
 
+    #[test]
+    #[cfg_attr(miri, ignore)] // miri can't call foreign function `ZSTD_createCCtx`
+    fn write_ipc_zstd() {
+        let batch = create_batch(8192);
+        let mut output = vec![];
+        let mut cursor = Cursor::new(&mut output);
+        write_ipc_compressed(
+            &batch,
+            &mut cursor,
+            &CompressionCodec::Zstd(1),
+            &Time::default(),
+        )
+        .unwrap();
+        assert_eq!(40218, output.len());
+    }
+
     #[test]
     fn test_slot_size() {
         let batch_size = 1usize;
@@ -1673,13 +1724,7 @@ mod test {
         num_partitions: usize,
         memory_limit: Option<usize>,
     ) {
-        let schema = Arc::new(Schema::new(vec![Field::new("a", DataType::Utf8, true)]));
-        let mut b = StringBuilder::new();
-        for i in 0..batch_size {
-            b.append_value(format!("{i}"));
-        }
-        let array = b.finish();
-        let batch = RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(array)]).unwrap();
+        let batch = create_batch(batch_size);
 
         let batches = (0..num_batches).map(|_| batch.clone()).collect::<Vec<_>>();
 
@@ -1687,6 +1732,7 @@ mod test {
         let exec = ShuffleWriterExec::try_new(
             Arc::new(MemoryExec::try_new(partitions, batch.schema(), None).unwrap()),
             Partitioning::Hash(vec![Arc::new(Column::new("a", 0))], num_partitions),
+            CompressionCodec::Zstd(1),
             "/tmp/data.out".to_string(),
             "/tmp/index.out".to_string(),
         )
@@ -1707,6 +1753,16 @@ mod test {
         rt.block_on(collect(stream)).unwrap();
     }
 
+    fn create_batch(batch_size: usize) -> RecordBatch {
+        let schema = Arc::new(Schema::new(vec![Field::new("a", DataType::Utf8, true)]));
+        let mut b = StringBuilder::new();
+        for i in 0..batch_size {
+            b.append_value(format!("{i}"));
+        }
+        let array = b.finish();
+        RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(array)]).unwrap()
+    }
+
     #[test]
     fn test_pmod() {
         let i: Vec<u32> = vec![0x99f0149d, 0x9c67b85d, 0xc8008529, 0xa05b5d7b, 0xcd1e64fb];
diff --git a/native/proto/src/proto/operator.proto b/native/proto/src/proto/operator.proto
index 74ec80cb54..5cb2802da8 100644
--- a/native/proto/src/proto/operator.proto
+++ b/native/proto/src/proto/operator.proto
@@ -82,10 +82,17 @@ message Limit {
   int32 offset = 2;
 }
 
+enum CompressionCodec {
+  None = 0;
+  Zstd = 1;
+}
+
 message ShuffleWriter {
   spark.spark_partitioning.Partitioning partitioning = 1;
   string output_data_file = 3;
   string output_index_file = 4;
+  CompressionCodec codec = 5;
+  int32 compression_level = 6;
 }
 
 enum AggregateMode {
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
index 0cd8a9ce67..3a11b8b28c 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala
@@ -52,8 +52,9 @@ import org.apache.spark.util.random.XORShiftRandom
 
 import com.google.common.base.Objects
 
+import org.apache.comet.CometConf
 import org.apache.comet.serde.{OperatorOuterClass, PartitioningOuterClass, QueryPlanSerde}
-import org.apache.comet.serde.OperatorOuterClass.Operator
+import org.apache.comet.serde.OperatorOuterClass.{CompressionCodec, Operator}
 import org.apache.comet.serde.QueryPlanSerde.serializeDataType
 import org.apache.comet.shims.ShimCometShuffleExchangeExec
 
@@ -553,6 +554,17 @@ class CometShuffleWriteProcessor(
       shuffleWriterBuilder.setOutputDataFile(dataFile)
       shuffleWriterBuilder.setOutputIndexFile(indexFile)
 
+      if (SparkEnv.get.conf.getBoolean("spark.shuffle.compress", true)) {
+        val codec = CometConf.COMET_EXEC_SHUFFLE_COMPRESSION_CODEC.get() match {
+          case "zstd" => CompressionCodec.Zstd
+          case other => throw new UnsupportedOperationException(s"invalid codec: $other")
+        }
+        shuffleWriterBuilder.setCodec(codec)
+      } else {
+        shuffleWriterBuilder.setCodec(CompressionCodec.None)
+      }
+      shuffleWriterBuilder.setCompressionLevel(CometConf.COMET_EXEC_SHUFFLE_COMPRESSION_LEVEL.get)
+
       outputPartitioning match {
         case _: HashPartitioning =>
           val hashPartitioning = outputPartitioning.asInstanceOf[HashPartitioning]
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleManager.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleManager.scala
index ef67167c4b..b2cc2c2bad 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleManager.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleManager.scala
@@ -243,7 +243,7 @@ object CometShuffleManager extends Logging {
 
   lazy val compressionCodecForShuffling: CompressionCodec = {
     val sparkConf = SparkEnv.get.conf
-    val codecName = CometConf.COMET_EXEC_SHUFFLE_CODEC.get(SQLConf.get)
+    val codecName = CometConf.COMET_EXEC_SHUFFLE_COMPRESSION_CODEC.get(SQLConf.get)
 
     // only zstd compression is supported at the moment
     if (codecName != "zstd") {

From 053b7ccc18c8397c7035a79b4df092beddf28289 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Sat, 21 Dec 2024 17:59:34 -0700
Subject: [PATCH 41/47] minor: move shuffle classes from common to spark
 (#1193)

---
 .../execution/shuffle/ArrowReaderIterator.scala |  0
 .../shuffle/CometBlockStoreShuffleReader.scala  | 17 ++++-------------
 .../shuffle/CometShuffleDependency.scala        |  0
 .../execution/shuffle/CometShuffledRowRDD.scala |  4 ++--
 .../shuffle/IpcInputStreamIterator.scala        |  9 +++------
 .../comet/execution/shuffle/ShuffleUtils.scala  |  0
 6 files changed, 9 insertions(+), 21 deletions(-)
 rename {common => spark}/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ArrowReaderIterator.scala (100%)
 rename {common => spark}/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometBlockStoreShuffleReader.scala (92%)
 rename {common => spark}/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleDependency.scala (100%)
 rename {common => spark}/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffledRowRDD.scala (95%)
 rename {common => spark}/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/IpcInputStreamIterator.scala (95%)
 rename {common => spark}/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ShuffleUtils.scala (100%)

diff --git a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ArrowReaderIterator.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ArrowReaderIterator.scala
similarity index 100%
rename from common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ArrowReaderIterator.scala
rename to spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ArrowReaderIterator.scala
diff --git a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometBlockStoreShuffleReader.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometBlockStoreShuffleReader.scala
similarity index 92%
rename from common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometBlockStoreShuffleReader.scala
rename to spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometBlockStoreShuffleReader.scala
index e026cbeb1a..74c6559504 100644
--- a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometBlockStoreShuffleReader.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometBlockStoreShuffleReader.scala
@@ -21,21 +21,12 @@ package org.apache.spark.sql.comet.execution.shuffle
 
 import java.io.InputStream
 
-import org.apache.spark.InterruptibleIterator
-import org.apache.spark.MapOutputTracker
-import org.apache.spark.SparkEnv
-import org.apache.spark.TaskContext
-import org.apache.spark.internal.Logging
-import org.apache.spark.internal.config
+import org.apache.spark.{InterruptibleIterator, MapOutputTracker, SparkEnv, TaskContext}
+import org.apache.spark.internal.{config, Logging}
 import org.apache.spark.io.CompressionCodec
 import org.apache.spark.serializer.SerializerManager
-import org.apache.spark.shuffle.BaseShuffleHandle
-import org.apache.spark.shuffle.ShuffleReader
-import org.apache.spark.shuffle.ShuffleReadMetricsReporter
-import org.apache.spark.storage.BlockId
-import org.apache.spark.storage.BlockManager
-import org.apache.spark.storage.BlockManagerId
-import org.apache.spark.storage.ShuffleBlockFetcherIterator
+import org.apache.spark.shuffle.{BaseShuffleHandle, ShuffleReader, ShuffleReadMetricsReporter}
+import org.apache.spark.storage.{BlockId, BlockManager, BlockManagerId, ShuffleBlockFetcherIterator}
 import org.apache.spark.util.CompletionIterator
 
 /**
diff --git a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleDependency.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleDependency.scala
similarity index 100%
rename from common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleDependency.scala
rename to spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleDependency.scala
diff --git a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffledRowRDD.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffledRowRDD.scala
similarity index 95%
rename from common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffledRowRDD.scala
rename to spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffledRowRDD.scala
index af78ed2905..ba6fc588e2 100644
--- a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffledRowRDD.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffledRowRDD.scala
@@ -19,10 +19,10 @@
 
 package org.apache.spark.sql.comet.execution.shuffle
 
-import org.apache.spark.{Dependency, MapOutputTrackerMaster, Partition, Partitioner, ShuffleDependency, SparkEnv, TaskContext}
+import org.apache.spark._
 import org.apache.spark.rdd.RDD
 import org.apache.spark.shuffle.sort.SortShuffleManager
-import org.apache.spark.sql.execution.{CoalescedMapperPartitionSpec, CoalescedPartitioner, CoalescedPartitionSpec, PartialMapperPartitionSpec, PartialReducerPartitionSpec, ShufflePartitionSpec}
+import org.apache.spark.sql.execution._
 import org.apache.spark.sql.execution.metric.{SQLMetric, SQLShuffleReadMetricsReporter}
 import org.apache.spark.sql.internal.SQLConf
 import org.apache.spark.sql.vectorized.ColumnarBatch
diff --git a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/IpcInputStreamIterator.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/IpcInputStreamIterator.scala
similarity index 95%
rename from common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/IpcInputStreamIterator.scala
rename to spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/IpcInputStreamIterator.scala
index d1d5af350f..aa40550488 100644
--- a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/IpcInputStreamIterator.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/IpcInputStreamIterator.scala
@@ -19,12 +19,9 @@
 
 package org.apache.spark.sql.comet.execution.shuffle
 
-import java.io.EOFException
-import java.io.InputStream
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-import java.nio.channels.Channels
-import java.nio.channels.ReadableByteChannel
+import java.io.{EOFException, InputStream}
+import java.nio.{ByteBuffer, ByteOrder}
+import java.nio.channels.{Channels, ReadableByteChannel}
 
 import org.apache.spark.TaskContext
 import org.apache.spark.internal.Logging
diff --git a/common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ShuffleUtils.scala b/spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ShuffleUtils.scala
similarity index 100%
rename from common/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ShuffleUtils.scala
rename to spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/ShuffleUtils.scala

From 639fa2fb450a760728bc6921ca58da64df0c64a7 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Sun, 22 Dec 2024 12:25:21 -0700
Subject: [PATCH 42/47] minor: refactor decodeBatches to make private in
 broadcast exchange (#1195)

---
 .../comet/CometBroadcastExchangeExec.scala    | 24 +++++++++++--
 .../apache/spark/sql/comet/operators.scala    | 35 ++-----------------
 .../apache/comet/exec/CometExecSuite.scala    | 33 -----------------
 3 files changed, 25 insertions(+), 67 deletions(-)

diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/CometBroadcastExchangeExec.scala b/spark/src/main/scala/org/apache/spark/sql/comet/CometBroadcastExchangeExec.scala
index ccf218cf6c..6bc519ab95 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/CometBroadcastExchangeExec.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/CometBroadcastExchangeExec.scala
@@ -19,6 +19,8 @@
 
 package org.apache.spark.sql.comet
 
+import java.io.DataInputStream
+import java.nio.channels.Channels
 import java.util.UUID
 import java.util.concurrent.{Future, TimeoutException, TimeUnit}
 
@@ -26,13 +28,15 @@ import scala.concurrent.{ExecutionContext, Promise}
 import scala.concurrent.duration.NANOSECONDS
 import scala.util.control.NonFatal
 
-import org.apache.spark.{broadcast, Partition, SparkContext, TaskContext}
+import org.apache.spark.{broadcast, Partition, SparkContext, SparkEnv, TaskContext}
 import org.apache.spark.comet.shims.ShimCometBroadcastExchangeExec
+import org.apache.spark.io.CompressionCodec
 import org.apache.spark.launcher.SparkLauncher
 import org.apache.spark.rdd.RDD
 import org.apache.spark.sql.catalyst.InternalRow
 import org.apache.spark.sql.catalyst.expressions.Attribute
 import org.apache.spark.sql.catalyst.plans.logical.Statistics
+import org.apache.spark.sql.comet.execution.shuffle.ArrowReaderIterator
 import org.apache.spark.sql.errors.QueryExecutionErrors
 import org.apache.spark.sql.execution.{ColumnarToRowExec, SparkPlan, SQLExecution}
 import org.apache.spark.sql.execution.adaptive.{AQEShuffleReadExec, ShuffleQueryStageExec}
@@ -299,7 +303,23 @@ class CometBatchRDD(
   override def compute(split: Partition, context: TaskContext): Iterator[ColumnarBatch] = {
     val partition = split.asInstanceOf[CometBatchPartition]
     partition.value.value.toIterator
-      .flatMap(CometExec.decodeBatches(_, this.getClass.getSimpleName))
+      .flatMap(decodeBatches(_, this.getClass.getSimpleName))
+  }
+
+  /**
+   * Decodes the byte arrays back to ColumnarBatchs and put them into buffer.
+   */
+  private def decodeBatches(bytes: ChunkedByteBuffer, source: String): Iterator[ColumnarBatch] = {
+    if (bytes.size == 0) {
+      return Iterator.empty
+    }
+
+    // use Spark's compression codec (LZ4 by default) and not Comet's compression
+    val codec = CompressionCodec.createCodec(SparkEnv.get.conf)
+    val cbbis = bytes.toInputStream()
+    val ins = new DataInputStream(codec.compressedInputStream(cbbis))
+    // batches are in Arrow IPC format
+    new ArrowReaderIterator(Channels.newChannel(ins), source)
   }
 }
 
diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala b/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala
index 77188312e4..c70f7464ec 100644
--- a/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala
+++ b/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala
@@ -19,14 +19,12 @@
 
 package org.apache.spark.sql.comet
 
-import java.io.{ByteArrayOutputStream, DataInputStream}
-import java.nio.channels.Channels
+import java.io.ByteArrayOutputStream
 
 import scala.collection.mutable
 import scala.collection.mutable.ArrayBuffer
 
-import org.apache.spark.{SparkEnv, TaskContext}
-import org.apache.spark.io.CompressionCodec
+import org.apache.spark.TaskContext
 import org.apache.spark.rdd.RDD
 import org.apache.spark.sql.catalyst.InternalRow
 import org.apache.spark.sql.catalyst.expressions.{Attribute, AttributeSet, Expression, NamedExpression, SortOrder}
@@ -34,7 +32,7 @@ import org.apache.spark.sql.catalyst.expressions.aggregate.{AggregateExpression,
 import org.apache.spark.sql.catalyst.optimizer.{BuildLeft, BuildRight, BuildSide}
 import org.apache.spark.sql.catalyst.plans._
 import org.apache.spark.sql.catalyst.plans.physical.{HashPartitioning, Partitioning, PartitioningCollection, UnknownPartitioning}
-import org.apache.spark.sql.comet.execution.shuffle.{ArrowReaderIterator, CometShuffleExchangeExec}
+import org.apache.spark.sql.comet.execution.shuffle.CometShuffleExchangeExec
 import org.apache.spark.sql.comet.plans.PartitioningPreservingUnaryExecNode
 import org.apache.spark.sql.comet.util.Utils
 import org.apache.spark.sql.execution.{BinaryExecNode, ColumnarToRowExec, ExecSubqueryExpression, ExplainUtils, LeafExecNode, ScalarSubquery, SparkPlan, UnaryExecNode}
@@ -78,18 +76,6 @@ abstract class CometExec extends CometPlan {
   // outputPartitioning of SparkPlan, e.g., AQEShuffleReadExec.
   override def outputPartitioning: Partitioning = originalPlan.outputPartitioning
 
-  /**
-   * Executes the Comet operator and returns the result as an iterator of ColumnarBatch.
-   */
-  def executeColumnarCollectIterator(): (Long, Iterator[ColumnarBatch]) = {
-    val countsAndBytes = CometExec.getByteArrayRdd(this).collect()
-    val total = countsAndBytes.map(_._1).sum
-    val rows = countsAndBytes.iterator
-      .flatMap(countAndBytes =>
-        CometExec.decodeBatches(countAndBytes._2, this.getClass.getSimpleName))
-    (total, rows)
-  }
-
   protected def setSubqueries(planId: Long, sparkPlan: SparkPlan): Unit = {
     sparkPlan.children.foreach(setSubqueries(planId, _))
 
@@ -161,21 +147,6 @@ object CometExec {
       Utils.serializeBatches(iter)
     }
   }
-
-  /**
-   * Decodes the byte arrays back to ColumnarBatchs and put them into buffer.
-   */
-  def decodeBatches(bytes: ChunkedByteBuffer, source: String): Iterator[ColumnarBatch] = {
-    if (bytes.size == 0) {
-      return Iterator.empty
-    }
-
-    val codec = CompressionCodec.createCodec(SparkEnv.get.conf)
-    val cbbis = bytes.toInputStream()
-    val ins = new DataInputStream(codec.compressedInputStream(cbbis))
-
-    new ArrowReaderIterator(Channels.newChannel(ins), source)
-  }
 }
 
 /**
diff --git a/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala b/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala
index 1027695372..90c3221e5d 100644
--- a/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/exec/CometExecSuite.scala
@@ -22,8 +22,6 @@ package org.apache.comet.exec
 import java.sql.Date
 import java.time.{Duration, Period}
 
-import scala.collection.JavaConverters._
-import scala.collection.mutable
 import scala.util.Random
 
 import org.scalactic.source.Position
@@ -462,37 +460,6 @@ class CometExecSuite extends CometTestBase {
     }
   }
 
-  test("CometExec.executeColumnarCollectIterator can collect ColumnarBatch results") {
-    assume(isSpark34Plus, "ChunkedByteBuffer is not serializable before Spark 3.4+")
-    withSQLConf(CometConf.COMET_EXEC_ENABLED.key -> "true") {
-      withParquetTable((0 until 50).map(i => (i, i + 1)), "tbl") {
-        val df = sql("SELECT _1 + 1, _2 + 2 FROM tbl WHERE _1 > 3")
-
-        val nativeProject = find(df.queryExecution.executedPlan) {
-          case _: CometProjectExec => true
-          case _ => false
-        }.get.asInstanceOf[CometProjectExec]
-
-        val (rows, batches) = nativeProject.executeColumnarCollectIterator()
-        assert(rows == 46)
-
-        val column1 = mutable.ArrayBuffer.empty[Int]
-        val column2 = mutable.ArrayBuffer.empty[Int]
-
-        batches.foreach(batch => {
-          batch.rowIterator().asScala.foreach { row =>
-            assert(row.numFields == 2)
-            column1 += row.getInt(0)
-            column2 += row.getInt(1)
-          }
-        })
-
-        assert(column1.toArray.sorted === (4 until 50).map(_ + 1).toArray)
-        assert(column2.toArray.sorted === (5 until 51).map(_ + 2).toArray)
-      }
-    }
-  }
-
   test("scalar subquery") {
     val dataTypes =
       Seq(

From 58dee739b6b8c3e7c6057e01c72307cdcff56ada Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Sun, 22 Dec 2024 12:25:35 -0700
Subject: [PATCH 43/47] minor: refactor prepare_output so that it does not
 require an ExecutionContext (#1194)

---
 native/core/src/execution/jni_api.rs | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/native/core/src/execution/jni_api.rs b/native/core/src/execution/jni_api.rs
index eb73675b5b..2c1a55f48f 100644
--- a/native/core/src/execution/jni_api.rs
+++ b/native/core/src/execution/jni_api.rs
@@ -231,7 +231,7 @@ fn prepare_output(
     array_addrs: jlongArray,
     schema_addrs: jlongArray,
     output_batch: RecordBatch,
-    exec_context: &mut ExecutionContext,
+    validate: bool,
 ) -> CometResult<jlong> {
     let array_address_array = unsafe { JLongArray::from_raw(array_addrs) };
     let num_cols = env.get_array_length(&array_address_array)? as usize;
@@ -255,7 +255,7 @@ fn prepare_output(
         )));
     }
 
-    if exec_context.debug_native {
+    if validate {
         // Validate the output arrays.
         for array in results.iter() {
             let array_data = array.to_data();
@@ -275,9 +275,6 @@ fn prepare_output(
         i += 1;
     }
 
-    // Update metrics
-    update_metrics(env, exec_context)?;
-
     Ok(num_rows as jlong)
 }
 
@@ -356,22 +353,22 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_executePlan(
             let next_item = exec_context.stream.as_mut().unwrap().next();
             let poll_output = exec_context.runtime.block_on(async { poll!(next_item) });
 
+            // Update metrics
+            update_metrics(&mut env, exec_context)?;
+
             match poll_output {
                 Poll::Ready(Some(output)) => {
+                    // prepare output for FFI transfer
                     return prepare_output(
                         &mut env,
                         array_addrs,
                         schema_addrs,
                         output?,
-                        exec_context,
+                        exec_context.debug_native,
                     );
                 }
                 Poll::Ready(None) => {
                     // Reaches EOF of output.
-
-                    // Update metrics
-                    update_metrics(&mut env, exec_context)?;
-
                     if exec_context.explain_native {
                         if let Some(plan) = &exec_context.root_op {
                             let formatted_plan_str =
@@ -391,9 +388,6 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_executePlan(
                 // A poll pending means there are more than one blocking operators,
                 // we don't need go back-forth between JVM/Native. Just keeping polling.
                 Poll::Pending => {
-                    // Update metrics
-                    update_metrics(&mut env, exec_context)?;
-
                     // Pull input batches
                     pull_input_batches(exec_context)?;
 

From 5432e03e4c441257056638dca70f576e1e4c186b Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Fri, 27 Dec 2024 08:43:53 +0200
Subject: [PATCH 44/47] fix: fix missing explanation for then branch in case
 when (#1200)

---
 .../src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
index b33f6b5a6b..518fa06858 100644
--- a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
+++ b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
@@ -1745,7 +1745,7 @@ object QueryPlanSerde extends Logging with ShimQueryPlanSerde with CometExprShim
             exprToProtoInternal(elements._1, inputs)
           })
           val thenSeq = branches.map(elements => {
-            allBranches = allBranches :+ elements._1
+            allBranches = allBranches :+ elements._2
             exprToProtoInternal(elements._2, inputs)
           })
           assert(whenSeq.length == thenSeq.length)

From 103f82f5491a48d8f0dbcb697741270d7fe268b8 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Fri, 27 Dec 2024 22:54:17 -0700
Subject: [PATCH 45/47] minor: remove unused source files (#1202)

---
 native/Cargo.lock                          |  48 +---
 native/core/Cargo.toml                     |   4 -
 native/core/src/parquet/compression.rs     | 319 ---------------------
 native/core/src/parquet/util/jni_buffer.rs |  98 -------
 4 files changed, 2 insertions(+), 467 deletions(-)
 delete mode 100644 native/core/src/parquet/compression.rs
 delete mode 100644 native/core/src/parquet/util/jni_buffer.rs

diff --git a/native/Cargo.lock b/native/Cargo.lock
index 538c40ee23..ad572acb9e 100644
--- a/native/Cargo.lock
+++ b/native/Cargo.lock
@@ -428,17 +428,6 @@ dependencies = [
  "generic-array",
 ]
 
-[[package]]
-name = "brotli"
-version = "3.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d640d25bc63c50fb1f0b545ffd80207d2e10a4c965530809b40ba3386825c391"
-dependencies = [
- "alloc-no-stdlib",
- "alloc-stdlib",
- "brotli-decompressor 2.5.1",
-]
-
 [[package]]
 name = "brotli"
 version = "7.0.0"
@@ -447,17 +436,7 @@ checksum = "cc97b8f16f944bba54f0433f07e30be199b6dc2bd25937444bbad560bcea29bd"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
- "brotli-decompressor 4.0.1",
-]
-
-[[package]]
-name = "brotli-decompressor"
-version = "2.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e2e4afe60d7dd600fdd3de8d0f08c2b7ec039712e3b6137ff98b7004e82de4f"
-dependencies = [
- "alloc-no-stdlib",
- "alloc-stdlib",
+ "brotli-decompressor",
 ]
 
 [[package]]
@@ -900,7 +879,6 @@ dependencies = [
  "arrow-schema",
  "assertables",
  "async-trait",
- "brotli 3.5.0",
  "bytes",
  "crc32fast",
  "criterion",
@@ -912,7 +890,6 @@ dependencies = [
  "datafusion-expr",
  "datafusion-functions-nested",
  "datafusion-physical-expr",
- "flate2",
  "futures",
  "hex",
  "itertools 0.11.0",
@@ -920,7 +897,6 @@ dependencies = [
  "lazy_static",
  "log",
  "log4rs",
- "lz4",
  "mimalloc",
  "num",
  "once_cell",
@@ -932,7 +908,6 @@ dependencies = [
  "regex",
  "serde",
  "simd-adler32",
- "snap",
  "tempfile",
  "thiserror",
  "tokio",
@@ -2111,25 +2086,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "lz4"
-version = "1.28.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d1febb2b4a79ddd1980eede06a8f7902197960aa0383ffcfdd62fe723036725"
-dependencies = [
- "lz4-sys",
-]
-
-[[package]]
-name = "lz4-sys"
-version = "1.11.1+lz4-1.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bd8c0d6c6ed0cd30b3652886bb8711dc4bb01d637a68105a3d5158039b418e6"
-dependencies = [
- "cc",
- "libc",
-]
-
 [[package]]
 name = "lz4_flex"
 version = "0.11.3"
@@ -2382,7 +2338,7 @@ dependencies = [
  "arrow-schema",
  "arrow-select",
  "base64",
- "brotli 7.0.0",
+ "brotli",
  "bytes",
  "chrono",
  "flate2",
diff --git a/native/core/Cargo.toml b/native/core/Cargo.toml
index 489da46d47..5089e67a03 100644
--- a/native/core/Cargo.toml
+++ b/native/core/Cargo.toml
@@ -52,10 +52,6 @@ serde = { version = "1", features = ["derive"] }
 lazy_static = "1.4.0"
 prost = "0.12.1"
 jni = "0.21"
-snap = "1.1"
-brotli = "3.3"
-flate2 = "1.0"
-lz4 = "1.24"
 zstd = "0.11"
 rand = { workspace = true}
 num = { workspace = true }
diff --git a/native/core/src/parquet/compression.rs b/native/core/src/parquet/compression.rs
deleted file mode 100644
index 37b857f4a2..0000000000
--- a/native/core/src/parquet/compression.rs
+++ /dev/null
@@ -1,319 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-//! Contains codec interface and supported codec implementations.
-//!
-//! See [`Compression`](crate::basic::Compression) enum for all available compression
-//! algorithms.
-//!
-//! # Example
-//!
-//! ```no_run
-//! use comet::parquet::{basic::Compression, compression::create_codec};
-//!
-//! let mut codec = match create_codec(Compression::SNAPPY) {
-//!     Ok(Some(codec)) => codec,
-//!     _ => panic!(),
-//! };
-//!
-//! let data = vec![b'p', b'a', b'r', b'q', b'u', b'e', b't'];
-//! let mut compressed = vec![];
-//! codec.compress(&data[..], &mut compressed).unwrap();
-//!
-//! let mut output = vec![];
-//! codec.decompress(&compressed[..], &mut output).unwrap();
-//!
-//! assert_eq!(output, data);
-//! ```
-
-use super::basic::Compression as CodecType;
-use crate::errors::{ParquetError, ParquetResult as Result};
-
-use brotli::Decompressor;
-use flate2::{read, write, Compression};
-use snap::raw::{decompress_len, max_compress_len, Decoder, Encoder};
-use std::io::{copy, Read, Write};
-
-/// Parquet compression codec interface.
-#[allow(clippy::ptr_arg)]
-pub trait Codec {
-    /// Compresses data stored in slice `input_buf` and writes the compressed result
-    /// to `output_buf`.
-    /// Note that you'll need to call `clear()` before reusing the same `output_buf`
-    /// across different `compress` calls.
-    fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()>;
-
-    /// Decompresses data stored in slice `input_buf` and writes output to `output_buf`.
-    /// Returns the total number of bytes written.
-    fn decompress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<usize>;
-}
-
-/// Given the compression type `codec`, returns a codec used to compress and decompress
-/// bytes for the compression type.
-/// This returns `None` if the codec type is `UNCOMPRESSED`.
-pub fn create_codec(codec: CodecType) -> Result<Option<Box<dyn Codec>>> {
-    match codec {
-        CodecType::BROTLI => Ok(Some(Box::new(BrotliCodec::new()))),
-        CodecType::GZIP => Ok(Some(Box::new(GZipCodec::new()))),
-        CodecType::SNAPPY => Ok(Some(Box::new(SnappyCodec::new()))),
-        CodecType::LZ4 => Ok(Some(Box::new(LZ4Codec::new()))),
-        CodecType::ZSTD => Ok(Some(Box::new(ZSTDCodec::new()))),
-        CodecType::UNCOMPRESSED => Ok(None),
-        _ => Err(nyi_err!("The codec type {} is not supported yet", codec)),
-    }
-}
-
-/// Codec for Snappy compression format.
-pub struct SnappyCodec {
-    decoder: Decoder,
-    encoder: Encoder,
-}
-
-impl SnappyCodec {
-    /// Creates new Snappy compression codec.
-    pub(crate) fn new() -> Self {
-        Self {
-            decoder: Decoder::new(),
-            encoder: Encoder::new(),
-        }
-    }
-}
-
-impl Codec for SnappyCodec {
-    fn decompress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<usize> {
-        let len = decompress_len(input_buf)?;
-        output_buf.resize(len, 0);
-        self.decoder
-            .decompress(input_buf, output_buf)
-            .map_err(|e| e.into())
-    }
-
-    fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()> {
-        let output_buf_len = output_buf.len();
-        let required_len = max_compress_len(input_buf.len());
-        output_buf.resize(output_buf_len + required_len, 0);
-        let n = self
-            .encoder
-            .compress(input_buf, &mut output_buf[output_buf_len..])?;
-        output_buf.truncate(output_buf_len + n);
-        Ok(())
-    }
-}
-
-/// Codec for GZIP compression algorithm.
-pub struct GZipCodec {}
-
-impl GZipCodec {
-    /// Creates new GZIP compression codec.
-    pub(crate) fn new() -> Self {
-        Self {}
-    }
-}
-
-impl Codec for GZipCodec {
-    fn decompress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<usize> {
-        let mut decoder = read::GzDecoder::new(input_buf);
-        decoder.read_to_end(output_buf).map_err(|e| e.into())
-    }
-
-    fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()> {
-        let mut encoder = write::GzEncoder::new(output_buf, Compression::default());
-        encoder.write_all(input_buf)?;
-        encoder.try_finish().map_err(|e| e.into())
-    }
-}
-
-const BROTLI_DEFAULT_BUFFER_SIZE: usize = 4096;
-const BROTLI_DEFAULT_COMPRESSION_QUALITY: u32 = 1; // supported levels 0-9
-const BROTLI_DEFAULT_LG_WINDOW_SIZE: u32 = 22; // recommended between 20-22
-
-/// Codec for Brotli compression algorithm.
-pub struct BrotliCodec {}
-
-impl BrotliCodec {
-    /// Creates new Brotli compression codec.
-    pub(crate) fn new() -> Self {
-        Self {}
-    }
-}
-
-impl Codec for BrotliCodec {
-    fn decompress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<usize> {
-        Decompressor::new(input_buf, BROTLI_DEFAULT_BUFFER_SIZE)
-            .read_to_end(output_buf)
-            .map_err(|e| e.into())
-    }
-
-    fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()> {
-        let mut encoder = brotli::CompressorWriter::new(
-            output_buf,
-            BROTLI_DEFAULT_BUFFER_SIZE,
-            BROTLI_DEFAULT_COMPRESSION_QUALITY,
-            BROTLI_DEFAULT_LG_WINDOW_SIZE,
-        );
-        encoder.write_all(input_buf)?;
-        encoder.flush().map_err(|e| e.into())
-    }
-}
-
-const LZ4_BUFFER_SIZE: usize = 4096;
-
-/// Codec for LZ4 compression algorithm.
-pub struct LZ4Codec {}
-
-impl LZ4Codec {
-    /// Creates new LZ4 compression codec.
-    pub(crate) fn new() -> Self {
-        Self {}
-    }
-}
-
-impl Codec for LZ4Codec {
-    fn decompress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<usize> {
-        let mut decoder = lz4::Decoder::new(input_buf)?;
-        let mut buffer: [u8; LZ4_BUFFER_SIZE] = [0; LZ4_BUFFER_SIZE];
-        let mut total_len = 0;
-        loop {
-            let len = decoder.read(&mut buffer)?;
-            if len == 0 {
-                break;
-            }
-            total_len += len;
-            output_buf.write_all(&buffer[0..len])?;
-        }
-        Ok(total_len)
-    }
-
-    fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()> {
-        let mut encoder = lz4::EncoderBuilder::new().build(output_buf)?;
-        let mut from = 0;
-        loop {
-            let to = std::cmp::min(from + LZ4_BUFFER_SIZE, input_buf.len());
-            encoder.write_all(&input_buf[from..to])?;
-            from += LZ4_BUFFER_SIZE;
-            if from >= input_buf.len() {
-                break;
-            }
-        }
-        encoder.finish().1.map_err(|e| e.into())
-    }
-}
-
-/// Codec for Zstandard compression algorithm.
-pub struct ZSTDCodec {}
-
-impl ZSTDCodec {
-    /// Creates new Zstandard compression codec.
-    pub(crate) fn new() -> Self {
-        Self {}
-    }
-}
-
-/// Compression level (1-21) for ZSTD. Choose 1 here for better compression speed.
-const ZSTD_COMPRESSION_LEVEL: i32 = 1;
-
-impl Codec for ZSTDCodec {
-    fn decompress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<usize> {
-        let mut decoder = zstd::Decoder::new(input_buf)?;
-        match copy(&mut decoder, output_buf) {
-            Ok(n) => Ok(n as usize),
-            Err(e) => Err(e.into()),
-        }
-    }
-
-    fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()> {
-        let mut encoder = zstd::Encoder::new(output_buf, ZSTD_COMPRESSION_LEVEL)?;
-        encoder.write_all(input_buf)?;
-        match encoder.finish() {
-            Ok(_) => Ok(()),
-            Err(e) => Err(e.into()),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use crate::parquet::util::test_common::*;
-
-    fn test_roundtrip(c: CodecType, data: &[u8]) {
-        let mut c1 = create_codec(c).unwrap().unwrap();
-        let mut c2 = create_codec(c).unwrap().unwrap();
-
-        // Compress with c1
-        let mut compressed = Vec::new();
-        let mut decompressed = Vec::new();
-        c1.compress(data, &mut compressed)
-            .expect("Error when compressing");
-
-        // Decompress with c2
-        let mut decompressed_size = c2
-            .decompress(compressed.as_slice(), &mut decompressed)
-            .expect("Error when decompressing");
-        assert_eq!(data.len(), decompressed_size);
-        decompressed.truncate(decompressed_size);
-        assert_eq!(data, decompressed.as_slice());
-
-        compressed.clear();
-
-        // Compress with c2
-        c2.compress(data, &mut compressed)
-            .expect("Error when compressing");
-
-        // Decompress with c1
-        decompressed_size = c1
-            .decompress(compressed.as_slice(), &mut decompressed)
-            .expect("Error when decompressing");
-        assert_eq!(data.len(), decompressed_size);
-        decompressed.truncate(decompressed_size);
-        assert_eq!(data, decompressed.as_slice());
-    }
-
-    fn test_codec(c: CodecType) {
-        let sizes = vec![100, 10000, 100000];
-        for size in sizes {
-            let data = random_bytes(size);
-            test_roundtrip(c, &data);
-        }
-    }
-
-    #[test]
-    fn test_codec_snappy() {
-        test_codec(CodecType::SNAPPY);
-    }
-
-    #[test]
-    fn test_codec_gzip() {
-        test_codec(CodecType::GZIP);
-    }
-
-    #[test]
-    fn test_codec_brotli() {
-        test_codec(CodecType::BROTLI);
-    }
-
-    #[test]
-    fn test_codec_lz4() {
-        test_codec(CodecType::LZ4);
-    }
-
-    #[test]
-    fn test_codec_zstd() {
-        test_codec(CodecType::ZSTD);
-    }
-}
diff --git a/native/core/src/parquet/util/jni_buffer.rs b/native/core/src/parquet/util/jni_buffer.rs
deleted file mode 100644
index 33f36ed9dd..0000000000
--- a/native/core/src/parquet/util/jni_buffer.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-use core::slice;
-use std::ptr::NonNull;
-
-use jni::{
-    objects::{ReleaseMode, TypeArray},
-    sys::{jbyte, jbyteArray, JNI_TRUE},
-    JavaVM,
-};
-
-use crate::errors::{CometError, CometResult as Result};
-
-use super::Buffer;
-
-/// An immutable byte buffer wrapping a JNI byte array allocated on heap.
-///
-/// Unlike `AutoArray`, this doesn't have a lifetime and can be used across different JNI calls.
-pub struct JniBuffer {
-    /// A pointer for the JVM instance, used to obtain byte array elements (via
-    /// `GetByteArrayElements`) and release byte array elements (via `ReleaseByteArrayElements`).
-    jvm: JavaVM,
-    /// The original JNI byte array that backs this buffer
-    inner: jbyteArray,
-    /// The raw pointer from the JNI byte array
-    ptr: NonNull<i8>,
-    /// Total number of bytes in the original array (i.e., `inner`).
-    len: usize,
-    /// Whether the JNI byte array is copied or not.
-    is_copy: bool,
-}
-
-impl JniBuffer {
-    pub fn try_new(jvm: JavaVM, array: jbyteArray, len: usize) -> Result<Self> {
-        let env = jvm.get_env()?;
-        let mut is_copy = 0xff;
-        let ptr = jbyte::get(&env, array.into(), &mut is_copy)?;
-        let res = Self {
-            jvm,
-            inner: array,
-            ptr: NonNull::new(ptr)
-                .ok_or_else(|| CometError::NullPointer("null byte array pointer".to_string()))?,
-            len,
-            is_copy: is_copy == JNI_TRUE,
-        };
-        Ok(res)
-    }
-
-    /// Whether the JNI byte array is copied or not, i.e., whether the JVM pinned down the original
-    /// Java byte array, or made a new copy of it.
-    pub fn is_copy(&self) -> bool {
-        self.is_copy
-    }
-}
-
-impl Buffer for JniBuffer {
-    fn len(&self) -> usize {
-        self.len
-    }
-
-    fn data(&self) -> &[u8] {
-        self.as_ref()
-    }
-}
-
-impl AsRef<[u8]> for JniBuffer {
-    fn as_ref(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.ptr.as_ptr() as *mut u8 as *const u8, self.len) }
-    }
-}
-
-impl Drop for JniBuffer {
-    fn drop(&mut self) {
-        let env = self.jvm.get_env().unwrap(); // TODO: log error here
-        jbyte::release(
-            &env,
-            self.inner.into(),
-            self.ptr,
-            ReleaseMode::NoCopyBack as i32, // don't copy back since it's read-only here
-        )
-        .unwrap();
-    }
-}

From 5d2c909f59caf90348096511d4a26e48a0ae8e3d Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Sat, 28 Dec 2024 15:14:11 -0700
Subject: [PATCH 46/47] chore: Upgrade to DataFusion 44.0.0-rc2 (#1154)

* move aggregate expressions to spark-expr crate

* move more expressions

* move benchmark

* normalize_nan

* bitwise not

* comet scalar funcs

* update bench imports

* save

* save

* save

* remove unused imports

* clippy

* implement more hashers

* implement Hash and PartialEq

* implement Hash and PartialEq

* implement Hash and PartialEq

* benches

* fix ScalarUDFImpl.return_type failure

* exclude test from miri

* ignore correct test

* ignore another test

* remove miri checks

* use return_type_from_exprs

* Revert "use return_type_from_exprs"

This reverts commit febc1f1ec1301f9b359fc23ad6a117224fce35b7.

* use DF main branch

* hacky workaround for regression in ScalarUDFImpl.return_type

* fix repo url

* pin to revision

* bump to latest rev

* bump to latest DF rev

* bump DF to rev 9f530dd

* add Cargo.lock

* bump DF version

* no default features

* Revert "remove miri checks"

This reverts commit 4638fe3aa5501966cd5d8b53acf26c698b10b3c9.

* Update pin to DataFusion e99e02b9b9093ceb0c13a2dd32a2a89beba47930

* update pin

* Update Cargo.toml

Bump to 44.0.0-rc2

* update cargo lock

* revert miri change

---------

Co-authored-by: Andrew Lamb <andrew@nerdnetworks.org>
---
 native/Cargo.lock                             | 598 +++++++++---------
 native/Cargo.toml                             |  29 +-
 .../expressions/bloom_filter_might_contain.rs |  46 +-
 .../src/execution/expressions/subquery.rs     |  23 +-
 native/core/src/execution/jni_api.rs          |   9 +-
 native/core/src/execution/operators/copy.rs   |   4 +-
 native/core/src/execution/operators/expand.rs |   6 +-
 native/core/src/execution/operators/filter.rs |   3 +-
 native/core/src/execution/operators/scan.rs   |   4 +-
 native/core/src/execution/planner.rs          |  55 +-
 .../src/execution/shuffle/shuffle_writer.rs   |   6 +-
 .../src/execution/util/spark_bit_array.rs     |   2 +-
 .../src/execution/util/spark_bloom_filter.rs  |   2 +-
 native/spark-expr/Cargo.toml                  |   1 +
 native/spark-expr/benches/aggregate.rs        |   3 +-
 native/spark-expr/src/avg.rs                  |  22 +-
 native/spark-expr/src/avg_decimal.rs          |  20 +-
 native/spark-expr/src/bitwise_not.rs          |  38 +-
 native/spark-expr/src/cast.rs                 |  42 +-
 native/spark-expr/src/checkoverflow.rs        |  53 +-
 native/spark-expr/src/correlation.rs          |  29 +-
 native/spark-expr/src/covariance.rs           |  26 +-
 native/spark-expr/src/if_expr.rs              |  49 +-
 native/spark-expr/src/list.rs                 | 127 ++--
 native/spark-expr/src/negative.rs             |  37 +-
 native/spark-expr/src/normalize_nan.rs        |  45 +-
 native/spark-expr/src/regexp.rs               |  27 +-
 native/spark-expr/src/stddev.rs               |  30 +-
 native/spark-expr/src/strings.rs              |  89 ++-
 native/spark-expr/src/structs.rs              |  59 +-
 native/spark-expr/src/sum_decimal.rs          |  28 +-
 native/spark-expr/src/temporal.rs             | 175 +++--
 native/spark-expr/src/to_json.rs              |  23 +-
 native/spark-expr/src/unbound.rs              |  21 +-
 native/spark-expr/src/variance.rs             |  19 +-
 35 files changed, 715 insertions(+), 1035 deletions(-)

diff --git a/native/Cargo.lock b/native/Cargo.lock
index ad572acb9e..bbc0ff97a9 100644
--- a/native/Cargo.lock
+++ b/native/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "addr2line"
@@ -57,9 +57,9 @@ dependencies = [
 
 [[package]]
 name = "allocator-api2"
-version = "0.2.20"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45862d1c77f2228b9e10bc609d5bc203d86ebc9b87ad8d5d5167a6c9abf739d9"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
 [[package]]
 name = "android-tzdata"
@@ -90,9 +90,9 @@ checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
 
 [[package]]
 name = "anyhow"
-version = "1.0.93"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c95c10ba0b00a02636238b814946408b1322d5ac4760326e6fb8ec956d85775"
+checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
 
 [[package]]
 name = "arc-swap"
@@ -114,9 +114,9 @@ checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "arrow"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4caf25cdc4a985f91df42ed9e9308e1adbcd341a31a72605c697033fcef163e3"
+checksum = "c91839b07e474b3995035fd8ac33ee54f9c9ccbbb1ea33d9909c71bffdf1259d"
 dependencies = [
  "arrow-arith",
  "arrow-array",
@@ -135,9 +135,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-arith"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91f2dfd1a7ec0aca967dfaa616096aec49779adc8eccec005e2f5e4111b1192a"
+checksum = "855c57c4efd26722b044dcd3e348252560e3e0333087fb9f6479dc0bf744054f"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -150,9 +150,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-array"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d39387ca628be747394890a6e47f138ceac1aa912eab64f02519fed24b637af8"
+checksum = "bd03279cea46569acf9295f6224fbc370c5df184b4d2ecfe97ccb131d5615a7f"
 dependencies = [
  "ahash",
  "arrow-buffer",
@@ -161,15 +161,15 @@ dependencies = [
  "chrono",
  "chrono-tz 0.10.0",
  "half",
- "hashbrown 0.14.5",
+ "hashbrown 0.15.2",
  "num",
 ]
 
 [[package]]
 name = "arrow-buffer"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e51e05228852ffe3eb391ce7178a0f97d2cf80cc6ef91d3c4a6b3cb688049ec"
+checksum = "9e4a9b9b1d6d7117f6138e13bc4dd5daa7f94e671b70e8c9c4dc37b4f5ecfc16"
 dependencies = [
  "bytes",
  "half",
@@ -178,9 +178,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-cast"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d09aea56ec9fa267f3f3f6cdab67d8a9974cbba90b3aa38c8fe9d0bb071bd8c1"
+checksum = "bc70e39916e60c5b7af7a8e2719e3ae589326039e1e863675a008bee5ffe90fd"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -199,9 +199,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-csv"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c07b5232be87d115fde73e32f2ca7f1b353bff1b44ac422d3c6fc6ae38f11f0d"
+checksum = "789b2af43c1049b03a8d088ff6b2257cdcea1756cd76b174b1f2600356771b97"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -218,9 +218,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-data"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b98ae0af50890b494cebd7d6b04b35e896205c1d1df7b29a6272c5d0d0249ef5"
+checksum = "e4e75edf21ffd53744a9b8e3ed11101f610e7ceb1a29860432824f1834a1f623"
 dependencies = [
  "arrow-buffer",
  "arrow-schema",
@@ -230,9 +230,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-ipc"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ed91bdeaff5a1c00d28d8f73466bcb64d32bbd7093b5a30156b4b9f4dba3eee"
+checksum = "d186a909dece9160bf8312f5124d797884f608ef5435a36d9d608e0b2a9bcbf8"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -245,9 +245,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-json"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0471f51260a5309307e5d409c9dc70aede1cd9cf1d4ff0f0a1e8e1a2dd0e0d3c"
+checksum = "b66ff2fedc1222942d0bd2fd391cb14a85baa3857be95c9373179bd616753b85"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -265,9 +265,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-ord"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2883d7035e0b600fb4c30ce1e50e66e53d8656aa729f2bfa4b51d359cf3ded52"
+checksum = "ece7b5bc1180e6d82d1a60e1688c199829e8842e38497563c3ab6ea813e527fd"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -280,9 +280,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-row"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "552907e8e587a6fde4f8843fd7a27a576a260f65dab6c065741ea79f633fc5be"
+checksum = "745c114c8f0e8ce211c83389270de6fbe96a9088a7b32c2a041258a443fe83ff"
 dependencies = [
  "ahash",
  "arrow-array",
@@ -294,18 +294,18 @@ dependencies = [
 
 [[package]]
 name = "arrow-schema"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "539ada65246b949bd99ffa0881a9a15a4a529448af1a07a9838dd78617dafab1"
+checksum = "b95513080e728e4cec37f1ff5af4f12c9688d47795d17cda80b6ec2cf74d4678"
 dependencies = [
  "bitflags 2.6.0",
 ]
 
 [[package]]
 name = "arrow-select"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6259e566b752da6dceab91766ed8b2e67bf6270eb9ad8a6e07a33c1bede2b125"
+checksum = "8e415279094ea70323c032c6e739c48ad8d80e78a09bef7117b8718ad5bf3722"
 dependencies = [
  "ahash",
  "arrow-array",
@@ -317,9 +317,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-string"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3179ccbd18ebf04277a095ba7321b93fd1f774f18816bd5f6b3ce2f594edb6c"
+checksum = "11d956cae7002eb8d83a27dbd34daaea1cf5b75852f0b84deb4d93a276e92bbf"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -346,7 +346,7 @@ checksum = "721cae7de5c34fbb2acd27e21e6d2cf7b886dce0c27388d46c4e6c47ea4318dd"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
@@ -385,6 +385,19 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "bigdecimal"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f31f3af01c5c65a07985c804d3366560e6fa7883d640a122819b14ec327482c"
+dependencies = [
+ "autocfg",
+ "libm",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -408,9 +421,9 @@ dependencies = [
 
 [[package]]
 name = "blake3"
-version = "1.5.4"
+version = "1.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d82033247fd8e890df8f740e407ad4d038debb9eb1f40533fffb32e7d17dc6f7"
+checksum = "b8ee0c1824c4dea5b5f81736aff91bae041d2c07ee1192bec91054e10e3e601e"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -457,9 +470,9 @@ checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
 
 [[package]]
 name = "bytemuck"
-version = "1.19.0"
+version = "1.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8334215b81e418a0a7bdb8ef0849474f40bb10c8b71f1c4ed315cff49f32494d"
+checksum = "ef657dfab802224e671f5818e9a4935f9b1957ed18e58292690cc39e7a4092a3"
 
 [[package]]
 name = "byteorder"
@@ -469,9 +482,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.8.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ac0150caa2ae65ca5bd83f25c7de183dea78d4d366469f148435e2acfbad0da"
+checksum = "325918d6fe32f23b19878fe4b34794ae41fc19ddbe53b10571a4874d44ffd39b"
 
 [[package]]
 name = "cast"
@@ -481,9 +494,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.1"
+version = "1.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd9de9f2205d5ef3fd67e685b0df337994ddd4495e2a28d185500d0e1edfea47"
+checksum = "8d6dbb628b8f8555f86d0323c2eb39e3ec81901f4b83e091db8a6a76d316a333"
 dependencies = [
  "jobserver",
  "libc",
@@ -504,9 +517,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.38"
+version = "0.4.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "7e36cc9d416881d2e24f9a963be5fb1cd90966419ac844274161d10488b3e825"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
@@ -586,18 +599,18 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.21"
+version = "4.5.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb3b4b9e5a7c7514dfa52869339ee98b3156b0bfb4e8a77c4ff4babb64b1604f"
+checksum = "3135e7ec2ef7b10c6ed8950f0f792ed96ee093fa088608f1c76e569722700c84"
 dependencies = [
  "clap_builder",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.5.21"
+version = "4.5.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b17a95aa67cc7b5ebd32aa5370189aa0d79069ef1c64ce893bd30fb24bff20ec"
+checksum = "30582fc632330df2bd26877bde0c1f4470d57c582bbc070376afcd04d8cb4838"
 dependencies = [
  "anstyle",
  "clap_lex",
@@ -605,9 +618,9 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afb84c814227b90d6895e01398aee0d8033c00e7466aca416fb6a8e0eb19d8a7"
+checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
 
 [[package]]
 name = "combine"
@@ -673,9 +686,9 @@ dependencies = [
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ca741a962e1b0bff6d724a1a0958b686406e853bb14061f218562e1896f95e6"
+checksum = "16b80225097f2e5ae4e7179dd2266824648f3e2f49d9134d584b76389d31c4c3"
 dependencies = [
  "libc",
 ]
@@ -729,9 +742,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -748,9 +761,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.20"
+version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "crunchy"
@@ -805,11 +818,9 @@ dependencies = [
 
 [[package]]
 name = "datafusion"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbba0799cf6913b456ed07a94f0f3b6e12c62a5d88b10809e2284a0f2b915c05"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
- "ahash",
  "arrow",
  "arrow-array",
  "arrow-ipc",
@@ -825,6 +836,7 @@ dependencies = [
  "datafusion-expr",
  "datafusion-functions",
  "datafusion-functions-aggregate",
+ "datafusion-functions-table",
  "datafusion-functions-window",
  "datafusion-optimizer",
  "datafusion-physical-expr",
@@ -834,18 +846,13 @@ dependencies = [
  "datafusion-sql",
  "futures",
  "glob",
- "half",
- "hashbrown 0.14.5",
- "indexmap",
  "itertools 0.13.0",
  "log",
- "num_cpus",
  "object_store",
  "parking_lot",
  "parquet",
- "paste",
- "pin-project-lite",
  "rand",
+ "regex",
  "sqlparser",
  "tempfile",
  "tokio",
@@ -855,9 +862,8 @@ dependencies = [
 
 [[package]]
 name = "datafusion-catalog"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7493c5c2d40eec435b13d92e5703554f4efc7059451fcb8d3a79580ff0e45560"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "arrow-schema",
  "async-trait",
@@ -937,6 +943,7 @@ dependencies = [
  "datafusion",
  "datafusion-common",
  "datafusion-expr",
+ "datafusion-expr-common",
  "datafusion-physical-expr",
  "futures",
  "num",
@@ -945,57 +952,56 @@ dependencies = [
  "regex",
  "thiserror",
  "tokio",
- "twox-hash 2.0.1",
+ "twox-hash 2.1.0",
 ]
 
 [[package]]
 name = "datafusion-common"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24953049ebbd6f8964f91f60aa3514e121b5e81e068e33b60e77815ab369b25c"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "ahash",
  "arrow",
  "arrow-array",
  "arrow-buffer",
  "arrow-schema",
- "chrono",
  "half",
  "hashbrown 0.14.5",
  "indexmap",
- "instant",
  "libc",
- "num_cpus",
+ "log",
  "object_store",
  "parquet",
  "paste",
  "sqlparser",
  "tokio",
+ "web-time",
 ]
 
 [[package]]
 name = "datafusion-common-runtime"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f06df4ef76872e11c924d3c814fd2a8dd09905ed2e2195f71c857d78abd19685"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "log",
  "tokio",
 ]
 
+[[package]]
+name = "datafusion-doc"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
+
 [[package]]
 name = "datafusion-execution"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bbdcb628d690f3ce5fea7de81642b514486d58ff9779a51f180a69a4eadb361"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "arrow",
- "chrono",
  "dashmap",
  "datafusion-common",
  "datafusion-expr",
  "futures",
- "hashbrown 0.14.5",
  "log",
  "object_store",
  "parking_lot",
@@ -1006,16 +1012,13 @@ dependencies = [
 
 [[package]]
 name = "datafusion-expr"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8036495980e3131f706b7d33ab00b4492d73dc714e3cb74d11b50f9602a73246"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
- "ahash",
  "arrow",
- "arrow-array",
- "arrow-buffer",
  "chrono",
  "datafusion-common",
+ "datafusion-doc",
  "datafusion-expr-common",
  "datafusion-functions-aggregate-common",
  "datafusion-functions-window-common",
@@ -1024,27 +1027,22 @@ dependencies = [
  "paste",
  "serde_json",
  "sqlparser",
- "strum",
- "strum_macros",
 ]
 
 [[package]]
 name = "datafusion-expr-common"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4da0f3cb4669f9523b403d6b5a0ec85023e0ab3bf0183afd1517475b3e64fdd2"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "arrow",
  "datafusion-common",
  "itertools 0.13.0",
- "paste",
 ]
 
 [[package]]
 name = "datafusion-functions"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f52c4012648b34853e40a2c6bcaa8772f837831019b68aca384fb38436dba162"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "arrow",
  "arrow-buffer",
@@ -1053,8 +1051,11 @@ dependencies = [
  "blake3",
  "chrono",
  "datafusion-common",
+ "datafusion-doc",
  "datafusion-execution",
  "datafusion-expr",
+ "datafusion-expr-common",
+ "datafusion-macros",
  "hashbrown 0.14.5",
  "hex",
  "itertools 0.13.0",
@@ -1069,44 +1070,41 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-aggregate"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5b8bb624597ba28ed7446df4a9bd7c7a7bde7c578b6b527da3f47371d5f6741"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "ahash",
  "arrow",
  "arrow-schema",
  "datafusion-common",
+ "datafusion-doc",
  "datafusion-execution",
  "datafusion-expr",
  "datafusion-functions-aggregate-common",
+ "datafusion-macros",
  "datafusion-physical-expr",
  "datafusion-physical-expr-common",
  "half",
- "indexmap",
  "log",
  "paste",
 ]
 
 [[package]]
 name = "datafusion-functions-aggregate-common"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb06208fc470bc8cf1ce2d9a1159d42db591f2c7264a8c1776b53ad8f675143"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "ahash",
  "arrow",
  "datafusion-common",
  "datafusion-expr-common",
  "datafusion-physical-expr-common",
- "rand",
 ]
 
 [[package]]
 name = "datafusion-functions-nested"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fca25bbb87323716d05e54114666e942172ccca23c5a507e9c7851db6e965317"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "arrow",
  "arrow-array",
@@ -1122,18 +1120,33 @@ dependencies = [
  "itertools 0.13.0",
  "log",
  "paste",
- "rand",
+]
+
+[[package]]
+name = "datafusion-functions-table"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "datafusion-catalog",
+ "datafusion-common",
+ "datafusion-expr",
+ "datafusion-physical-plan",
+ "parking_lot",
+ "paste",
 ]
 
 [[package]]
 name = "datafusion-functions-window"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ae23356c634e54c59f7c51acb7a5b9f6240ffb2cf997049a1a24a8a88598dbe"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "datafusion-common",
+ "datafusion-doc",
  "datafusion-expr",
  "datafusion-functions-window-common",
+ "datafusion-macros",
  "datafusion-physical-expr",
  "datafusion-physical-expr-common",
  "log",
@@ -1142,48 +1155,49 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-window-common"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4b3d6ff7794acea026de36007077a06b18b89e4f9c3fea7f2215f9f7dd9059b"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "datafusion-common",
  "datafusion-physical-expr-common",
 ]
 
+[[package]]
+name = "datafusion-macros"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
+dependencies = [
+ "quote",
+ "syn 2.0.92",
+]
+
 [[package]]
 name = "datafusion-optimizer"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bec6241eb80c595fa0e1a8a6b69686b5cf3bd5fdacb8319582a0943b0bd788aa"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "arrow",
- "async-trait",
  "chrono",
  "datafusion-common",
  "datafusion-expr",
  "datafusion-physical-expr",
- "hashbrown 0.14.5",
  "indexmap",
  "itertools 0.13.0",
  "log",
- "paste",
+ "regex",
  "regex-syntax",
 ]
 
 [[package]]
 name = "datafusion-physical-expr"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3370357b8fc75ec38577700644e5d1b0bc78f38babab99c0b8bd26bafb3e4335"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "ahash",
  "arrow",
  "arrow-array",
  "arrow-buffer",
- "arrow-ord",
  "arrow-schema",
- "arrow-string",
- "chrono",
  "datafusion-common",
  "datafusion-expr",
  "datafusion-expr-common",
@@ -1200,39 +1214,36 @@ dependencies = [
 
 [[package]]
 name = "datafusion-physical-expr-common"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8b7734d94bf2fa6f6e570935b0ddddd8421179ce200065be97874e13d46a47b"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "ahash",
  "arrow",
  "datafusion-common",
  "datafusion-expr-common",
  "hashbrown 0.14.5",
- "rand",
+ "itertools 0.13.0",
 ]
 
 [[package]]
 name = "datafusion-physical-optimizer"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7eee8c479522df21d7b395640dff88c5ed05361852dce6544d7c98e9dbcebffe"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "arrow",
- "arrow-schema",
  "datafusion-common",
  "datafusion-execution",
  "datafusion-expr-common",
  "datafusion-physical-expr",
  "datafusion-physical-plan",
  "itertools 0.13.0",
+ "log",
 ]
 
 [[package]]
 name = "datafusion-physical-plan"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17e1fc2e2c239d14e8556f2622b19a726bf6bc6962cc00c71fc52626274bee24"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "ahash",
  "arrow",
@@ -1246,7 +1257,6 @@ dependencies = [
  "datafusion-common-runtime",
  "datafusion-execution",
  "datafusion-expr",
- "datafusion-functions-aggregate-common",
  "datafusion-functions-window-common",
  "datafusion-physical-expr",
  "datafusion-physical-expr-common",
@@ -1256,29 +1266,26 @@ dependencies = [
  "indexmap",
  "itertools 0.13.0",
  "log",
- "once_cell",
  "parking_lot",
  "pin-project-lite",
- "rand",
  "tokio",
 ]
 
 [[package]]
 name = "datafusion-sql"
-version = "43.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63e3a4ed41dbee20a5d947a59ca035c225d67dc9cbe869c10f66dcdf25e7ce51"
+version = "44.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=44.0.0-rc2#3cc3fca31e6edc2d953e663bfd7f856bcb70d8c4"
 dependencies = [
  "arrow",
  "arrow-array",
  "arrow-schema",
+ "bigdecimal",
  "datafusion-common",
  "datafusion-expr",
  "indexmap",
  "log",
  "regex",
  "sqlparser",
- "strum",
 ]
 
 [[package]]
@@ -1326,7 +1333,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
@@ -1343,19 +1350,19 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "errno"
-version = "0.3.9"
+version = "0.3.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "fastrand"
-version = "2.2.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "486f806e73c5707928240ddc295403b1b93c96a02038563881c4a2fd84b81ac4"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
 name = "findshlibs"
@@ -1377,9 +1384,9 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flatbuffers"
-version = "24.3.25"
+version = "24.12.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8add37afff2d4ffa83bc748a70b4b1370984f6980768554182424ef71447c35f"
+checksum = "4f1baf0dbf96932ec9a3038d57900329c015b0bfb7b63d904f3bc27e2b02a096"
 dependencies = [
  "bitflags 1.3.2",
  "rustc_version",
@@ -1466,7 +1473,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
@@ -1555,9 +1562,9 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.15.1"
+version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a9bfc1af68b1726ea47d3d5109de126281def866b33970e10fbab11b5dafab3"
+checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
 
 [[package]]
 name = "heck"
@@ -1574,12 +1581,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "hermit-abi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
-
 [[package]]
 name = "hermit-abi"
 version = "0.4.0"
@@ -1594,11 +1595,11 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "home"
-version = "0.5.9"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1745,7 +1746,7 @@ checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
@@ -1771,12 +1772,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.6.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
+checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f"
 dependencies = [
  "equivalent",
- "hashbrown 0.15.1",
+ "hashbrown 0.15.2",
 ]
 
 [[package]]
@@ -1797,18 +1798,6 @@ dependencies = [
  "str_stack",
 ]
 
-[[package]]
-name = "instant"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222"
-dependencies = [
- "cfg-if",
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
 [[package]]
 name = "integer-encoding"
 version = "3.0.4"
@@ -1821,7 +1810,7 @@ version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b"
 dependencies = [
- "hermit-abi 0.4.0",
+ "hermit-abi",
  "libc",
  "windows-sys 0.52.0",
 ]
@@ -1864,9 +1853,9 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.11"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
 
 [[package]]
 name = "java-locator"
@@ -1912,10 +1901,11 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.72"
+version = "0.3.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a88f1bda2bd75b0452a14784937d796722fdebfe50df998aeb3f0b7603019a9"
+checksum = "6717b6b5b077764fb5966237269cb3c64edddde4b14ce42647430a78ced9e7b7"
 dependencies = [
+ "once_cell",
  "wasm-bindgen",
 ]
 
@@ -1927,9 +1917,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "lexical-core"
-version = "1.0.2"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0431c65b318a590c1de6b8fd6e72798c92291d27762d94c9e6c37ed7a73d8458"
+checksum = "b765c31809609075565a70b4b71402281283aeda7ecaf4818ac14a7b2ade8958"
 dependencies = [
  "lexical-parse-float",
  "lexical-parse-integer",
@@ -1940,9 +1930,9 @@ dependencies = [
 
 [[package]]
 name = "lexical-parse-float"
-version = "1.0.2"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb17a4bdb9b418051aa59d41d65b1c9be5affab314a872e5ad7f06231fb3b4e0"
+checksum = "de6f9cb01fb0b08060209a057c048fcbab8717b4c1ecd2eac66ebfe39a65b0f2"
 dependencies = [
  "lexical-parse-integer",
  "lexical-util",
@@ -1951,9 +1941,9 @@ dependencies = [
 
 [[package]]
 name = "lexical-parse-integer"
-version = "1.0.2"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5df98f4a4ab53bf8b175b363a34c7af608fe31f93cc1fb1bf07130622ca4ef61"
+checksum = "72207aae22fc0a121ba7b6d479e42cbfea549af1479c3f3a4f12c70dd66df12e"
 dependencies = [
  "lexical-util",
  "static_assertions",
@@ -1961,18 +1951,18 @@ dependencies = [
 
 [[package]]
 name = "lexical-util"
-version = "1.0.3"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85314db53332e5c192b6bca611fb10c114a80d1b831ddac0af1e9be1b9232ca0"
+checksum = "5a82e24bf537fd24c177ffbbdc6ebcc8d54732c35b50a3f28cc3f4e4c949a0b3"
 dependencies = [
  "static_assertions",
 ]
 
 [[package]]
 name = "lexical-write-float"
-version = "1.0.2"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e7c3ad4e37db81c1cbe7cf34610340adc09c322871972f74877a712abc6c809"
+checksum = "c5afc668a27f460fb45a81a757b6bf2f43c2d7e30cb5a2dcd3abf294c78d62bd"
 dependencies = [
  "lexical-util",
  "lexical-write-integer",
@@ -1981,9 +1971,9 @@ dependencies = [
 
 [[package]]
 name = "lexical-write-integer"
-version = "1.0.2"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb89e9f6958b83258afa3deed90b5de9ef68eef090ad5086c791cd2345610162"
+checksum = "629ddff1a914a836fb245616a7888b62903aae58fa771e1d83943035efa0f978"
 dependencies = [
  "lexical-util",
  "static_assertions",
@@ -1991,9 +1981,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.162"
+version = "0.2.169"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18d287de67fe55fd7e1581fe933d965a5a9477b38e949cfa9f8574ef01506398"
+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
 
 [[package]]
 name = "libloading"
@@ -2029,9 +2019,9 @@ checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
 
 [[package]]
 name = "litemap"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "643cb0b8d4fcc284004d5fd0d67ccf61dfffadb7f75e1e71bc420f4688a3a704"
+checksum = "4ee93343901ab17bd981295f2cf0026d4ad018c7c31ba84549a4ddbb47a45104"
 
 [[package]]
 name = "lock_api"
@@ -2131,9 +2121,9 @@ dependencies = [
 
 [[package]]
 name = "miniz_oxide"
-version = "0.8.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1"
+checksum = "4ffbe83022cedc1d264172192511ae958937694cd57ce297164951b8b3568394"
 dependencies = [
  "adler2",
 ]
@@ -2239,30 +2229,20 @@ dependencies = [
  "libm",
 ]
 
-[[package]]
-name = "num_cpus"
-version = "1.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
-dependencies = [
- "hermit-abi 0.3.9",
- "libc",
-]
-
 [[package]]
 name = "object"
-version = "0.36.5"
+version = "0.36.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aedf0a2d09c573ed1d8d85b30c119153926a2b36dce0ab28322c09a117a4683e"
+checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "object_store"
-version = "0.11.1"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6eb4c22c6154a1e759d7099f9ffad7cc5ef8245f9efbab4a41b92623079c82f3"
+checksum = "3cfccb68961a56facde1163f9319e0d15743352344e7808a11795fb99698dcaf"
 dependencies = [
  "async-trait",
  "bytes",
@@ -2325,9 +2305,9 @@ dependencies = [
 
 [[package]]
 name = "parquet"
-version = "53.2.0"
+version = "53.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dea02606ba6f5e856561d8d507dba8bac060aefca2a6c0f1aa1d361fed91ff3e"
+checksum = "2b449890367085eb65d7d3321540abc3d7babbd179ce31df0016e90719114191"
 dependencies = [
  "ahash",
  "arrow-array",
@@ -2344,7 +2324,7 @@ dependencies = [
  "flate2",
  "futures",
  "half",
- "hashbrown 0.14.5",
+ "hashbrown 0.15.2",
  "lz4_flex",
  "num",
  "num-bigint",
@@ -2506,9 +2486,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.89"
+version = "1.0.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
 dependencies = [
  "unicode-ident",
 ]
@@ -2576,7 +2556,7 @@ dependencies = [
  "itertools 0.12.1",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
@@ -2600,9 +2580,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
 dependencies = [
  "proc-macro2",
 ]
@@ -2659,9 +2639,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.7"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
+checksum = "03a862b389f93e68874fbf580b9de08dd02facb9a788ebadaf4a3fd33cf58834"
 dependencies = [
  "bitflags 2.6.0",
 ]
@@ -2721,22 +2701,22 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.40"
+version = "0.38.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99e4ea3e1cdc4b559b8e5650f9c8e5998e3e5c1343b4eaf034565f32318d63c0"
+checksum = "f93dc38ecbab2eb790ff964bb77fa94faf256fd3e73285fd7ba0903b76bedb85"
 dependencies = [
  "bitflags 2.6.0",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "rustversion"
-version = "1.0.18"
+version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e819f2bc632f285be6d7cd36e25940d45b2391dd6d9b939e79de557f7014248"
+checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4"
 
 [[package]]
 name = "ryu"
@@ -2761,9 +2741,9 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "semver"
-version = "1.0.23"
+version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
+checksum = "3cb6eb87a131f756572d7fb904f6e7b68633f09cca868c5df1c4b8d1a694bbba"
 
 [[package]]
 name = "seq-macro"
@@ -2773,9 +2753,9 @@ checksum = "a3f0bf26fd526d2a95683cd0f87bf103b8539e2ca1ef48ce002d67aad59aa0b4"
 
 [[package]]
 name = "serde"
-version = "1.0.215"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f"
+checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
 dependencies = [
  "serde_derive",
 ]
@@ -2792,20 +2772,20 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.215"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"
+checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.132"
+version = "1.0.134"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d726bfaff4b320266d395898905d0eba0345aae23b54aee3a737e260fd46db03"
+checksum = "d00f4175c42ee48b15416f6193a959ba3a0d67fc699a0db9ad12df9f83991c7d"
 dependencies = [
  "itoa",
  "memchr",
@@ -2888,7 +2868,7 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
@@ -2899,9 +2879,9 @@ checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b"
 
 [[package]]
 name = "sqlparser"
-version = "0.51.0"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fe11944a61da0da3f592e19a45ebe5ab92dc14a779907ff1f08fbb797bfefc7"
+checksum = "05a528114c392209b3264855ad491fcce534b94a38771b0a0b97a79379275ce8"
 dependencies = [
  "log",
  "sqlparser_derive",
@@ -2909,13 +2889,13 @@ dependencies = [
 
 [[package]]
 name = "sqlparser_derive"
-version = "0.2.2"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01b2e185515564f15375f593fb966b5718bc624ba77fe49fa4616ad619690554"
+checksum = "da5fc6819faabb412da764b99d3b713bb55083c11e7e0c00144d386cd6a1939c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
@@ -2941,9 +2921,6 @@ name = "strum"
 version = "0.26.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
-dependencies = [
- "strum_macros",
-]
 
 [[package]]
 name = "strum_macros"
@@ -2955,7 +2932,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
@@ -2966,9 +2943,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "symbolic-common"
-version = "12.12.1"
+version = "12.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d4d73159efebfb389d819fd479afb2dbd57dcb3e3f4b7fcfa0e675f5a46c1cb"
+checksum = "cd33e73f154e36ec223c18013f7064a2c120f1162fc086ac9933542def186b00"
 dependencies = [
  "debugid",
  "memmap2",
@@ -2978,9 +2955,9 @@ dependencies = [
 
 [[package]]
 name = "symbolic-demangle"
-version = "12.12.1"
+version = "12.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a767859f6549c665011970874c3f541838b4835d5aaaa493d3ee383918be9f10"
+checksum = "89e51191290147f071777e37fe111800bb82a9059f9c95b19d2dd41bfeddf477"
 dependencies = [
  "cpp_demangle",
  "rustc-demangle",
@@ -3000,9 +2977,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.87"
+version = "2.0.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d"
+checksum = "70ae51629bf965c5c098cc9e87908a3df5301051a9e087d6f9bef5c9771ed126"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3017,7 +2994,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
@@ -3050,7 +3027,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
@@ -3105,9 +3082,9 @@ dependencies = [
 
 [[package]]
 name = "tokio"
-version = "1.41.1"
+version = "1.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22cfb5bee7a6a52939ca9224d6ac897bb669134078daa8735560897f69de4d33"
+checksum = "5cec9b21b0450273377fc97bd4c33a8acffc8c996c987a7c5b319a0083707551"
 dependencies = [
  "backtrace",
  "bytes",
@@ -3123,14 +3100,14 @@ checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
 name = "tracing"
-version = "0.1.40"
+version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
  "pin-project-lite",
  "tracing-attributes",
@@ -3139,20 +3116,20 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.27"
+version = "0.1.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
+checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
 name = "tracing-core"
-version = "0.1.32"
+version = "0.1.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
+checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
 dependencies = [
  "once_cell",
 ]
@@ -3169,9 +3146,9 @@ dependencies = [
 
 [[package]]
 name = "twox-hash"
-version = "2.0.1"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6db6856664807f43c17fbaf2718e2381ac1476a449aa104f5f64622defa1245"
+checksum = "e7b17f197b3050ba473acf9181f7b1d3b66d1cf7356c6cc57886662276e65908"
 dependencies = [
  "rand",
 ]
@@ -3193,9 +3170,9 @@ checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.13"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
 
 [[package]]
 name = "unicode-segmentation"
@@ -3226,9 +3203,9 @@ checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
 
 [[package]]
 name = "url"
-version = "2.5.3"
+version = "2.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d157f1b96d14500ffdc1f10ba712e780825526c03d9a49b4d0324b0d9113ada"
+checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
 dependencies = [
  "form_urlencoded",
  "idna",
@@ -3280,9 +3257,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.95"
+version = "0.2.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "128d1e363af62632b8eb57219c8fd7877144af57558fb2ef0368d0087bddeb2e"
+checksum = "a474f6281d1d70c17ae7aa6a613c87fce69a127e2624002df63dcb39d6cf6396"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -3291,24 +3268,23 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.95"
+version = "0.2.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb6dd4d3ca0ddffd1dd1c9c04f94b868c37ff5fac97c30b97cff2d74fce3a358"
+checksum = "5f89bb38646b4f81674e8f5c3fb81b562be1fd936d84320f3264486418519c79"
 dependencies = [
  "bumpalo",
  "log",
- "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.95"
+version = "0.2.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e79384be7f8f5a9dd5d7167216f022090cf1f9ec128e6e6a482a2cb5c5422c56"
+checksum = "2cc6181fd9a7492eef6fef1f33961e3695e4579b9872a6f7c83aee556666d4fe"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -3316,28 +3292,38 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.95"
+version = "0.2.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26c6ab57572f7a24a4985830b120de1594465e5d500f24afe89e16b4e833ef68"
+checksum = "30d7a95b763d3c45903ed6c81f156801839e5ee968bb07e534c44df0fcd330c2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.95"
+version = "0.2.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65fc09f10666a9f147042251e0dda9c18f166ff7de300607007e96bdebc1068d"
+checksum = "943aab3fdaaa029a6e0271b35ea10b72b943135afe9bffca82384098ad0e06a6"
 
 [[package]]
 name = "web-sys"
-version = "0.3.72"
+version = "0.3.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6488b90108c040df0fe62fa815cbdee25124641df01814dd7282749234c6112"
+checksum = "04dd7223427d52553d3702c004d3b2fe07c148165faa56313cb00211e31c12bc"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -3557,9 +3543,9 @@ checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
 
 [[package]]
 name = "yoke"
-version = "0.7.4"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c5b1314b079b0930c31e3af543d8ee1757b1951ae1e1565ec704403a7240ca5"
+checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
 dependencies = [
  "serde",
  "stable_deref_trait",
@@ -3569,13 +3555,13 @@ dependencies = [
 
 [[package]]
 name = "yoke-derive"
-version = "0.7.4"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28cc31741b18cb6f1d5ff12f5b7523e3d6eb0852bbbad19d73905511d9849b95"
+checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
  "synstructure",
 ]
 
@@ -3597,27 +3583,27 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
 name = "zerofrom"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91ec111ce797d0e0784a1116d0ddcdbea84322cd79e5d5ad173daeba4f93ab55"
+checksum = "cff3ee08c995dee1859d998dea82f7374f2826091dd9cd47def953cae446cd2e"
 dependencies = [
  "zerofrom-derive",
 ]
 
 [[package]]
 name = "zerofrom-derive"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ea7b4a3637ea8669cedf0f1fd5c286a17f3de97b8dd5a70a6c167a1730e63a5"
+checksum = "595eed982f7d355beb85837f651fa22e90b3c044842dc7f2c2842c086f295808"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
  "synstructure",
 ]
 
@@ -3640,7 +3626,7 @@ checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.92",
 ]
 
 [[package]]
diff --git a/native/Cargo.toml b/native/Cargo.toml
index bd46cf0c9f..cf4921ebed 100644
--- a/native/Cargo.toml
+++ b/native/Cargo.toml
@@ -33,20 +33,21 @@ edition = "2021"
 rust-version = "1.79"
 
 [workspace.dependencies]
-arrow = { version = "53.2.0", features = ["prettyprint", "ffi", "chrono-tz"] }
-arrow-array = { version = "53.2.0" }
-arrow-buffer = { version = "53.2.0" }
-arrow-data = { version = "53.2.0" }
-arrow-schema = { version = "53.2.0" }
-parquet = { version = "53.2.0", default-features = false, features = ["experimental"] }
-datafusion = { version = "43.0.0", default-features = false, features = ["unicode_expressions", "crypto_expressions"] }
-datafusion-common = { version = "43.0.0" }
-datafusion-functions = { version = "43.0.0", features = ["crypto_expressions"] }
-datafusion-functions-nested = { version = "43.0.0", default-features = false }
-datafusion-expr = { version = "43.0.0", default-features = false }
-datafusion-execution = { version = "43.0.0", default-features = false }
-datafusion-physical-plan = { version = "43.0.0", default-features = false }
-datafusion-physical-expr = { version = "43.0.0", default-features = false }
+arrow = { version = "53.3.0", features = ["prettyprint", "ffi", "chrono-tz"] }
+arrow-array = { version = "53.3.0" }
+arrow-buffer = { version = "53.3.0" }
+arrow-data = { version = "53.3.0" }
+arrow-schema = { version = "53.3.0" }
+parquet = { version = "53.3.0", default-features = false, features = ["experimental"] }
+datafusion = { git = "https://github.com/apache/datafusion.git", rev = "44.0.0-rc2", default-features = false, features = ["unicode_expressions", "crypto_expressions"] }
+datafusion-common = { git = "https://github.com/apache/datafusion.git", rev = "44.0.0-rc2", default-features = false }
+datafusion-functions = { git = "https://github.com/apache/datafusion.git", rev = "44.0.0-rc2", default-features = false, features = ["crypto_expressions"] }
+datafusion-functions-nested = { git = "https://github.com/apache/datafusion.git", rev = "44.0.0-rc2", default-features = false }
+datafusion-expr = { git = "https://github.com/apache/datafusion.git", rev = "44.0.0-rc2", default-features = false }
+datafusion-expr-common = { git = "https://github.com/apache/datafusion.git", rev = "44.0.0-rc2", default-features = false }
+datafusion-execution = { git = "https://github.com/apache/datafusion.git", rev = "44.0.0-rc2", default-features = false }
+datafusion-physical-plan = { git = "https://github.com/apache/datafusion.git", rev = "44.0.0-rc2", default-features = false }
+datafusion-physical-expr = { git = "https://github.com/apache/datafusion.git", rev = "44.0.0-rc2", default-features = false }
 datafusion-comet-spark-expr = { path = "spark-expr", version = "0.5.0" }
 datafusion-comet-proto = { path = "proto", version = "0.5.0" }
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
diff --git a/native/core/src/execution/expressions/bloom_filter_might_contain.rs b/native/core/src/execution/expressions/bloom_filter_might_contain.rs
index af6a5a47a3..b14fab62f6 100644
--- a/native/core/src/execution/expressions/bloom_filter_might_contain.rs
+++ b/native/core/src/execution/expressions/bloom_filter_might_contain.rs
@@ -19,26 +19,37 @@ use crate::{execution::util::spark_bloom_filter::SparkBloomFilter, parquet::data
 use arrow::record_batch::RecordBatch;
 use arrow_array::cast::as_primitive_array;
 use arrow_schema::{DataType, Schema};
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion::physical_plan::ColumnarValue;
 use datafusion_common::{internal_err, Result, ScalarValue};
 use datafusion_physical_expr::PhysicalExpr;
-use std::{
-    any::Any,
-    fmt::Display,
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
+use std::hash::Hash;
+use std::{any::Any, fmt::Display, sync::Arc};
 
 /// A physical expression that checks if a value might be in a bloom filter. It corresponds to the
 /// Spark's `BloomFilterMightContain` expression.
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct BloomFilterMightContain {
     pub bloom_filter_expr: Arc<dyn PhysicalExpr>,
     pub value_expr: Arc<dyn PhysicalExpr>,
     bloom_filter: Option<SparkBloomFilter>,
 }
 
+impl Hash for BloomFilterMightContain {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.bloom_filter_expr.hash(state);
+        self.value_expr.hash(state);
+        self.bloom_filter.hash(state);
+    }
+}
+
+impl PartialEq for BloomFilterMightContain {
+    fn eq(&self, other: &Self) -> bool {
+        self.bloom_filter_expr.eq(&other.bloom_filter_expr)
+            && self.value_expr.eq(&other.value_expr)
+            && self.bloom_filter.eq(&other.bloom_filter)
+    }
+}
+
 impl Display for BloomFilterMightContain {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(
@@ -49,18 +60,6 @@ impl Display for BloomFilterMightContain {
     }
 }
 
-impl PartialEq<dyn Any> for BloomFilterMightContain {
-    fn eq(&self, _other: &dyn Any) -> bool {
-        down_cast_any_ref(_other)
-            .downcast_ref::<Self>()
-            .map(|other| {
-                self.bloom_filter_expr.eq(&other.bloom_filter_expr)
-                    && self.value_expr.eq(&other.value_expr)
-            })
-            .unwrap_or(false)
-    }
-}
-
 fn evaluate_bloom_filter(
     bloom_filter_expr: &Arc<dyn PhysicalExpr>,
 ) -> Result<Option<SparkBloomFilter>> {
@@ -141,11 +140,4 @@ impl PhysicalExpr for BloomFilterMightContain {
             Arc::clone(&children[1]),
         )?))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.bloom_filter_expr.hash(&mut s);
-        self.value_expr.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
diff --git a/native/core/src/execution/expressions/subquery.rs b/native/core/src/execution/expressions/subquery.rs
index 3eeb29c16e..d933a6096a 100644
--- a/native/core/src/execution/expressions/subquery.rs
+++ b/native/core/src/execution/expressions/subquery.rs
@@ -22,7 +22,6 @@ use crate::{
 use arrow_array::RecordBatch;
 use arrow_schema::{DataType, Schema, TimeUnit};
 use datafusion::logical_expr::ColumnarValue;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{internal_err, ScalarValue};
 use datafusion_physical_expr::PhysicalExpr;
 use jni::{
@@ -32,11 +31,11 @@ use jni::{
 use std::{
     any::Any,
     fmt::{Display, Formatter},
-    hash::{Hash, Hasher},
+    hash::Hash,
     sync::Arc,
 };
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Hash, PartialEq, Eq)]
 pub struct Subquery {
     /// The ID of the execution context that owns this subquery. We use this ID to retrieve the
     /// subquery result.
@@ -63,19 +62,6 @@ impl Display for Subquery {
     }
 }
 
-impl PartialEq<dyn Any> for Subquery {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.id.eq(&x.id)
-                    && self.data_type.eq(&x.data_type)
-                    && self.exec_context_id.eq(&x.exec_context_id)
-            })
-            .unwrap_or(false)
-    }
-}
-
 impl PhysicalExpr for Subquery {
     fn as_any(&self) -> &dyn Any {
         self
@@ -209,9 +195,4 @@ impl PhysicalExpr for Subquery {
     ) -> datafusion_common::Result<Arc<dyn PhysicalExpr>> {
         Ok(self)
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.hash(&mut s)
-    }
 }
diff --git a/native/core/src/execution/jni_api.rs b/native/core/src/execution/jni_api.rs
index 2c1a55f48f..09caf5e279 100644
--- a/native/core/src/execution/jni_api.rs
+++ b/native/core/src/execution/jni_api.rs
@@ -20,10 +20,7 @@
 use arrow::datatypes::DataType as ArrowDataType;
 use arrow_array::RecordBatch;
 use datafusion::{
-    execution::{
-        disk_manager::DiskManagerConfig,
-        runtime_env::{RuntimeConfig, RuntimeEnv},
-    },
+    execution::{disk_manager::DiskManagerConfig, runtime_env::RuntimeEnv},
     physical_plan::{display::DisplayableExecutionPlan, SendableRecordBatchStream},
     prelude::{SessionConfig, SessionContext},
 };
@@ -52,6 +49,7 @@ use crate::{
 };
 use datafusion_comet_proto::spark_operator::Operator;
 use datafusion_common::ScalarValue;
+use datafusion_execution::runtime_env::RuntimeEnvBuilder;
 use futures::stream::StreamExt;
 use jni::{
     objects::GlobalRef,
@@ -188,7 +186,7 @@ fn prepare_datafusion_session_context(
     memory_fraction: f64,
     comet_task_memory_manager: Arc<GlobalRef>,
 ) -> CometResult<SessionContext> {
-    let mut rt_config = RuntimeConfig::new().with_disk_manager(DiskManagerConfig::NewOs);
+    let mut rt_config = RuntimeEnvBuilder::new().with_disk_manager(DiskManagerConfig::NewOs);
 
     // Check if we are using unified memory manager integrated with Spark.
     if use_unified_memory_manager {
@@ -216,6 +214,7 @@ fn prepare_datafusion_session_context(
             &ScalarValue::Float64(Some(1.1)),
         );
 
+    #[allow(deprecated)]
     let runtime = RuntimeEnv::try_new(rt_config)?;
 
     let mut session_ctx = SessionContext::new_with_config_rt(session_config, Arc::new(runtime));
diff --git a/native/core/src/execution/operators/copy.rs b/native/core/src/execution/operators/copy.rs
index 8eeda8a5ad..cec00eb28c 100644
--- a/native/core/src/execution/operators/copy.rs
+++ b/native/core/src/execution/operators/copy.rs
@@ -30,6 +30,7 @@ use arrow_array::{
 use arrow_data::transform::MutableArrayData;
 use arrow_schema::{ArrowError, DataType, Field, FieldRef, Schema, SchemaRef};
 
+use datafusion::physical_plan::execution_plan::{Boundedness, EmissionType};
 use datafusion::physical_plan::metrics::{BaselineMetrics, ExecutionPlanMetricsSet, MetricsSet};
 use datafusion::{execution::TaskContext, physical_expr::*, physical_plan::*};
 use datafusion_common::{arrow_datafusion_err, DataFusionError, Result as DataFusionResult};
@@ -78,7 +79,8 @@ impl CopyExec {
         let cache = PlanProperties::new(
             EquivalenceProperties::new(Arc::clone(&schema)),
             Partitioning::UnknownPartitioning(1),
-            ExecutionMode::Bounded,
+            EmissionType::Final,
+            Boundedness::Bounded,
         );
 
         Self {
diff --git a/native/core/src/execution/operators/expand.rs b/native/core/src/execution/operators/expand.rs
index fb43a6e49f..f75822d408 100644
--- a/native/core/src/execution/operators/expand.rs
+++ b/native/core/src/execution/operators/expand.rs
@@ -17,10 +17,11 @@
 
 use arrow_array::{RecordBatch, RecordBatchOptions};
 use arrow_schema::SchemaRef;
+use datafusion::physical_plan::execution_plan::{Boundedness, EmissionType};
 use datafusion::{
     execution::TaskContext,
     physical_plan::{
-        DisplayAs, DisplayFormatType, ExecutionMode, ExecutionPlan, Partitioning, PlanProperties,
+        DisplayAs, DisplayFormatType, ExecutionPlan, Partitioning, PlanProperties,
         RecordBatchStream, SendableRecordBatchStream,
     },
 };
@@ -54,7 +55,8 @@ impl ExpandExec {
         let cache = PlanProperties::new(
             EquivalenceProperties::new(Arc::clone(&schema)),
             Partitioning::UnknownPartitioning(1),
-            ExecutionMode::Bounded,
+            EmissionType::Final,
+            Boundedness::Bounded,
         );
 
         Self {
diff --git a/native/core/src/execution/operators/filter.rs b/native/core/src/execution/operators/filter.rs
index d9a54712dc..eab30a3560 100644
--- a/native/core/src/execution/operators/filter.rs
+++ b/native/core/src/execution/operators/filter.rs
@@ -210,7 +210,8 @@ impl FilterExec {
         Ok(PlanProperties::new(
             eq_properties,
             input.output_partitioning().clone(), // Output Partitioning
-            input.execution_mode(),              // Execution Mode
+            input.pipeline_behavior(),
+            input.boundedness(),
         ))
     }
 }
diff --git a/native/core/src/execution/operators/scan.rs b/native/core/src/execution/operators/scan.rs
index a297f87c1f..888cd2fdb5 100644
--- a/native/core/src/execution/operators/scan.rs
+++ b/native/core/src/execution/operators/scan.rs
@@ -28,6 +28,7 @@ use arrow_data::ffi::FFI_ArrowArray;
 use arrow_data::ArrayData;
 use arrow_schema::ffi::FFI_ArrowSchema;
 use arrow_schema::{DataType, Field, Schema, SchemaRef};
+use datafusion::physical_plan::execution_plan::{Boundedness, EmissionType};
 use datafusion::physical_plan::metrics::{
     BaselineMetrics, ExecutionPlanMetricsSet, MetricBuilder, MetricsSet, Time,
 };
@@ -122,7 +123,8 @@ impl ScanExec {
             // The partitioning is not important because we are not using DataFusion's
             // query planner or optimizer
             Partitioning::UnknownPartitioning(1),
-            ExecutionMode::Bounded,
+            EmissionType::Final,
+            Boundedness::Bounded,
         );
 
         Ok(Self {
diff --git a/native/core/src/execution/planner.rs b/native/core/src/execution/planner.rs
index 0a74933547..5a35c62e33 100644
--- a/native/core/src/execution/planner.rs
+++ b/native/core/src/execution/planner.rs
@@ -94,7 +94,6 @@ use datafusion_common::{
     tree_node::{Transformed, TransformedResult, TreeNode, TreeNodeRecursion, TreeNodeRewriter},
     JoinType as DFJoinType, ScalarValue,
 };
-use datafusion_expr::expr::find_df_window_func;
 use datafusion_expr::{
     AggregateUDF, ScalarUDF, WindowFrame, WindowFrameBound, WindowFrameUnits,
     WindowFunctionDefinition,
@@ -1515,10 +1514,7 @@ impl PhysicalPlanner {
 
                 let builder = match datatype {
                     DataType::Decimal128(_, _) => {
-                        let func = AggregateUDF::new_from_impl(SumDecimal::try_new(
-                            Arc::clone(&child),
-                            datatype,
-                        )?);
+                        let func = AggregateUDF::new_from_impl(SumDecimal::try_new(datatype)?);
                         AggregateExprBuilder::new(Arc::new(func), vec![child])
                     }
                     _ => {
@@ -1543,11 +1539,8 @@ impl PhysicalPlanner {
                 let input_datatype = to_arrow_datatype(expr.sum_datatype.as_ref().unwrap());
                 let builder = match datatype {
                     DataType::Decimal128(_, _) => {
-                        let func = AggregateUDF::new_from_impl(AvgDecimal::new(
-                            Arc::clone(&child),
-                            datatype,
-                            input_datatype,
-                        ));
+                        let func =
+                            AggregateUDF::new_from_impl(AvgDecimal::new(datatype, input_datatype));
                         AggregateExprBuilder::new(Arc::new(func), vec![child])
                     }
                     _ => {
@@ -1556,11 +1549,7 @@ impl PhysicalPlanner {
                         // failure since it should have already been checked at Spark side.
                         let child: Arc<dyn PhysicalExpr> =
                             Arc::new(CastExpr::new(Arc::clone(&child), datatype.clone(), None));
-                        let func = AggregateUDF::new_from_impl(Avg::new(
-                            Arc::clone(&child),
-                            "avg",
-                            datatype,
-                        ));
+                        let func = AggregateUDF::new_from_impl(Avg::new("avg", datatype));
                         AggregateExprBuilder::new(Arc::new(func), vec![child])
                     }
                 };
@@ -1638,8 +1627,6 @@ impl PhysicalPlanner {
                 match expr.stats_type {
                     0 => {
                         let func = AggregateUDF::new_from_impl(Covariance::new(
-                            Arc::clone(&child1),
-                            Arc::clone(&child2),
                             "covariance",
                             datatype,
                             StatsType::Sample,
@@ -1655,8 +1642,6 @@ impl PhysicalPlanner {
                     }
                     1 => {
                         let func = AggregateUDF::new_from_impl(Covariance::new(
-                            Arc::clone(&child1),
-                            Arc::clone(&child2),
                             "covariance_pop",
                             datatype,
                             StatsType::Population,
@@ -1682,7 +1667,6 @@ impl PhysicalPlanner {
                 match expr.stats_type {
                     0 => {
                         let func = AggregateUDF::new_from_impl(Variance::new(
-                            Arc::clone(&child),
                             "variance",
                             datatype,
                             StatsType::Sample,
@@ -1693,7 +1677,6 @@ impl PhysicalPlanner {
                     }
                     1 => {
                         let func = AggregateUDF::new_from_impl(Variance::new(
-                            Arc::clone(&child),
                             "variance_pop",
                             datatype,
                             StatsType::Population,
@@ -1714,7 +1697,6 @@ impl PhysicalPlanner {
                 match expr.stats_type {
                     0 => {
                         let func = AggregateUDF::new_from_impl(Stddev::new(
-                            Arc::clone(&child),
                             "stddev",
                             datatype,
                             StatsType::Sample,
@@ -1725,7 +1707,6 @@ impl PhysicalPlanner {
                     }
                     1 => {
                         let func = AggregateUDF::new_from_impl(Stddev::new(
-                            Arc::clone(&child),
                             "stddev_pop",
                             datatype,
                             StatsType::Population,
@@ -1747,8 +1728,6 @@ impl PhysicalPlanner {
                     self.create_expr(expr.child2.as_ref().unwrap(), Arc::clone(&schema))?;
                 let datatype = to_arrow_datatype(expr.datatype.as_ref().unwrap());
                 let func = AggregateUDF::new_from_impl(Correlation::new(
-                    Arc::clone(&child1),
-                    Arc::clone(&child2),
                     "correlation",
                     datatype,
                     expr.null_on_divide_by_zero,
@@ -1935,7 +1914,7 @@ impl PhysicalPlanner {
             window_func_name,
             &window_args,
             partition_by,
-            sort_exprs,
+            &LexOrdering::new(sort_exprs.to_vec()),
             window_frame.into(),
             input_schema.as_ref(),
             false, // TODO: Ignore nulls
@@ -1985,15 +1964,11 @@ impl PhysicalPlanner {
 
     /// Find DataFusion's built-in window function by name.
     fn find_df_window_function(&self, name: &str) -> Option<WindowFunctionDefinition> {
-        if let Some(f) = find_df_window_func(name) {
-            Some(f)
-        } else {
-            let registry = &self.session_ctx.state();
-            registry
-                .udaf(name)
-                .map(WindowFunctionDefinition::AggregateUDF)
-                .ok()
-        }
+        let registry = &self.session_ctx.state();
+        registry
+            .udaf(name)
+            .map(WindowFunctionDefinition::AggregateUDF)
+            .ok()
     }
 
     /// Create a DataFusion physical partitioning from Spark physical partitioning
@@ -2049,7 +2024,15 @@ impl PhysicalPlanner {
                         .coerce_types(&input_expr_types)
                         .unwrap_or_else(|_| input_expr_types.clone());
 
-                    let data_type = func.inner().return_type(&coerced_types)?;
+                    let data_type = match fun_name {
+                        // workaround for https://github.com/apache/datafusion/issues/13716
+                        "datepart" => DataType::Int32,
+                        _ => {
+                            // TODO need to call `return_type_from_exprs` instead
+                            #[allow(deprecated)]
+                            func.inner().return_type(&coerced_types)?
+                        }
+                    };
 
                     (data_type, coerced_types)
                 }
diff --git a/native/core/src/execution/shuffle/shuffle_writer.rs b/native/core/src/execution/shuffle/shuffle_writer.rs
index 01117199eb..f3fa685b88 100644
--- a/native/core/src/execution/shuffle/shuffle_writer.rs
+++ b/native/core/src/execution/shuffle/shuffle_writer.rs
@@ -25,6 +25,7 @@ use arrow::{datatypes::*, ipc::writer::StreamWriter};
 use async_trait::async_trait;
 use bytes::Buf;
 use crc32fast::Hasher;
+use datafusion::physical_plan::execution_plan::{Boundedness, EmissionType};
 use datafusion::{
     arrow::{
         array::*,
@@ -44,7 +45,7 @@ use datafusion::{
             BaselineMetrics, Count, ExecutionPlanMetricsSet, MetricBuilder, MetricsSet, Time,
         },
         stream::RecordBatchStreamAdapter,
-        DisplayAs, DisplayFormatType, ExecutionMode, ExecutionPlan, Partitioning, PlanProperties,
+        DisplayAs, DisplayFormatType, ExecutionPlan, Partitioning, PlanProperties,
         RecordBatchStream, SendableRecordBatchStream, Statistics,
     },
 };
@@ -191,7 +192,8 @@ impl ShuffleWriterExec {
         let cache = PlanProperties::new(
             EquivalenceProperties::new(Arc::clone(&input.schema())),
             partitioning.clone(),
-            ExecutionMode::Bounded,
+            EmissionType::Final,
+            Boundedness::Bounded,
         );
 
         Ok(ShuffleWriterExec {
diff --git a/native/core/src/execution/util/spark_bit_array.rs b/native/core/src/execution/util/spark_bit_array.rs
index 6cfecc1bfb..3ac8b199bf 100644
--- a/native/core/src/execution/util/spark_bit_array.rs
+++ b/native/core/src/execution/util/spark_bit_array.rs
@@ -22,7 +22,7 @@ use std::iter::zip;
 /// A simple bit array implementation that simulates the behavior of Spark's BitArray which is
 /// used in the BloomFilter implementation. Some methods are not implemented as they are not
 /// required for the current use case.
-#[derive(Debug, Hash)]
+#[derive(Debug, Hash, PartialEq, Eq)]
 pub struct SparkBitArray {
     data: Vec<u64>,
     bit_count: usize,
diff --git a/native/core/src/execution/util/spark_bloom_filter.rs b/native/core/src/execution/util/spark_bloom_filter.rs
index 2c3af16916..61245757cf 100644
--- a/native/core/src/execution/util/spark_bloom_filter.rs
+++ b/native/core/src/execution/util/spark_bloom_filter.rs
@@ -27,7 +27,7 @@ const SPARK_BLOOM_FILTER_VERSION_1: i32 = 1;
 /// A Bloom filter implementation that simulates the behavior of Spark's BloomFilter.
 /// It's not a complete implementation of Spark's BloomFilter, but just add the minimum
 /// methods to support mightContainsLong in the native side.
-#[derive(Debug, Hash)]
+#[derive(Debug, Hash, PartialEq, Eq)]
 pub struct SparkBloomFilter {
     bits: SparkBitArray,
     num_hash_functions: u32,
diff --git a/native/spark-expr/Cargo.toml b/native/spark-expr/Cargo.toml
index 27367d83e1..fc348f81bf 100644
--- a/native/spark-expr/Cargo.toml
+++ b/native/spark-expr/Cargo.toml
@@ -36,6 +36,7 @@ chrono = { workspace = true }
 datafusion = { workspace = true, features = ["parquet"] }
 datafusion-common = { workspace = true }
 datafusion-expr = { workspace = true }
+datafusion-expr-common = { workspace = true }
 datafusion-physical-expr = { workspace = true }
 chrono-tz = { workspace = true }
 num = { workspace = true }
diff --git a/native/spark-expr/benches/aggregate.rs b/native/spark-expr/benches/aggregate.rs
index 43194fdda2..051ac5eb62 100644
--- a/native/spark-expr/benches/aggregate.rs
+++ b/native/spark-expr/benches/aggregate.rs
@@ -66,7 +66,6 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     group.bench_function("avg_decimal_comet", |b| {
         let comet_avg_decimal = Arc::new(AggregateUDF::new_from_impl(AvgDecimal::new(
-            Arc::clone(&c1),
             DataType::Decimal128(38, 10),
             DataType::Decimal128(38, 10),
         )));
@@ -96,7 +95,7 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     group.bench_function("sum_decimal_comet", |b| {
         let comet_sum_decimal = Arc::new(AggregateUDF::new_from_impl(
-            SumDecimal::try_new(Arc::clone(&c1), DataType::Decimal128(38, 10)).unwrap(),
+            SumDecimal::try_new(DataType::Decimal128(38, 10)).unwrap(),
         ));
         b.to_async(&rt).iter(|| {
             black_box(agg_test(
diff --git a/native/spark-expr/src/avg.rs b/native/spark-expr/src/avg.rs
index 7820497d46..816440ac9a 100644
--- a/native/spark-expr/src/avg.rs
+++ b/native/spark-expr/src/avg.rs
@@ -27,11 +27,10 @@ use datafusion::logical_expr::{
     type_coercion::aggregates::avg_return_type, Accumulator, EmitTo, GroupsAccumulator, Signature,
 };
 use datafusion_common::{not_impl_err, Result, ScalarValue};
-use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
+use datafusion_physical_expr::expressions::format_state_name;
 use std::{any::Any, sync::Arc};
 
 use arrow_array::ArrowNativeTypeOp;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
 use datafusion_expr::Volatility::Immutable;
 use datafusion_expr::{AggregateUDFImpl, ReversedUDAF};
@@ -42,20 +41,19 @@ use DataType::*;
 pub struct Avg {
     name: String,
     signature: Signature,
-    expr: Arc<dyn PhysicalExpr>,
+    // expr: Arc<dyn PhysicalExpr>,
     input_data_type: DataType,
     result_data_type: DataType,
 }
 
 impl Avg {
     /// Create a new AVG aggregate function
-    pub fn new(expr: Arc<dyn PhysicalExpr>, name: impl Into<String>, data_type: DataType) -> Self {
+    pub fn new(name: impl Into<String>, data_type: DataType) -> Self {
         let result_data_type = avg_return_type("avg", &data_type).unwrap();
 
         Self {
             name: name.into(),
             signature: Signature::user_defined(Immutable),
-            expr,
             input_data_type: data_type,
             result_data_type,
         }
@@ -139,20 +137,6 @@ impl AggregateUDFImpl for Avg {
     }
 }
 
-impl PartialEq<dyn Any> for Avg {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.name == x.name
-                    && self.input_data_type == x.input_data_type
-                    && self.result_data_type == x.result_data_type
-                    && self.expr.eq(&x.expr)
-            })
-            .unwrap_or(false)
-    }
-}
-
 /// An accumulator to compute the average
 #[derive(Debug, Default)]
 pub struct AvgAccumulator {
diff --git a/native/spark-expr/src/avg_decimal.rs b/native/spark-expr/src/avg_decimal.rs
index 163e1560b6..05fc28e583 100644
--- a/native/spark-expr/src/avg_decimal.rs
+++ b/native/spark-expr/src/avg_decimal.rs
@@ -25,14 +25,13 @@ use arrow_array::{
 use arrow_schema::{DataType, Field};
 use datafusion::logical_expr::{Accumulator, EmitTo, GroupsAccumulator, Signature};
 use datafusion_common::{not_impl_err, Result, ScalarValue};
-use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
+use datafusion_physical_expr::expressions::format_state_name;
 use std::{any::Any, sync::Arc};
 
 use crate::utils::is_valid_decimal_precision;
 use arrow_array::ArrowNativeTypeOp;
 use arrow_data::decimal::{MAX_DECIMAL_FOR_EACH_PRECISION, MIN_DECIMAL_FOR_EACH_PRECISION};
 use datafusion::logical_expr::Volatility::Immutable;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
 use datafusion_expr::type_coercion::aggregates::avg_return_type;
 use datafusion_expr::{AggregateUDFImpl, ReversedUDAF};
@@ -43,17 +42,15 @@ use DataType::*;
 #[derive(Debug, Clone)]
 pub struct AvgDecimal {
     signature: Signature,
-    expr: Arc<dyn PhysicalExpr>,
     sum_data_type: DataType,
     result_data_type: DataType,
 }
 
 impl AvgDecimal {
     /// Create a new AVG aggregate function
-    pub fn new(expr: Arc<dyn PhysicalExpr>, result_type: DataType, sum_type: DataType) -> Self {
+    pub fn new(result_type: DataType, sum_type: DataType) -> Self {
         Self {
             signature: Signature::user_defined(Immutable),
-            expr,
             result_data_type: result_type,
             sum_data_type: sum_type,
         }
@@ -156,19 +153,6 @@ impl AggregateUDFImpl for AvgDecimal {
     }
 }
 
-impl PartialEq<dyn Any> for AvgDecimal {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.sum_data_type == x.sum_data_type
-                    && self.result_data_type == x.result_data_type
-                    && self.expr.eq(&x.expr)
-            })
-            .unwrap_or(false)
-    }
-}
-
 /// An accumulator to compute the average for decimals
 #[derive(Debug)]
 struct AvgDecimalAccumulator {
diff --git a/native/spark-expr/src/bitwise_not.rs b/native/spark-expr/src/bitwise_not.rs
index 36234935e1..d7c31836ff 100644
--- a/native/spark-expr/src/bitwise_not.rs
+++ b/native/spark-expr/src/bitwise_not.rs
@@ -15,21 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::{
-    any::Any,
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
-
 use arrow::{
     array::*,
     datatypes::{DataType, Schema},
     record_batch::RecordBatch,
 };
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion::{error::DataFusionError, logical_expr::ColumnarValue};
 use datafusion_common::Result;
 use datafusion_physical_expr::PhysicalExpr;
+use std::hash::Hash;
+use std::{any::Any, sync::Arc};
 
 macro_rules! compute_op {
     ($OPERAND:expr, $DT:ident) => {{
@@ -43,12 +38,24 @@ macro_rules! compute_op {
 }
 
 /// BitwiseNot expression
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct BitwiseNotExpr {
     /// Input expression
     arg: Arc<dyn PhysicalExpr>,
 }
 
+impl Hash for BitwiseNotExpr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.arg.hash(state);
+    }
+}
+
+impl PartialEq for BitwiseNotExpr {
+    fn eq(&self, other: &Self) -> bool {
+        self.arg.eq(&other.arg)
+    }
+}
+
 impl BitwiseNotExpr {
     /// Create new bitwise not expression
     pub fn new(arg: Arc<dyn PhysicalExpr>) -> Self {
@@ -114,21 +121,6 @@ impl PhysicalExpr for BitwiseNotExpr {
     ) -> Result<Arc<dyn PhysicalExpr>> {
         Ok(Arc::new(BitwiseNotExpr::new(Arc::clone(&children[0]))))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.arg.hash(&mut s);
-        self.hash(&mut s);
-    }
-}
-
-impl PartialEq<dyn Any> for BitwiseNotExpr {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.arg.eq(&x.arg))
-            .unwrap_or(false)
-    }
 }
 
 pub fn bitwise_not(arg: Arc<dyn PhysicalExpr>) -> Result<Arc<dyn PhysicalExpr>> {
diff --git a/native/spark-expr/src/cast.rs b/native/spark-expr/src/cast.rs
index d96bcbbdb6..6e0e0915cd 100644
--- a/native/spark-expr/src/cast.rs
+++ b/native/spark-expr/src/cast.rs
@@ -39,7 +39,6 @@ use arrow_array::builder::StringBuilder;
 use arrow_array::{DictionaryArray, StringArray, StructArray};
 use arrow_schema::{DataType, Field, Schema};
 use chrono::{NaiveDate, NaiveDateTime, TimeZone, Timelike};
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{
     cast::as_generic_string_array, internal_err, Result as DataFusionResult, ScalarValue,
 };
@@ -54,7 +53,7 @@ use std::str::FromStr;
 use std::{
     any::Any,
     fmt::{Debug, Display, Formatter},
-    hash::{Hash, Hasher},
+    hash::Hash,
     num::Wrapping,
     sync::Arc,
 };
@@ -131,13 +130,29 @@ impl TimeStampInfo {
     }
 }
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct Cast {
     pub child: Arc<dyn PhysicalExpr>,
     pub data_type: DataType,
     pub cast_options: SparkCastOptions,
 }
 
+impl PartialEq for Cast {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child)
+            && self.data_type.eq(&other.data_type)
+            && self.cast_options.eq(&other.cast_options)
+    }
+}
+
+impl Hash for Cast {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.data_type.hash(state);
+        self.cast_options.hash(state);
+    }
+}
+
 /// Determine if Comet supports a cast, taking options such as EvalMode and Timezone into account.
 pub fn cast_supported(
     from_type: &DataType,
@@ -1681,19 +1696,6 @@ impl Display for Cast {
     }
 }
 
-impl PartialEq<dyn Any> for Cast {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.child.eq(&x.child)
-                    && self.cast_options.eq(&x.cast_options)
-                    && self.data_type.eq(&x.data_type)
-            })
-            .unwrap_or(false)
-    }
-}
-
 impl PhysicalExpr for Cast {
     fn as_any(&self) -> &dyn Any {
         self
@@ -1729,14 +1731,6 @@ impl PhysicalExpr for Cast {
             _ => internal_err!("Cast should have exactly one child"),
         }
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.data_type.hash(&mut s);
-        self.cast_options.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
 fn timestamp_parser<T: TimeZone>(
diff --git a/native/spark-expr/src/checkoverflow.rs b/native/spark-expr/src/checkoverflow.rs
index e922171bd2..528bbd5d96 100644
--- a/native/spark-expr/src/checkoverflow.rs
+++ b/native/spark-expr/src/checkoverflow.rs
@@ -15,13 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::{
-    any::Any,
-    fmt::{Display, Formatter},
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
-
 use arrow::{
     array::{as_primitive_array, Array, ArrayRef, Decimal128Array},
     datatypes::{Decimal128Type, DecimalType},
@@ -29,21 +22,42 @@ use arrow::{
 };
 use arrow_schema::{DataType, Schema};
 use datafusion::logical_expr::ColumnarValue;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{DataFusionError, ScalarValue};
 use datafusion_physical_expr::PhysicalExpr;
+use std::hash::Hash;
+use std::{
+    any::Any,
+    fmt::{Display, Formatter},
+    sync::Arc,
+};
 
 /// This is from Spark `CheckOverflow` expression. Spark `CheckOverflow` expression rounds decimals
 /// to given scale and check if the decimals can fit in given precision. As `cast` kernel rounds
 /// decimals already, Comet `CheckOverflow` expression only checks if the decimals can fit in the
 /// precision.
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct CheckOverflow {
     pub child: Arc<dyn PhysicalExpr>,
     pub data_type: DataType,
     pub fail_on_error: bool,
 }
 
+impl Hash for CheckOverflow {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.data_type.hash(state);
+        self.fail_on_error.hash(state);
+    }
+}
+
+impl PartialEq for CheckOverflow {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child)
+            && self.data_type.eq(&other.data_type)
+            && self.fail_on_error.eq(&other.fail_on_error)
+    }
+}
+
 impl CheckOverflow {
     pub fn new(child: Arc<dyn PhysicalExpr>, data_type: DataType, fail_on_error: bool) -> Self {
         Self {
@@ -64,19 +78,6 @@ impl Display for CheckOverflow {
     }
 }
 
-impl PartialEq<dyn Any> for CheckOverflow {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.child.eq(&x.child)
-                    && self.data_type.eq(&x.data_type)
-                    && self.fail_on_error.eq(&x.fail_on_error)
-            })
-            .unwrap_or(false)
-    }
-}
-
 impl PhysicalExpr for CheckOverflow {
     fn as_any(&self) -> &dyn Any {
         self
@@ -162,12 +163,4 @@ impl PhysicalExpr for CheckOverflow {
             self.fail_on_error,
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.data_type.hash(&mut s);
-        self.fail_on_error.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
diff --git a/native/spark-expr/src/correlation.rs b/native/spark-expr/src/correlation.rs
index e5f36c6f95..e4ddab95de 100644
--- a/native/spark-expr/src/correlation.rs
+++ b/native/spark-expr/src/correlation.rs
@@ -26,13 +26,12 @@ use arrow::{
     datatypes::{DataType, Field},
 };
 use datafusion::logical_expr::Accumulator;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{Result, ScalarValue};
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
 use datafusion_expr::type_coercion::aggregates::NUMERICS;
 use datafusion_expr::{AggregateUDFImpl, Signature, Volatility};
+use datafusion_physical_expr::expressions::format_state_name;
 use datafusion_physical_expr::expressions::StatsType;
-use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 
 /// CORR aggregate expression
 /// The implementation mostly is the same as the DataFusion's implementation. The reason
@@ -43,26 +42,16 @@ use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 pub struct Correlation {
     name: String,
     signature: Signature,
-    expr1: Arc<dyn PhysicalExpr>,
-    expr2: Arc<dyn PhysicalExpr>,
     null_on_divide_by_zero: bool,
 }
 
 impl Correlation {
-    pub fn new(
-        expr1: Arc<dyn PhysicalExpr>,
-        expr2: Arc<dyn PhysicalExpr>,
-        name: impl Into<String>,
-        data_type: DataType,
-        null_on_divide_by_zero: bool,
-    ) -> Self {
+    pub fn new(name: impl Into<String>, data_type: DataType, null_on_divide_by_zero: bool) -> Self {
         // the result of correlation just support FLOAT64 data type.
         assert!(matches!(data_type, DataType::Float64));
         Self {
             name: name.into(),
             signature: Signature::uniform(2, NUMERICS.to_vec(), Volatility::Immutable),
-            expr1,
-            expr2,
             null_on_divide_by_zero,
         }
     }
@@ -131,20 +120,6 @@ impl AggregateUDFImpl for Correlation {
     }
 }
 
-impl PartialEq<dyn Any> for Correlation {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.name == x.name
-                    && self.expr1.eq(&x.expr1)
-                    && self.expr2.eq(&x.expr2)
-                    && self.null_on_divide_by_zero == x.null_on_divide_by_zero
-            })
-            .unwrap_or(false)
-    }
-}
-
 /// An accumulator to compute correlation
 #[derive(Debug)]
 pub struct CorrelationAccumulator {
diff --git a/native/spark-expr/src/covariance.rs b/native/spark-expr/src/covariance.rs
index 9166e39766..fa3563cdea 100644
--- a/native/spark-expr/src/covariance.rs
+++ b/native/spark-expr/src/covariance.rs
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-use std::{any::Any, sync::Arc};
+use std::any::Any;
 
 use arrow::{
     array::{ArrayRef, Float64Array},
@@ -25,15 +25,14 @@ use arrow::{
     datatypes::{DataType, Field},
 };
 use datafusion::logical_expr::Accumulator;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{
     downcast_value, unwrap_or_internal_err, DataFusionError, Result, ScalarValue,
 };
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
 use datafusion_expr::type_coercion::aggregates::NUMERICS;
 use datafusion_expr::{AggregateUDFImpl, Signature, Volatility};
+use datafusion_physical_expr::expressions::format_state_name;
 use datafusion_physical_expr::expressions::StatsType;
-use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 
 /// COVAR_SAMP and COVAR_POP aggregate expression
 /// The implementation mostly is the same as the DataFusion's implementation. The reason
@@ -43,8 +42,6 @@ use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 pub struct Covariance {
     name: String,
     signature: Signature,
-    expr1: Arc<dyn PhysicalExpr>,
-    expr2: Arc<dyn PhysicalExpr>,
     stats_type: StatsType,
     null_on_divide_by_zero: bool,
 }
@@ -52,8 +49,6 @@ pub struct Covariance {
 impl Covariance {
     /// Create a new COVAR aggregate function
     pub fn new(
-        expr1: Arc<dyn PhysicalExpr>,
-        expr2: Arc<dyn PhysicalExpr>,
         name: impl Into<String>,
         data_type: DataType,
         stats_type: StatsType,
@@ -64,8 +59,6 @@ impl Covariance {
         Self {
             name: name.into(),
             signature: Signature::uniform(2, NUMERICS.to_vec(), Volatility::Immutable),
-            expr1,
-            expr2,
             stats_type,
             null_on_divide_by_zero,
         }
@@ -126,21 +119,6 @@ impl AggregateUDFImpl for Covariance {
     }
 }
 
-impl PartialEq<dyn Any> for Covariance {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.name == x.name
-                    && self.expr1.eq(&x.expr1)
-                    && self.expr2.eq(&x.expr2)
-                    && self.stats_type == x.stats_type
-                    && self.null_on_divide_by_zero == x.null_on_divide_by_zero
-            })
-            .unwrap_or(false)
-    }
-}
-
 /// An accumulator to compute covariance
 #[derive(Debug)]
 pub struct CovarianceAccumulator {
diff --git a/native/spark-expr/src/if_expr.rs b/native/spark-expr/src/if_expr.rs
index 193a90fb55..01c754ad6d 100644
--- a/native/spark-expr/src/if_expr.rs
+++ b/native/spark-expr/src/if_expr.rs
@@ -15,24 +15,19 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::{
-    any::Any,
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
-
 use arrow::{
     datatypes::{DataType, Schema},
     record_batch::RecordBatch,
 };
 use datafusion::logical_expr::ColumnarValue;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::Result;
 use datafusion_physical_expr::{expressions::CaseExpr, PhysicalExpr};
+use std::hash::Hash;
+use std::{any::Any, sync::Arc};
 
 /// IfExpr is a wrapper around CaseExpr, because `IF(a, b, c)` is semantically equivalent to
 /// `CASE WHEN a THEN b ELSE c END`.
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct IfExpr {
     if_expr: Arc<dyn PhysicalExpr>,
     true_expr: Arc<dyn PhysicalExpr>,
@@ -41,6 +36,23 @@ pub struct IfExpr {
     case_expr: Arc<CaseExpr>,
 }
 
+impl Hash for IfExpr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.if_expr.hash(state);
+        self.true_expr.hash(state);
+        self.false_expr.hash(state);
+        self.case_expr.hash(state);
+    }
+}
+impl PartialEq for IfExpr {
+    fn eq(&self, other: &Self) -> bool {
+        self.if_expr.eq(&other.if_expr)
+            && self.true_expr.eq(&other.true_expr)
+            && self.false_expr.eq(&other.false_expr)
+            && self.case_expr.eq(&other.case_expr)
+    }
+}
+
 impl std::fmt::Display for IfExpr {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(
@@ -106,27 +118,6 @@ impl PhysicalExpr for IfExpr {
             Arc::clone(&children[2]),
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.if_expr.hash(&mut s);
-        self.true_expr.hash(&mut s);
-        self.false_expr.hash(&mut s);
-        self.hash(&mut s);
-    }
-}
-
-impl PartialEq<dyn Any> for IfExpr {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.if_expr.eq(&x.if_expr)
-                    && self.true_expr.eq(&x.true_expr)
-                    && self.false_expr.eq(&x.false_expr)
-            })
-            .unwrap_or(false)
-    }
 }
 
 #[cfg(test)]
diff --git a/native/spark-expr/src/list.rs b/native/spark-expr/src/list.rs
index 7dc17b5688..fc31b11a0b 100644
--- a/native/spark-expr/src/list.rs
+++ b/native/spark-expr/src/list.rs
@@ -26,16 +26,15 @@ use arrow_array::{
 };
 use arrow_schema::{DataType, Field, FieldRef, Schema};
 use datafusion::logical_expr::ColumnarValue;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{
     cast::{as_int32_array, as_large_list_array, as_list_array},
     internal_err, DataFusionError, Result as DataFusionResult, ScalarValue,
 };
 use datafusion_physical_expr::PhysicalExpr;
+use std::hash::Hash;
 use std::{
     any::Any,
     fmt::{Debug, Display, Formatter},
-    hash::{Hash, Hasher},
     sync::Arc,
 };
 
@@ -44,7 +43,7 @@ use std::{
 // https://github.com/apache/spark/blob/master/common/utils/src/main/java/org/apache/spark/unsafe/array/ByteArrayUtils.java
 const MAX_ROUNDED_ARRAY_LENGTH: usize = 2147483632;
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct ListExtract {
     child: Arc<dyn PhysicalExpr>,
     ordinal: Arc<dyn PhysicalExpr>,
@@ -53,6 +52,25 @@ pub struct ListExtract {
     fail_on_error: bool,
 }
 
+impl Hash for ListExtract {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.ordinal.hash(state);
+        self.default_value.hash(state);
+        self.one_based.hash(state);
+        self.fail_on_error.hash(state);
+    }
+}
+impl PartialEq for ListExtract {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child)
+            && self.ordinal.eq(&other.ordinal)
+            && self.default_value.eq(&other.default_value)
+            && self.one_based.eq(&other.one_based)
+            && self.fail_on_error.eq(&other.fail_on_error)
+    }
+}
+
 impl ListExtract {
     pub fn new(
         child: Arc<dyn PhysicalExpr>,
@@ -176,16 +194,6 @@ impl PhysicalExpr for ListExtract {
             _ => internal_err!("ListExtract should have exactly two children"),
         }
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.ordinal.hash(&mut s);
-        self.default_value.hash(&mut s);
-        self.one_based.hash(&mut s);
-        self.fail_on_error.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
 fn one_based_index(index: i32, len: usize) -> DataFusionResult<Option<usize>> {
@@ -267,33 +275,24 @@ impl Display for ListExtract {
     }
 }
 
-impl PartialEq<dyn Any> for ListExtract {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.child.eq(&x.child)
-                    && self.ordinal.eq(&x.ordinal)
-                    && (self.default_value.is_none() == x.default_value.is_none())
-                    && self
-                        .default_value
-                        .as_ref()
-                        .zip(x.default_value.as_ref())
-                        .map(|(s, x)| s.eq(x))
-                        .unwrap_or(true)
-                    && self.one_based.eq(&x.one_based)
-                    && self.fail_on_error.eq(&x.fail_on_error)
-            })
-            .unwrap_or(false)
-    }
-}
-
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct GetArrayStructFields {
     child: Arc<dyn PhysicalExpr>,
     ordinal: usize,
 }
 
+impl Hash for GetArrayStructFields {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.ordinal.hash(state);
+    }
+}
+impl PartialEq for GetArrayStructFields {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child) && self.ordinal.eq(&other.ordinal)
+    }
+}
+
 impl GetArrayStructFields {
     pub fn new(child: Arc<dyn PhysicalExpr>, ordinal: usize) -> Self {
         Self { child, ordinal }
@@ -379,13 +378,6 @@ impl PhysicalExpr for GetArrayStructFields {
             _ => internal_err!("GetArrayStructFields should have exactly one child"),
         }
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.ordinal.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
 fn get_array_struct_fields<O: OffsetSizeTrait>(
@@ -417,16 +409,7 @@ impl Display for GetArrayStructFields {
     }
 }
 
-impl PartialEq<dyn Any> for GetArrayStructFields {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.child.eq(&x.child) && self.ordinal.eq(&x.ordinal))
-            .unwrap_or(false)
-    }
-}
-
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct ArrayInsert {
     src_array_expr: Arc<dyn PhysicalExpr>,
     pos_expr: Arc<dyn PhysicalExpr>,
@@ -434,6 +417,23 @@ pub struct ArrayInsert {
     legacy_negative_index: bool,
 }
 
+impl Hash for ArrayInsert {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.src_array_expr.hash(state);
+        self.pos_expr.hash(state);
+        self.item_expr.hash(state);
+        self.legacy_negative_index.hash(state);
+    }
+}
+impl PartialEq for ArrayInsert {
+    fn eq(&self, other: &Self) -> bool {
+        self.src_array_expr.eq(&other.src_array_expr)
+            && self.pos_expr.eq(&other.pos_expr)
+            && self.item_expr.eq(&other.item_expr)
+            && self.legacy_negative_index.eq(&other.legacy_negative_index)
+    }
+}
+
 impl ArrayInsert {
     pub fn new(
         src_array_expr: Arc<dyn PhysicalExpr>,
@@ -555,15 +555,6 @@ impl PhysicalExpr for ArrayInsert {
             _ => internal_err!("ArrayInsert should have exactly three childrens"),
         }
     }
-
-    fn dyn_hash(&self, _state: &mut dyn Hasher) {
-        let mut s = _state;
-        self.src_array_expr.hash(&mut s);
-        self.pos_expr.hash(&mut s);
-        self.item_expr.hash(&mut s);
-        self.legacy_negative_index.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
 fn array_insert<O: OffsetSizeTrait>(
@@ -694,20 +685,6 @@ impl Display for ArrayInsert {
     }
 }
 
-impl PartialEq<dyn Any> for ArrayInsert {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.src_array_expr.eq(&x.src_array_expr)
-                    && self.pos_expr.eq(&x.pos_expr)
-                    && self.item_expr.eq(&x.item_expr)
-                    && self.legacy_negative_index.eq(&x.legacy_negative_index)
-            })
-            .unwrap_or(false)
-    }
-}
-
 #[cfg(test)]
 mod test {
     use crate::list::{array_insert, list_extract, zero_based_index};
diff --git a/native/spark-expr/src/negative.rs b/native/spark-expr/src/negative.rs
index 3d9063e783..7fb5089179 100644
--- a/native/spark-expr/src/negative.rs
+++ b/native/spark-expr/src/negative.rs
@@ -21,18 +21,14 @@ use arrow::{compute::kernels::numeric::neg_wrapping, datatypes::IntervalDayTimeT
 use arrow_array::RecordBatch;
 use arrow_buffer::IntervalDayTime;
 use arrow_schema::{DataType, Schema};
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion::{
     logical_expr::{interval_arithmetic::Interval, ColumnarValue},
     physical_expr::PhysicalExpr,
 };
 use datafusion_common::{DataFusionError, Result, ScalarValue};
 use datafusion_expr::sort_properties::ExprProperties;
-use std::{
-    any::Any,
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
+use std::hash::Hash;
+use std::{any::Any, sync::Arc};
 
 pub fn create_negate_expr(
     expr: Arc<dyn PhysicalExpr>,
@@ -42,13 +38,26 @@ pub fn create_negate_expr(
 }
 
 /// Negative expression
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct NegativeExpr {
     /// Input expression
     arg: Arc<dyn PhysicalExpr>,
     fail_on_error: bool,
 }
 
+impl Hash for NegativeExpr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.arg.hash(state);
+        self.fail_on_error.hash(state);
+    }
+}
+
+impl PartialEq for NegativeExpr {
+    fn eq(&self, other: &Self) -> bool {
+        self.arg.eq(&other.arg) && self.fail_on_error.eq(&other.fail_on_error)
+    }
+}
+
 macro_rules! check_overflow {
     ($array:expr, $array_type:ty, $min_val:expr, $type_name:expr) => {{
         let typed_array = $array
@@ -204,11 +213,6 @@ impl PhysicalExpr for NegativeExpr {
         )))
     }
 
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.hash(&mut s);
-    }
-
     /// Given the child interval of a NegativeExpr, it calculates the NegativeExpr's interval.
     /// It replaces the upper and lower bounds after multiplying them with -1.
     /// Ex: `(a, b]` => `[-b, -a)`
@@ -255,12 +259,3 @@ impl PhysicalExpr for NegativeExpr {
         Ok(properties)
     }
 }
-
-impl PartialEq<dyn Any> for NegativeExpr {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.arg.eq(&x.arg))
-            .unwrap_or(false)
-    }
-}
diff --git a/native/spark-expr/src/normalize_nan.rs b/native/spark-expr/src/normalize_nan.rs
index c5331ad7bd..078ce4b5a4 100644
--- a/native/spark-expr/src/normalize_nan.rs
+++ b/native/spark-expr/src/normalize_nan.rs
@@ -15,13 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::{
-    any::Any,
-    fmt::{Display, Formatter},
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
-
 use arrow::{
     array::{as_primitive_array, ArrayAccessor, ArrayIter, Float32Array, Float64Array},
     datatypes::{ArrowNativeType, Float32Type, Float64Type},
@@ -29,15 +22,33 @@ use arrow::{
 };
 use arrow_schema::{DataType, Schema};
 use datafusion::logical_expr::ColumnarValue;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_physical_expr::PhysicalExpr;
+use std::hash::Hash;
+use std::{
+    any::Any,
+    fmt::{Display, Formatter},
+    sync::Arc,
+};
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct NormalizeNaNAndZero {
     pub data_type: DataType,
     pub child: Arc<dyn PhysicalExpr>,
 }
 
+impl PartialEq for NormalizeNaNAndZero {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child) && self.data_type.eq(&other.data_type)
+    }
+}
+
+impl Hash for NormalizeNaNAndZero {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.data_type.hash(state);
+    }
+}
+
 impl NormalizeNaNAndZero {
     pub fn new(data_type: DataType, child: Arc<dyn PhysicalExpr>) -> Self {
         Self { data_type, child }
@@ -89,13 +100,6 @@ impl PhysicalExpr for NormalizeNaNAndZero {
             Arc::clone(&children[0]),
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.data_type.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
 fn eval_typed<V: FloatDouble, T: ArrayAccessor<Item = V>>(input: T) -> Vec<Option<V>> {
@@ -120,15 +124,6 @@ impl Display for NormalizeNaNAndZero {
     }
 }
 
-impl PartialEq<dyn Any> for NormalizeNaNAndZero {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.child.eq(&x.child) && self.data_type.eq(&x.data_type))
-            .unwrap_or(false)
-    }
-}
-
 trait FloatDouble: ArrowNativeType {
     fn is_nan(&self) -> bool;
     fn nan(&self) -> Self;
diff --git a/native/spark-expr/src/regexp.rs b/native/spark-expr/src/regexp.rs
index c7626285a2..7f367a8bb9 100644
--- a/native/spark-expr/src/regexp.rs
+++ b/native/spark-expr/src/regexp.rs
@@ -21,7 +21,7 @@ use arrow_array::builder::BooleanBuilder;
 use arrow_array::types::Int32Type;
 use arrow_array::{Array, BooleanArray, DictionaryArray, RecordBatch, StringArray};
 use arrow_schema::{DataType, Schema};
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
+use datafusion::physical_expr_common::physical_expr::DynEq;
 use datafusion_common::{internal_err, Result};
 use datafusion_expr::ColumnarValue;
 use datafusion_physical_expr::PhysicalExpr;
@@ -53,6 +53,16 @@ impl Hash for RLike {
     }
 }
 
+impl DynEq for RLike {
+    fn dyn_eq(&self, other: &dyn Any) -> bool {
+        if let Some(other) = other.downcast_ref::<Self>() {
+            self.pattern_str == other.pattern_str
+        } else {
+            false
+        }
+    }
+}
+
 impl RLike {
     pub fn try_new(child: Arc<dyn PhysicalExpr>, pattern: &str) -> Result<Self> {
         Ok(Self {
@@ -93,15 +103,6 @@ impl Display for RLike {
     }
 }
 
-impl PartialEq<dyn Any> for RLike {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.child.eq(&x.child) && self.pattern_str.eq(&x.pattern_str))
-            .unwrap_or(false)
-    }
-}
-
 impl PhysicalExpr for RLike {
     fn as_any(&self) -> &dyn Any {
         self
@@ -161,10 +162,4 @@ impl PhysicalExpr for RLike {
             &self.pattern_str,
         )?))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        use std::hash::Hash;
-        let mut s = state;
-        self.hash(&mut s);
-    }
 }
diff --git a/native/spark-expr/src/stddev.rs b/native/spark-expr/src/stddev.rs
index 3cf604da0b..1ec5ffb69a 100644
--- a/native/spark-expr/src/stddev.rs
+++ b/native/spark-expr/src/stddev.rs
@@ -23,12 +23,12 @@ use arrow::{
     datatypes::{DataType, Field},
 };
 use datafusion::logical_expr::Accumulator;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
+use datafusion_common::types::NativeType;
 use datafusion_common::{internal_err, Result, ScalarValue};
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
 use datafusion_expr::{AggregateUDFImpl, Signature, Volatility};
+use datafusion_physical_expr::expressions::format_state_name;
 use datafusion_physical_expr::expressions::StatsType;
-use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 
 /// STDDEV and STDDEV_SAMP (standard deviation) aggregate expression
 /// The implementation mostly is the same as the DataFusion's implementation. The reason
@@ -39,7 +39,6 @@ use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 pub struct Stddev {
     name: String,
     signature: Signature,
-    expr: Arc<dyn PhysicalExpr>,
     stats_type: StatsType,
     null_on_divide_by_zero: bool,
 }
@@ -47,7 +46,6 @@ pub struct Stddev {
 impl Stddev {
     /// Create a new STDDEV aggregate function
     pub fn new(
-        expr: Arc<dyn PhysicalExpr>,
         name: impl Into<String>,
         data_type: DataType,
         stats_type: StatsType,
@@ -57,8 +55,14 @@ impl Stddev {
         assert!(matches!(data_type, DataType::Float64));
         Self {
             name: name.into(),
-            signature: Signature::coercible(vec![DataType::Float64], Volatility::Immutable),
-            expr,
+            signature: Signature::coercible(
+                vec![
+                    datafusion_expr_common::signature::TypeSignatureClass::Native(Arc::new(
+                        NativeType::Float64,
+                    )),
+                ],
+                Volatility::Immutable,
+            ),
             stats_type,
             null_on_divide_by_zero,
         }
@@ -121,20 +125,6 @@ impl AggregateUDFImpl for Stddev {
     }
 }
 
-impl PartialEq<dyn Any> for Stddev {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.name == x.name
-                    && self.expr.eq(&x.expr)
-                    && self.null_on_divide_by_zero == x.null_on_divide_by_zero
-                    && self.stats_type == x.stats_type
-            })
-            .unwrap_or(false)
-    }
-}
-
 /// An accumulator to compute the standard deviation
 #[derive(Debug)]
 pub struct StddevAccumulator {
diff --git a/native/spark-expr/src/strings.rs b/native/spark-expr/src/strings.rs
index a8aab6aee9..c2706b5896 100644
--- a/native/spark-expr/src/strings.rs
+++ b/native/spark-expr/src/strings.rs
@@ -27,19 +27,18 @@ use arrow::{
 };
 use arrow_schema::{DataType, Schema};
 use datafusion::logical_expr::ColumnarValue;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{DataFusionError, ScalarValue::Utf8};
 use datafusion_physical_expr::PhysicalExpr;
 use std::{
     any::Any,
     fmt::{Display, Formatter},
-    hash::{Hash, Hasher},
+    hash::Hash,
     sync::Arc,
 };
 
 macro_rules! make_predicate_function {
     ($name: ident, $kernel: ident, $str_scalar_kernel: ident) => {
-        #[derive(Debug, Hash)]
+        #[derive(Debug, Eq)]
         pub struct $name {
             left: Arc<dyn PhysicalExpr>,
             right: Arc<dyn PhysicalExpr>,
@@ -57,12 +56,16 @@ macro_rules! make_predicate_function {
             }
         }
 
-        impl PartialEq<dyn Any> for $name {
-            fn eq(&self, other: &dyn Any) -> bool {
-                down_cast_any_ref(other)
-                    .downcast_ref::<Self>()
-                    .map(|x| self.left.eq(&x.left) && self.right.eq(&x.right))
-                    .unwrap_or(false)
+        impl Hash for $name {
+            fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+                self.left.hash(state);
+                self.right.hash(state);
+            }
+        }
+
+        impl PartialEq for $name {
+            fn eq(&self, other: &Self) -> bool {
+                self.left.eq(&other.left) && self.right.eq(&other.right)
             }
         }
 
@@ -122,13 +125,6 @@ macro_rules! make_predicate_function {
                     children[1].clone(),
                 )))
             }
-
-            fn dyn_hash(&self, state: &mut dyn Hasher) {
-                let mut s = state;
-                self.left.hash(&mut s);
-                self.right.hash(&mut s);
-                self.hash(&mut s);
-            }
         }
     };
 }
@@ -141,18 +137,43 @@ make_predicate_function!(EndsWith, ends_with_dyn, ends_with_utf8_scalar_dyn);
 
 make_predicate_function!(Contains, contains_dyn, contains_utf8_scalar_dyn);
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct SubstringExpr {
     pub child: Arc<dyn PhysicalExpr>,
     pub start: i64,
     pub len: u64,
 }
 
-#[derive(Debug, Hash)]
+impl Hash for SubstringExpr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.start.hash(state);
+        self.len.hash(state);
+    }
+}
+
+impl PartialEq for SubstringExpr {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child) && self.start.eq(&other.start) && self.len.eq(&other.len)
+    }
+}
+#[derive(Debug, Eq)]
 pub struct StringSpaceExpr {
     pub child: Arc<dyn PhysicalExpr>,
 }
 
+impl Hash for StringSpaceExpr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+    }
+}
+
+impl PartialEq for StringSpaceExpr {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child)
+    }
+}
+
 impl SubstringExpr {
     pub fn new(child: Arc<dyn PhysicalExpr>, start: i64, len: u64) -> Self {
         Self { child, start, len }
@@ -181,15 +202,6 @@ impl Display for StringSpaceExpr {
     }
 }
 
-impl PartialEq<dyn Any> for SubstringExpr {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.child.eq(&x.child) && self.start.eq(&x.start) && self.len.eq(&x.len))
-            .unwrap_or(false)
-    }
-}
-
 impl PhysicalExpr for SubstringExpr {
     fn as_any(&self) -> &dyn Any {
         self
@@ -231,23 +243,6 @@ impl PhysicalExpr for SubstringExpr {
             self.len,
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.start.hash(&mut s);
-        self.len.hash(&mut s);
-        self.hash(&mut s);
-    }
-}
-
-impl PartialEq<dyn Any> for StringSpaceExpr {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.child.eq(&x.child))
-            .unwrap_or(false)
-    }
 }
 
 impl PhysicalExpr for StringSpaceExpr {
@@ -292,10 +287,4 @@ impl PhysicalExpr for StringSpaceExpr {
     ) -> datafusion_common::Result<Arc<dyn PhysicalExpr>> {
         Ok(Arc::new(StringSpaceExpr::new(Arc::clone(&children[0]))))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
diff --git a/native/spark-expr/src/structs.rs b/native/spark-expr/src/structs.rs
index cda8246d90..7cc49e4281 100644
--- a/native/spark-expr/src/structs.rs
+++ b/native/spark-expr/src/structs.rs
@@ -19,17 +19,16 @@ use arrow::record_batch::RecordBatch;
 use arrow_array::{Array, StructArray};
 use arrow_schema::{DataType, Field, Schema};
 use datafusion::logical_expr::ColumnarValue;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{DataFusionError, Result as DataFusionResult, ScalarValue};
 use datafusion_physical_expr::PhysicalExpr;
 use std::{
     any::Any,
     fmt::{Display, Formatter},
-    hash::{Hash, Hasher},
+    hash::Hash,
     sync::Arc,
 };
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Hash, PartialEq, Eq)]
 pub struct CreateNamedStruct {
     values: Vec<Arc<dyn PhysicalExpr>>,
     names: Vec<String>,
@@ -95,13 +94,6 @@ impl PhysicalExpr for CreateNamedStruct {
             self.names.clone(),
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.values.hash(&mut s);
-        self.names.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
 impl Display for CreateNamedStruct {
@@ -114,29 +106,24 @@ impl Display for CreateNamedStruct {
     }
 }
 
-impl PartialEq<dyn Any> for CreateNamedStruct {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.values
-                    .iter()
-                    .zip(x.values.iter())
-                    .all(|(a, b)| a.eq(b))
-                    && self.values.len() == x.values.len()
-                    && self.names.iter().zip(x.names.iter()).all(|(a, b)| a.eq(b))
-                    && self.names.len() == x.names.len()
-            })
-            .unwrap_or(false)
-    }
-}
-
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct GetStructField {
     child: Arc<dyn PhysicalExpr>,
     ordinal: usize,
 }
 
+impl Hash for GetStructField {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.ordinal.hash(state);
+    }
+}
+impl PartialEq for GetStructField {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child) && self.ordinal.eq(&other.ordinal)
+    }
+}
+
 impl GetStructField {
     pub fn new(child: Arc<dyn PhysicalExpr>, ordinal: usize) -> Self {
         Self { child, ordinal }
@@ -203,13 +190,6 @@ impl PhysicalExpr for GetStructField {
             self.ordinal,
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.ordinal.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
 impl Display for GetStructField {
@@ -222,15 +202,6 @@ impl Display for GetStructField {
     }
 }
 
-impl PartialEq<dyn Any> for GetStructField {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.child.eq(&x.child) && self.ordinal.eq(&x.ordinal))
-            .unwrap_or(false)
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::CreateNamedStruct;
diff --git a/native/spark-expr/src/sum_decimal.rs b/native/spark-expr/src/sum_decimal.rs
index ab142aee69..f3f34d9bfa 100644
--- a/native/spark-expr/src/sum_decimal.rs
+++ b/native/spark-expr/src/sum_decimal.rs
@@ -25,20 +25,16 @@ use arrow_array::{
 };
 use arrow_schema::{DataType, Field};
 use datafusion::logical_expr::{Accumulator, EmitTo, GroupsAccumulator};
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{DataFusionError, Result as DFResult, ScalarValue};
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
 use datafusion_expr::Volatility::Immutable;
 use datafusion_expr::{AggregateUDFImpl, ReversedUDAF, Signature};
-use datafusion_physical_expr::PhysicalExpr;
 use std::{any::Any, ops::BitAnd, sync::Arc};
 
 #[derive(Debug)]
 pub struct SumDecimal {
     /// Aggregate function signature
     signature: Signature,
-    /// The expression that provides the input decimal values to be summed
-    expr: Arc<dyn PhysicalExpr>,
     /// The data type of the SUM result. This will always be a decimal type
     /// with the same precision and scale as specified in this struct
     result_type: DataType,
@@ -49,7 +45,7 @@ pub struct SumDecimal {
 }
 
 impl SumDecimal {
-    pub fn try_new(expr: Arc<dyn PhysicalExpr>, data_type: DataType) -> DFResult<Self> {
+    pub fn try_new(data_type: DataType) -> DFResult<Self> {
         // The `data_type` is the SUM result type passed from Spark side
         let (precision, scale) = match data_type {
             DataType::Decimal128(p, s) => (p, s),
@@ -61,7 +57,6 @@ impl SumDecimal {
         };
         Ok(Self {
             signature: Signature::user_defined(Immutable),
-            expr,
             result_type: data_type,
             precision,
             scale,
@@ -132,20 +127,6 @@ impl AggregateUDFImpl for SumDecimal {
     }
 }
 
-impl PartialEq<dyn Any> for SumDecimal {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                // note that we do not compare result_type because this
-                // is guaranteed to match if the precision and scale
-                // match
-                self.precision == x.precision && self.scale == x.scale && self.expr.eq(&x.expr)
-            })
-            .unwrap_or(false)
-    }
-}
-
 #[derive(Debug)]
 struct SumDecimalAccumulator {
     sum: i128,
@@ -491,13 +472,13 @@ mod tests {
     use datafusion_common::Result;
     use datafusion_expr::AggregateUDF;
     use datafusion_physical_expr::aggregate::AggregateExprBuilder;
-    use datafusion_physical_expr::expressions::{Column, Literal};
+    use datafusion_physical_expr::expressions::Column;
+    use datafusion_physical_expr::PhysicalExpr;
     use futures::StreamExt;
 
     #[test]
     fn invalid_data_type() {
-        let expr = Arc::new(Literal::new(ScalarValue::Int32(Some(1))));
-        assert!(SumDecimal::try_new(expr, DataType::Int32).is_err());
+        assert!(SumDecimal::try_new(DataType::Int32).is_err());
     }
 
     #[tokio::test]
@@ -518,7 +499,6 @@ mod tests {
             Arc::new(MemoryExec::try_new(partitions, Arc::clone(&schema), None).unwrap());
 
         let aggregate_udf = Arc::new(AggregateUDF::new_from_impl(SumDecimal::try_new(
-            Arc::clone(&c1),
             data_type.clone(),
         )?));
 
diff --git a/native/spark-expr/src/temporal.rs b/native/spark-expr/src/temporal.rs
index 91953dd600..fb549f9ce8 100644
--- a/native/spark-expr/src/temporal.rs
+++ b/native/spark-expr/src/temporal.rs
@@ -15,36 +15,45 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::{
-    any::Any,
-    fmt::{Debug, Display, Formatter},
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
-
+use crate::utils::array_with_timezone;
 use arrow::{
     compute::{date_part, DatePart},
     record_batch::RecordBatch,
 };
 use arrow_schema::{DataType, Schema, TimeUnit::Microsecond};
 use datafusion::logical_expr::ColumnarValue;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{DataFusionError, ScalarValue::Utf8};
 use datafusion_physical_expr::PhysicalExpr;
-
-use crate::utils::array_with_timezone;
+use std::hash::Hash;
+use std::{
+    any::Any,
+    fmt::{Debug, Display, Formatter},
+    sync::Arc,
+};
 
 use crate::kernels::temporal::{
     date_trunc_array_fmt_dyn, date_trunc_dyn, timestamp_trunc_array_fmt_dyn, timestamp_trunc_dyn,
 };
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct HourExpr {
     /// An array with DataType::Timestamp(TimeUnit::Microsecond, None)
     child: Arc<dyn PhysicalExpr>,
     timezone: String,
 }
 
+impl Hash for HourExpr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.timezone.hash(state);
+    }
+}
+impl PartialEq for HourExpr {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child) && self.timezone.eq(&other.timezone)
+    }
+}
+
 impl HourExpr {
     pub fn new(child: Arc<dyn PhysicalExpr>, timezone: String) -> Self {
         HourExpr { child, timezone }
@@ -61,15 +70,6 @@ impl Display for HourExpr {
     }
 }
 
-impl PartialEq<dyn Any> for HourExpr {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.child.eq(&x.child) && self.timezone.eq(&x.timezone))
-            .unwrap_or(false)
-    }
-}
-
 impl PhysicalExpr for HourExpr {
     fn as_any(&self) -> &dyn Any {
         self
@@ -123,22 +123,27 @@ impl PhysicalExpr for HourExpr {
             self.timezone.clone(),
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.timezone.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct MinuteExpr {
     /// An array with DataType::Timestamp(TimeUnit::Microsecond, None)
     child: Arc<dyn PhysicalExpr>,
     timezone: String,
 }
 
+impl Hash for MinuteExpr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.timezone.hash(state);
+    }
+}
+impl PartialEq for MinuteExpr {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child) && self.timezone.eq(&other.timezone)
+    }
+}
+
 impl MinuteExpr {
     pub fn new(child: Arc<dyn PhysicalExpr>, timezone: String) -> Self {
         MinuteExpr { child, timezone }
@@ -155,15 +160,6 @@ impl Display for MinuteExpr {
     }
 }
 
-impl PartialEq<dyn Any> for MinuteExpr {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.child.eq(&x.child) && self.timezone.eq(&x.timezone))
-            .unwrap_or(false)
-    }
-}
-
 impl PhysicalExpr for MinuteExpr {
     fn as_any(&self) -> &dyn Any {
         self
@@ -217,22 +213,27 @@ impl PhysicalExpr for MinuteExpr {
             self.timezone.clone(),
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.timezone.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct SecondExpr {
     /// An array with DataType::Timestamp(TimeUnit::Microsecond, None)
     child: Arc<dyn PhysicalExpr>,
     timezone: String,
 }
 
+impl Hash for SecondExpr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.timezone.hash(state);
+    }
+}
+impl PartialEq for SecondExpr {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child) && self.timezone.eq(&other.timezone)
+    }
+}
+
 impl SecondExpr {
     pub fn new(child: Arc<dyn PhysicalExpr>, timezone: String) -> Self {
         SecondExpr { child, timezone }
@@ -249,15 +250,6 @@ impl Display for SecondExpr {
     }
 }
 
-impl PartialEq<dyn Any> for SecondExpr {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.child.eq(&x.child) && self.timezone.eq(&x.timezone))
-            .unwrap_or(false)
-    }
-}
-
 impl PhysicalExpr for SecondExpr {
     fn as_any(&self) -> &dyn Any {
         self
@@ -311,16 +303,9 @@ impl PhysicalExpr for SecondExpr {
             self.timezone.clone(),
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.timezone.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct DateTruncExpr {
     /// An array with DataType::Date32
     child: Arc<dyn PhysicalExpr>,
@@ -328,6 +313,18 @@ pub struct DateTruncExpr {
     format: Arc<dyn PhysicalExpr>,
 }
 
+impl Hash for DateTruncExpr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.format.hash(state);
+    }
+}
+impl PartialEq for DateTruncExpr {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child) && self.format.eq(&other.format)
+    }
+}
+
 impl DateTruncExpr {
     pub fn new(child: Arc<dyn PhysicalExpr>, format: Arc<dyn PhysicalExpr>) -> Self {
         DateTruncExpr { child, format }
@@ -344,15 +341,6 @@ impl Display for DateTruncExpr {
     }
 }
 
-impl PartialEq<dyn Any> for DateTruncExpr {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self.child.eq(&x.child) && self.format.eq(&x.format))
-            .unwrap_or(false)
-    }
-}
-
 impl PhysicalExpr for DateTruncExpr {
     fn as_any(&self) -> &dyn Any {
         self
@@ -398,16 +386,9 @@ impl PhysicalExpr for DateTruncExpr {
             Arc::clone(&self.format),
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.format.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct TimestampTruncExpr {
     /// An array with DataType::Timestamp(TimeUnit::Microsecond, None)
     child: Arc<dyn PhysicalExpr>,
@@ -422,6 +403,21 @@ pub struct TimestampTruncExpr {
     timezone: String,
 }
 
+impl Hash for TimestampTruncExpr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.child.hash(state);
+        self.format.hash(state);
+        self.timezone.hash(state);
+    }
+}
+impl PartialEq for TimestampTruncExpr {
+    fn eq(&self, other: &Self) -> bool {
+        self.child.eq(&other.child)
+            && self.format.eq(&other.format)
+            && self.timezone.eq(&other.timezone)
+    }
+}
+
 impl TimestampTruncExpr {
     pub fn new(
         child: Arc<dyn PhysicalExpr>,
@@ -446,19 +442,6 @@ impl Display for TimestampTruncExpr {
     }
 }
 
-impl PartialEq<dyn Any> for TimestampTruncExpr {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.child.eq(&x.child)
-                    && self.format.eq(&x.format)
-                    && self.timezone.eq(&x.timezone)
-            })
-            .unwrap_or(false)
-    }
-}
-
 impl PhysicalExpr for TimestampTruncExpr {
     fn as_any(&self) -> &dyn Any {
         self
@@ -524,12 +507,4 @@ impl PhysicalExpr for TimestampTruncExpr {
             self.timezone.clone(),
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.child.hash(&mut s);
-        self.format.hash(&mut s);
-        self.timezone.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
diff --git a/native/spark-expr/src/to_json.rs b/native/spark-expr/src/to_json.rs
index 1f68eb8606..91b46c6f04 100644
--- a/native/spark-expr/src/to_json.rs
+++ b/native/spark-expr/src/to_json.rs
@@ -29,11 +29,11 @@ use datafusion_expr::ColumnarValue;
 use datafusion_physical_expr::PhysicalExpr;
 use std::any::Any;
 use std::fmt::{Debug, Display, Formatter};
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
 use std::sync::Arc;
 
 /// to_json function
-#[derive(Debug, Hash)]
+#[derive(Debug, Eq)]
 pub struct ToJson {
     /// The input to convert to JSON
     expr: Arc<dyn PhysicalExpr>,
@@ -41,6 +41,18 @@ pub struct ToJson {
     timezone: String,
 }
 
+impl Hash for ToJson {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.expr.hash(state);
+        self.timezone.hash(state);
+    }
+}
+impl PartialEq for ToJson {
+    fn eq(&self, other: &Self) -> bool {
+        self.expr.eq(&other.expr) && self.timezone.eq(&other.timezone)
+    }
+}
+
 impl ToJson {
     pub fn new(expr: Arc<dyn PhysicalExpr>, timezone: &str) -> Self {
         Self {
@@ -101,13 +113,6 @@ impl PhysicalExpr for ToJson {
             &self.timezone,
         )))
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.expr.hash(&mut s);
-        self.timezone.hash(&mut s);
-        self.hash(&mut s);
-    }
 }
 
 /// Convert an array into a JSON value string representation
diff --git a/native/spark-expr/src/unbound.rs b/native/spark-expr/src/unbound.rs
index a6babd0f7e..14f68c9cd6 100644
--- a/native/spark-expr/src/unbound.rs
+++ b/native/spark-expr/src/unbound.rs
@@ -17,15 +17,10 @@
 
 use arrow_array::RecordBatch;
 use arrow_schema::{DataType, Schema};
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion::physical_plan::ColumnarValue;
 use datafusion_common::{internal_err, Result};
 use datafusion_physical_expr::PhysicalExpr;
-use std::{
-    any::Any,
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
+use std::{hash::Hash, sync::Arc};
 
 /// This is similar to `UnKnownColumn` in DataFusion, but it has data type.
 /// This is only used when the column is not bound to a schema, for example, the
@@ -93,18 +88,4 @@ impl PhysicalExpr for UnboundColumn {
     ) -> Result<Arc<dyn PhysicalExpr>> {
         Ok(self)
     }
-
-    fn dyn_hash(&self, state: &mut dyn Hasher) {
-        let mut s = state;
-        self.hash(&mut s);
-    }
-}
-
-impl PartialEq<dyn Any> for UnboundColumn {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| self == x)
-            .unwrap_or(false)
-    }
 }
diff --git a/native/spark-expr/src/variance.rs b/native/spark-expr/src/variance.rs
index 4370d89ff4..e71d713f59 100644
--- a/native/spark-expr/src/variance.rs
+++ b/native/spark-expr/src/variance.rs
@@ -15,20 +15,19 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::{any::Any, sync::Arc};
+use std::any::Any;
 
 use arrow::{
     array::{ArrayRef, Float64Array},
     datatypes::{DataType, Field},
 };
 use datafusion::logical_expr::Accumulator;
-use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_common::{downcast_value, DataFusionError, Result, ScalarValue};
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
 use datafusion_expr::Volatility::Immutable;
 use datafusion_expr::{AggregateUDFImpl, Signature};
+use datafusion_physical_expr::expressions::format_state_name;
 use datafusion_physical_expr::expressions::StatsType;
-use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 
 /// VAR_SAMP and VAR_POP aggregate expression
 /// The implementation mostly is the same as the DataFusion's implementation. The reason
@@ -39,7 +38,6 @@ use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 pub struct Variance {
     name: String,
     signature: Signature,
-    expr: Arc<dyn PhysicalExpr>,
     stats_type: StatsType,
     null_on_divide_by_zero: bool,
 }
@@ -47,7 +45,6 @@ pub struct Variance {
 impl Variance {
     /// Create a new VARIANCE aggregate function
     pub fn new(
-        expr: Arc<dyn PhysicalExpr>,
         name: impl Into<String>,
         data_type: DataType,
         stats_type: StatsType,
@@ -58,7 +55,6 @@ impl Variance {
         Self {
             name: name.into(),
             signature: Signature::numeric(1, Immutable),
-            expr,
             stats_type,
             null_on_divide_by_zero,
         }
@@ -118,17 +114,6 @@ impl AggregateUDFImpl for Variance {
     }
 }
 
-impl PartialEq<dyn Any> for Variance {
-    fn eq(&self, other: &dyn Any) -> bool {
-        down_cast_any_ref(other)
-            .downcast_ref::<Self>()
-            .map(|x| {
-                self.name == x.name && self.expr.eq(&x.expr) && self.stats_type == x.stats_type
-            })
-            .unwrap_or(false)
-    }
-}
-
 /// An accumulator to compute variance
 #[derive(Debug)]
 pub struct VarianceAccumulator {

From 4f8ce757b2832730e3d6974848cf5d3d89072283 Mon Sep 17 00:00:00 2001
From: Dharan Aditya <dharan.aditya@gmail.com>
Date: Fri, 3 Jan 2025 01:13:02 +0530
Subject: [PATCH 47/47] feat: add support for array_contains expression (#1163)

* feat: add support for array_contains expression

* test: add unit test for array_contains function

* Removes unnecessary case expression for handling null values

* chore: Move more expressions from core crate to spark-expr crate (#1152)

* move aggregate expressions to spark-expr crate

* move more expressions

* move benchmark

* normalize_nan

* bitwise not

* comet scalar funcs

* update bench imports

* remove dead code (#1155)

* fix: Spark 4.0-preview1 SPARK-47120 (#1156)

## Which issue does this PR close?

Part of https://github.com/apache/datafusion-comet/issues/372 and https://github.com/apache/datafusion-comet/issues/551

## Rationale for this change

To be ready for Spark 4.0

## What changes are included in this PR?

This PR fixes the new test SPARK-47120 added in Spark 4.0

## How are these changes tested?

tests enabled

* chore: Move string kernels and expressions to spark-expr crate (#1164)

* Move string kernels and expressions to spark-expr crate

* remove unused hash kernel

* remove unused dependencies

* chore: Move remaining expressions to spark-expr crate + some minor refactoring (#1165)

* move CheckOverflow to spark-expr crate

* move NegativeExpr to spark-expr crate

* move UnboundColumn to spark-expr crate

* move ExpandExec from execution::datafusion::operators to execution::operators

* refactoring to remove datafusion subpackage

* update imports in benches

* fix

* fix

* chore: Add ignored tests for reading complex types from Parquet (#1167)

* Add ignored tests for reading structs from Parquet

* add basic map test

* add tests for Map and Array

* feat: Add Spark-compatible implementation of SchemaAdapterFactory (#1169)

* Add Spark-compatible SchemaAdapterFactory implementation

* remove prototype code

* fix

* refactor

* implement more cast logic

* implement more cast logic

* add basic test

* improve test

* cleanup

* fmt

* add support for casting unsigned int to signed int

* clippy

* address feedback

* fix test

* fix: Document enabling comet explain plan usage in Spark (4.0) (#1176)

* test: enabling Spark tests with offHeap requirement (#1177)

## Which issue does this PR close?

## Rationale for this change

After https://github.com/apache/datafusion-comet/pull/1062 We have not running Spark tests for native execution

## What changes are included in this PR?

Removed the off heap requirement for testing

## How are these changes tested?

Bringing back Spark tests for native execution

* feat: Improve shuffle metrics (second attempt) (#1175)

* improve shuffle metrics

* docs

* more metrics

* refactor

* address feedback

* fix: stddev_pop should not directly return 0.0 when count is 1.0 (#1184)

* add test

* fix

* fix

* fix

* feat: Make native shuffle compression configurable and respect `spark.shuffle.compress` (#1185)

* Make shuffle compression codec and level configurable

* remove lz4 references

* docs

* update comment

* clippy

* fix benches

* clippy

* clippy

* disable test for miri

* remove lz4 reference from proto

* minor: move shuffle classes from common to spark (#1193)

* minor: refactor decodeBatches to make private in broadcast exchange (#1195)

* minor: refactor prepare_output so that it does not require an ExecutionContext (#1194)

* fix: fix missing explanation for then branch in case when (#1200)

* minor: remove unused source files (#1202)

* chore: Upgrade to DataFusion 44.0.0-rc2 (#1154)

* move aggregate expressions to spark-expr crate

* move more expressions

* move benchmark

* normalize_nan

* bitwise not

* comet scalar funcs

* update bench imports

* save

* save

* save

* remove unused imports

* clippy

* implement more hashers

* implement Hash and PartialEq

* implement Hash and PartialEq

* implement Hash and PartialEq

* benches

* fix ScalarUDFImpl.return_type failure

* exclude test from miri

* ignore correct test

* ignore another test

* remove miri checks

* use return_type_from_exprs

* Revert "use return_type_from_exprs"

This reverts commit febc1f1ec1301f9b359fc23ad6a117224fce35b7.

* use DF main branch

* hacky workaround for regression in ScalarUDFImpl.return_type

* fix repo url

* pin to revision

* bump to latest rev

* bump to latest DF rev

* bump DF to rev 9f530dd

* add Cargo.lock

* bump DF version

* no default features

* Revert "remove miri checks"

This reverts commit 4638fe3aa5501966cd5d8b53acf26c698b10b3c9.

* Update pin to DataFusion e99e02b9b9093ceb0c13a2dd32a2a89beba47930

* update pin

* Update Cargo.toml

Bump to 44.0.0-rc2

* update cargo lock

* revert miri change

---------

Co-authored-by: Andrew Lamb <andrew@nerdnetworks.org>

* update UT

Signed-off-by: Dharan Aditya <dharan.aditya@gmail.com>

* fix typo in UT

Signed-off-by: Dharan Aditya <dharan.aditya@gmail.com>

---------

Signed-off-by: Dharan Aditya <dharan.aditya@gmail.com>
Co-authored-by: Andy Grove <agrove@apache.org>
Co-authored-by: KAZUYUKI TANIMURA <ktanimura@apple.com>
Co-authored-by: Parth Chandra <parthc@apache.org>
Co-authored-by: Liang-Chi Hsieh <viirya@gmail.com>
Co-authored-by: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Co-authored-by: Andrew Lamb <andrew@nerdnetworks.org>
---
 native/core/src/execution/planner.rs              | 15 +++++++++++++++
 native/proto/src/proto/expr.proto                 |  1 +
 .../org/apache/comet/serde/QueryPlanSerde.scala   |  6 ++++++
 .../org/apache/comet/CometExpressionSuite.scala   | 12 ++++++++++++
 4 files changed, 34 insertions(+)

diff --git a/native/core/src/execution/planner.rs b/native/core/src/execution/planner.rs
index 5a35c62e33..c40e2e73f9 100644
--- a/native/core/src/execution/planner.rs
+++ b/native/core/src/execution/planner.rs
@@ -98,6 +98,7 @@ use datafusion_expr::{
     AggregateUDF, ScalarUDF, WindowFrame, WindowFrameBound, WindowFrameUnits,
     WindowFunctionDefinition,
 };
+use datafusion_functions_nested::array_has::ArrayHas;
 use datafusion_physical_expr::expressions::{Literal, StatsType};
 use datafusion_physical_expr::window::WindowExpr;
 use datafusion_physical_expr::LexOrdering;
@@ -719,6 +720,20 @@ impl PhysicalPlanner {
                     expr.legacy_negative_index,
                 )))
             }
+            ExprStruct::ArrayContains(expr) => {
+                let src_array_expr =
+                    self.create_expr(expr.left.as_ref().unwrap(), Arc::clone(&input_schema))?;
+                let key_expr =
+                    self.create_expr(expr.right.as_ref().unwrap(), Arc::clone(&input_schema))?;
+                let args = vec![Arc::clone(&src_array_expr), key_expr];
+                let array_has_expr = Arc::new(ScalarFunctionExpr::new(
+                    "array_has",
+                    Arc::new(ScalarUDF::new_from_impl(ArrayHas::new())),
+                    args,
+                    DataType::Boolean,
+                ));
+                Ok(array_has_expr)
+            }
             expr => Err(ExecutionError::GeneralError(format!(
                 "Not implemented: {:?}",
                 expr
diff --git a/native/proto/src/proto/expr.proto b/native/proto/src/proto/expr.proto
index 7a8ea78d57..e76ecdccf1 100644
--- a/native/proto/src/proto/expr.proto
+++ b/native/proto/src/proto/expr.proto
@@ -84,6 +84,7 @@ message Expr {
     GetArrayStructFields get_array_struct_fields = 57;
     BinaryExpr array_append = 58;
     ArrayInsert array_insert = 59;
+    BinaryExpr array_contains = 60;
   }
 }
 
diff --git a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
index 518fa06858..dc081b196b 100644
--- a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
+++ b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
@@ -2266,6 +2266,12 @@ object QueryPlanSerde extends Logging with ShimQueryPlanSerde with CometExprShim
             withInfo(expr, "unsupported arguments for GetArrayStructFields", child)
             None
           }
+        case expr if expr.prettyName == "array_contains" =>
+          createBinaryExpr(
+            expr.children(0),
+            expr.children(1),
+            inputs,
+            (builder, binaryExpr) => builder.setArrayContains(binaryExpr))
         case _ if expr.prettyName == "array_append" =>
           createBinaryExpr(
             expr.children(0),
diff --git a/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala b/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
index cce7cb20a1..36d3706506 100644
--- a/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
@@ -2517,4 +2517,16 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
       checkSparkAnswer(df.select("arrUnsupportedArgs"))
     }
   }
+
+  test("array_contains") {
+    withTempDir { dir =>
+      val path = new Path(dir.toURI.toString, "test.parquet")
+      makeParquetFileAllTypes(path, dictionaryEnabled = false, n = 10000)
+      spark.read.parquet(path.toString).createOrReplaceTempView("t1");
+      checkSparkAnswerAndOperator(
+        spark.sql("SELECT array_contains(array(_2, _3, _4), _2) FROM t1"))
+      checkSparkAnswerAndOperator(
+        spark.sql("SELECT array_contains((CASE WHEN _2 =_3 THEN array(_4) END), _4) FROM t1"));
+    }
+  }
 }