From ee35695dd47f033afc4bdd2be6e8c7a45fb435d1 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 5 Dec 2024 16:58:54 -0700
Subject: [PATCH 1/6] replace pub with pub(crate)

---
 native/core/README.md                         |  26 ++++
 native/core/benches/common.rs                 |   8 +-
 native/core/benches/parquet_read.rs           |   2 +-
 native/core/benches/perf.rs                   |   4 +-
 native/core/benches/row_columnar.rs           |   4 +-
 native/core/src/common/bit.rs                 | 115 +++++++++---------
 native/core/src/common/buffer.rs              |  28 ++---
 native/core/src/common/mod.rs                 |   4 +-
 native/core/src/data_type.rs                  |  32 ++---
 native/core/src/errors.rs                     |  44 +++----
 .../execution/datafusion/expressions/avg.rs   |  12 +-
 .../datafusion/expressions/avg_decimal.rs     |  17 ++-
 .../datafusion/expressions/bitwise_not.rs     |   8 +-
 .../expressions/bloom_filter_agg.rs           |   4 +-
 .../expressions/bloom_filter_might_contain.rs |   8 +-
 .../datafusion/expressions/checkoverflow.rs   |  16 ++-
 .../expressions/comet_scalar_funcs.rs         |   2 +-
 .../datafusion/expressions/correlation.rs     |   8 +-
 .../datafusion/expressions/covariance.rs      |  16 +--
 .../execution/datafusion/expressions/mod.rs   |  36 +++---
 .../datafusion/expressions/negative.rs        |   8 +-
 .../datafusion/expressions/normalize_nan.rs   |   8 +-
 .../datafusion/expressions/stddev.rs          |  10 +-
 .../datafusion/expressions/strings.rs         |  20 +--
 .../datafusion/expressions/subquery.rs        |   8 +-
 .../datafusion/expressions/sum_decimal.rs     |   4 +-
 .../datafusion/expressions/unbound.rs         |   6 +-
 .../datafusion/expressions/variance.rs        |  14 +--
 native/core/src/execution/datafusion/mod.rs   |   6 +-
 .../execution/datafusion/operators/expand.rs  |   8 +-
 .../src/execution/datafusion/operators/mod.rs |   2 +-
 .../core/src/execution/datafusion/planner.rs  |  18 +--
 .../execution/datafusion/shuffle_writer.rs    |  10 +-
 .../core/src/execution/datafusion/util/mod.rs |   4 +-
 .../datafusion/util/spark_bit_array.rs        |  24 ++--
 .../datafusion/util/spark_bloom_filter.rs     |  18 +--
 native/core/src/execution/jni_api.rs          |  36 +++---
 native/core/src/execution/kernels/hash.rs     |   2 +-
 native/core/src/execution/kernels/mod.rs      |   1 -
 native/core/src/execution/kernels/strings.rs  |  10 +-
 native/core/src/execution/memory_pool.rs      |   4 +-
 native/core/src/execution/metrics/mod.rs      |   2 +-
 native/core/src/execution/metrics/utils.rs    |   2 +-
 native/core/src/execution/mod.rs              |  15 ++-
 native/core/src/execution/operators/copy.rs   |   6 +-
 native/core/src/execution/operators/filter.rs |  18 +--
 native/core/src/execution/operators/mod.rs    |   9 +-
 native/core/src/execution/operators/scan.rs   |  26 ++--
 native/core/src/execution/serde.rs            |  10 +-
 native/core/src/execution/shuffle/list.rs     |   6 +-
 native/core/src/execution/shuffle/map.rs      |   6 +-
 native/core/src/execution/shuffle/mod.rs      |   2 +-
 native/core/src/execution/shuffle/row.rs      |  18 +--
 native/core/src/execution/sort.rs             |   4 +-
 native/core/src/execution/utils.rs            |   4 +-
 native/core/src/jvm_bridge/batch_iterator.rs  |  12 +-
 native/core/src/jvm_bridge/comet_exec.rs      |  52 ++++----
 .../core/src/jvm_bridge/comet_metric_node.rs  |  16 +--
 .../jvm_bridge/comet_task_memory_manager.rs   |  16 +--
 native/core/src/jvm_bridge/mod.rs             |  42 +++----
 native/core/src/lib.rs                        |  10 +-
 native/core/src/parquet/compression.rs        |  14 +--
 native/core/src/parquet/data_type.rs          |   6 +-
 native/core/src/parquet/mod.rs                |  58 ++++-----
 native/core/src/parquet/mutable_vector.rs     |  24 ++--
 native/core/src/parquet/read/column.rs        |  73 +++++------
 native/core/src/parquet/read/levels.rs        |  10 +-
 native/core/src/parquet/read/mod.rs           |  16 +--
 native/core/src/parquet/read/values.rs        |  16 +--
 native/core/src/parquet/util/bit_packing.rs   |   6 +-
 native/core/src/parquet/util/buffer.rs        |  16 +--
 native/core/src/parquet/util/jni.rs           |  15 ++-
 native/core/src/parquet/util/jni_buffer.rs    |   6 +-
 native/core/src/parquet/util/memory.rs        |  72 +++++------
 native/core/src/parquet/util/mod.rs           |   7 +-
 .../src/parquet/util/test_common/file_util.rs |   4 +-
 .../core/src/parquet/util/test_common/mod.rs  |  10 +-
 .../src/parquet/util/test_common/page_util.rs |  16 +--
 .../src/parquet/util/test_common/rand_gen.rs  |   8 +-
 79 files changed, 665 insertions(+), 603 deletions(-)
 create mode 100644 native/core/README.md

diff --git a/native/core/README.md b/native/core/README.md
new file mode 100644
index 000000000..c855216f4
--- /dev/null
+++ b/native/core/README.md
@@ -0,0 +1,26 @@
+<!--
+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.
+-->
+
+# Apache DataFusion Comet: Plugin Native Code 
+
+This crate contains the native code that is invoked from the Comet's Spark plugin and is not intended to be 
+used as a dependency from other projects. Therefore, it does not provide a public API and is not published to crates.io.
+
+However, the `datafusion-comet-proto` and `datafusion-comet-spark-expr` crates do provide public APIs and are 
+published to crates.io.
\ No newline at end of file
diff --git a/native/core/benches/common.rs b/native/core/benches/common.rs
index 15952b83c..1596e56b5 100644
--- a/native/core/benches/common.rs
+++ b/native/core/benches/common.rs
@@ -28,11 +28,11 @@ use rand::{
 use std::sync::Arc;
 
 /// Returns fixed seedable RNG
-pub fn seedable_rng() -> StdRng {
+pub(crate) fn seedable_rng() -> StdRng {
     StdRng::seed_from_u64(42)
 }
 
-pub fn create_int64_array(size: usize, null_density: f32, min: i64, max: i64) -> Int64Array {
+pub(crate) fn create_int64_array(size: usize, null_density: f32, min: i64, max: i64) -> Int64Array {
     let mut rng = seedable_rng();
     (0..size)
         .map(|_| {
@@ -46,7 +46,7 @@ pub fn create_int64_array(size: usize, null_density: f32, min: i64, max: i64) ->
 }
 
 #[allow(dead_code)]
-pub fn create_primitive_array<T>(size: usize, null_density: f32) -> PrimitiveArray<T>
+pub(crate) fn create_primitive_array<T>(size: usize, null_density: f32) -> PrimitiveArray<T>
 where
     T: ArrowPrimitiveType,
     Standard: Distribution<T::Native>,
@@ -66,7 +66,7 @@ where
 /// Creates a dictionary with random keys and values, with value type `T`.
 /// Note here the keys are the dictionary indices.
 #[allow(dead_code)]
-pub fn create_dictionary_array<T>(
+pub(crate) fn create_dictionary_array<T>(
     size: usize,
     value_size: usize,
     null_density: f32,
diff --git a/native/core/benches/parquet_read.rs b/native/core/benches/parquet_read.rs
index 1f8178cd2..c5eadf073 100644
--- a/native/core/benches/parquet_read.rs
+++ b/native/core/benches/parquet_read.rs
@@ -156,7 +156,7 @@ struct TestColumnReader {
 }
 
 impl TestColumnReader {
-    pub fn new(
+    pub(crate) fn new(
         cd: ColumnDescriptor,
         promotion_info: TypePromotionInfo,
         batch_size: usize,
diff --git a/native/core/benches/perf.rs b/native/core/benches/perf.rs
index f92ec0250..3c21782e1 100644
--- a/native/core/benches/perf.rs
+++ b/native/core/benches/perf.rs
@@ -25,13 +25,13 @@ use pprof::ProfilerGuard;
 /// Mostly followed this blog post: https://www.jibbow.com/posts/criterion-flamegraphs/
 /// After `cargo bench --bench <bench-name> -- --profile-time=<time>`
 /// You can find flamegraph.svg under `target/criterion/<bench-name>/<bench-method-name>/profile`
-pub struct FlamegraphProfiler<'a> {
+pub(crate) struct FlamegraphProfiler<'a> {
     frequency: c_int,
     active_profiler: Option<ProfilerGuard<'a>>,
 }
 
 impl<'a> FlamegraphProfiler<'a> {
-    pub fn new(frequency: c_int) -> Self {
+    pub(crate) fn new(frequency: c_int) -> Self {
         FlamegraphProfiler {
             frequency,
             active_profiler: None,
diff --git a/native/core/benches/row_columnar.rs b/native/core/benches/row_columnar.rs
index 60b41330e..056557b59 100644
--- a/native/core/benches/row_columnar.rs
+++ b/native/core/benches/row_columnar.rs
@@ -88,13 +88,13 @@ struct Row {
 }
 
 impl Row {
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Row {
             data: Box::new([0u8; ROW_SIZE]),
         }
     }
 
-    pub fn to_spark_row(&self, spark_row: &mut SparkUnsafeRow) {
+    pub(crate) fn to_spark_row(&self, spark_row: &mut SparkUnsafeRow) {
         spark_row.point_to_slice(self.data.as_ref());
     }
 }
diff --git a/native/core/src/common/bit.rs b/native/core/src/common/bit.rs
index 871786bb1..aef5a2100 100644
--- a/native/core/src/common/bit.rs
+++ b/native/core/src/common/bit.rs
@@ -27,7 +27,7 @@ use crate::{
 };
 
 #[inline]
-pub fn from_ne_slice<T: FromBytes>(bs: &[u8]) -> T {
+pub(crate) fn from_ne_slice<T: FromBytes>(bs: &[u8]) -> T {
     let mut b = T::Buffer::default();
     {
         let b = b.as_mut();
@@ -37,7 +37,7 @@ pub fn from_ne_slice<T: FromBytes>(bs: &[u8]) -> T {
     T::from_ne_bytes(b)
 }
 
-pub trait FromBytes: Sized {
+pub(crate) trait FromBytes: Sized {
     type Buffer: AsMut<[u8]> + Default;
     fn from_le_bytes(bs: Self::Buffer) -> Self;
     fn from_be_bytes(bs: Self::Buffer) -> Self;
@@ -108,7 +108,7 @@ macro_rules! read_num_bytes {
 /// u64 specific version of read_num_bytes!
 /// This is faster than read_num_bytes! because this method avoids buffer copies.
 #[inline]
-pub fn read_num_bytes_u64(size: usize, src: &[u8]) -> u64 {
+pub(crate) fn read_num_bytes_u64(size: usize, src: &[u8]) -> u64 {
     debug_assert!(size <= src.len());
     if unlikely(src.len() < 8) {
         return read_num_bytes!(u64, size, src);
@@ -121,7 +121,7 @@ pub fn read_num_bytes_u64(size: usize, src: &[u8]) -> u64 {
 /// u32 specific version of read_num_bytes!
 /// This is faster than read_num_bytes! because this method avoids buffer copies.
 #[inline]
-pub fn read_num_bytes_u32(size: usize, src: &[u8]) -> u32 {
+pub(crate) fn read_num_bytes_u32(size: usize, src: &[u8]) -> u32 {
     debug_assert!(size <= src.len());
     if unlikely(src.len() < 4) {
         return read_num_bytes!(u32, size, src);
@@ -132,13 +132,13 @@ pub fn read_num_bytes_u32(size: usize, src: &[u8]) -> u32 {
 }
 
 #[inline]
-pub fn read_u64(src: &[u8]) -> u64 {
+pub(crate) fn read_u64(src: &[u8]) -> u64 {
     let in_ptr = src.as_ptr() as *const u64;
     unsafe { in_ptr.read_unaligned() }
 }
 
 #[inline]
-pub fn read_u32(src: &[u8]) -> u32 {
+pub(crate) fn read_u32(src: &[u8]) -> u32 {
     let in_ptr = src.as_ptr() as *const u32;
     unsafe { in_ptr.read_unaligned() }
 }
@@ -155,7 +155,7 @@ macro_rules! read_num_be_bytes {
 }
 
 #[inline]
-pub fn memcpy(source: &[u8], target: &mut [u8]) {
+pub(crate) fn memcpy(source: &[u8], target: &mut [u8]) {
     debug_assert!(target.len() >= source.len(), "Copying from source to target is not possible. Source has {} bytes but target has {} bytes", source.len(), target.len());
     // Originally `target[..source.len()].copy_from_slice(source)`
     // We use the unsafe copy method to avoid some expensive bounds checking/
@@ -163,7 +163,7 @@ pub fn memcpy(source: &[u8], target: &mut [u8]) {
 }
 
 #[inline]
-pub fn memcpy_value<T>(source: &T, num_bytes: usize, target: &mut [u8])
+pub(crate) fn memcpy_value<T>(source: &T, num_bytes: usize, target: &mut [u8])
 where
     T: ?Sized + AsBytes,
 {
@@ -178,13 +178,13 @@ where
 
 /// Returns the ceil of value/divisor
 #[inline]
-pub fn ceil(value: usize, divisor: usize) -> usize {
+pub(crate) fn ceil(value: usize, divisor: usize) -> usize {
     value / divisor + ((value % divisor != 0) as usize)
 }
 
 /// Returns ceil(log2(x))
 #[inline]
-pub fn log2(mut x: u64) -> u32 {
+pub(crate) fn log2(mut x: u64) -> u32 {
     if x == 1 {
         return 0;
     }
@@ -194,7 +194,7 @@ pub fn log2(mut x: u64) -> u32 {
 
 /// Returns the `num_bits` least-significant bits of `v`
 #[inline]
-pub fn trailing_bits(v: u64, num_bits: usize) -> u64 {
+pub(crate) fn trailing_bits(v: u64, num_bits: usize) -> u64 {
     if unlikely(num_bits == 0) {
         return 0;
     }
@@ -205,7 +205,7 @@ pub fn trailing_bits(v: u64, num_bits: usize) -> u64 {
 }
 
 #[inline]
-pub fn set_bit(bits: &mut [u8], i: usize) {
+pub(crate) fn set_bit(bits: &mut [u8], i: usize) {
     bits[i / 8] |= 1 << (i % 8);
 }
 
@@ -214,17 +214,17 @@ pub fn set_bit(bits: &mut [u8], i: usize) {
 /// # Safety
 /// This doesn't check bounds, the caller must ensure that `i` is in (0, bits.len() * 8)
 #[inline]
-pub unsafe fn set_bit_raw(bits: *mut u8, i: usize) {
+pub(crate) unsafe fn set_bit_raw(bits: *mut u8, i: usize) {
     *bits.add(i / 8) |= 1 << (i % 8);
 }
 
 #[inline]
-pub fn unset_bit(bits: &mut [u8], i: usize) {
+pub(crate) fn unset_bit(bits: &mut [u8], i: usize) {
     bits[i / 8] &= !(1 << (i % 8));
 }
 
 #[inline]
-pub fn set_bits(bits: &mut [u8], offset: usize, length: usize) {
+pub(crate) fn set_bits(bits: &mut [u8], offset: usize, length: usize) {
     let mut byte_i = offset / 8;
     let offset_r = offset % 8;
     let end = offset + length;
@@ -255,7 +255,7 @@ pub fn set_bits(bits: &mut [u8], offset: usize, length: usize) {
 }
 
 #[inline(always)]
-pub fn mix_hash(lower: u64, upper: u64) -> u64 {
+pub(crate) fn mix_hash(lower: u64, upper: u64) -> u64 {
     let hash = (17 * 37u64).wrapping_add(lower);
     hash.wrapping_mul(37).wrapping_add(upper)
 }
@@ -264,7 +264,7 @@ static BIT_MASK: [u8; 8] = [1, 2, 4, 8, 16, 32, 64, 128];
 
 /// Returns whether bit at position `i` in `data` is set or not
 #[inline]
-pub fn get_bit(data: &[u8], i: usize) -> bool {
+pub(crate) fn get_bit(data: &[u8], i: usize) -> bool {
     (data[i >> 3] & BIT_MASK[i & 7]) != 0
 }
 
@@ -273,13 +273,13 @@ pub fn get_bit(data: &[u8], i: usize) -> bool {
 /// # Safety
 /// This doesn't check bounds, the caller must ensure that index < self.len()
 #[inline]
-pub unsafe fn get_bit_raw(ptr: *const u8, i: usize) -> bool {
+pub(crate) unsafe fn get_bit_raw(ptr: *const u8, i: usize) -> bool {
     (*ptr.add(i >> 3) & BIT_MASK[i & 7]) != 0
 }
 
 /// Utility class for writing bit/byte streams. This class can write data in either
 /// bit packed or byte aligned fashion.
-pub struct BitWriter {
+pub(crate) struct BitWriter {
     buffer: Vec<u8>,
     max_bytes: usize,
     buffered_values: u64,
@@ -289,7 +289,7 @@ pub struct BitWriter {
 }
 
 impl BitWriter {
-    pub fn new(max_bytes: usize) -> Self {
+    pub(crate) fn new(max_bytes: usize) -> Self {
         Self {
             buffer: vec![0; max_bytes],
             max_bytes,
@@ -302,7 +302,7 @@ impl BitWriter {
 
     /// Initializes the writer from the existing buffer `buffer` and starting
     /// offset `start`.
-    pub fn new_from_buf(buffer: Vec<u8>, start: usize) -> Self {
+    pub(crate) fn new_from_buf(buffer: Vec<u8>, start: usize) -> Self {
         debug_assert!(start < buffer.len());
         let len = buffer.len();
         Self {
@@ -317,7 +317,7 @@ impl BitWriter {
 
     /// Extend buffer size by `increment` bytes
     #[inline]
-    pub fn extend(&mut self, increment: usize) {
+    pub(crate) fn extend(&mut self, increment: usize) {
         self.max_bytes += increment;
         let extra = vec![0; increment];
         self.buffer.extend(extra);
@@ -325,13 +325,13 @@ impl BitWriter {
 
     /// Report buffer size, in bytes
     #[inline]
-    pub fn capacity(&mut self) -> usize {
+    pub(crate) fn capacity(&mut self) -> usize {
         self.max_bytes
     }
 
     /// Consumes and returns the current buffer.
     #[inline]
-    pub fn consume(mut self) -> Vec<u8> {
+    pub(crate) fn consume(mut self) -> Vec<u8> {
         self.flush();
         self.buffer.truncate(self.byte_offset);
         self.buffer
@@ -340,14 +340,14 @@ impl BitWriter {
     /// Flushes the internal buffered bits and returns the buffer's content.
     /// This is a borrow equivalent of `consume` method.
     #[inline]
-    pub fn flush_buffer(&mut self) -> &[u8] {
+    pub(crate) fn flush_buffer(&mut self) -> &[u8] {
         self.flush();
         &self.buffer()[0..self.byte_offset]
     }
 
     /// Clears the internal state so the buffer can be reused.
     #[inline]
-    pub fn clear(&mut self) {
+    pub(crate) fn clear(&mut self) {
         self.buffered_values = 0;
         self.byte_offset = self.start;
         self.bit_offset = 0;
@@ -355,7 +355,7 @@ impl BitWriter {
 
     /// Flushes the internal buffered bits and the align the buffer to the next byte.
     #[inline]
-    pub fn flush(&mut self) {
+    pub(crate) fn flush(&mut self) {
         let num_bytes = ceil(self.bit_offset, 8);
         debug_assert!(self.byte_offset + num_bytes <= self.max_bytes);
         memcpy_value(
@@ -376,7 +376,7 @@ impl BitWriter {
     /// Returns error if `num_bytes` is beyond the boundary of the internal buffer.
     /// Otherwise, returns the old offset.
     #[inline]
-    pub fn skip(&mut self, num_bytes: usize) -> Result<usize> {
+    pub(crate) fn skip(&mut self, num_bytes: usize) -> Result<usize> {
         self.flush();
         debug_assert!(self.byte_offset <= self.max_bytes);
         if unlikely(self.byte_offset + num_bytes > self.max_bytes) {
@@ -396,23 +396,23 @@ impl BitWriter {
     /// This is useful when you want to jump over `num_bytes` bytes and come back later
     /// to fill these bytes.
     #[inline]
-    pub fn get_next_byte_ptr(&mut self, num_bytes: usize) -> Result<&mut [u8]> {
+    pub(crate) fn get_next_byte_ptr(&mut self, num_bytes: usize) -> Result<&mut [u8]> {
         let offset = self.skip(num_bytes)?;
         Ok(&mut self.buffer[offset..offset + num_bytes])
     }
 
     #[inline]
-    pub fn bytes_written(&self) -> usize {
+    pub(crate) fn bytes_written(&self) -> usize {
         self.byte_offset - self.start + ceil(self.bit_offset, 8)
     }
 
     #[inline]
-    pub fn buffer(&self) -> &[u8] {
+    pub(crate) fn buffer(&self) -> &[u8] {
         &self.buffer[self.start..]
     }
 
     #[inline]
-    pub fn byte_offset(&self) -> usize {
+    pub(crate) fn byte_offset(&self) -> usize {
         self.byte_offset
     }
 
@@ -420,12 +420,12 @@ impl BitWriter {
     /// writer can write. User needs to call `consume` to consume the current buffer
     /// before more data can be written.
     #[inline]
-    pub fn buffer_len(&self) -> usize {
+    pub(crate) fn buffer_len(&self) -> usize {
         self.max_bytes
     }
 
     /// Writes the entire byte `value` at the byte `offset`
-    pub fn write_at(&mut self, offset: usize, value: u8) {
+    pub(crate) fn write_at(&mut self, offset: usize, value: u8) {
         self.buffer[offset] = value;
     }
 
@@ -435,7 +435,7 @@ impl BitWriter {
     /// Returns false if there's not enough room left. True otherwise.
     #[inline]
     #[allow(clippy::unnecessary_cast)]
-    pub fn put_value(&mut self, v: u64, num_bits: usize) -> bool {
+    pub(crate) fn put_value(&mut self, v: u64, num_bits: usize) -> bool {
         debug_assert!(num_bits <= 64);
         debug_assert_eq!(v.checked_shr(num_bits as u32).unwrap_or(0), 0); // covers case v >> 64
 
@@ -470,7 +470,7 @@ impl BitWriter {
     ///
     /// Returns false if there's not enough room left. True otherwise.
     #[inline]
-    pub fn put_aligned<T: AsBytes>(&mut self, val: T, num_bytes: usize) -> bool {
+    pub(crate) fn put_aligned<T: AsBytes>(&mut self, val: T, num_bytes: usize) -> bool {
         let result = self.get_next_byte_ptr(num_bytes);
         if unlikely(result.is_err()) {
             // TODO: should we return `Result` for this func?
@@ -490,7 +490,7 @@ impl BitWriter {
     /// Returns false if there's not enough room left, or the `pos` is not valid.
     /// True otherwise.
     #[inline]
-    pub fn put_aligned_offset<T: AsBytes>(
+    pub(crate) fn put_aligned_offset<T: AsBytes>(
         &mut self,
         val: T,
         num_bytes: usize,
@@ -511,7 +511,7 @@ impl BitWriter {
     ///
     /// Returns false if there's not enough room left. True otherwise.
     #[inline]
-    pub fn put_vlq_int(&mut self, mut v: u64) -> bool {
+    pub(crate) fn put_vlq_int(&mut self, mut v: u64) -> bool {
         let mut result = true;
         while v & 0xFFFFFFFFFFFFFF80 != 0 {
             result &= self.put_aligned::<u8>(((v & 0x7F) | 0x80) as u8, 1);
@@ -528,7 +528,7 @@ impl BitWriter {
     ///
     /// Returns false if there's not enough room left. True otherwise.
     #[inline]
-    pub fn put_zigzag_vlq_int(&mut self, v: i64) -> bool {
+    pub(crate) fn put_zigzag_vlq_int(&mut self, v: i64) -> bool {
         let u: u64 = ((v << 1) ^ (v >> 63)) as u64;
         self.put_vlq_int(u)
     }
@@ -536,9 +536,9 @@ impl BitWriter {
 
 /// Maximum byte length for a VLQ encoded integer
 /// MAX_VLQ_BYTE_LEN = 5 for i32, and MAX_VLQ_BYTE_LEN = 10 for i64
-pub const MAX_VLQ_BYTE_LEN: usize = 10;
+pub(crate) const MAX_VLQ_BYTE_LEN: usize = 10;
 
-pub struct BitReader {
+pub(crate) struct BitReader {
     /// The byte buffer to read from, passed in by client
     buffer: Buffer, // TODO: generalize this
 
@@ -565,7 +565,7 @@ pub struct BitReader {
 /// Utility class to read bit/byte stream. This class can read bits or bytes that are
 /// either byte aligned or not.
 impl BitReader {
-    pub fn new(buf: Buffer, len: usize) -> Self {
+    pub(crate) fn new(buf: Buffer, len: usize) -> Self {
         let buffered_values = if size_of::<u64>() > len {
             read_num_bytes_u64(len, buf.as_slice())
         } else {
@@ -580,12 +580,12 @@ impl BitReader {
         }
     }
 
-    pub fn new_all(buf: Buffer) -> Self {
+    pub(crate) fn new_all(buf: Buffer) -> Self {
         let len = buf.len();
         Self::new(buf, len)
     }
 
-    pub fn reset(&mut self, buf: Buffer) {
+    pub(crate) fn reset(&mut self, buf: Buffer) {
         self.buffer = buf;
         self.total_bytes = self.buffer.len();
         self.buffered_values = if size_of::<u64>() > self.total_bytes {
@@ -599,14 +599,14 @@ impl BitReader {
 
     /// Gets the current byte offset
     #[inline]
-    pub fn get_byte_offset(&self) -> usize {
+    pub(crate) fn get_byte_offset(&self) -> usize {
         self.byte_offset + ceil(self.bit_offset, 8)
     }
 
     /// Reads a value of type `T` and of size `num_bits`.
     ///
     /// Returns `None` if there's not enough data available. `Some` otherwise.
-    pub fn get_value<T: FromBytes>(&mut self, num_bits: usize) -> Option<T> {
+    pub(crate) fn get_value<T: FromBytes>(&mut self, num_bits: usize) -> Option<T> {
         debug_assert!(num_bits <= 64);
         debug_assert!(num_bits <= size_of::<T>() * 8);
 
@@ -629,7 +629,7 @@ impl BitReader {
     ///
     /// Undefined behavior will happen if any of the above assumptions is violated.
     #[inline]
-    pub fn get_u32_value(&mut self, num_bits: usize) -> u32 {
+    pub(crate) fn get_u32_value(&mut self, num_bits: usize) -> u32 {
         self.get_u64_value(num_bits) as u32
     }
 
@@ -661,7 +661,7 @@ impl BitReader {
     ///
     /// # Preconditions
     /// * `offset` MUST < dst.len() * 8
-    pub fn get_bits(&mut self, dst: &mut [u8], offset: usize, num_bits: usize) -> usize {
+    pub(crate) fn get_bits(&mut self, dst: &mut [u8], offset: usize, num_bits: usize) -> usize {
         debug_assert!(offset < dst.len() * 8);
 
         let remaining_bits = (self.total_bytes - self.byte_offset) * 8 - self.bit_offset;
@@ -744,7 +744,7 @@ impl BitReader {
     /// Skips at most `num` bits from this reader.
     ///
     /// Returns the actual number of bits skipped.
-    pub fn skip_bits(&mut self, num_bits: usize) -> usize {
+    pub(crate) fn skip_bits(&mut self, num_bits: usize) -> usize {
         let remaining_bits = (self.total_bytes - self.byte_offset) * 8 - self.bit_offset;
         let num_bits_to_read = min(remaining_bits, num_bits);
         let mut i = 0;
@@ -795,7 +795,12 @@ impl BitReader {
     /// Unlike `[get_batch]`, this method removes a few checks such as checking the remaining number
     /// of bits as well as checking the bit width for the element type in `dst`. Therefore, it is
     /// more efficient.
-    pub unsafe fn get_u32_batch(&mut self, mut dst: *mut u32, total: usize, num_bits: usize) {
+    pub(crate) unsafe fn get_u32_batch(
+        &mut self,
+        mut dst: *mut u32,
+        total: usize,
+        num_bits: usize,
+    ) {
         let mut i = 0;
 
         // First align bit offset to byte offset
@@ -824,7 +829,7 @@ impl BitReader {
         }
     }
 
-    pub fn get_batch<T: FromBytes>(&mut self, batch: &mut [T], num_bits: usize) -> usize {
+    pub(crate) fn get_batch<T: FromBytes>(&mut self, batch: &mut [T], num_bits: usize) -> usize {
         debug_assert!(num_bits <= 32);
         debug_assert!(num_bits <= size_of::<T>() * 8);
 
@@ -906,7 +911,7 @@ impl BitReader {
 
     /// Returns `Some` if there's enough bytes left to form a value of `T`.
     /// Otherwise `None`.
-    pub fn get_aligned<T: FromBytes>(&mut self, num_bytes: usize) -> Option<T> {
+    pub(crate) fn get_aligned<T: FromBytes>(&mut self, num_bytes: usize) -> Option<T> {
         debug_assert!(8 >= size_of::<T>());
         debug_assert!(num_bytes <= size_of::<T>());
 
@@ -949,7 +954,7 @@ impl BitReader {
     /// The encoded int must start at the beginning of a byte.
     ///
     /// Returns `None` if there's not enough bytes in the stream. `Some` otherwise.
-    pub fn get_vlq_int(&mut self) -> Option<i64> {
+    pub(crate) fn get_vlq_int(&mut self) -> Option<i64> {
         let mut shift = 0;
         let mut v: i64 = 0;
         while let Some(byte) = self.get_aligned::<u8>(1) {
@@ -977,7 +982,7 @@ impl BitReader {
     /// Returns `None` if the number of bytes there's not enough bytes in the stream.
     /// `Some` otherwise.
     #[inline]
-    pub fn get_zigzag_vlq_int(&mut self) -> Option<i64> {
+    pub(crate) fn get_zigzag_vlq_int(&mut self) -> Option<i64> {
         self.get_vlq_int().map(|v| {
             let u = v as u64;
             (u >> 1) as i64 ^ -((u & 1) as i64)
@@ -1006,7 +1011,7 @@ impl From<Vec<u8>> for BitReader {
 /// be a power of 2.
 ///
 /// Copied from the arrow crate to make arrow optional
-pub fn round_upto_power_of_2(num: usize, factor: usize) -> usize {
+pub(crate) fn round_upto_power_of_2(num: usize, factor: usize) -> usize {
     debug_assert!(factor > 0 && (factor & (factor - 1)) == 0);
     (num + (factor - 1)) & !(factor - 1)
 }
diff --git a/native/core/src/common/buffer.rs b/native/core/src/common/buffer.rs
index f24038a95..ed4694126 100644
--- a/native/core/src/common/buffer.rs
+++ b/native/core/src/common/buffer.rs
@@ -37,7 +37,7 @@ use std::{
 /// If `owned` is false, this buffer is an alias to another buffer. The buffer itself becomes
 /// immutable and can only be read.
 #[derive(Debug)]
-pub struct CometBuffer {
+pub(crate) struct CometBuffer {
     data: NonNull<u8>,
     len: usize,
     capacity: usize,
@@ -53,7 +53,7 @@ const ALIGNMENT: usize = 64;
 
 impl CometBuffer {
     /// Initializes a owned buffer filled with 0.
-    pub fn new(capacity: usize) -> Self {
+    pub(crate) fn new(capacity: usize) -> Self {
         let aligned_capacity = bit::round_upto_power_of_2(capacity, ALIGNMENT);
         unsafe {
             let layout = Layout::from_size_align_unchecked(aligned_capacity, ALIGNMENT);
@@ -67,7 +67,7 @@ impl CometBuffer {
         }
     }
 
-    pub fn from_ptr(ptr: *const u8, len: usize, capacity: usize) -> Self {
+    pub(crate) fn from_ptr(ptr: *const u8, len: usize, capacity: usize) -> Self {
         assert_eq!(
             capacity % ALIGNMENT,
             0,
@@ -88,34 +88,34 @@ impl CometBuffer {
     }
 
     /// Returns the capacity of this buffer.
-    pub fn capacity(&self) -> usize {
+    pub(crate) fn capacity(&self) -> usize {
         self.capacity
     }
 
     /// Returns the length (i.e., number of bytes) in this buffer.
-    pub fn len(&self) -> usize {
+    pub(crate) fn len(&self) -> usize {
         self.len
     }
 
     /// Whether this buffer is empty.
-    pub fn is_empty(&self) -> bool {
+    pub(crate) fn is_empty(&self) -> bool {
         self.len == 0
     }
 
     /// Returns the data stored in this buffer as a slice.
-    pub fn as_slice(&self) -> &[u8] {
+    pub(crate) fn as_slice(&self) -> &[u8] {
         self
     }
 
     /// Returns the data stored in this buffer as a mutable slice.
-    pub fn as_slice_mut(&mut self) -> &mut [u8] {
+    pub(crate) fn as_slice_mut(&mut self) -> &mut [u8] {
         debug_assert!(self.owned, "cannot modify un-owned buffer");
         self
     }
 
     /// Extends this buffer (must be an owned buffer) by appending bytes from `src`,
     /// starting from `offset`.
-    pub fn extend_from_slice(&mut self, offset: usize, src: &[u8]) {
+    pub(crate) fn extend_from_slice(&mut self, offset: usize, src: &[u8]) {
         debug_assert!(self.owned, "cannot modify un-owned buffer");
         debug_assert!(
             offset + src.len() <= self.capacity(),
@@ -134,14 +134,14 @@ impl CometBuffer {
     /// Returns a raw pointer to this buffer's internal memory
     /// This pointer is guaranteed to be aligned along cache-lines.
     #[inline]
-    pub const fn as_ptr(&self) -> *const u8 {
+    pub(crate) const fn as_ptr(&self) -> *const u8 {
         self.data.as_ptr()
     }
 
     /// Returns a mutable raw pointer to this buffer's internal memory
     /// This pointer is guaranteed to be aligned along cache-lines.
     #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut u8 {
+    pub(crate) fn as_mut_ptr(&mut self) -> *mut u8 {
         debug_assert!(self.owned, "cannot modify un-owned buffer");
         self.data.as_ptr()
     }
@@ -163,7 +163,7 @@ impl CometBuffer {
     /// because of the iterator-style pattern, the content of the original mutable buffer will only
     /// be updated once upstream operators fully consumed the previous output batch. For breaking
     /// operators, they are responsible for copying content out of the buffers.
-    pub unsafe fn to_arrow(&self) -> ArrowBuffer {
+    pub(crate) unsafe fn to_arrow(&self) -> ArrowBuffer {
         let ptr = NonNull::new_unchecked(self.data.as_ptr());
         // Uses a dummy `Arc::new(0)` as `Allocation` to ensure the memory region pointed by
         // `ptr` won't be freed when the returned `ArrowBuffer` goes out of scope.
@@ -171,7 +171,7 @@ impl CometBuffer {
     }
 
     /// Resets this buffer by filling all bytes with zeros.
-    pub fn reset(&mut self) {
+    pub(crate) fn reset(&mut self) {
         debug_assert!(self.owned, "cannot modify un-owned buffer");
         unsafe {
             std::ptr::write_bytes(self.as_mut_ptr(), 0, self.len);
@@ -181,7 +181,7 @@ impl CometBuffer {
     /// Resize this buffer to the `new_capacity`. For additional bytes allocated, they are filled
     /// with 0. if `new_capacity` is less than the current capacity of this buffer, this is a no-op.
     #[inline(always)]
-    pub fn resize(&mut self, new_capacity: usize) {
+    pub(crate) fn resize(&mut self, new_capacity: usize) {
         debug_assert!(self.owned, "cannot modify un-owned buffer");
         if new_capacity > self.len {
             let (ptr, new_capacity) =
diff --git a/native/core/src/common/mod.rs b/native/core/src/common/mod.rs
index 1b7dfad28..db5d07d54 100644
--- a/native/core/src/common/mod.rs
+++ b/native/core/src/common/mod.rs
@@ -16,7 +16,7 @@
 // under the License.
 
 #[macro_use]
-pub mod bit;
+pub(crate) mod bit;
 
 use crate::TypeTrait;
 
@@ -36,4 +36,4 @@ trait ValueSetter<T: TypeTrait> {
 }
 
 mod buffer;
-pub use buffer::*;
+pub(crate) use buffer::*;
diff --git a/native/core/src/data_type.rs b/native/core/src/data_type.rs
index b275de1c6..f03856877 100644
--- a/native/core/src/data_type.rs
+++ b/native/core/src/data_type.rs
@@ -20,7 +20,7 @@ use arrow_schema::TimeUnit;
 use std::{cmp, fmt::Debug};
 
 #[derive(Debug, PartialEq)]
-pub enum DataType {
+pub(crate) enum DataType {
     Boolean,
     Byte,
     Short,
@@ -60,7 +60,7 @@ impl From<&ArrowDataType> for DataType {
 }
 
 impl DataType {
-    pub fn kind(&self) -> TypeKind {
+    pub(crate) fn kind(&self) -> TypeKind {
         match self {
             DataType::Boolean => TypeKind::Boolean,
             DataType::Byte => TypeKind::Byte,
@@ -87,7 +87,7 @@ fn is_valid_key_type(dt: &ArrowDataType) -> bool {
 /// 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 {
+pub(crate) enum TypeKind {
     Boolean,
     Byte,
     Short,
@@ -102,11 +102,11 @@ pub enum TypeKind {
     Date,
 }
 
-pub const BITS_PER_BYTE: usize = 8;
+pub(crate) const BITS_PER_BYTE: usize = 8;
 
 impl TypeKind {
     /// Returns the size of this type, in number of bits.
-    pub fn type_size(&self) -> usize {
+    pub(crate) fn type_size(&self) -> usize {
         match self {
             TypeKind::Boolean => 1,
             TypeKind::Byte => BITS_PER_BYTE,
@@ -121,19 +121,19 @@ impl TypeKind {
     }
 }
 
-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
+pub(crate) const STRING_VIEW_LEN: usize = 16; // StringView is stored using 16 bytes
+pub(crate) 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,
+pub(crate) struct StringView {
+    pub(crate) len: u32,
+    pub(crate) prefix: [u8; STRING_VIEW_PREFIX_LEN],
+    pub(crate) ptr: usize,
 }
 
 impl StringView {
-    pub fn as_utf8_str(&self) -> &str {
+    pub(crate) 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)
@@ -163,7 +163,7 @@ impl PartialEq for StringView {
     }
 }
 
-pub trait NativeEqual {
+pub(crate) trait NativeEqual {
     fn is_equal(&self, other: &Self) -> bool;
 }
 
@@ -196,7 +196,7 @@ impl NativeEqual for f64 {
         self.total_cmp(other) == cmp::Ordering::Equal
     }
 }
-pub trait NativeType: Debug + Default + Copy + NativeEqual {}
+pub(crate) trait NativeType: Debug + Default + Copy + NativeEqual {}
 
 impl NativeType for bool {}
 impl NativeType for i8 {}
@@ -210,14 +210,14 @@ 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 {
+pub(crate) 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 {}
+        pub(crate) struct $name {}
         impl TypeTrait for $name {
             type Native = $native_ty;
             fn type_kind() -> TypeKind {
diff --git a/native/core/src/errors.rs b/native/core/src/errors.rs
index 92799bcf6..19fc86d15 100644
--- a/native/core/src/errors.rs
+++ b/native/core/src/errors.rs
@@ -50,7 +50,7 @@ lazy_static! {
 }
 
 #[derive(thiserror::Error, Debug)]
-pub enum CometError {
+pub(crate) enum CometError {
     #[error("Configuration Error: {0}")]
     Config(String),
 
@@ -144,7 +144,7 @@ pub enum CometError {
     },
 }
 
-pub fn init() {
+pub(crate) fn init() {
     std::panic::set_hook(Box::new(|_panic_info| {
         // Capture the backtrace for a panic
         *PANIC_BACKTRACE.lock().unwrap() =
@@ -244,7 +244,7 @@ impl jni::errors::ToException for CometError {
 
 /// Error returned when there is an error during executing an expression.
 #[derive(thiserror::Error, Debug)]
-pub enum ExpressionError {
+pub(crate) enum ExpressionError {
     /// Simple error
     #[error("General expression error with reason {0}.")]
     General(String),
@@ -263,7 +263,7 @@ pub enum ExpressionError {
 }
 
 /// A specialized `Result` for Comet errors.
-pub type CometResult<T> = result::Result<T, CometError>;
+pub(crate) type CometResult<T> = result::Result<T, CometError>;
 
 // ----------------------------------------------------------------------
 // Convenient macros for different errors
@@ -282,7 +282,7 @@ macro_rules! general_err {
 /// NOTE: We can't just use [Default] since both the trait and the object are defined in other
 /// crates.
 /// See [Rust Compiler Error Index - E0117](https://doc.rust-lang.org/error-index.html#E0117)
-pub trait JNIDefault {
+pub(crate) trait JNIDefault {
     fn default() -> Self;
 }
 
@@ -348,7 +348,7 @@ impl JNIDefault for () {
 // Unwrap the result returned from `panic::catch_unwind` when `Ok`, otherwise throw a
 // `RuntimeException` back to the calling Java.  Since a return result is required, use `JNIDefault`
 // to create a reasonable result.  This returned default value will be ignored due to the exception.
-pub fn unwrap_or_throw_default<T: JNIDefault>(
+pub(crate) fn unwrap_or_throw_default<T: JNIDefault>(
     env: &mut JNIEnv,
     result: std::result::Result<T, CometError>,
 ) -> T {
@@ -487,7 +487,7 @@ where
 
 // 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
+pub(crate) fn try_assert_unwind_safe_or_throw<T, F>(env: &JNIEnv, f: F) -> T
 where
     T: JNIDefault,
     F: FnOnce(JNIEnv) -> Result<T, CometError>,
@@ -504,7 +504,7 @@ where
 
 // 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
+pub(crate) fn try_unwrap_or_throw<T, F>(env: &JNIEnv, f: F) -> T
 where
     T: JNIDefault,
     F: FnOnce(JNIEnv) -> Result<T, CometError> + UnwindSafe,
@@ -539,7 +539,7 @@ mod tests {
         assert_starts_with_as_result,
     };
 
-    pub fn jvm() -> &'static Arc<JavaVM> {
+    pub(crate) fn jvm() -> &'static Arc<JavaVM> {
         static mut JVM: Option<Arc<JavaVM>> = None;
         static INIT: Once = Once::new();
 
@@ -585,7 +585,7 @@ mod tests {
 
     #[test]
     #[cfg_attr(miri, ignore)] // miri can't call foreign function `dlopen`
-    pub fn error_from_panic() {
+    pub(crate) fn error_from_panic() {
         let _guard = attach_current_thread();
         let mut env = jvm().get_env().unwrap();
 
@@ -604,7 +604,7 @@ mod tests {
     // a test of the "happy path".
     #[test]
     #[cfg_attr(miri, ignore)] // miri can't call foreign function `dlopen`
-    pub fn object_result() {
+    pub(crate) fn object_result() {
         let _guard = attach_current_thread();
         let mut env = jvm().get_env().unwrap();
 
@@ -622,7 +622,7 @@ mod tests {
     // a test of the "happy path".
     #[test]
     #[cfg_attr(miri, ignore)] // miri can't call foreign function `dlopen`
-    pub fn jlong_result() {
+    pub(crate) fn jlong_result() {
         let _guard = attach_current_thread();
         let mut env = jvm().get_env().unwrap();
 
@@ -639,7 +639,7 @@ mod tests {
     // causes an exception by dividing by zero.
     #[test]
     #[cfg_attr(miri, ignore)] // miri can't call foreign function `dlopen`
-    pub fn jlong_panic_exception() {
+    pub(crate) fn jlong_panic_exception() {
         let _guard = attach_current_thread();
         let mut env = jvm().get_env().unwrap();
 
@@ -660,7 +660,7 @@ mod tests {
     // a test of the "happy path".
     #[test]
     #[cfg_attr(miri, ignore)] // miri can't call foreign function `dlopen`
-    pub fn jlong_result_ok() {
+    pub(crate) fn jlong_result_ok() {
         let _guard = attach_current_thread();
         let mut env = jvm().get_env().unwrap();
 
@@ -677,7 +677,7 @@ mod tests {
     // a test of the "happy path".
     #[test]
     #[cfg_attr(miri, ignore)] // miri can't call foreign function `dlopen`
-    pub fn jlong_result_err() {
+    pub(crate) fn jlong_result_err() {
         let _guard = attach_current_thread();
         let mut env = jvm().get_env().unwrap();
 
@@ -698,7 +698,7 @@ mod tests {
     // a test of the "happy path".
     #[test]
     #[cfg_attr(miri, ignore)] // miri can't call foreign function `dlopen`
-    pub fn jint_array_result() {
+    pub(crate) fn jint_array_result() {
         let _guard = attach_current_thread();
         let mut env = jvm().get_env().unwrap();
 
@@ -719,7 +719,7 @@ mod tests {
     // causes an exception by dividing by zero.
     #[test]
     #[cfg_attr(miri, ignore)] // miri can't call foreign function `dlopen`
-    pub fn jint_array_panic_exception() {
+    pub(crate) fn jint_array_panic_exception() {
         let _guard = attach_current_thread();
         let mut env = jvm().get_env().unwrap();
 
@@ -743,7 +743,7 @@ mod tests {
     /// that the resulting stack trace includes the offending call.
     #[test]
     #[cfg_attr(miri, ignore)] // miri can't call foreign function `dlopen`
-    pub fn stacktrace_string() {
+    pub(crate) fn stacktrace_string() {
         // Setup: Start with a backtrace that includes all of the expected scenarios, including
         // cases where the file and location are not provided as part of the backtrace capture
         let backtrace_string = read_resource("testdata/backtrace.txt").expect("backtrace content");
@@ -773,7 +773,7 @@ mod tests {
     // * returning an object
     // * throwing an exception from `.expect()`
     #[no_mangle]
-    pub extern "system" fn Java_Errors_hello(
+    pub(crate) extern "system" fn Java_Errors_hello(
         e: &JNIEnv,
         _class: JClass,
         input: JString,
@@ -796,7 +796,7 @@ mod tests {
     // * returning an native type
     // * throwing an exception when dividing by zero
     #[no_mangle]
-    pub extern "system" fn Java_Errors_div(
+    pub(crate) extern "system" fn Java_Errors_div(
         env: &JNIEnv,
         _class: JClass,
         a: jlong,
@@ -806,7 +806,7 @@ mod tests {
     }
 
     #[no_mangle]
-    pub extern "system" fn Java_Errors_div_with_parse(
+    pub(crate) extern "system" fn Java_Errors_div_with_parse(
         e: &JNIEnv,
         _class: JClass,
         a: JString,
@@ -823,7 +823,7 @@ mod tests {
     // * returning an array
     // * throwing an exception when dividing by zero
     #[no_mangle]
-    pub extern "system" fn Java_Errors_array_div(
+    pub(crate) extern "system" fn Java_Errors_array_div(
         e: &JNIEnv,
         _class: JClass,
         input: &JIntArray,
diff --git a/native/core/src/execution/datafusion/expressions/avg.rs b/native/core/src/execution/datafusion/expressions/avg.rs
index 7820497d4..ae4942c5c 100644
--- a/native/core/src/execution/datafusion/expressions/avg.rs
+++ b/native/core/src/execution/datafusion/expressions/avg.rs
@@ -39,7 +39,7 @@ use DataType::*;
 
 /// AVG aggregate expression
 #[derive(Debug, Clone)]
-pub struct Avg {
+pub(crate) struct Avg {
     name: String,
     signature: Signature,
     expr: Arc<dyn PhysicalExpr>,
@@ -49,7 +49,11 @@ pub struct Avg {
 
 impl Avg {
     /// Create a new AVG aggregate function
-    pub fn new(expr: Arc<dyn PhysicalExpr>, name: impl Into<String>, data_type: DataType) -> Self {
+    pub(crate) fn new(
+        expr: Arc<dyn PhysicalExpr>,
+        name: impl Into<String>,
+        data_type: DataType,
+    ) -> Self {
         let result_data_type = avg_return_type("avg", &data_type).unwrap();
 
         Self {
@@ -155,7 +159,7 @@ impl PartialEq<dyn Any> for Avg {
 
 /// An accumulator to compute the average
 #[derive(Debug, Default)]
-pub struct AvgAccumulator {
+pub(crate) struct AvgAccumulator {
     sum: Option<f64>,
     count: i64,
 }
@@ -236,7 +240,7 @@ where
     T: ArrowNumericType + Send,
     F: Fn(T::Native, i64) -> Result<T::Native> + Send,
 {
-    pub fn new(return_data_type: &DataType, avg_fn: F) -> Self {
+    pub(crate) fn new(return_data_type: &DataType, avg_fn: F) -> Self {
         Self {
             return_data_type: return_data_type.clone(),
             counts: vec![],
diff --git a/native/core/src/execution/datafusion/expressions/avg_decimal.rs b/native/core/src/execution/datafusion/expressions/avg_decimal.rs
index a265fdc29..c74c03860 100644
--- a/native/core/src/execution/datafusion/expressions/avg_decimal.rs
+++ b/native/core/src/execution/datafusion/expressions/avg_decimal.rs
@@ -41,7 +41,7 @@ use DataType::*;
 
 /// AVG aggregate expression
 #[derive(Debug, Clone)]
-pub struct AvgDecimal {
+pub(crate) struct AvgDecimal {
     signature: Signature,
     expr: Arc<dyn PhysicalExpr>,
     sum_data_type: DataType,
@@ -50,7 +50,11 @@ pub struct AvgDecimal {
 
 impl AvgDecimal {
     /// Create a new AVG aggregate function
-    pub fn new(expr: Arc<dyn PhysicalExpr>, result_type: DataType, sum_type: DataType) -> Self {
+    pub(crate) fn new(
+        expr: Arc<dyn PhysicalExpr>,
+        result_type: DataType,
+        sum_type: DataType,
+    ) -> Self {
         Self {
             signature: Signature::user_defined(Immutable),
             expr,
@@ -183,7 +187,12 @@ struct AvgDecimalAccumulator {
 }
 
 impl AvgDecimalAccumulator {
-    pub fn new(sum_scale: i8, sum_precision: u8, target_precision: u8, target_scale: i8) -> Self {
+    pub(crate) fn new(
+        sum_scale: i8,
+        sum_precision: u8,
+        target_precision: u8,
+        target_scale: i8,
+    ) -> Self {
         Self {
             sum: None,
             count: 0,
@@ -334,7 +343,7 @@ struct AvgDecimalGroupsAccumulator {
 }
 
 impl AvgDecimalGroupsAccumulator {
-    pub fn new(
+    pub(crate) fn new(
         return_data_type: &DataType,
         sum_data_type: &DataType,
         target_precision: u8,
diff --git a/native/core/src/execution/datafusion/expressions/bitwise_not.rs b/native/core/src/execution/datafusion/expressions/bitwise_not.rs
index a2b9ebe5b..5c3e796de 100644
--- a/native/core/src/execution/datafusion/expressions/bitwise_not.rs
+++ b/native/core/src/execution/datafusion/expressions/bitwise_not.rs
@@ -44,19 +44,19 @@ macro_rules! compute_op {
 
 /// BitwiseNot expression
 #[derive(Debug, Hash)]
-pub struct BitwiseNotExpr {
+pub(crate) struct BitwiseNotExpr {
     /// Input expression
     arg: Arc<dyn PhysicalExpr>,
 }
 
 impl BitwiseNotExpr {
     /// Create new bitwise not expression
-    pub fn new(arg: Arc<dyn PhysicalExpr>) -> Self {
+    pub(crate) fn new(arg: Arc<dyn PhysicalExpr>) -> Self {
         Self { arg }
     }
 
     /// Get the input expression
-    pub fn arg(&self) -> &Arc<dyn PhysicalExpr> {
+    pub(crate) fn arg(&self) -> &Arc<dyn PhysicalExpr> {
         &self.arg
     }
 }
@@ -131,7 +131,7 @@ impl PartialEq<dyn Any> for BitwiseNotExpr {
     }
 }
 
-pub fn bitwise_not(arg: Arc<dyn PhysicalExpr>) -> Result<Arc<dyn PhysicalExpr>> {
+pub(crate) fn bitwise_not(arg: Arc<dyn PhysicalExpr>) -> Result<Arc<dyn PhysicalExpr>> {
     Ok(Arc::new(BitwiseNotExpr::new(arg)))
 }
 
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 e6528a563..2870dc98d 100644
--- a/native/core/src/execution/datafusion/expressions/bloom_filter_agg.rs
+++ b/native/core/src/execution/datafusion/expressions/bloom_filter_agg.rs
@@ -33,7 +33,7 @@ use datafusion_expr::{
 use datafusion_physical_expr::expressions::Literal;
 
 #[derive(Debug, Clone)]
-pub struct BloomFilterAgg {
+pub(crate) struct BloomFilterAgg {
     name: String,
     signature: Signature,
     expr: Arc<dyn PhysicalExpr>,
@@ -52,7 +52,7 @@ fn extract_i32_from_literal(expr: Arc<dyn PhysicalExpr>) -> i32 {
 }
 
 impl BloomFilterAgg {
-    pub fn new(
+    pub(crate) fn new(
         expr: Arc<dyn PhysicalExpr>,
         num_items: Arc<dyn PhysicalExpr>,
         num_bits: Arc<dyn PhysicalExpr>,
diff --git a/native/core/src/execution/datafusion/expressions/bloom_filter_might_contain.rs b/native/core/src/execution/datafusion/expressions/bloom_filter_might_contain.rs
index de922d831..893f10cdf 100644
--- a/native/core/src/execution/datafusion/expressions/bloom_filter_might_contain.rs
+++ b/native/core/src/execution/datafusion/expressions/bloom_filter_might_contain.rs
@@ -35,9 +35,9 @@ use std::{
 /// 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)]
-pub struct BloomFilterMightContain {
-    pub bloom_filter_expr: Arc<dyn PhysicalExpr>,
-    pub value_expr: Arc<dyn PhysicalExpr>,
+pub(crate) struct BloomFilterMightContain {
+    pub(crate) bloom_filter_expr: Arc<dyn PhysicalExpr>,
+    pub(crate) value_expr: Arc<dyn PhysicalExpr>,
     bloom_filter: Option<SparkBloomFilter>,
 }
 
@@ -79,7 +79,7 @@ fn evaluate_bloom_filter(
 }
 
 impl BloomFilterMightContain {
-    pub fn try_new(
+    pub(crate) fn try_new(
         bloom_filter_expr: Arc<dyn PhysicalExpr>,
         value_expr: Arc<dyn PhysicalExpr>,
     ) -> Result<Self> {
diff --git a/native/core/src/execution/datafusion/expressions/checkoverflow.rs b/native/core/src/execution/datafusion/expressions/checkoverflow.rs
index ed03ab667..6682eefa6 100644
--- a/native/core/src/execution/datafusion/expressions/checkoverflow.rs
+++ b/native/core/src/execution/datafusion/expressions/checkoverflow.rs
@@ -39,14 +39,18 @@ use datafusion_physical_expr::PhysicalExpr;
 /// decimals already, Comet `CheckOverflow` expression only checks if the decimals can fit in the
 /// precision.
 #[derive(Debug, Hash)]
-pub struct CheckOverflow {
-    pub child: Arc<dyn PhysicalExpr>,
-    pub data_type: DataType,
-    pub fail_on_error: bool,
+pub(crate) struct CheckOverflow {
+    pub(crate) child: Arc<dyn PhysicalExpr>,
+    pub(crate) data_type: DataType,
+    pub(crate) fail_on_error: bool,
 }
 
 impl CheckOverflow {
-    pub fn new(child: Arc<dyn PhysicalExpr>, data_type: DataType, fail_on_error: bool) -> Self {
+    pub(crate) fn new(
+        child: Arc<dyn PhysicalExpr>,
+        data_type: DataType,
+        fail_on_error: bool,
+    ) -> Self {
         Self {
             child,
             data_type,
@@ -179,7 +183,7 @@ impl PhysicalExpr for CheckOverflow {
 /// 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 {
+pub(crate) 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/comet_scalar_funcs.rs b/native/core/src/execution/datafusion/expressions/comet_scalar_funcs.rs
index 06717aabe..28172e00d 100644
--- a/native/core/src/execution/datafusion/expressions/comet_scalar_funcs.rs
+++ b/native/core/src/execution/datafusion/expressions/comet_scalar_funcs.rs
@@ -55,7 +55,7 @@ macro_rules! make_comet_scalar_udf {
 }
 
 /// Create a physical scalar function.
-pub fn create_comet_physical_fun(
+pub(crate) fn create_comet_physical_fun(
     fun_name: &str,
     data_type: DataType,
     registry: &dyn FunctionRegistry,
diff --git a/native/core/src/execution/datafusion/expressions/correlation.rs b/native/core/src/execution/datafusion/expressions/correlation.rs
index 6bf35e711..bdcfdcfed 100644
--- a/native/core/src/execution/datafusion/expressions/correlation.rs
+++ b/native/core/src/execution/datafusion/expressions/correlation.rs
@@ -41,7 +41,7 @@ use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 /// while Spark has Double for count. Also we have added `null_on_divide_by_zero`
 /// to be consistent with Spark's implementation.
 #[derive(Debug)]
-pub struct Correlation {
+pub(crate) struct Correlation {
     name: String,
     signature: Signature,
     expr1: Arc<dyn PhysicalExpr>,
@@ -50,7 +50,7 @@ pub struct Correlation {
 }
 
 impl Correlation {
-    pub fn new(
+    pub(crate) fn new(
         expr1: Arc<dyn PhysicalExpr>,
         expr2: Arc<dyn PhysicalExpr>,
         name: impl Into<String>,
@@ -148,7 +148,7 @@ impl PartialEq<dyn Any> for Correlation {
 
 /// An accumulator to compute correlation
 #[derive(Debug)]
-pub struct CorrelationAccumulator {
+pub(crate) struct CorrelationAccumulator {
     covar: CovarianceAccumulator,
     stddev1: StddevAccumulator,
     stddev2: StddevAccumulator,
@@ -157,7 +157,7 @@ pub struct CorrelationAccumulator {
 
 impl CorrelationAccumulator {
     /// Creates a new `CorrelationAccumulator`
-    pub fn try_new(null_on_divide_by_zero: bool) -> Result<Self> {
+    pub(crate) fn try_new(null_on_divide_by_zero: bool) -> Result<Self> {
         Ok(Self {
             covar: CovarianceAccumulator::try_new(StatsType::Population, null_on_divide_by_zero)?,
             stddev1: StddevAccumulator::try_new(StatsType::Population, null_on_divide_by_zero)?,
diff --git a/native/core/src/execution/datafusion/expressions/covariance.rs b/native/core/src/execution/datafusion/expressions/covariance.rs
index 9166e3976..f482aa3a2 100644
--- a/native/core/src/execution/datafusion/expressions/covariance.rs
+++ b/native/core/src/execution/datafusion/expressions/covariance.rs
@@ -40,7 +40,7 @@ use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 /// we have our own implementation is that DataFusion has UInt64 for state_field count,
 /// while Spark has Double for count.
 #[derive(Debug, Clone)]
-pub struct Covariance {
+pub(crate) struct Covariance {
     name: String,
     signature: Signature,
     expr1: Arc<dyn PhysicalExpr>,
@@ -51,7 +51,7 @@ pub struct Covariance {
 
 impl Covariance {
     /// Create a new COVAR aggregate function
-    pub fn new(
+    pub(crate) fn new(
         expr1: Arc<dyn PhysicalExpr>,
         expr2: Arc<dyn PhysicalExpr>,
         name: impl Into<String>,
@@ -143,7 +143,7 @@ impl PartialEq<dyn Any> for Covariance {
 
 /// An accumulator to compute covariance
 #[derive(Debug)]
-pub struct CovarianceAccumulator {
+pub(crate) struct CovarianceAccumulator {
     algo_const: f64,
     mean1: f64,
     mean2: f64,
@@ -154,7 +154,7 @@ pub struct CovarianceAccumulator {
 
 impl CovarianceAccumulator {
     /// Creates a new `CovarianceAccumulator`
-    pub fn try_new(s_type: StatsType, null_on_divide_by_zero: bool) -> Result<Self> {
+    pub(crate) fn try_new(s_type: StatsType, null_on_divide_by_zero: bool) -> Result<Self> {
         Ok(Self {
             algo_const: 0_f64,
             mean1: 0_f64,
@@ -165,19 +165,19 @@ impl CovarianceAccumulator {
         })
     }
 
-    pub fn get_count(&self) -> f64 {
+    pub(crate) fn get_count(&self) -> f64 {
         self.count
     }
 
-    pub fn get_mean1(&self) -> f64 {
+    pub(crate) fn get_mean1(&self) -> f64 {
         self.mean1
     }
 
-    pub fn get_mean2(&self) -> f64 {
+    pub(crate) fn get_mean2(&self) -> f64 {
         self.mean2
     }
 
-    pub fn get_algo_const(&self) -> f64 {
+    pub(crate) fn get_algo_const(&self) -> f64 {
         self.algo_const
     }
 }
diff --git a/native/core/src/execution/datafusion/expressions/mod.rs b/native/core/src/execution/datafusion/expressions/mod.rs
index 48b80384b..724da98c9 100644
--- a/native/core/src/execution/datafusion/expressions/mod.rs
+++ b/native/core/src/execution/datafusion/expressions/mod.rs
@@ -17,28 +17,28 @@
 
 //! Native DataFusion expressions
 
-pub mod bitwise_not;
-pub mod checkoverflow;
+pub(crate) mod bitwise_not;
+pub(crate) mod checkoverflow;
 mod normalize_nan;
-pub use normalize_nan::NormalizeNaNAndZero;
+pub(crate) 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(crate) mod avg;
+pub(crate) mod avg_decimal;
+pub(crate) mod bloom_filter_agg;
+pub(crate) mod bloom_filter_might_contain;
+pub(crate) mod comet_scalar_funcs;
+pub(crate) mod correlation;
+pub(crate) mod covariance;
+pub(crate) mod negative;
+pub(crate) mod stddev;
+pub(crate) mod strings;
+pub(crate) mod subquery;
+pub(crate) mod sum_decimal;
+pub(crate) mod unbound;
+pub(crate) mod variance;
 
-pub use datafusion_comet_spark_expr::{EvalMode, SparkError};
+pub(crate) use datafusion_comet_spark_expr::{EvalMode, SparkError};
 
 fn arithmetic_overflow_error(from_type: &str) -> CometError {
     CometError::Spark(SparkError::ArithmeticOverflow {
diff --git a/native/core/src/execution/datafusion/expressions/negative.rs b/native/core/src/execution/datafusion/expressions/negative.rs
index 8dfe71742..b00348357 100644
--- a/native/core/src/execution/datafusion/expressions/negative.rs
+++ b/native/core/src/execution/datafusion/expressions/negative.rs
@@ -35,7 +35,7 @@ use std::{
     sync::Arc,
 };
 
-pub fn create_negate_expr(
+pub(crate) fn create_negate_expr(
     expr: Arc<dyn PhysicalExpr>,
     fail_on_error: bool,
 ) -> Result<Arc<dyn PhysicalExpr>, CometError> {
@@ -44,7 +44,7 @@ pub fn create_negate_expr(
 
 /// Negative expression
 #[derive(Debug, Hash)]
-pub struct NegativeExpr {
+pub(crate) struct NegativeExpr {
     /// Input expression
     arg: Arc<dyn PhysicalExpr>,
     fail_on_error: bool,
@@ -70,12 +70,12 @@ macro_rules! check_overflow {
 
 impl NegativeExpr {
     /// Create new not expression
-    pub fn new(arg: Arc<dyn PhysicalExpr>, fail_on_error: bool) -> Self {
+    pub(crate) fn new(arg: Arc<dyn PhysicalExpr>, fail_on_error: bool) -> Self {
         Self { arg, fail_on_error }
     }
 
     /// Get the input expression
-    pub fn arg(&self) -> &Arc<dyn PhysicalExpr> {
+    pub(crate) fn arg(&self) -> &Arc<dyn PhysicalExpr> {
         &self.arg
     }
 }
diff --git a/native/core/src/execution/datafusion/expressions/normalize_nan.rs b/native/core/src/execution/datafusion/expressions/normalize_nan.rs
index c5331ad7b..0bc01b6fb 100644
--- a/native/core/src/execution/datafusion/expressions/normalize_nan.rs
+++ b/native/core/src/execution/datafusion/expressions/normalize_nan.rs
@@ -33,13 +33,13 @@ use datafusion::physical_expr_common::physical_expr::down_cast_any_ref;
 use datafusion_physical_expr::PhysicalExpr;
 
 #[derive(Debug, Hash)]
-pub struct NormalizeNaNAndZero {
-    pub data_type: DataType,
-    pub child: Arc<dyn PhysicalExpr>,
+pub(crate) struct NormalizeNaNAndZero {
+    pub(crate) data_type: DataType,
+    pub(crate) child: Arc<dyn PhysicalExpr>,
 }
 
 impl NormalizeNaNAndZero {
-    pub fn new(data_type: DataType, child: Arc<dyn PhysicalExpr>) -> Self {
+    pub(crate) fn new(data_type: DataType, child: Arc<dyn PhysicalExpr>) -> Self {
         Self { data_type, child }
     }
 }
diff --git a/native/core/src/execution/datafusion/expressions/stddev.rs b/native/core/src/execution/datafusion/expressions/stddev.rs
index 1ba495e21..17652bb58 100644
--- a/native/core/src/execution/datafusion/expressions/stddev.rs
+++ b/native/core/src/execution/datafusion/expressions/stddev.rs
@@ -36,7 +36,7 @@ use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 /// while Spark has Double for count. Also we have added `null_on_divide_by_zero`
 /// to be consistent with Spark's implementation.
 #[derive(Debug)]
-pub struct Stddev {
+pub(crate) struct Stddev {
     name: String,
     signature: Signature,
     expr: Arc<dyn PhysicalExpr>,
@@ -46,7 +46,7 @@ pub struct Stddev {
 
 impl Stddev {
     /// Create a new STDDEV aggregate function
-    pub fn new(
+    pub(crate) fn new(
         expr: Arc<dyn PhysicalExpr>,
         name: impl Into<String>,
         data_type: DataType,
@@ -137,19 +137,19 @@ impl PartialEq<dyn Any> for Stddev {
 
 /// An accumulator to compute the standard deviation
 #[derive(Debug)]
-pub struct StddevAccumulator {
+pub(crate) struct StddevAccumulator {
     variance: VarianceAccumulator,
 }
 
 impl StddevAccumulator {
     /// Creates a new `StddevAccumulator`
-    pub fn try_new(s_type: StatsType, null_on_divide_by_zero: bool) -> Result<Self> {
+    pub(crate) fn try_new(s_type: StatsType, null_on_divide_by_zero: bool) -> Result<Self> {
         Ok(Self {
             variance: VarianceAccumulator::try_new(s_type, null_on_divide_by_zero)?,
         })
     }
 
-    pub fn get_m2(&self) -> f64 {
+    pub(crate) fn get_m2(&self) -> f64 {
         self.variance.get_m2()
     }
 }
diff --git a/native/core/src/execution/datafusion/expressions/strings.rs b/native/core/src/execution/datafusion/expressions/strings.rs
index 200b4ec5a..c535aeaf1 100644
--- a/native/core/src/execution/datafusion/expressions/strings.rs
+++ b/native/core/src/execution/datafusion/expressions/strings.rs
@@ -40,13 +40,13 @@ use std::{
 macro_rules! make_predicate_function {
     ($name: ident, $kernel: ident, $str_scalar_kernel: ident) => {
         #[derive(Debug, Hash)]
-        pub struct $name {
+        pub(crate) struct $name {
             left: Arc<dyn PhysicalExpr>,
             right: Arc<dyn PhysicalExpr>,
         }
 
         impl $name {
-            pub fn new(left: Arc<dyn PhysicalExpr>, right: Arc<dyn PhysicalExpr>) -> Self {
+            pub(crate) fn new(left: Arc<dyn PhysicalExpr>, right: Arc<dyn PhysicalExpr>) -> Self {
                 Self { left, right }
             }
         }
@@ -142,25 +142,25 @@ 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)]
-pub struct SubstringExpr {
-    pub child: Arc<dyn PhysicalExpr>,
-    pub start: i64,
-    pub len: u64,
+pub(crate) struct SubstringExpr {
+    pub(crate) child: Arc<dyn PhysicalExpr>,
+    pub(crate) start: i64,
+    pub(crate) len: u64,
 }
 
 #[derive(Debug, Hash)]
-pub struct StringSpaceExpr {
-    pub child: Arc<dyn PhysicalExpr>,
+pub(crate) struct StringSpaceExpr {
+    pub(crate) child: Arc<dyn PhysicalExpr>,
 }
 
 impl SubstringExpr {
-    pub fn new(child: Arc<dyn PhysicalExpr>, start: i64, len: u64) -> Self {
+    pub(crate) fn new(child: Arc<dyn PhysicalExpr>, start: i64, len: u64) -> Self {
         Self { child, start, len }
     }
 }
 
 impl StringSpaceExpr {
-    pub fn new(child: Arc<dyn PhysicalExpr>) -> Self {
+    pub(crate) fn new(child: Arc<dyn PhysicalExpr>) -> Self {
         Self { child }
     }
 }
diff --git a/native/core/src/execution/datafusion/expressions/subquery.rs b/native/core/src/execution/datafusion/expressions/subquery.rs
index 3eeb29c16..0665c9eb0 100644
--- a/native/core/src/execution/datafusion/expressions/subquery.rs
+++ b/native/core/src/execution/datafusion/expressions/subquery.rs
@@ -37,18 +37,18 @@ use std::{
 };
 
 #[derive(Debug, Hash)]
-pub struct Subquery {
+pub(crate) struct Subquery {
     /// The ID of the execution context that owns this subquery. We use this ID to retrieve the
     /// subquery result.
     exec_context_id: i64,
     /// The ID of the subquery, we retrieve the subquery result from JVM using this ID.
-    pub id: i64,
+    pub(crate) id: i64,
     /// The data type of the subquery result.
-    pub data_type: DataType,
+    pub(crate) data_type: DataType,
 }
 
 impl Subquery {
-    pub fn new(exec_context_id: i64, id: i64, data_type: DataType) -> Self {
+    pub(crate) fn new(exec_context_id: i64, id: i64, data_type: DataType) -> Self {
         Self {
             exec_context_id,
             id,
diff --git a/native/core/src/execution/datafusion/expressions/sum_decimal.rs b/native/core/src/execution/datafusion/expressions/sum_decimal.rs
index d885ff90b..f476aef92 100644
--- a/native/core/src/execution/datafusion/expressions/sum_decimal.rs
+++ b/native/core/src/execution/datafusion/expressions/sum_decimal.rs
@@ -35,7 +35,7 @@ use datafusion_physical_expr::PhysicalExpr;
 use std::{any::Any, ops::BitAnd, sync::Arc};
 
 #[derive(Debug)]
-pub struct SumDecimal {
+pub(crate) struct SumDecimal {
     /// Aggregate function signature
     signature: Signature,
     /// The expression that provides the input decimal values to be summed
@@ -50,7 +50,7 @@ pub struct SumDecimal {
 }
 
 impl SumDecimal {
-    pub fn try_new(expr: Arc<dyn PhysicalExpr>, data_type: DataType) -> DFResult<Self> {
+    pub(crate) fn try_new(expr: Arc<dyn PhysicalExpr>, 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),
diff --git a/native/core/src/execution/datafusion/expressions/unbound.rs b/native/core/src/execution/datafusion/expressions/unbound.rs
index a6babd0f7..e14a18b62 100644
--- a/native/core/src/execution/datafusion/expressions/unbound.rs
+++ b/native/core/src/execution/datafusion/expressions/unbound.rs
@@ -36,14 +36,14 @@ use std::{
 /// data types. As `UnKnownColumn` doesn't have data type, we implement this
 /// `UnboundColumn` to carry the data type.
 #[derive(Debug, Hash, PartialEq, Eq, Clone)]
-pub struct UnboundColumn {
+pub(crate) struct UnboundColumn {
     name: String,
     datatype: DataType,
 }
 
 impl UnboundColumn {
     /// Create a new unbound column expression
-    pub fn new(name: &str, datatype: DataType) -> Self {
+    pub(crate) fn new(name: &str, datatype: DataType) -> Self {
         Self {
             name: name.to_owned(),
             datatype,
@@ -51,7 +51,7 @@ impl UnboundColumn {
     }
 
     /// Get the column name
-    pub fn name(&self) -> &str {
+    pub(crate) fn name(&self) -> &str {
         &self.name
     }
 }
diff --git a/native/core/src/execution/datafusion/expressions/variance.rs b/native/core/src/execution/datafusion/expressions/variance.rs
index 2f4d8091c..2247c16b8 100644
--- a/native/core/src/execution/datafusion/expressions/variance.rs
+++ b/native/core/src/execution/datafusion/expressions/variance.rs
@@ -36,7 +36,7 @@ use datafusion_physical_expr::{expressions::format_state_name, PhysicalExpr};
 /// while Spark has Double for count. Also we have added `null_on_divide_by_zero`
 /// to be consistent with Spark's implementation.
 #[derive(Debug)]
-pub struct Variance {
+pub(crate) struct Variance {
     name: String,
     signature: Signature,
     expr: Arc<dyn PhysicalExpr>,
@@ -46,7 +46,7 @@ pub struct Variance {
 
 impl Variance {
     /// Create a new VARIANCE aggregate function
-    pub fn new(
+    pub(crate) fn new(
         expr: Arc<dyn PhysicalExpr>,
         name: impl Into<String>,
         data_type: DataType,
@@ -131,7 +131,7 @@ impl PartialEq<dyn Any> for Variance {
 
 /// An accumulator to compute variance
 #[derive(Debug)]
-pub struct VarianceAccumulator {
+pub(crate) struct VarianceAccumulator {
     m2: f64,
     mean: f64,
     count: f64,
@@ -141,7 +141,7 @@ pub struct VarianceAccumulator {
 
 impl VarianceAccumulator {
     /// Creates a new `VarianceAccumulator`
-    pub fn try_new(s_type: StatsType, null_on_divide_by_zero: bool) -> Result<Self> {
+    pub(crate) fn try_new(s_type: StatsType, null_on_divide_by_zero: bool) -> Result<Self> {
         Ok(Self {
             m2: 0_f64,
             mean: 0_f64,
@@ -151,15 +151,15 @@ impl VarianceAccumulator {
         })
     }
 
-    pub fn get_count(&self) -> f64 {
+    pub(crate) fn get_count(&self) -> f64 {
         self.count
     }
 
-    pub fn get_mean(&self) -> f64 {
+    pub(crate) fn get_mean(&self) -> f64 {
         self.mean
     }
 
-    pub fn get_m2(&self) -> f64 {
+    pub(crate) fn get_m2(&self) -> f64 {
         self.m2
     }
 }
diff --git a/native/core/src/execution/datafusion/mod.rs b/native/core/src/execution/datafusion/mod.rs
index ca41fa0aa..05a98bfa9 100644
--- a/native/core/src/execution/datafusion/mod.rs
+++ b/native/core/src/execution/datafusion/mod.rs
@@ -17,9 +17,9 @@
 
 //! Native execution through DataFusion
 
-pub mod expressions;
+pub(crate) mod expressions;
 mod operators;
-pub mod planner;
-pub mod shuffle_writer;
+pub(crate) mod planner;
+pub(crate) mod shuffle_writer;
 pub(crate) mod spark_plan;
 mod util;
diff --git a/native/core/src/execution/datafusion/operators/expand.rs b/native/core/src/execution/datafusion/operators/expand.rs
index a3dd06507..347c1c27e 100644
--- a/native/core/src/execution/datafusion/operators/expand.rs
+++ b/native/core/src/execution/datafusion/operators/expand.rs
@@ -37,7 +37,7 @@ 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(crate) struct CometExpandExec {
     projections: Vec<Vec<Arc<dyn PhysicalExpr>>>,
     child: Arc<dyn ExecutionPlan>,
     schema: SchemaRef,
@@ -46,7 +46,7 @@ pub struct CometExpandExec {
 
 impl CometExpandExec {
     /// Create a new ExpandExec
-    pub fn new(
+    pub(crate) fn new(
         projections: Vec<Vec<Arc<dyn PhysicalExpr>>>,
         child: Arc<dyn ExecutionPlan>,
         schema: SchemaRef,
@@ -135,7 +135,7 @@ impl ExecutionPlan for CometExpandExec {
     }
 }
 
-pub struct ExpandStream {
+pub(crate) struct ExpandStream {
     projections: Vec<Vec<Arc<dyn PhysicalExpr>>>,
     child_stream: SendableRecordBatchStream,
     schema: SchemaRef,
@@ -146,7 +146,7 @@ pub struct ExpandStream {
 
 impl ExpandStream {
     /// Create a new ExpandStream
-    pub fn new(
+    pub(crate) fn new(
         projections: Vec<Vec<Arc<dyn PhysicalExpr>>>,
         child_stream: SendableRecordBatchStream,
         schema: SchemaRef,
diff --git a/native/core/src/execution/datafusion/operators/mod.rs b/native/core/src/execution/datafusion/operators/mod.rs
index 3d28a266a..aad834285 100644
--- a/native/core/src/execution/datafusion/operators/mod.rs
+++ b/native/core/src/execution/datafusion/operators/mod.rs
@@ -15,4 +15,4 @@
 // specific language governing permissions and limitations
 // under the License.
 
-pub mod expand;
+pub(crate) mod expand;
diff --git a/native/core/src/execution/datafusion/planner.rs b/native/core/src/execution/datafusion/planner.rs
index 83f86dbee..fbc6b50aa 100644
--- a/native/core/src/execution/datafusion/planner.rs
+++ b/native/core/src/execution/datafusion/planner.rs
@@ -128,17 +128,17 @@ type PhyExprResult = Result<Vec<(Arc<dyn PhysicalExpr>, String)>, ExecutionError
 type PartitionPhyExprResult = Result<Vec<Arc<dyn PhysicalExpr>>, ExecutionError>;
 
 struct JoinParameters {
-    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,
+    pub(crate) left: Arc<SparkPlan>,
+    pub(crate) right: Arc<SparkPlan>,
+    pub(crate) join_on: Vec<(Arc<dyn PhysicalExpr>, Arc<dyn PhysicalExpr>)>,
+    pub(crate) join_filter: Option<JoinFilter>,
+    pub(crate) join_type: DFJoinType,
 }
 
-pub const TEST_EXEC_CONTEXT_ID: i64 = -1;
+pub(crate) const TEST_EXEC_CONTEXT_ID: i64 = -1;
 
 /// The query planner for converting Spark query plans to DataFusion query plans.
-pub struct PhysicalPlanner {
+pub(crate) struct PhysicalPlanner {
     // The execution context id of this planner.
     exec_context_id: i64,
     execution_props: ExecutionProps,
@@ -158,7 +158,7 @@ impl Default for PhysicalPlanner {
 }
 
 impl PhysicalPlanner {
-    pub fn new(session_ctx: Arc<SessionContext>) -> Self {
+    pub(crate) fn new(session_ctx: Arc<SessionContext>) -> Self {
         let execution_props = ExecutionProps::new();
         Self {
             exec_context_id: TEST_EXEC_CONTEXT_ID,
@@ -167,7 +167,7 @@ impl PhysicalPlanner {
         }
     }
 
-    pub fn with_exec_id(self, exec_context_id: i64) -> Self {
+    pub(crate) fn with_exec_id(self, exec_context_id: i64) -> Self {
         Self {
             exec_context_id,
             execution_props: self.execution_props,
diff --git a/native/core/src/execution/datafusion/shuffle_writer.rs b/native/core/src/execution/datafusion/shuffle_writer.rs
index c79eeeb4a..7792c30cc 100644
--- a/native/core/src/execution/datafusion/shuffle_writer.rs
+++ b/native/core/src/execution/datafusion/shuffle_writer.rs
@@ -77,7 +77,7 @@ enum AppendRowStatus {
 /// The shuffle writer operator maps each input partition to M output partitions based on a
 /// partitioning scheme. No guarantees are made about the order of the resulting partitions.
 #[derive(Debug)]
-pub struct ShuffleWriterExec {
+pub(crate) struct ShuffleWriterExec {
     /// Input execution plan
     input: Arc<dyn ExecutionPlan>,
     /// Partitioning scheme to use
@@ -179,7 +179,7 @@ impl ExecutionPlan for ShuffleWriterExec {
 
 impl ShuffleWriterExec {
     /// Create a new ShuffleWriterExec
-    pub fn try_new(
+    pub(crate) fn try_new(
         input: Arc<dyn ExecutionPlan>,
         partitioning: Partitioning,
         output_data_file: String,
@@ -653,7 +653,7 @@ impl ShuffleRepartitionerMetrics {
 
 impl ShuffleRepartitioner {
     #[allow(clippy::too_many_arguments)]
-    pub fn new(
+    pub(crate) fn new(
         partition_id: usize,
         output_data_file: String,
         output_index_file: String,
@@ -1528,14 +1528,14 @@ pub(crate) fn write_ipc_compressed<W: Write + Seek>(
 }
 
 /// A stream that yields no record batches which represent end of output.
-pub struct EmptyStream {
+pub(crate) struct EmptyStream {
     /// Schema representing the data
     schema: SchemaRef,
 }
 
 impl EmptyStream {
     /// Create an iterator for a vector of record batches
-    pub fn try_new(schema: SchemaRef) -> Result<Self> {
+    pub(crate) fn try_new(schema: SchemaRef) -> Result<Self> {
         Ok(Self { schema })
     }
 }
diff --git a/native/core/src/execution/datafusion/util/mod.rs b/native/core/src/execution/datafusion/util/mod.rs
index 75b763af5..2dabcfdd2 100644
--- a/native/core/src/execution/datafusion/util/mod.rs
+++ b/native/core/src/execution/datafusion/util/mod.rs
@@ -15,5 +15,5 @@
 // specific language governing permissions and limitations
 // under the License.
 
-pub mod spark_bit_array;
-pub mod spark_bloom_filter;
+pub(crate) mod spark_bit_array;
+pub(crate) mod spark_bloom_filter;
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 68b97d660..af862580f 100644
--- a/native/core/src/execution/datafusion/util/spark_bit_array.rs
+++ b/native/core/src/execution/datafusion/util/spark_bit_array.rs
@@ -23,13 +23,13 @@ use std::iter::zip;
 /// used in the BloomFilter implementation. Some methods are not implemented as they are not
 /// required for the current use case.
 #[derive(Debug, Hash)]
-pub struct SparkBitArray {
+pub(crate) struct SparkBitArray {
     data: Vec<u64>,
     bit_count: usize,
 }
 
 impl SparkBitArray {
-    pub fn new(buf: Vec<u64>) -> Self {
+    pub(crate) fn new(buf: Vec<u64>) -> Self {
         let num_bits = buf.iter().map(|x| x.count_ones() as usize).sum();
         Self {
             data: buf,
@@ -37,7 +37,7 @@ impl SparkBitArray {
         }
     }
 
-    pub fn set(&mut self, index: usize) -> bool {
+    pub(crate) fn set(&mut self, index: usize) -> bool {
         if !self.get(index) {
             // see the get method for the explanation of the shift operators
             self.data[index >> 6] |= 1u64 << (index & 0x3f);
@@ -48,7 +48,7 @@ impl SparkBitArray {
         }
     }
 
-    pub fn get(&self, index: usize) -> bool {
+    pub(crate) fn get(&self, index: usize) -> bool {
         // Java version: (data[(int) (index >> 6)] & (1L << (index))) != 0
         // Rust and Java have different semantics for the shift operators. Java's shift operators
         // explicitly mask the right-hand operand with 0x3f [1], while Rust's shift operators does
@@ -58,33 +58,33 @@ impl SparkBitArray {
         (self.data[index >> 6] & (1u64 << (index & 0x3f))) != 0
     }
 
-    pub fn bit_size(&self) -> u64 {
+    pub(crate) fn bit_size(&self) -> u64 {
         self.word_size() as u64 * 64
     }
 
-    pub fn byte_size(&self) -> usize {
+    pub(crate) fn byte_size(&self) -> usize {
         self.word_size() * 8
     }
 
-    pub fn word_size(&self) -> usize {
+    pub(crate) fn word_size(&self) -> usize {
         self.data.len()
     }
 
-    pub fn cardinality(&self) -> usize {
+    pub(crate) fn cardinality(&self) -> usize {
         self.bit_count
     }
 
-    pub fn to_bytes(&self) -> Vec<u8> {
+    pub(crate) fn to_bytes(&self) -> Vec<u8> {
         Vec::from(self.data.to_byte_slice())
     }
 
-    pub fn data(&self) -> Vec<u64> {
+    pub(crate) fn data(&self) -> Vec<u64> {
         self.data.clone()
     }
 
     // Combines SparkBitArrays, however other is a &[u8] because we anticipate to come from an
     // Arrow ScalarValue::Binary which is a byte vector underneath, rather than a word vector.
-    pub fn merge_bits(&mut self, other: &[u8]) {
+    pub(crate) fn merge_bits(&mut self, other: &[u8]) {
         assert_eq!(self.byte_size(), other.len());
         let mut bit_count: usize = 0;
         // For each word, merge the bits into self, and accumulate a new bit_count.
@@ -101,7 +101,7 @@ impl SparkBitArray {
     }
 }
 
-pub fn num_words(num_bits: i32) -> i32 {
+pub(crate) fn num_words(num_bits: i32) -> i32 {
     bit::ceil(num_bits as usize, 64) as i32
 }
 
diff --git a/native/core/src/execution/datafusion/util/spark_bloom_filter.rs b/native/core/src/execution/datafusion/util/spark_bloom_filter.rs
index 35fa23b46..4e145f6b3 100644
--- a/native/core/src/execution/datafusion/util/spark_bloom_filter.rs
+++ b/native/core/src/execution/datafusion/util/spark_bloom_filter.rs
@@ -28,12 +28,12 @@ const SPARK_BLOOM_FILTER_VERSION_1: i32 = 1;
 /// 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)]
-pub struct SparkBloomFilter {
+pub(crate) struct SparkBloomFilter {
     bits: SparkBitArray,
     num_hash_functions: u32,
 }
 
-pub fn optimal_num_hash_functions(expected_items: i32, num_bits: i32) -> i32 {
+pub(crate) fn optimal_num_hash_functions(expected_items: i32, num_bits: i32) -> i32 {
     cmp::max(
         1,
         ((num_bits as f64 / expected_items as f64) * 2.0_f64.ln()).round() as i32,
@@ -83,7 +83,7 @@ impl From<&[u8]> for SparkBloomFilter {
 impl SparkBloomFilter {
     /// Serializes a SparkBloomFilter to a byte array conforming to Spark's BloomFilter
     /// binary format version 1.
-    pub fn spark_serialization(&self) -> Vec<u8> {
+    pub(crate) fn spark_serialization(&self) -> Vec<u8> {
         // There might be a more efficient way to do this, even with all the endianness stuff.
         let mut spark_bloom_filter: Vec<u8> = 1_u32.to_be_bytes().to_vec();
         spark_bloom_filter.append(&mut self.num_hash_functions.to_be_bytes().to_vec());
@@ -98,7 +98,7 @@ impl SparkBloomFilter {
         spark_bloom_filter
     }
 
-    pub fn put_long(&mut self, item: i64) -> bool {
+    pub(crate) fn put_long(&mut self, item: i64) -> bool {
         // Here we first hash the input long element into 2 int hash values, h1 and h2, then produce
         // n hash values by `h1 + i * h2` with 1 <= i <= num_hash_functions.
         let h1 = spark_compatible_murmur3_hash(item.to_le_bytes(), 0);
@@ -115,7 +115,7 @@ impl SparkBloomFilter {
         bit_changed
     }
 
-    pub fn put_binary(&mut self, item: &[u8]) -> bool {
+    pub(crate) fn put_binary(&mut self, item: &[u8]) -> bool {
         // Here we first hash the input long element into 2 int hash values, h1 and h2, then produce
         // n hash values by `h1 + i * h2` with 1 <= i <= num_hash_functions.
         let h1 = spark_compatible_murmur3_hash(item, 0);
@@ -132,7 +132,7 @@ impl SparkBloomFilter {
         bit_changed
     }
 
-    pub fn might_contain_long(&self, item: i64) -> bool {
+    pub(crate) fn might_contain_long(&self, item: i64) -> bool {
         let h1 = spark_compatible_murmur3_hash(item.to_le_bytes(), 0);
         let h2 = spark_compatible_murmur3_hash(item.to_le_bytes(), h1);
         let bit_size = self.bits.bit_size() as i32;
@@ -148,18 +148,18 @@ impl SparkBloomFilter {
         true
     }
 
-    pub fn might_contain_longs(&self, items: &Int64Array) -> BooleanArray {
+    pub(crate) fn might_contain_longs(&self, items: &Int64Array) -> BooleanArray {
         items
             .iter()
             .map(|v| v.map(|x| self.might_contain_long(x)))
             .collect()
     }
 
-    pub fn state_as_bytes(&self) -> Vec<u8> {
+    pub(crate) fn state_as_bytes(&self) -> Vec<u8> {
         self.bits.to_bytes()
     }
 
-    pub fn merge_filter(&mut self, other: &[u8]) {
+    pub(crate) fn merge_filter(&mut self, other: &[u8]) {
         assert_eq!(
             other.len(),
             self.bits.byte_size(),
diff --git a/native/core/src/execution/jni_api.rs b/native/core/src/execution/jni_api.rs
index 8afe134cd..8733977ed 100644
--- a/native/core/src/execution/jni_api.rs
+++ b/native/core/src/execution/jni_api.rs
@@ -66,38 +66,38 @@ use log::info;
 /// Comet native execution context. Kept alive across JNI calls.
 struct ExecutionContext {
     /// The id of the execution context.
-    pub id: i64,
+    pub(crate) id: i64,
     /// The deserialized Spark plan
-    pub spark_plan: Operator,
+    pub(crate) spark_plan: Operator,
     /// The DataFusion root operator converted from the `spark_plan`
-    pub root_op: Option<Arc<SparkPlan>>,
+    pub(crate) root_op: Option<Arc<SparkPlan>>,
     /// The input sources for the DataFusion plan
-    pub scans: Vec<ScanExec>,
+    pub(crate) scans: Vec<ScanExec>,
     /// The global reference of input sources for the DataFusion plan
-    pub input_sources: Vec<Arc<GlobalRef>>,
+    pub(crate) input_sources: Vec<Arc<GlobalRef>>,
     /// The record batch stream to pull results from
-    pub stream: Option<SendableRecordBatchStream>,
+    pub(crate) stream: Option<SendableRecordBatchStream>,
     /// The Tokio runtime used for async.
-    pub runtime: Runtime,
+    pub(crate) runtime: Runtime,
     /// Native metrics
-    pub metrics: Arc<GlobalRef>,
+    pub(crate) metrics: Arc<GlobalRef>,
     /// The time it took to create the native plan and configure the context
-    pub plan_creation_time: Duration,
+    pub(crate) plan_creation_time: Duration,
     /// DataFusion SessionContext
-    pub session_ctx: Arc<SessionContext>,
+    pub(crate) session_ctx: Arc<SessionContext>,
     /// Whether to enable additional debugging checks & messages
-    pub debug_native: bool,
+    pub(crate) debug_native: bool,
     /// Whether to write native plans with metrics to stdout
-    pub explain_native: bool,
+    pub(crate) explain_native: bool,
     /// Map of metrics name -> jstring object to cache jni_NewStringUTF calls.
-    pub metrics_jstrings: HashMap<String, Arc<GlobalRef>>,
+    pub(crate) metrics_jstrings: HashMap<String, Arc<GlobalRef>>,
 }
 
 /// Accept serialized query plan and return the address of the native query plan.
 /// # Safety
 /// This function is inheritly unsafe since it deals with raw pointers passed from JNI.
 #[no_mangle]
-pub unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
+pub(crate) unsafe extern "system" fn Java_org_apache_comet_Native_createPlan(
     e: JNIEnv,
     _class: JClass,
     id: jlong,
@@ -290,7 +290,7 @@ fn pull_input_batches(exec_context: &mut ExecutionContext) -> Result<(), CometEr
 /// # Safety
 /// This function is inheritly unsafe since it deals with raw pointers passed from JNI.
 #[no_mangle]
-pub unsafe extern "system" fn Java_org_apache_comet_Native_executePlan(
+pub(crate) unsafe extern "system" fn Java_org_apache_comet_Native_executePlan(
     e: JNIEnv,
     _class: JClass,
     stage_id: jint,
@@ -397,7 +397,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_executePlan(
 
 #[no_mangle]
 /// Drop the native query plan object and context object.
-pub extern "system" fn Java_org_apache_comet_Native_releasePlan(
+pub(crate) extern "system" fn Java_org_apache_comet_Native_releasePlan(
     e: JNIEnv,
     _class: JClass,
     exec_context: jlong,
@@ -451,7 +451,7 @@ fn get_execution_context<'a>(id: i64) -> &'a mut ExecutionContext {
 /// # Safety
 /// This function is inheritly unsafe since it deals with raw pointers passed from JNI.
 #[no_mangle]
-pub unsafe extern "system" fn Java_org_apache_comet_Native_writeSortedFileNative(
+pub(crate) unsafe extern "system" fn Java_org_apache_comet_Native_writeSortedFileNative(
     e: JNIEnv,
     _class: JClass,
     row_addresses: jlongArray,
@@ -520,7 +520,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_Native_writeSortedFileNative
 
 #[no_mangle]
 /// Used by Comet shuffle external sorter to sort in-memory row partition ids.
-pub extern "system" fn Java_org_apache_comet_Native_sortRowPartitionsNative(
+pub(crate) extern "system" fn Java_org_apache_comet_Native_sortRowPartitionsNative(
     e: JNIEnv,
     _class: JClass,
     address: jlong,
diff --git a/native/core/src/execution/kernels/hash.rs b/native/core/src/execution/kernels/hash.rs
index b39fd6224..7a9bce906 100644
--- a/native/core/src/execution/kernels/hash.rs
+++ b/native/core/src/execution/kernels/hash.rs
@@ -25,7 +25,7 @@ use arrow_array::{
 use arrow_buffer::{IntervalDayTime, IntervalMonthDayNano};
 use std::fmt::Debug;
 
-pub fn hash(src: &[ArrayRef], dst: &mut [u64]) {
+pub(crate) fn hash(src: &[ArrayRef], dst: &mut [u64]) {
     let state = RandomState::with_seed(42);
     src.iter().enumerate().for_each(|(idx, v)| {
         downcast_dictionary_array!(
diff --git a/native/core/src/execution/kernels/mod.rs b/native/core/src/execution/kernels/mod.rs
index 675dcd489..ea92f52de 100644
--- a/native/core/src/execution/kernels/mod.rs
+++ b/native/core/src/execution/kernels/mod.rs
@@ -18,6 +18,5 @@
 //! Kernels
 
 mod hash;
-pub use hash::hash;
 
 pub(crate) mod strings;
diff --git a/native/core/src/execution/kernels/strings.rs b/native/core/src/execution/kernels/strings.rs
index 2e5e67b67..447cd3dd9 100644
--- a/native/core/src/execution/kernels/strings.rs
+++ b/native/core/src/execution/kernels/strings.rs
@@ -33,7 +33,7 @@ use crate::errors::ExpressionError;
 /// # Preconditions
 ///
 /// - elements in `length` must not be negative
-pub fn string_space(length: &dyn Array) -> Result<ArrayRef, ExpressionError> {
+pub(crate) fn string_space(length: &dyn Array) -> Result<ArrayRef, ExpressionError> {
     match length.data_type() {
         DataType::Int32 => {
             let array = length.as_any().downcast_ref::<Int32Array>().unwrap();
@@ -52,7 +52,11 @@ pub fn string_space(length: &dyn Array) -> Result<ArrayRef, ExpressionError> {
     }
 }
 
-pub fn substring(array: &dyn Array, start: i64, length: u64) -> Result<ArrayRef, ExpressionError> {
+pub(crate) fn substring(
+    array: &dyn Array,
+    start: i64,
+    length: u64,
+) -> Result<ArrayRef, ExpressionError> {
     match array.data_type() {
         DataType::LargeUtf8 => substring_by_char(
             array
@@ -96,7 +100,7 @@ pub fn substring(array: &dyn Array, start: i64, length: u64) -> Result<ArrayRef,
 ///
 /// Note: this is different from arrow-rs `substring` kernel in that both `start` and `length` are
 /// `Int32Array` here.
-pub fn substring_with_array(
+pub(crate) fn substring_with_array(
     array: &dyn Array,
     start: &Int32Array,
     length: &Int32Array,
diff --git a/native/core/src/execution/memory_pool.rs b/native/core/src/execution/memory_pool.rs
index 4eb18c3f1..011f3c297 100644
--- a/native/core/src/execution/memory_pool.rs
+++ b/native/core/src/execution/memory_pool.rs
@@ -37,7 +37,7 @@ use crate::{
 
 /// A DataFusion `MemoryPool` implementation for Comet. Internally this is
 /// implemented via delegating calls to [`crate::jvm_bridge::CometTaskMemoryManager`].
-pub struct CometMemoryPool {
+pub(crate) struct CometMemoryPool {
     task_memory_manager_handle: Arc<GlobalRef>,
     used: AtomicUsize,
 }
@@ -51,7 +51,7 @@ impl Debug for CometMemoryPool {
 }
 
 impl CometMemoryPool {
-    pub fn new(task_memory_manager_handle: Arc<GlobalRef>) -> CometMemoryPool {
+    pub(crate) fn new(task_memory_manager_handle: Arc<GlobalRef>) -> CometMemoryPool {
         Self {
             task_memory_manager_handle,
             used: AtomicUsize::new(0),
diff --git a/native/core/src/execution/metrics/mod.rs b/native/core/src/execution/metrics/mod.rs
index a777b6863..922ab3c16 100644
--- a/native/core/src/execution/metrics/mod.rs
+++ b/native/core/src/execution/metrics/mod.rs
@@ -15,4 +15,4 @@
 // specific language governing permissions and limitations
 // under the License.
 
-pub mod utils;
+pub(crate) mod utils;
diff --git a/native/core/src/execution/metrics/utils.rs b/native/core/src/execution/metrics/utils.rs
index 4bb1c4474..9082ffd3d 100644
--- a/native/core/src/execution/metrics/utils.rs
+++ b/native/core/src/execution/metrics/utils.rs
@@ -30,7 +30,7 @@ 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
 /// native execution plan and pushed to the Java side through JNI.
-pub fn update_comet_metric(
+pub(crate) fn update_comet_metric(
     env: &mut JNIEnv,
     metric_node: &JObject,
     spark_plan: &Arc<SparkPlan>,
diff --git a/native/core/src/execution/mod.rs b/native/core/src/execution/mod.rs
index f17935702..ff93c6ad2 100644
--- a/native/core/src/execution/mod.rs
+++ b/native/core/src/execution/mod.rs
@@ -16,21 +16,20 @@
 // under the License.
 
 //! PoC of vectorization execution through JNI to Rust.
-pub mod datafusion;
-pub mod jni_api;
+pub(crate) mod datafusion;
+pub(crate) mod jni_api;
 
-pub mod kernels; // for benchmarking
+pub(crate) mod kernels; // for benchmarking
 
 mod metrics;
-pub mod operators;
-pub mod serde;
-pub mod shuffle;
+pub(crate) mod operators;
+pub(crate) mod serde;
+pub(crate) mod shuffle;
 pub(crate) mod sort;
-pub use datafusion_comet_spark_expr::timezone;
 pub(crate) mod utils;
 
 mod memory_pool;
-pub use memory_pool::*;
+pub(crate) use memory_pool::*;
 
 #[cfg(test)]
 mod tests {
diff --git a/native/core/src/execution/operators/copy.rs b/native/core/src/execution/operators/copy.rs
index 8eeda8a5a..7989828a6 100644
--- a/native/core/src/execution/operators/copy.rs
+++ b/native/core/src/execution/operators/copy.rs
@@ -40,7 +40,7 @@ use datafusion_common::{arrow_datafusion_err, DataFusionError, Result as DataFus
 /// This could cause issues for Comet, since we re-use column vectors across different batches.
 /// For those scenarios, this can be used as an adapter node.
 #[derive(Debug)]
-pub struct CopyExec {
+pub(crate) struct CopyExec {
     input: Arc<dyn ExecutionPlan>,
     schema: SchemaRef,
     cache: PlanProperties,
@@ -49,7 +49,7 @@ pub struct CopyExec {
 }
 
 #[derive(Debug, PartialEq, Clone)]
-pub enum CopyMode {
+pub(crate) enum CopyMode {
     /// Perform a deep copy and also unpack dictionaries
     UnpackOrDeepCopy,
     /// Perform a clone and also unpack dictionaries
@@ -57,7 +57,7 @@ pub enum CopyMode {
 }
 
 impl CopyExec {
-    pub fn new(input: Arc<dyn ExecutionPlan>, mode: CopyMode) -> Self {
+    pub(crate) fn new(input: Arc<dyn ExecutionPlan>, mode: CopyMode) -> Self {
         // change schema to remove dictionary types because CopyExec always unpacks
         // dictionaries
 
diff --git a/native/core/src/execution/operators/filter.rs b/native/core/src/execution/operators/filter.rs
index d9a54712d..2ae217999 100644
--- a/native/core/src/execution/operators/filter.rs
+++ b/native/core/src/execution/operators/filter.rs
@@ -51,7 +51,7 @@ use log::trace;
 /// batches are never passed through unchanged. The changes are between the comments
 /// `BEGIN Comet change` and `END Comet change`.
 #[derive(Debug)]
-pub struct FilterExec {
+pub(crate) struct FilterExec {
     /// The expression to filter on. This expression must evaluate to a boolean value.
     predicate: Arc<dyn PhysicalExpr>,
     /// The input plan
@@ -66,7 +66,7 @@ pub struct FilterExec {
 
 impl FilterExec {
     /// Create a FilterExec on an input
-    pub fn try_new(
+    pub(crate) fn try_new(
         predicate: Arc<dyn PhysicalExpr>,
         input: Arc<dyn ExecutionPlan>,
     ) -> Result<Self> {
@@ -88,7 +88,7 @@ impl FilterExec {
         }
     }
 
-    pub fn with_default_selectivity(
+    pub(crate) fn with_default_selectivity(
         mut self,
         default_selectivity: u8,
     ) -> Result<Self, DataFusionError> {
@@ -102,17 +102,17 @@ impl FilterExec {
     }
 
     /// The expression to filter on. This expression must evaluate to a boolean value.
-    pub fn predicate(&self) -> &Arc<dyn PhysicalExpr> {
+    pub(crate) fn predicate(&self) -> &Arc<dyn PhysicalExpr> {
         &self.predicate
     }
 
     /// The input plan
-    pub fn input(&self) -> &Arc<dyn ExecutionPlan> {
+    pub(crate) fn input(&self) -> &Arc<dyn ExecutionPlan> {
         &self.input
     }
 
     /// The default selectivity
-    pub fn default_selectivity(&self) -> u8 {
+    pub(crate) fn default_selectivity(&self) -> u8 {
         self.default_selectivity
     }
 
@@ -362,7 +362,7 @@ pub(crate) fn batch_filter(
 // BEGIN Comet changes
 // `FilterExec` could modify input batch or return input batch without change. Instead of always
 // adding `CopyExec` on top of it, we only copy input batch for the special case.
-pub fn comet_filter_record_batch(
+pub(crate) fn comet_filter_record_batch(
     record_batch: &RecordBatch,
     predicate: &BooleanArray,
 ) -> std::result::Result<RecordBatch, ArrowError> {
@@ -446,7 +446,7 @@ fn collect_columns_from_predicate(predicate: &Arc<dyn PhysicalExpr>) -> EqualAnd
 }
 
 /// Pair of `Arc<dyn PhysicalExpr>`s
-pub type PhysicalExprPairRef<'a> = (&'a Arc<dyn PhysicalExpr>, &'a Arc<dyn PhysicalExpr>);
+pub(crate) type PhysicalExprPairRef<'a> = (&'a Arc<dyn PhysicalExpr>, &'a Arc<dyn PhysicalExpr>);
 
 /// The equals Column-Pairs and Non-equals Column-Pairs in the Predicates
-pub type EqualAndNonEqual<'a> = (Vec<PhysicalExprPairRef<'a>>, Vec<PhysicalExprPairRef<'a>>);
+pub(crate) type EqualAndNonEqual<'a> = (Vec<PhysicalExprPairRef<'a>>, Vec<PhysicalExprPairRef<'a>>);
diff --git a/native/core/src/execution/operators/mod.rs b/native/core/src/execution/operators/mod.rs
index bdc233e94..8ffe9646d 100644
--- a/native/core/src/execution/operators/mod.rs
+++ b/native/core/src/execution/operators/mod.rs
@@ -21,10 +21,9 @@ use std::fmt::Debug;
 
 use jni::objects::GlobalRef;
 
-pub use copy::*;
-pub use filter::comet_filter_record_batch;
-pub use filter::FilterExec;
-pub use scan::*;
+pub(crate) use copy::*;
+pub(crate) use filter::FilterExec;
+pub(crate) use scan::*;
 
 mod copy;
 mod filter;
@@ -32,7 +31,7 @@ mod scan;
 
 /// Error returned during executing operators.
 #[derive(thiserror::Error, Debug)]
-pub enum ExecutionError {
+pub(crate) enum ExecutionError {
     /// Simple error
     #[allow(dead_code)]
     #[error("General execution error with reason: {0}.")]
diff --git a/native/core/src/execution/operators/scan.rs b/native/core/src/execution/operators/scan.rs
index 2cb8a84d9..0df25a8d8 100644
--- a/native/core/src/execution/operators/scan.rs
+++ b/native/core/src/execution/operators/scan.rs
@@ -56,21 +56,21 @@ use std::{
 /// 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 {
+pub(crate) struct ScanExec {
     /// The ID of the execution context that owns this subquery. We use this ID to retrieve the JVM
     /// environment `JNIEnv` from the execution context.
-    pub exec_context_id: i64,
+    pub(crate) exec_context_id: i64,
     /// The input source of scan node. It is a global reference of JVM `CometBatchIterator` object.
-    pub input_source: Option<Arc<GlobalRef>>,
+    pub(crate) input_source: Option<Arc<GlobalRef>>,
     /// A description of the input source for informational purposes
-    pub input_source_description: String,
+    pub(crate) input_source_description: String,
     /// The data types of columns of the input batch. Converted from Spark schema.
-    pub data_types: Vec<DataType>,
+    pub(crate) data_types: Vec<DataType>,
     /// Schema of first batch
-    pub schema: SchemaRef,
+    pub(crate) 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>>>,
+    pub(crate) batch: Arc<Mutex<Option<InputBatch>>>,
     /// Cache of expensive-to-compute plan properties
     cache: PlanProperties,
     /// Metrics collector
@@ -80,7 +80,7 @@ pub struct ScanExec {
 }
 
 impl ScanExec {
-    pub fn new(
+    pub(crate) fn new(
         exec_context_id: i64,
         input_source: Option<Arc<GlobalRef>>,
         input_source_description: &str,
@@ -153,12 +153,12 @@ impl ScanExec {
     }
 
     /// Feeds input batch into this `Scan`. Only used in unit test.
-    pub fn set_input_batch(&mut self, input: InputBatch) {
+    pub(crate) fn set_input_batch(&mut self, input: InputBatch) {
         *self.batch.try_lock().unwrap() = Some(input);
     }
 
     /// Pull next input batch from JVM.
-    pub fn get_next_batch(&mut self) -> Result<(), CometError> {
+    pub(crate) fn get_next_batch(&mut self) -> Result<(), CometError> {
         if self.input_source.is_none() {
             // This is a unit test. We don't need to call JNI.
             return Ok(());
@@ -374,7 +374,7 @@ struct ScanStream<'a> {
 }
 
 impl<'a> ScanStream<'a> {
-    pub fn new(
+    pub(crate) fn new(
         scan: ScanExec,
         schema: SchemaRef,
         partition: usize,
@@ -462,7 +462,7 @@ impl<'a> RecordBatchStream for ScanStream<'a> {
 }
 
 #[derive(Clone, Debug)]
-pub enum InputBatch {
+pub(crate) enum InputBatch {
     /// The end of input batches.
     EOF,
 
@@ -476,7 +476,7 @@ impl InputBatch {
     /// Constructs a `InputBatch` from columns and optional number of rows.
     /// If `num_rows` is none, this function will calculate it from given
     /// columns.
-    pub fn new(columns: Vec<ArrayRef>, num_rows: Option<usize>) -> Self {
+    pub(crate) fn new(columns: Vec<ArrayRef>, num_rows: Option<usize>) -> Self {
         let num_rows = num_rows.unwrap_or_else(|| {
             let lengths = columns.iter().map(|a| a.len()).unique().collect::<Vec<_>>();
             assert!(lengths.len() <= 1, "Columns have different lengths.");
diff --git a/native/core/src/execution/serde.rs b/native/core/src/execution/serde.rs
index 659ce41f0..be59f5074 100644
--- a/native/core/src/execution/serde.rs
+++ b/native/core/src/execution/serde.rs
@@ -47,7 +47,7 @@ impl From<prost::DecodeError> for ExecutionError {
 }
 
 /// Deserialize bytes to protobuf type of expression
-pub fn deserialize_expr(buf: &[u8]) -> Result<spark_expression::Expr, ExpressionError> {
+pub(crate) fn deserialize_expr(buf: &[u8]) -> Result<spark_expression::Expr, ExpressionError> {
     match spark_expression::Expr::decode(&mut Cursor::new(buf)) {
         Ok(e) => Ok(e),
         Err(err) => Err(ExpressionError::from(err)),
@@ -55,7 +55,7 @@ pub fn deserialize_expr(buf: &[u8]) -> Result<spark_expression::Expr, Expression
 }
 
 /// Deserialize bytes to protobuf type of operator
-pub fn deserialize_op(buf: &[u8]) -> Result<spark_operator::Operator, ExecutionError> {
+pub(crate) fn deserialize_op(buf: &[u8]) -> Result<spark_operator::Operator, ExecutionError> {
     match spark_operator::Operator::decode(&mut Cursor::new(buf)) {
         Ok(e) => Ok(e),
         Err(err) => Err(ExecutionError::from(err)),
@@ -63,7 +63,9 @@ pub fn deserialize_op(buf: &[u8]) -> Result<spark_operator::Operator, ExecutionE
 }
 
 /// Deserialize bytes to protobuf type of data type
-pub fn deserialize_data_type(buf: &[u8]) -> Result<spark_expression::DataType, ExecutionError> {
+pub(crate) fn deserialize_data_type(
+    buf: &[u8],
+) -> Result<spark_expression::DataType, ExecutionError> {
     match spark_expression::DataType::decode(&mut Cursor::new(buf)) {
         Ok(e) => Ok(e),
         Err(err) => Err(ExecutionError::from(err)),
@@ -71,7 +73,7 @@ pub fn deserialize_data_type(buf: &[u8]) -> Result<spark_expression::DataType, E
 }
 
 /// Converts Protobuf data type to Arrow data type.
-pub fn to_arrow_datatype(dt_value: &DataType) -> ArrowDataType {
+pub(crate) fn to_arrow_datatype(dt_value: &DataType) -> ArrowDataType {
     match DataTypeId::try_from(dt_value.type_id).unwrap() {
         Bool => ArrowDataType::Boolean,
         Int8 => ArrowDataType::Int8,
diff --git a/native/core/src/execution/shuffle/list.rs b/native/core/src/execution/shuffle/list.rs
index d8bdcb197..f4e4ef442 100644
--- a/native/core/src/execution/shuffle/list.rs
+++ b/native/core/src/execution/shuffle/list.rs
@@ -26,7 +26,7 @@ use arrow_array::builder::{
 };
 use arrow_schema::{DataType, TimeUnit};
 
-pub struct SparkUnsafeArray {
+pub(crate) struct SparkUnsafeArray {
     row_addr: i64,
     row_size: i32,
     num_elements: usize,
@@ -45,7 +45,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(crate) fn new(addr: i64, size: i32) -> 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());
@@ -181,7 +181,7 @@ define_append_element!(
 /// Appending the given list stored in `SparkUnsafeArray` into `ListBuilder`.
 /// `element_dt` is the data type of the list element. `list_builder` is the list builder.
 /// `list` is the list stored in `SparkUnsafeArray`.
-pub fn append_list_element<T: ArrayBuilder>(
+pub(crate) fn append_list_element<T: ArrayBuilder>(
     element_dt: &DataType,
     list_builder: &mut ListBuilder<T>,
     list: &SparkUnsafeArray,
diff --git a/native/core/src/execution/shuffle/map.rs b/native/core/src/execution/shuffle/map.rs
index 014695293..babe7416e 100644
--- a/native/core/src/execution/shuffle/map.rs
+++ b/native/core/src/execution/shuffle/map.rs
@@ -29,7 +29,7 @@ use arrow_array::builder::{
 };
 use arrow_schema::{DataType, FieldRef, Fields, TimeUnit};
 
-pub struct SparkUnsafeMap {
+pub(crate) struct SparkUnsafeMap {
     row_addr: i64,
     row_size: i32,
     pub(crate) keys: SparkUnsafeArray,
@@ -1931,7 +1931,7 @@ define_append_map_struct_key_element!(
 /// Appending the given map stored in `SparkUnsafeMap` into `MapBuilder`.
 /// `field` includes data types of the map element. `map_builder` is the map builder.
 /// `map` is the map stored in `SparkUnsafeMap`.
-pub fn append_map_elements<K: ArrayBuilder, V: ArrayBuilder>(
+pub(crate) fn append_map_elements<K: ArrayBuilder, V: ArrayBuilder>(
     field: &FieldRef,
     map_builder: &mut MapBuilder<K, V>,
     map: &SparkUnsafeMap,
@@ -2843,7 +2843,7 @@ pub fn append_map_elements<K: ArrayBuilder, V: ArrayBuilder>(
 }
 
 #[allow(clippy::field_reassign_with_default)]
-pub fn get_map_key_value_dt(
+pub(crate) fn get_map_key_value_dt(
     field: &FieldRef,
 ) -> Result<(&DataType, &DataType, MapFieldNames), CometError> {
     let mut map_fieldnames = MapFieldNames::default();
diff --git a/native/core/src/execution/shuffle/mod.rs b/native/core/src/execution/shuffle/mod.rs
index b052df29b..e48e5219d 100644
--- a/native/core/src/execution/shuffle/mod.rs
+++ b/native/core/src/execution/shuffle/mod.rs
@@ -17,4 +17,4 @@
 
 mod list;
 mod map;
-pub mod row;
+pub(crate) mod row;
diff --git a/native/core/src/execution/shuffle/row.rs b/native/core/src/execution/shuffle/row.rs
index 2aeb48815..910689f1a 100644
--- a/native/core/src/execution/shuffle/row.rs
+++ b/native/core/src/execution/shuffle/row.rs
@@ -55,7 +55,7 @@ const NESTED_TYPE_BUILDER_CAPACITY: usize = 100;
 /// A common trait for Spark Unsafe classes that can be used to access the underlying data,
 /// e.g., `UnsafeRow` and `UnsafeArray`. This defines a set of methods that can be used to
 /// access the underlying data with index.
-pub trait SparkUnsafeObject {
+pub(crate) trait SparkUnsafeObject {
     /// Returns the address of the row.
     fn get_row_addr(&self) -> i64;
 
@@ -180,7 +180,7 @@ pub trait SparkUnsafeObject {
     }
 }
 
-pub struct SparkUnsafeRow {
+pub(crate) struct SparkUnsafeRow {
     row_addr: i64,
     row_size: i32,
     row_bitset_width: i64,
@@ -216,18 +216,18 @@ impl SparkUnsafeRow {
     }
 
     /// Returns true if the row is a null row.
-    pub fn is_null_row(&self) -> bool {
+    pub(crate) fn is_null_row(&self) -> bool {
         self.row_addr == -1 && self.row_size == -1 && self.row_bitset_width == -1
     }
 
     /// Calculate the width of the bitset for the row in bytes.
     /// The logic is from Spark `UnsafeRow.calculateBitSetWidthInBytes`.
     #[inline]
-    pub const fn get_row_bitset_width(num_fields: usize) -> usize {
+    pub(crate) const fn get_row_bitset_width(num_fields: usize) -> usize {
         ((num_fields + 63) / 64) * 8
     }
 
-    pub fn new_with_num_fields(num_fields: usize) -> Self {
+    pub(crate) fn new_with_num_fields(num_fields: usize) -> Self {
         Self {
             row_addr: -1,
             row_size: -1,
@@ -236,7 +236,7 @@ impl SparkUnsafeRow {
     }
 
     /// Points the row to the given slice.
-    pub fn point_to_slice(&mut self, slice: &[u8]) {
+    pub(crate) fn point_to_slice(&mut self, slice: &[u8]) {
         self.row_addr = slice.as_ptr() as i64;
         self.row_size = slice.len() as i32;
     }
@@ -247,7 +247,7 @@ impl SparkUnsafeRow {
         self.row_size = row_size;
     }
 
-    pub fn get_row_size(&self) -> i32 {
+    pub(crate) fn get_row_size(&self) -> i32 {
         self.row_size
     }
 
@@ -263,7 +263,7 @@ impl SparkUnsafeRow {
     }
 
     /// Unsets the null bit at the given index of the row, i.e., set the bit to 0 (not null).
-    pub fn set_not_null_at(&mut self, index: usize) {
+    pub(crate) fn set_not_null_at(&mut self, index: usize) {
         unsafe {
             let mask: i64 = 1i64 << (index & 0x3f);
             let word_offset = (self.row_addr + (((index >> 6) as i64) << 3)) as *mut i64;
@@ -3281,7 +3281,7 @@ fn make_builders(
 
 /// Processes a sorted row partition and writes the result to the given output path.
 #[allow(clippy::too_many_arguments)]
-pub fn process_sorted_row_partition(
+pub(crate) fn process_sorted_row_partition(
     row_num: usize,
     batch_size: usize,
     row_addresses_ptr: *mut jlong,
diff --git a/native/core/src/execution/sort.rs b/native/core/src/execution/sort.rs
index 8579949c7..80ae94232 100644
--- a/native/core/src/execution/sort.rs
+++ b/native/core/src/execution/sort.rs
@@ -21,7 +21,7 @@ use std::{cmp, mem, ptr};
 /// - removed `Rdx` implementations for all types except for i64 which is the packed representation
 ///   of row addresses and partition ids from Spark.
 
-pub trait Rdx {
+pub(crate) trait Rdx {
     /// Sets the number of buckets used by the generic implementation.
     fn cfg_nbuckets() -> usize;
 
@@ -77,7 +77,7 @@ impl Rdx for i64 {
 }
 
 /// Radix Sort implementation for some type
-pub trait RdxSort {
+pub(crate) trait RdxSort {
     /// Execute Radix Sort, overwrites (unsorted) content of the type.
     fn rdxsort(&mut self);
 }
diff --git a/native/core/src/execution/utils.rs b/native/core/src/execution/utils.rs
index 553d42606..2b8cc9429 100644
--- a/native/core/src/execution/utils.rs
+++ b/native/core/src/execution/utils.rs
@@ -45,7 +45,7 @@ impl From<ExpressionError> for ArrowError {
     }
 }
 
-pub trait SparkArrowConvert {
+pub(crate) trait SparkArrowConvert {
     /// Build Arrow Arrays from C data interface passed from Spark.
     /// It accepts a tuple (ArrowArray address, ArrowSchema address).
     fn from_spark(addresses: (i64, i64)) -> Result<Self, ExecutionError>
@@ -128,7 +128,7 @@ impl SparkArrowConvert for ArrayData {
 
 /// Converts a slice of bytes to i128. The bytes are serialized in big-endian order by
 /// `BigInteger.toByteArray()` in Java.
-pub fn bytes_to_i128(slice: &[u8]) -> i128 {
+pub(crate) fn bytes_to_i128(slice: &[u8]) -> i128 {
     let mut bytes = [0; 16];
     let mut i = 0;
     while i != 16 && i != slice.len() {
diff --git a/native/core/src/jvm_bridge/batch_iterator.rs b/native/core/src/jvm_bridge/batch_iterator.rs
index 4870624d2..fa758a9db 100644
--- a/native/core/src/jvm_bridge/batch_iterator.rs
+++ b/native/core/src/jvm_bridge/batch_iterator.rs
@@ -24,16 +24,16 @@ 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_next: JMethodID,
-    pub method_next_ret: ReturnType,
+pub(crate) struct CometBatchIterator<'a> {
+    pub(crate) class: JClass<'a>,
+    pub(crate) method_next: JMethodID,
+    pub(crate) method_next_ret: ReturnType,
 }
 
 impl<'a> CometBatchIterator<'a> {
-    pub const JVM_CLASS: &'static str = "org/apache/comet/CometBatchIterator";
+    pub(crate) const JVM_CLASS: &'static str = "org/apache/comet/CometBatchIterator";
 
-    pub fn new(env: &mut JNIEnv<'a>) -> JniResult<CometBatchIterator<'a>> {
+    pub(crate) fn new(env: &mut JNIEnv<'a>) -> JniResult<CometBatchIterator<'a>> {
         let class = env.find_class(Self::JVM_CLASS)?;
 
         Ok(CometBatchIterator {
diff --git a/native/core/src/jvm_bridge/comet_exec.rs b/native/core/src/jvm_bridge/comet_exec.rs
index 1bcbbc4ad..25b9f10da 100644
--- a/native/core/src/jvm_bridge/comet_exec.rs
+++ b/native/core/src/jvm_bridge/comet_exec.rs
@@ -23,36 +23,36 @@ use jni::{
 };
 
 /// A struct that holds all the JNI methods and fields for JVM CometExec object.
-pub struct CometExec<'a> {
-    pub class: JClass<'a>,
-    pub method_get_bool: JStaticMethodID,
-    pub method_get_bool_ret: ReturnType,
-    pub method_get_byte: JStaticMethodID,
-    pub method_get_byte_ret: ReturnType,
-    pub method_get_short: JStaticMethodID,
-    pub method_get_short_ret: ReturnType,
-    pub method_get_int: JStaticMethodID,
-    pub method_get_int_ret: ReturnType,
-    pub method_get_long: JStaticMethodID,
-    pub method_get_long_ret: ReturnType,
-    pub method_get_float: JStaticMethodID,
-    pub method_get_float_ret: ReturnType,
-    pub method_get_double: JStaticMethodID,
-    pub method_get_double_ret: ReturnType,
-    pub method_get_decimal: JStaticMethodID,
-    pub method_get_decimal_ret: ReturnType,
-    pub method_get_string: JStaticMethodID,
-    pub method_get_string_ret: ReturnType,
-    pub method_get_binary: JStaticMethodID,
-    pub method_get_binary_ret: ReturnType,
-    pub method_is_null: JStaticMethodID,
-    pub method_is_null_ret: ReturnType,
+pub(crate) struct CometExec<'a> {
+    pub(crate) class: JClass<'a>,
+    pub(crate) method_get_bool: JStaticMethodID,
+    pub(crate) method_get_bool_ret: ReturnType,
+    pub(crate) method_get_byte: JStaticMethodID,
+    pub(crate) method_get_byte_ret: ReturnType,
+    pub(crate) method_get_short: JStaticMethodID,
+    pub(crate) method_get_short_ret: ReturnType,
+    pub(crate) method_get_int: JStaticMethodID,
+    pub(crate) method_get_int_ret: ReturnType,
+    pub(crate) method_get_long: JStaticMethodID,
+    pub(crate) method_get_long_ret: ReturnType,
+    pub(crate) method_get_float: JStaticMethodID,
+    pub(crate) method_get_float_ret: ReturnType,
+    pub(crate) method_get_double: JStaticMethodID,
+    pub(crate) method_get_double_ret: ReturnType,
+    pub(crate) method_get_decimal: JStaticMethodID,
+    pub(crate) method_get_decimal_ret: ReturnType,
+    pub(crate) method_get_string: JStaticMethodID,
+    pub(crate) method_get_string_ret: ReturnType,
+    pub(crate) method_get_binary: JStaticMethodID,
+    pub(crate) method_get_binary_ret: ReturnType,
+    pub(crate) method_is_null: JStaticMethodID,
+    pub(crate) method_is_null_ret: ReturnType,
 }
 
 impl<'a> CometExec<'a> {
-    pub const JVM_CLASS: &'static str = "org/apache/spark/sql/comet/CometScalarSubquery";
+    pub(crate) const JVM_CLASS: &'static str = "org/apache/spark/sql/comet/CometScalarSubquery";
 
-    pub fn new(env: &mut JNIEnv<'a>) -> JniResult<CometExec<'a>> {
+    pub(crate) fn new(env: &mut JNIEnv<'a>) -> JniResult<CometExec<'a>> {
         let class = env.find_class(Self::JVM_CLASS)?;
 
         Ok(CometExec {
diff --git a/native/core/src/jvm_bridge/comet_metric_node.rs b/native/core/src/jvm_bridge/comet_metric_node.rs
index 8647e071a..b7b3c69ec 100644
--- a/native/core/src/jvm_bridge/comet_metric_node.rs
+++ b/native/core/src/jvm_bridge/comet_metric_node.rs
@@ -23,18 +23,18 @@ use jni::{
 };
 
 /// A struct that holds all the JNI methods and fields for JVM CometMetricNode class.
-pub struct CometMetricNode<'a> {
-    pub class: JClass<'a>,
-    pub method_get_child_node: JMethodID,
-    pub method_get_child_node_ret: ReturnType,
-    pub method_set: JMethodID,
-    pub method_set_ret: ReturnType,
+pub(crate) struct CometMetricNode<'a> {
+    pub(crate) class: JClass<'a>,
+    pub(crate) method_get_child_node: JMethodID,
+    pub(crate) method_get_child_node_ret: ReturnType,
+    pub(crate) method_set: JMethodID,
+    pub(crate) method_set_ret: ReturnType,
 }
 
 impl<'a> CometMetricNode<'a> {
-    pub const JVM_CLASS: &'static str = "org/apache/spark/sql/comet/CometMetricNode";
+    pub(crate) const JVM_CLASS: &'static str = "org/apache/spark/sql/comet/CometMetricNode";
 
-    pub fn new(env: &mut JNIEnv<'a>) -> JniResult<CometMetricNode<'a>> {
+    pub(crate) fn new(env: &mut JNIEnv<'a>) -> JniResult<CometMetricNode<'a>> {
         let class = env.find_class(Self::JVM_CLASS)?;
 
         Ok(CometMetricNode {
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 97d1bf3a7..891075c1c 100644
--- a/native/core/src/jvm_bridge/comet_task_memory_manager.rs
+++ b/native/core/src/jvm_bridge/comet_task_memory_manager.rs
@@ -25,19 +25,19 @@ use jni::{
 /// A wrapper which delegate acquire/release memory calls to the
 /// JVM side `CometTaskMemoryManager`.
 #[derive(Debug)]
-pub struct CometTaskMemoryManager<'a> {
-    pub class: JClass<'a>,
-    pub method_acquire_memory: JMethodID,
-    pub method_release_memory: JMethodID,
+pub(crate) struct CometTaskMemoryManager<'a> {
+    pub(crate) class: JClass<'a>,
+    pub(crate) method_acquire_memory: JMethodID,
+    pub(crate) method_release_memory: JMethodID,
 
-    pub method_acquire_memory_ret: ReturnType,
-    pub method_release_memory_ret: ReturnType,
+    pub(crate) method_acquire_memory_ret: ReturnType,
+    pub(crate) method_release_memory_ret: ReturnType,
 }
 
 impl<'a> CometTaskMemoryManager<'a> {
-    pub const JVM_CLASS: &'static str = "org/apache/spark/CometTaskMemoryManager";
+    pub(crate) const JVM_CLASS: &'static str = "org/apache/spark/CometTaskMemoryManager";
 
-    pub fn new(env: &mut JNIEnv<'a>) -> JniResult<CometTaskMemoryManager<'a>> {
+    pub(crate) fn new(env: &mut JNIEnv<'a>) -> JniResult<CometTaskMemoryManager<'a>> {
         let class = env.find_class(Self::JVM_CLASS)?;
 
         let result = CometTaskMemoryManager {
diff --git a/native/core/src/jvm_bridge/mod.rs b/native/core/src/jvm_bridge/mod.rs
index 4936b1c5b..1b6a6c567 100644
--- a/native/core/src/jvm_bridge/mod.rs
+++ b/native/core/src/jvm_bridge/mod.rs
@@ -113,30 +113,30 @@ macro_rules! jni_static_call {
 
 /// Wrapper for JString. Because we cannot implement `TryFrom` trait for `JString` as they
 /// are defined in different crates.
-pub struct StringWrapper<'a> {
+pub(crate) struct StringWrapper<'a> {
     value: JString<'a>,
 }
 
 impl<'a> StringWrapper<'a> {
-    pub fn new(value: JString<'a>) -> StringWrapper<'a> {
+    pub(crate) fn new(value: JString<'a>) -> StringWrapper<'a> {
         Self { value }
     }
 
-    pub fn get(&self) -> &JString {
+    pub(crate) fn get(&self) -> &JString {
         &self.value
     }
 }
 
-pub struct BinaryWrapper<'a> {
+pub(crate) struct BinaryWrapper<'a> {
     value: JObject<'a>,
 }
 
 impl<'a> BinaryWrapper<'a> {
-    pub fn new(value: JObject<'a>) -> BinaryWrapper<'a> {
+    pub(crate) fn new(value: JObject<'a>) -> BinaryWrapper<'a> {
         Self { value }
     }
 
-    pub fn get(&self) -> &JObject {
+    pub(crate) fn get(&self) -> &JObject {
         &self.value
     }
 }
@@ -178,18 +178,18 @@ pub(crate) use jni_static_call;
 pub(crate) use jvalues;
 
 mod comet_exec;
-pub use comet_exec::*;
+pub(crate) use comet_exec::*;
 mod batch_iterator;
 mod comet_metric_node;
 mod comet_task_memory_manager;
 
 use crate::{errors::CometError, JAVA_VM};
 use batch_iterator::CometBatchIterator;
-pub use comet_metric_node::*;
-pub use comet_task_memory_manager::*;
+pub(crate) use comet_metric_node::*;
+pub(crate) use comet_task_memory_manager::*;
 
 /// The JVM classes that are used in the JNI calls.
-pub struct JVMClasses<'a> {
+pub(crate) struct JVMClasses<'a> {
     /// Cached JClass for "java.lang.Object"
     java_lang_object: JClass<'a>,
     /// Cached JClass for "java.lang.Class"
@@ -197,23 +197,23 @@ pub struct JVMClasses<'a> {
     /// Cached JClass for "java.lang.Throwable"
     java_lang_throwable: JClass<'a>,
     /// Cached method ID for "java.lang.Object#getClass"
-    pub object_get_class_method: JMethodID,
+    pub(crate) object_get_class_method: JMethodID,
     /// Cached method ID for "java.lang.Class#getName"
-    pub class_get_name_method: JMethodID,
+    pub(crate) class_get_name_method: JMethodID,
     /// Cached method ID for "java.lang.Throwable#getMessage"
-    pub throwable_get_message_method: JMethodID,
+    pub(crate) throwable_get_message_method: JMethodID,
     /// Cached method ID for "java.lang.Throwable#getCause"
-    pub throwable_get_cause_method: JMethodID,
+    pub(crate) throwable_get_cause_method: JMethodID,
 
     /// The CometMetricNode class. Used for updating the metrics.
-    pub comet_metric_node: CometMetricNode<'a>,
+    pub(crate) comet_metric_node: CometMetricNode<'a>,
     /// The static CometExec class. Used for getting the subquery result.
-    pub comet_exec: CometExec<'a>,
+    pub(crate) comet_exec: CometExec<'a>,
     /// The CometBatchIterator class. Used for iterating over the batches.
-    pub comet_batch_iterator: CometBatchIterator<'a>,
+    pub(crate) comet_batch_iterator: CometBatchIterator<'a>,
     /// The CometTaskMemoryManager used for interacting with JVM side to
     /// acquire & release native memory.
-    pub comet_task_memory_manager: CometTaskMemoryManager<'a>,
+    pub(crate) comet_task_memory_manager: CometTaskMemoryManager<'a>,
 }
 
 unsafe impl<'a> Send for JVMClasses<'a> {}
@@ -225,7 +225,7 @@ static JVM_CLASSES: OnceCell<JVMClasses> = OnceCell::new();
 
 impl JVMClasses<'_> {
     /// Creates a new JVMClasses struct.
-    pub fn init(env: &mut JNIEnv) {
+    pub(crate) fn init(env: &mut JNIEnv) {
         JVM_CLASSES.get_or_init(|| {
             // A hack to make the `JNIEnv` static. It is not safe but we don't really use the
             // `JNIEnv` except for creating the global references of the classes.
@@ -269,12 +269,12 @@ impl JVMClasses<'_> {
         });
     }
 
-    pub fn get() -> &'static JVMClasses<'static> {
+    pub(crate) fn get() -> &'static JVMClasses<'static> {
         unsafe { JVM_CLASSES.get_unchecked() }
     }
 
     /// Gets the JNIEnv for the current thread.
-    pub fn get_env() -> CometResult<AttachGuard<'static>> {
+    pub(crate) fn get_env() -> CometResult<AttachGuard<'static>> {
         unsafe {
             let java_vm = JAVA_VM.get_unchecked();
             java_vm.attach_current_thread().map_err(|e| {
diff --git a/native/core/src/lib.rs b/native/core/src/lib.rs
index 36e63e39c..7cf8c3f7d 100644
--- a/native/core/src/lib.rs
+++ b/native/core/src/lib.rs
@@ -40,18 +40,18 @@ use log4rs::{
 use mimalloc::MiMalloc;
 use once_cell::sync::OnceCell;
 
-pub use data_type::*;
+pub(crate) use data_type::*;
 
 use errors::{try_unwrap_or_throw, CometError, CometResult};
 
 #[macro_use]
 mod errors;
 #[macro_use]
-pub mod common;
+pub(crate) mod common;
 mod data_type;
-pub mod execution;
+pub(crate) mod execution;
 mod jvm_bridge;
-pub mod parquet;
+pub(crate) mod parquet;
 
 #[cfg(feature = "mimalloc")]
 #[global_allocator]
@@ -60,7 +60,7 @@ static GLOBAL: MiMalloc = MiMalloc;
 static JAVA_VM: OnceCell<JavaVM> = OnceCell::new();
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_NativeBase_init(
+pub(crate) extern "system" fn Java_org_apache_comet_NativeBase_init(
     e: JNIEnv,
     _: JClass,
     log_conf_path: JString,
diff --git a/native/core/src/parquet/compression.rs b/native/core/src/parquet/compression.rs
index 37b857f4a..a187e0040 100644
--- a/native/core/src/parquet/compression.rs
+++ b/native/core/src/parquet/compression.rs
@@ -50,7 +50,7 @@ use std::io::{copy, Read, Write};
 
 /// Parquet compression codec interface.
 #[allow(clippy::ptr_arg)]
-pub trait Codec {
+pub(crate) 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`
@@ -65,7 +65,7 @@ pub trait Codec {
 /// 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>>> {
+pub(crate) 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()))),
@@ -78,7 +78,7 @@ pub fn create_codec(codec: CodecType) -> Result<Option<Box<dyn Codec>>> {
 }
 
 /// Codec for Snappy compression format.
-pub struct SnappyCodec {
+pub(crate) struct SnappyCodec {
     decoder: Decoder,
     encoder: Encoder,
 }
@@ -115,7 +115,7 @@ impl Codec for SnappyCodec {
 }
 
 /// Codec for GZIP compression algorithm.
-pub struct GZipCodec {}
+pub(crate) struct GZipCodec {}
 
 impl GZipCodec {
     /// Creates new GZIP compression codec.
@@ -142,7 +142,7 @@ 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 {}
+pub(crate) struct BrotliCodec {}
 
 impl BrotliCodec {
     /// Creates new Brotli compression codec.
@@ -173,7 +173,7 @@ impl Codec for BrotliCodec {
 const LZ4_BUFFER_SIZE: usize = 4096;
 
 /// Codec for LZ4 compression algorithm.
-pub struct LZ4Codec {}
+pub(crate) struct LZ4Codec {}
 
 impl LZ4Codec {
     /// Creates new LZ4 compression codec.
@@ -214,7 +214,7 @@ impl Codec for LZ4Codec {
 }
 
 /// Codec for Zstandard compression algorithm.
-pub struct ZSTDCodec {}
+pub(crate) struct ZSTDCodec {}
 
 impl ZSTDCodec {
     /// Creates new Zstandard compression codec.
diff --git a/native/core/src/parquet/data_type.rs b/native/core/src/parquet/data_type.rs
index cd578e2a2..f14d6a223 100644
--- a/native/core/src/parquet/data_type.rs
+++ b/native/core/src/parquet/data_type.rs
@@ -17,11 +17,11 @@
 
 use super::read::{PlainDecoding, PlainDictDecoding};
 
-pub trait DataType: PlainDecoding + PlainDictDecoding + 'static {}
+pub(crate) trait DataType: PlainDecoding + PlainDictDecoding + 'static {}
 
 macro_rules! make_type {
     ($name:ident) => {
-        pub struct $name {}
+        pub(crate) struct $name {}
         impl DataType for $name {}
     };
 }
@@ -57,7 +57,7 @@ make_type!(Int64TimestampMillisType);
 make_type!(Int64TimestampMicrosType);
 make_type!(Int96TimestampMicrosType);
 
-pub trait AsBytes {
+pub(crate) trait AsBytes {
     /// Returns the slice of bytes for an instance of this data type.
     fn as_bytes(&self) -> &[u8];
 }
diff --git a/native/core/src/parquet/mod.rs b/native/core/src/parquet/mod.rs
index 455f19929..6cbb97d66 100644
--- a/native/core/src/parquet/mod.rs
+++ b/native/core/src/parquet/mod.rs
@@ -15,13 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
-pub mod data_type;
-pub mod mutable_vector;
-pub use mutable_vector::*;
+pub(crate) mod data_type;
+pub(crate) mod mutable_vector;
+pub(crate) use mutable_vector::*;
 
 #[macro_use]
-pub mod util;
-pub mod read;
+pub(crate) mod util;
+pub(crate) mod read;
 
 use std::{boxed::Box, ptr::NonNull, sync::Arc};
 
@@ -51,12 +51,12 @@ const STR_CLASS_NAME: &str = "java/lang/String";
 
 /// Parquet read context maintained across multiple JNI calls.
 struct Context {
-    pub column_reader: ColumnReader,
+    pub(crate) column_reader: ColumnReader,
     last_data_page: Option<GlobalRef>,
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_initColumnReader(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_initColumnReader(
     e: JNIEnv,
     _jclass: JClass,
     primitive_type: jint,
@@ -119,7 +119,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_initColumnReader(
 /// # Safety
 /// This function is inheritly unsafe since it deals with raw pointers passed from JNI.
 #[no_mangle]
-pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setDictionaryPage(
+pub(crate) unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setDictionaryPage(
     e: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -147,7 +147,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setDictionary
 /// # Safety
 /// This function is inheritly unsafe since it deals with raw pointers passed from JNI.
 #[no_mangle]
-pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setPageV1(
+pub(crate) unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setPageV1(
     e: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -175,7 +175,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setPageV1(
 /// # Safety
 /// This function is inheritly unsafe since it deals with raw pointers passed from JNI.
 #[no_mangle]
-pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setPageBufferV1(
+pub(crate) unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setPageBufferV1(
     e: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -216,7 +216,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setPageBuffer
 /// # Safety
 /// This function is inheritly unsafe since it deals with raw pointers passed from JNI.
 #[no_mangle]
-pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setPageV2(
+pub(crate) unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setPageV2(
     e: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -260,7 +260,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setPageV2(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_setNull(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_setNull(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -273,7 +273,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_setNull(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_setBoolean(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_setBoolean(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -287,7 +287,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_setBoolean(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_setByte(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_setByte(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -301,7 +301,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_setByte(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_setShort(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_setShort(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -315,7 +315,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_setShort(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_setInt(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_setInt(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -329,7 +329,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_setInt(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_setLong(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_setLong(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -343,7 +343,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_setLong(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_setFloat(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_setFloat(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -357,7 +357,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_setFloat(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_setDouble(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_setDouble(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -373,7 +373,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_setDouble(
 /// # Safety
 /// This function is inheritly unsafe since it deals with raw pointers passed from JNI.
 #[no_mangle]
-pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setBinary(
+pub(crate) unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setBinary(
     e: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -394,7 +394,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setBinary(
 /// # Safety
 /// This function is inheritly unsafe since it deals with raw pointers passed from JNI.
 #[no_mangle]
-pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setDecimal(
+pub(crate) unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setDecimal(
     e: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -413,7 +413,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setDecimal(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_setPosition(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_setPosition(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -430,7 +430,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_setPosition(
 /// # Safety
 /// This function is inheritly unsafe since it deals with raw pointers passed from JNI.
 #[no_mangle]
-pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setIndices(
+pub(crate) unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setIndices(
     e: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -468,7 +468,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setIndices(
 /// # Safety
 /// This function is inheritly unsafe since it deals with raw pointers passed from JNI.
 #[no_mangle]
-pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setIsDeleted(
+pub(crate) unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setIsDeleted(
     e: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -487,7 +487,7 @@ pub unsafe extern "system" fn Java_org_apache_comet_parquet_Native_setIsDeleted(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_resetBatch(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_resetBatch(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -500,7 +500,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_resetBatch(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_readBatch(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_readBatch(
     e: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -519,7 +519,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_readBatch(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_skipBatch(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_skipBatch(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -533,7 +533,7 @@ pub extern "system" fn Java_org_apache_comet_parquet_Native_skipBatch(
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_currentBatch(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_currentBatch(
     e: JNIEnv,
     _jclass: JClass,
     handle: jlong,
@@ -564,7 +564,7 @@ fn get_reader<'a>(handle: jlong) -> Result<&'a mut ColumnReader, CometError> {
 }
 
 #[no_mangle]
-pub extern "system" fn Java_org_apache_comet_parquet_Native_closeColumnReader(
+pub(crate) extern "system" fn Java_org_apache_comet_parquet_Native_closeColumnReader(
     env: JNIEnv,
     _jclass: JClass,
     handle: jlong,
diff --git a/native/core/src/parquet/mutable_vector.rs b/native/core/src/parquet/mutable_vector.rs
index 7f30d7d87..f5bd3f5db 100644
--- a/native/core/src/parquet/mutable_vector.rs
+++ b/native/core/src/parquet/mutable_vector.rs
@@ -30,7 +30,7 @@ const DEFAULT_ARRAY_LEN: usize = 4;
 ///
 /// TODO: unify the two structs in future
 #[derive(Debug)]
-pub struct ParquetMutableVector {
+pub(crate) struct ParquetMutableVector {
     /// The Arrow type for the elements of this vector.
     pub(crate) arrow_type: ArrowDataType,
 
@@ -64,12 +64,12 @@ pub struct ParquetMutableVector {
 }
 
 impl ParquetMutableVector {
-    pub fn new(capacity: usize, arrow_type: &ArrowDataType) -> Self {
+    pub(crate) fn new(capacity: usize, arrow_type: &ArrowDataType) -> Self {
         let bit_width = Self::bit_width(arrow_type);
         Self::new_with_bit_width(capacity, arrow_type.clone(), bit_width)
     }
 
-    pub fn new_with_bit_width(
+    pub(crate) fn new_with_bit_width(
         capacity: usize,
         arrow_type: ArrowDataType,
         bit_width: usize,
@@ -120,13 +120,13 @@ impl ParquetMutableVector {
 
     /// Whether the given value at `idx` of this vector is null.
     #[inline]
-    pub fn is_null(&self, idx: usize) -> bool {
+    pub(crate) fn is_null(&self, idx: usize) -> bool {
         unsafe { !bit::get_bit_raw(self.validity_buffer.as_ptr(), idx) }
     }
 
     /// Resets this vector to the initial state.
     #[inline]
-    pub fn reset(&mut self) {
+    pub(crate) fn reset(&mut self) {
         self.num_values = 0;
         self.num_nulls = 0;
         self.validity_buffer.reset();
@@ -144,13 +144,13 @@ impl ParquetMutableVector {
 
     /// Appends a new null value to the end of this vector.
     #[inline]
-    pub fn put_null(&mut self) {
+    pub(crate) fn put_null(&mut self) {
         self.put_nulls(1)
     }
 
     /// Appends `n` null values to the end of this vector.
     #[inline]
-    pub fn put_nulls(&mut self, n: usize) {
+    pub(crate) fn put_nulls(&mut self, n: usize) {
         // We need to update offset buffer for binary.
         if Self::is_binary_type(&self.arrow_type) {
             let mut offset = self.num_values * 4;
@@ -168,18 +168,18 @@ impl ParquetMutableVector {
 
     /// Returns the number of total values (including both null and non-null) of this vector.
     #[inline]
-    pub fn num_values(&self) -> usize {
+    pub(crate) fn num_values(&self) -> usize {
         self.num_values
     }
 
     /// Returns the number of null values of this vector.
     #[inline]
-    pub fn num_nulls(&self) -> usize {
+    pub(crate) fn num_nulls(&self) -> usize {
         self.num_nulls
     }
 
     /// Sets the dictionary of this to be `dict`.
-    pub fn set_dictionary(&mut self, dict: ParquetMutableVector) {
+    pub(crate) fn set_dictionary(&mut self, dict: ParquetMutableVector) {
         self.dictionary = Some(Box::new(dict))
     }
 
@@ -192,7 +192,7 @@ impl ParquetMutableVector {
     /// This method is highly unsafe since it calls `CometBuffer::to_arrow` which leaks raw
     /// pointer to the memory region that are tracked by `CometBuffer`. Please see comments on
     /// `to_arrow` buffer to understand the motivation.
-    pub fn get_array_data(&mut self) -> ArrayData {
+    pub(crate) fn get_array_data(&mut self) -> ArrayData {
         unsafe {
             let data_type = if let Some(d) = &self.dictionary {
                 ArrowDataType::Dictionary(
@@ -223,7 +223,7 @@ impl ParquetMutableVector {
 
     /// Returns the number of bits it takes to store one element of `arrow_type` in the value buffer
     /// of this vector.
-    pub fn bit_width(arrow_type: &ArrowDataType) -> usize {
+    pub(crate) fn bit_width(arrow_type: &ArrowDataType) -> usize {
         match arrow_type {
             ArrowDataType::Boolean => 1,
             ArrowDataType::Int8 => 8,
diff --git a/native/core/src/parquet/read/column.rs b/native/core/src/parquet/read/column.rs
index 73f8df956..2ca9a0940 100644
--- a/native/core/src/parquet/read/column.rs
+++ b/native/core/src/parquet/read/column.rs
@@ -46,7 +46,7 @@ const DECIMAL_MAX_INT_DIGITS: i32 = 9;
 /// Maximum number of decimal digits an i64 can represent
 const DECIMAL_MAX_LONG_DIGITS: i32 = 18;
 
-pub enum ColumnReader {
+pub(crate) enum ColumnReader {
     BoolColumnReader(TypedColumnReader<BoolType>),
     Int8ColumnReader(TypedColumnReader<Int8Type>),
     UInt8ColumnReader(TypedColumnReader<UInt8Type>),
@@ -91,7 +91,7 @@ impl ColumnReader {
     /// - `use_legacy_date_timestamp_or_ntz`: Whether to read dates/timestamps that were written
     ///   using the legacy Julian/Gregorian hybrid calendar as it is. If false, exceptions will be
     ///   thrown. If the spark type is TimestampNTZ, this should be true.
-    pub fn get(
+    pub(crate) fn get(
         desc: ColumnDescriptor,
         promotion_info: TypePromotionInfo,
         capacity: usize,
@@ -515,12 +515,12 @@ macro_rules! make_func_mut {
 
 impl ColumnReader {
     #[inline]
-    pub fn get_descriptor(&self) -> &ColumnDescriptor {
+    pub(crate) fn get_descriptor(&self) -> &ColumnDescriptor {
         make_func!(self, get_descriptor)
     }
 
     #[inline]
-    pub fn set_dictionary_page(
+    pub(crate) fn set_dictionary_page(
         &mut self,
         page_value_count: usize,
         page_data: Buffer,
@@ -536,12 +536,17 @@ impl ColumnReader {
     }
 
     #[inline]
-    pub fn set_page_v1(&mut self, page_value_count: usize, page_data: Buffer, encoding: Encoding) {
+    pub(crate) fn set_page_v1(
+        &mut self,
+        page_value_count: usize,
+        page_data: Buffer,
+        encoding: Encoding,
+    ) {
         make_func_mut!(self, set_page_v1, page_value_count, page_data, encoding)
     }
 
     #[inline]
-    pub fn set_page_v2(
+    pub(crate) fn set_page_v2(
         &mut self,
         page_value_count: usize,
         def_level_data: Buffer,
@@ -561,63 +566,63 @@ impl ColumnReader {
     }
 
     #[inline]
-    pub fn set_null(&mut self) {
+    pub(crate) fn set_null(&mut self) {
         make_func_mut!(self, set_null)
     }
 
     #[inline]
-    pub fn set_boolean(&mut self, value: bool) {
+    pub(crate) fn set_boolean(&mut self, value: bool) {
         make_func_mut!(self, set_boolean, value)
     }
 
     #[inline]
-    pub fn set_fixed<U: ArrowNativeType + AsBytes>(&mut self, value: U) {
+    pub(crate) fn set_fixed<U: ArrowNativeType + AsBytes>(&mut self, value: U) {
         make_func_mut!(self, set_fixed, value)
     }
 
     #[inline]
-    pub fn set_binary(&mut self, value: MutableBuffer) {
+    pub(crate) fn set_binary(&mut self, value: MutableBuffer) {
         make_func_mut!(self, set_binary, value)
     }
 
     #[inline]
-    pub fn set_decimal_flba(&mut self, value: MutableBuffer) {
+    pub(crate) fn set_decimal_flba(&mut self, value: MutableBuffer) {
         make_func_mut!(self, set_decimal_flba, value)
     }
 
     #[inline]
-    pub fn set_position(&mut self, value: i64, size: usize) {
+    pub(crate) fn set_position(&mut self, value: i64, size: usize) {
         make_func_mut!(self, set_position, value, size)
     }
 
     #[inline]
-    pub fn set_is_deleted(&mut self, value: MutableBuffer) {
+    pub(crate) fn set_is_deleted(&mut self, value: MutableBuffer) {
         make_func_mut!(self, set_is_deleted, value)
     }
 
     #[inline]
-    pub fn reset_batch(&mut self) {
+    pub(crate) fn reset_batch(&mut self) {
         make_func_mut!(self, reset_batch)
     }
 
     #[inline]
-    pub fn current_batch(&mut self) -> ArrayData {
+    pub(crate) fn current_batch(&mut self) -> ArrayData {
         make_func_mut!(self, current_batch)
     }
 
     #[inline]
-    pub fn read_batch(&mut self, total: usize, null_pad_size: usize) -> (usize, usize) {
+    pub(crate) fn read_batch(&mut self, total: usize, null_pad_size: usize) -> (usize, usize) {
         make_func_mut!(self, read_batch, total, null_pad_size)
     }
 
     #[inline]
-    pub fn skip_batch(&mut self, total: usize, put_nulls: bool) -> usize {
+    pub(crate) fn skip_batch(&mut self, total: usize, put_nulls: bool) -> usize {
         make_func_mut!(self, skip_batch, total, put_nulls)
     }
 }
 
 /// A batched reader for a primitive Parquet column.
-pub struct TypedColumnReader<T: DataType> {
+pub(crate) struct TypedColumnReader<T: DataType> {
     desc: ColumnDescPtr,
     arrow_type: ArrowDataType,
     rep_level_decoder: Option<LevelDecoder>,
@@ -643,7 +648,7 @@ pub struct TypedColumnReader<T: DataType> {
 }
 
 impl<T: DataType> TypedColumnReader<T> {
-    pub fn new(
+    pub(crate) fn new(
         desc: ColumnDescriptor,
         capacity: usize,
         arrow_type: ArrowDataType,
@@ -668,14 +673,14 @@ impl<T: DataType> TypedColumnReader<T> {
     }
 
     #[inline]
-    pub fn get_descriptor(&self) -> &ColumnDescriptor {
+    pub(crate) fn get_descriptor(&self) -> &ColumnDescriptor {
         &self.desc
     }
 
     /// Reset the current batch. This will clear all the content of the current columnar vector as
     /// well as reset all of its internal states.
     #[inline]
-    pub fn reset_batch(&mut self) {
+    pub(crate) fn reset_batch(&mut self) {
         self.vector.reset()
     }
 
@@ -684,7 +689,7 @@ impl<T: DataType> TypedColumnReader<T> {
     /// Note: the caller must make sure the returned Arrow vector is fully consumed before calling
     /// `read_batch` again.
     #[inline]
-    pub fn current_batch(&mut self) -> ArrayData {
+    pub(crate) fn current_batch(&mut self) -> ArrayData {
         self.vector.get_array_data()
     }
 
@@ -696,7 +701,7 @@ impl<T: DataType> TypedColumnReader<T> {
     ///
     /// If the return number of values is < `total`, it means the current page is drained and the
     /// caller should call `set_page_v1` or `set_page_v2` before calling next `read_batch`.
-    pub fn read_batch(&mut self, total: usize, null_pad_size: usize) -> (usize, usize) {
+    pub(crate) fn read_batch(&mut self, total: usize, null_pad_size: usize) -> (usize, usize) {
         debug_assert!(
             self.value_decoder.is_some() && self.def_level_decoder.is_some(),
             "set_page_v1/v2 should have been called"
@@ -719,7 +724,7 @@ impl<T: DataType> TypedColumnReader<T> {
     ///
     /// If the return value is < `total`, it means the current page is drained and the caller should
     /// call `set_page_v1` or `set_page_v2` before calling next `skip_batch`.
-    pub fn skip_batch(&mut self, total: usize, put_nulls: bool) -> usize {
+    pub(crate) fn skip_batch(&mut self, total: usize, put_nulls: bool) -> usize {
         debug_assert!(
             self.value_decoder.is_some() && self.def_level_decoder.is_some(),
             "set_page_v1/v2 should have been called"
@@ -742,7 +747,7 @@ impl<T: DataType> TypedColumnReader<T> {
     /// - If being called more than once during the lifetime of this column reader. A Parquet column
     ///   chunk should only contain a single dictionary page.
     /// - If the input `encoding` is neither `PLAIN`, `PLAIN_DICTIONARY` nor `RLE_DICTIONARY`.
-    pub fn set_dictionary_page(
+    pub(crate) fn set_dictionary_page(
         &mut self,
         page_value_count: usize,
         page_data: Buffer,
@@ -781,7 +786,7 @@ impl<T: DataType> TypedColumnReader<T> {
     }
 
     /// Resets the Parquet data page for this column reader.
-    pub fn set_page_v1(
+    pub(crate) fn set_page_v1(
         &mut self,
         page_value_count: usize,
         page_data: Buffer,
@@ -817,7 +822,7 @@ impl<T: DataType> TypedColumnReader<T> {
     }
 
     /// Resets the Parquet data page for this column reader.
-    pub fn set_page_v2(
+    pub(crate) fn set_page_v2(
         &mut self,
         page_value_count: usize,
         def_level_data: Buffer,
@@ -843,13 +848,13 @@ impl<T: DataType> TypedColumnReader<T> {
     }
 
     /// Sets all values in the vector of this column reader to be null.
-    pub fn set_null(&mut self) {
+    pub(crate) fn set_null(&mut self) {
         self.check_const("set_null");
         self.vector.put_nulls(self.capacity);
     }
 
     /// Sets all values in the vector of this column reader to be `value`.
-    pub fn set_boolean(&mut self, value: bool) {
+    pub(crate) fn set_boolean(&mut self, value: bool) {
         self.check_const("set_boolean");
         if value {
             let dst = self.vector.value_buffer.as_slice_mut();
@@ -859,7 +864,7 @@ impl<T: DataType> TypedColumnReader<T> {
     }
 
     /// Sets all values in the vector of this column reader to be `value`.
-    pub fn set_fixed<U: ArrowNativeType + AsBytes>(&mut self, value: U) {
+    pub(crate) fn set_fixed<U: ArrowNativeType + AsBytes>(&mut self, value: U) {
         self.check_const("set_fixed");
         let type_size = std::mem::size_of::<U>();
 
@@ -872,7 +877,7 @@ impl<T: DataType> TypedColumnReader<T> {
     }
 
     /// Sets all values in the vector of this column reader to be binary represented by `buffer`.
-    pub fn set_binary(&mut self, buffer: MutableBuffer) {
+    pub(crate) fn set_binary(&mut self, buffer: MutableBuffer) {
         self.check_const("set_binary");
 
         // TODO: consider using dictionary here
@@ -902,7 +907,7 @@ impl<T: DataType> TypedColumnReader<T> {
     }
 
     /// Sets all values in the vector of this column reader to be decimal represented by `buffer`.
-    pub fn set_decimal_flba(&mut self, buffer: MutableBuffer) {
+    pub(crate) fn set_decimal_flba(&mut self, buffer: MutableBuffer) {
         self.check_const("set_decimal_flba");
 
         // TODO: consider using dictionary here
@@ -926,7 +931,7 @@ impl<T: DataType> TypedColumnReader<T> {
     }
 
     /// Sets position values of this column reader to the vector starting from `value`.
-    pub fn set_position(&mut self, value: i64, size: usize) {
+    pub(crate) fn set_position(&mut self, value: i64, size: usize) {
         let i64_size = std::mem::size_of::<i64>();
 
         let mut offset = self.vector.num_values * i64_size;
@@ -940,7 +945,7 @@ impl<T: DataType> TypedColumnReader<T> {
 
     /// Sets the values in the vector of this column reader to be a boolean array represented
     /// by `buffer`.
-    pub fn set_is_deleted(&mut self, buffer: MutableBuffer) {
+    pub(crate) fn set_is_deleted(&mut self, buffer: MutableBuffer) {
         let len = buffer.len();
         let dst = self.vector.value_buffer.as_slice_mut();
         for i in 0..len {
diff --git a/native/core/src/parquet/read/levels.rs b/native/core/src/parquet/read/levels.rs
index 3d74b277c..780c9e1b2 100644
--- a/native/core/src/parquet/read/levels.rs
+++ b/native/core/src/parquet/read/levels.rs
@@ -35,7 +35,7 @@ enum Mode {
 }
 
 /// A decoder for Parquet definition & repetition levels.
-pub struct LevelDecoder {
+pub(crate) struct LevelDecoder {
     /// The descriptor of the column that this level decoder is associated to.
     desc: ColumnDescPtr,
     /// Number of bits used to represent the levels.
@@ -62,7 +62,7 @@ pub struct LevelDecoder {
 }
 
 impl LevelDecoder {
-    pub fn new(desc: ColumnDescPtr, bit_width: u8, need_length: bool) -> Self {
+    pub(crate) fn new(desc: ColumnDescPtr, bit_width: u8, need_length: bool) -> Self {
         Self {
             desc,
             bit_width,
@@ -79,7 +79,7 @@ impl LevelDecoder {
 
     /// Sets data for this level decoder, and returns total number of bytes consumed. This is used
     /// for reading DataPage v1 levels.
-    pub fn set_data(&mut self, page_value_count: usize, page_data: &Buffer) -> usize {
+    pub(crate) fn set_data(&mut self, page_value_count: usize, page_data: &Buffer) -> usize {
         self.num_values = page_value_count;
         if self.bit_width == 0 {
             // Special case where the page doesn't have encoded rl/dl data. Here we'll treat it as
@@ -101,7 +101,7 @@ impl LevelDecoder {
 
     /// Reads a batch of `total` values into `vector`. The value decoding is done by
     /// `value_decoder`.
-    pub fn read_batch(
+    pub(crate) fn read_batch(
         &mut self,
         total: usize,
         vector: &mut ParquetMutableVector,
@@ -149,7 +149,7 @@ impl LevelDecoder {
     }
 
     /// Skips a batch of `total` values. The value decoding is done by `value_decoder`.
-    pub fn skip_batch(
+    pub(crate) fn skip_batch(
         &mut self,
         total: usize,
         vector: &mut ParquetMutableVector,
diff --git a/native/core/src/parquet/read/mod.rs b/native/core/src/parquet/read/mod.rs
index 4d057a06c..40dc6708d 100644
--- a/native/core/src/parquet/read/mod.rs
+++ b/native/core/src/parquet/read/mod.rs
@@ -15,11 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
-pub mod column;
-pub mod levels;
-pub mod values;
+pub(crate) mod column;
+pub(crate) mod levels;
+pub(crate) mod values;
 
-pub use column::ColumnReader;
+pub(crate) use column::ColumnReader;
 use parquet::schema::types::ColumnDescPtr;
 
 use super::ParquetMutableVector;
@@ -31,13 +31,13 @@ use bytes::Buf;
 pub(crate) const DECIMAL_BYTE_WIDTH: usize = 16;
 
 #[derive(Clone, Copy)]
-pub struct ReadOptions {
+pub(crate) struct ReadOptions {
     // Whether to read legacy dates/timestamps as it is. If false, throw exceptions.
     pub(crate) use_legacy_date_timestamp_or_ntz: bool,
 }
 
 /// Internal states for PLAIN decoder. Used in combination of `PlainDecoding`.
-pub struct PlainDecoderInner {
+pub(crate) struct PlainDecoderInner {
     /// The input buffer containing values to be decoded
     data: Buffer,
 
@@ -61,7 +61,7 @@ pub struct PlainDecoderInner {
 /// format given an input and output buffer.
 ///
 /// The actual implementations of this trait is in `read/values.rs`.
-pub trait PlainDecoding {
+pub(crate) trait PlainDecoding {
     /// Decodes `num` of items from `src`, and store the result into `dst`, in Arrow format.
     ///
     /// Note: this assumes the `src` has data for at least `num` elements, and won't do any
@@ -75,7 +75,7 @@ pub trait PlainDecoding {
     fn skip(src: &mut PlainDecoderInner, num: usize);
 }
 
-pub trait PlainDictDecoding {
+pub(crate) trait PlainDictDecoding {
     /// Eagerly decode vector `src` which must have dictionary associated. The decoded values are
     /// appended into `dst`.
     fn decode_dict(src: ParquetMutableVector, dst: &mut ParquetMutableVector, bit_width: usize) {
diff --git a/native/core/src/parquet/read/values.rs b/native/core/src/parquet/read/values.rs
index b439e29e6..93b1ced9d 100644
--- a/native/core/src/parquet/read/values.rs
+++ b/native/core/src/parquet/read/values.rs
@@ -32,7 +32,7 @@ use crate::{
 };
 use arrow::datatypes::DataType as ArrowDataType;
 
-pub fn get_decoder<T: DataType>(
+pub(crate) fn get_decoder<T: DataType>(
     value_data: Buffer,
     num_values: usize,
     encoding: Encoding,
@@ -54,7 +54,7 @@ pub fn get_decoder<T: DataType>(
 }
 
 /// A Parquet decoder for values within a Parquet data page.
-pub trait Decoder {
+pub(crate) trait Decoder {
     /// Consumes a single value from the decoder and stores it into `dst`.
     ///
     /// # Preconditions
@@ -99,7 +99,7 @@ const MICROS_PER_MILLIS: i64 = 1000;
 
 const MICROS_PER_DAY: i64 = 24_i64 * 60 * 60 * 1000 * 1000;
 
-pub struct PlainDecoder<T: DataType> {
+pub(crate) struct PlainDecoder<T: DataType> {
     /// Internal states for this decoder.
     inner: PlainDecoderInner,
 
@@ -108,7 +108,7 @@ pub struct PlainDecoder<T: DataType> {
 }
 
 impl<T: DataType> PlainDecoder<T> {
-    pub fn new(
+    pub(crate) fn new(
         value_data: Buffer,
         num_values: usize,
         desc: ColumnDescPtr,
@@ -561,7 +561,7 @@ macro_rules! write_null {
 
 macro_rules! generate_cast_to_unsigned {
     ($name: ident, $src_type:ty, $dst_type:ty, $zero_value:expr) => {
-        pub fn $name(src: &[u8], dst: &mut [u8], num: usize) {
+        pub(crate) fn $name(src: &[u8], dst: &mut [u8], num: usize) {
             debug_assert!(
                 src.len() >= num * std::mem::size_of::<$src_type>(),
                 "Source slice is too small"
@@ -590,7 +590,7 @@ generate_cast_to_unsigned!(copy_i32_to_u32, i32, u32, 0_u32);
 
 macro_rules! generate_cast_to_signed {
     ($name: ident, $src_type:ty, $dst_type:ty) => {
-        pub fn $name(src: &[u8], dst: &mut [u8], num: usize) {
+        pub(crate) fn $name(src: &[u8], dst: &mut [u8], num: usize) {
             debug_assert!(
                 src.len() >= num * std::mem::size_of::<$src_type>(),
                 "Source slice is too small"
@@ -934,7 +934,7 @@ impl<T: DataType> Decoder for PlainDecoder<T> {
 
 /// A decoder for Parquet dictionary indices, which is always of integer type, and encoded with
 /// RLE/BitPacked encoding.
-pub struct DictDecoder {
+pub(crate) struct DictDecoder {
     /// Number of bits used to represent dictionary indices. Must be between `[0, 64]`.
     bit_width: usize,
 
@@ -955,7 +955,7 @@ pub struct DictDecoder {
 }
 
 impl DictDecoder {
-    pub fn new(buf: Buffer, num_values: usize) -> Self {
+    pub(crate) fn new(buf: Buffer, num_values: usize) -> Self {
         let bit_width = buf.as_bytes()[0] as usize;
 
         Self {
diff --git a/native/core/src/parquet/util/bit_packing.rs b/native/core/src/parquet/util/bit_packing.rs
index fd39ba8fa..5040e080a 100644
--- a/native/core/src/parquet/util/bit_packing.rs
+++ b/native/core/src/parquet/util/bit_packing.rs
@@ -26,7 +26,11 @@
 //    https://github.com/tantivy-search/bitpacking
 // but the layout it uses for SIMD is different from Parquet.
 // TODO: support packing as well, which is used for encoding.
-pub unsafe fn unpack32(mut in_ptr: *const u32, out_ptr: *mut u32, num_bits: usize) -> *const u32 {
+pub(crate) unsafe fn unpack32(
+    mut in_ptr: *const u32,
+    out_ptr: *mut u32,
+    num_bits: usize,
+) -> *const u32 {
     in_ptr = match num_bits {
         0 => nullunpacker32(in_ptr, out_ptr),
         1 => unpack1_32(in_ptr, out_ptr),
diff --git a/native/core/src/parquet/util/buffer.rs b/native/core/src/parquet/util/buffer.rs
index 72cfa3fe3..83cb996c2 100644
--- a/native/core/src/parquet/util/buffer.rs
+++ b/native/core/src/parquet/util/buffer.rs
@@ -18,7 +18,7 @@
 use std::{ops::Index, slice::SliceIndex, sync::Arc};
 
 /// An immutable byte buffer.
-pub trait Buffer {
+pub(crate) trait Buffer {
     /// Returns the length (in bytes) of this buffer.
     fn len(&self) -> usize;
 
@@ -41,14 +41,14 @@ impl Buffer for Vec<u8> {
     }
 }
 
-pub struct BufferRef {
+pub(crate) struct BufferRef {
     inner: Arc<dyn Buffer>,
     offset: usize,
     len: usize,
 }
 
 impl BufferRef {
-    pub fn new(inner: Arc<dyn Buffer>) -> Self {
+    pub(crate) fn new(inner: Arc<dyn Buffer>) -> Self {
         let len = inner.len();
         Self {
             inner,
@@ -59,23 +59,23 @@ impl BufferRef {
 
     /// Returns the length of this buffer.
     #[inline]
-    pub fn len(&self) -> usize {
+    pub(crate) fn len(&self) -> usize {
         self.len
     }
 
     #[inline]
-    pub fn is_empty(&self) -> bool {
+    pub(crate) fn is_empty(&self) -> bool {
         self.len == 0
     }
 
     #[inline]
-    pub fn data(&self) -> &[u8] {
+    pub(crate) fn data(&self) -> &[u8] {
         self.inner.data()
     }
 
     /// Creates a new byte buffer containing elements in `[offset, offset+len)`
     #[inline]
-    pub fn slice(&self, offset: usize, len: usize) -> BufferRef {
+    pub(crate) fn slice(&self, offset: usize, len: usize) -> BufferRef {
         assert!(
             self.offset + offset + len <= self.inner.len(),
             "can't create a buffer slice with offset exceeding original \
@@ -95,7 +95,7 @@ impl BufferRef {
 
     /// Creates a new byte buffer containing all elements starting from `offset` in this byte array.
     #[inline]
-    pub fn start(&self, offset: usize) -> BufferRef {
+    pub(crate) fn start(&self, offset: usize) -> BufferRef {
         assert!(
             self.offset + offset <= self.inner.len(),
             "can't create a buffer slice with offset exceeding original \
diff --git a/native/core/src/parquet/util/jni.rs b/native/core/src/parquet/util/jni.rs
index b61fbeab3..dc6e2711a 100644
--- a/native/core/src/parquet/util/jni.rs
+++ b/native/core/src/parquet/util/jni.rs
@@ -32,7 +32,7 @@ use parquet::{
 
 /// Convert primitives from Spark side into a `ColumnDescriptor`.
 #[allow(clippy::too_many_arguments)]
-pub fn convert_column_descriptor(
+pub(crate) fn convert_column_descriptor(
     env: &mut JNIEnv,
     physical_type_id: jint,
     logical_type_id: jint,
@@ -78,7 +78,7 @@ pub fn convert_column_descriptor(
     Ok(result)
 }
 
-pub fn convert_encoding(ordinal: jint) -> Encoding {
+pub(crate) fn convert_encoding(ordinal: jint) -> Encoding {
     match ordinal {
         0 => Encoding::PLAIN,
         1 => Encoding::RLE,
@@ -94,7 +94,7 @@ pub fn convert_encoding(ordinal: jint) -> Encoding {
 }
 
 #[derive(Debug)]
-pub struct TypePromotionInfo {
+pub(crate) struct TypePromotionInfo {
     pub(crate) physical_type: PhysicalType,
     pub(crate) precision: i32,
     pub(crate) scale: i32,
@@ -102,7 +102,7 @@ pub struct TypePromotionInfo {
 }
 
 impl TypePromotionInfo {
-    pub fn new_from_jni(
+    pub(crate) fn new_from_jni(
         physical_type_id: jint,
         precision: jint,
         scale: jint,
@@ -117,7 +117,12 @@ impl TypePromotionInfo {
         }
     }
 
-    pub fn new(physical_type: PhysicalType, precision: i32, scale: i32, bit_width: i32) -> Self {
+    pub(crate) fn new(
+        physical_type: PhysicalType,
+        precision: i32,
+        scale: i32,
+        bit_width: i32,
+    ) -> Self {
         Self {
             physical_type,
             precision,
diff --git a/native/core/src/parquet/util/jni_buffer.rs b/native/core/src/parquet/util/jni_buffer.rs
index 33f36ed9d..effd7800b 100644
--- a/native/core/src/parquet/util/jni_buffer.rs
+++ b/native/core/src/parquet/util/jni_buffer.rs
@@ -31,7 +31,7 @@ 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 {
+pub(crate) 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,
@@ -46,7 +46,7 @@ pub struct JniBuffer {
 }
 
 impl JniBuffer {
-    pub fn try_new(jvm: JavaVM, array: jbyteArray, len: usize) -> Result<Self> {
+    pub(crate) 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)?;
@@ -63,7 +63,7 @@ impl JniBuffer {
 
     /// 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 {
+    pub(crate) fn is_copy(&self) -> bool {
         self.is_copy
     }
 }
diff --git a/native/core/src/parquet/util/memory.rs b/native/core/src/parquet/util/memory.rs
index ed2ab9807..28ae80c32 100644
--- a/native/core/src/parquet/util/memory.rs
+++ b/native/core/src/parquet/util/memory.rs
@@ -32,13 +32,13 @@ use std::{
 // Memory Tracker classes
 
 /// Reference counted pointer for [`MemTracker`].
-pub type MemTrackerPtr = Arc<MemTracker>;
+pub(crate) type MemTrackerPtr = Arc<MemTracker>;
 /// Non-owning reference for [`MemTracker`].
-pub type WeakMemTrackerPtr = Weak<MemTracker>;
+pub(crate) type WeakMemTrackerPtr = Weak<MemTracker>;
 
 /// Struct to track memory usage information.
 #[derive(Debug)]
-pub struct MemTracker {
+pub(crate) struct MemTracker {
     // In the tuple, the first element is the current memory allocated (in bytes),
     // and the second element is the maximum memory allocated so far (in bytes).
     current_memory_usage: AtomicI64,
@@ -48,7 +48,7 @@ pub struct MemTracker {
 impl MemTracker {
     /// Creates new memory tracker.
     #[inline]
-    pub fn new() -> MemTracker {
+    pub(crate) fn new() -> MemTracker {
         MemTracker {
             current_memory_usage: Default::default(),
             max_memory_usage: Default::default(),
@@ -56,18 +56,18 @@ impl MemTracker {
     }
 
     /// Returns the current memory consumption, in bytes.
-    pub fn memory_usage(&self) -> i64 {
+    pub(crate) fn memory_usage(&self) -> i64 {
         self.current_memory_usage.load(Ordering::Acquire)
     }
 
     /// Returns the maximum memory consumption so far, in bytes.
-    pub fn max_memory_usage(&self) -> i64 {
+    pub(crate) fn max_memory_usage(&self) -> i64 {
         self.max_memory_usage.load(Ordering::Acquire)
     }
 
     /// Adds `num_bytes` to the memory consumption tracked by this memory tracker.
     #[inline]
-    pub fn alloc(&self, num_bytes: i64) {
+    pub(crate) fn alloc(&self, num_bytes: i64) {
         let new_current = self
             .current_memory_usage
             .fetch_add(num_bytes, Ordering::Acquire)
@@ -87,9 +87,9 @@ impl Default for MemTracker {
 // Buffer classes
 
 /// Type alias for [`Buffer`].
-pub type ByteBuffer = Buffer<u8>;
+pub(crate) type ByteBuffer = Buffer<u8>;
 /// Type alias for [`BufferPtr`].
-pub type ByteBufferPtr = BufferPtr<u8>;
+pub(crate) type ByteBufferPtr = BufferPtr<u8>;
 
 /// A resize-able buffer class with generic member, with optional memory tracker.
 ///
@@ -98,7 +98,7 @@ pub type ByteBufferPtr = BufferPtr<u8>;
 /// the buffer, while the latter is the actual number of elements.
 /// Invariant: `capacity` >= `size`.
 /// The total allocated bytes for a buffer equals to `capacity * sizeof<T>()`.
-pub struct Buffer<T: Clone> {
+pub(crate) struct Buffer<T: Clone> {
     data: Vec<T>,
     mem_tracker: Option<MemTrackerPtr>,
     type_length: usize,
@@ -106,7 +106,7 @@ pub struct Buffer<T: Clone> {
 
 impl<T: Clone> Buffer<T> {
     /// Creates new empty buffer.
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Buffer {
             data: vec![],
             mem_tracker: None,
@@ -116,7 +116,7 @@ impl<T: Clone> Buffer<T> {
 
     /// Adds [`MemTracker`] for this buffer.
     #[inline]
-    pub fn with_mem_tracker(mut self, mc: MemTrackerPtr) -> Self {
+    pub(crate) fn with_mem_tracker(mut self, mc: MemTrackerPtr) -> Self {
         mc.alloc((self.data.capacity() * self.type_length) as i64);
         self.mem_tracker = Some(mc);
         self
@@ -124,13 +124,13 @@ impl<T: Clone> Buffer<T> {
 
     /// Returns slice of data in this buffer.
     #[inline]
-    pub fn data(&self) -> &[T] {
+    pub(crate) fn data(&self) -> &[T] {
         self.data.as_slice()
     }
 
     /// Sets data for this buffer.
     #[inline]
-    pub fn set_data(&mut self, new_data: Vec<T>) {
+    pub(crate) fn set_data(&mut self, new_data: Vec<T>) {
         if let Some(ref mc) = self.mem_tracker {
             let capacity_diff = new_data.capacity() as i64 - self.data.capacity() as i64;
             mc.alloc(capacity_diff * self.type_length as i64);
@@ -145,7 +145,7 @@ impl<T: Clone> Buffer<T> {
     ///
     /// Memory tracker is also updated, if available.
     #[inline]
-    pub fn resize(&mut self, new_size: usize, init_value: T) {
+    pub(crate) fn resize(&mut self, new_size: usize, init_value: T) {
         let old_capacity = self.data.capacity();
         self.data.resize(new_size, init_value);
         if let Some(ref mc) = self.mem_tracker {
@@ -156,7 +156,7 @@ impl<T: Clone> Buffer<T> {
 
     /// Clears underlying data.
     #[inline]
-    pub fn clear(&mut self) {
+    pub(crate) fn clear(&mut self) {
         self.data.clear()
     }
 
@@ -164,7 +164,7 @@ impl<T: Clone> Buffer<T> {
     ///
     /// Memory tracker is also updated, if available.
     #[inline]
-    pub fn reserve(&mut self, additional_capacity: usize) {
+    pub(crate) fn reserve(&mut self, additional_capacity: usize) {
         let old_capacity = self.data.capacity();
         self.data.reserve(additional_capacity);
         if self.data.capacity() > old_capacity {
@@ -178,7 +178,7 @@ impl<T: Clone> Buffer<T> {
     /// Returns [`BufferPtr`] with buffer data.
     /// Buffer data is reset.
     #[inline]
-    pub fn consume(&mut self) -> BufferPtr<T> {
+    pub(crate) fn consume(&mut self) -> BufferPtr<T> {
         let old_data = mem::take(&mut self.data);
         let mut result = BufferPtr::new(old_data);
         if let Some(ref mc) = self.mem_tracker {
@@ -189,25 +189,25 @@ impl<T: Clone> Buffer<T> {
 
     /// Adds `value` to the buffer.
     #[inline]
-    pub fn push(&mut self, value: T) {
+    pub(crate) fn push(&mut self, value: T) {
         self.data.push(value)
     }
 
     /// Returns current capacity for the buffer.
     #[inline]
-    pub fn capacity(&self) -> usize {
+    pub(crate) fn capacity(&self) -> usize {
         self.data.capacity()
     }
 
     /// Returns current size for the buffer.
     #[inline]
-    pub fn size(&self) -> usize {
+    pub(crate) fn size(&self) -> usize {
         self.data.len()
     }
 
     /// Returns `true` if memory tracker is added to buffer, `false` otherwise.
     #[inline]
-    pub fn is_mem_tracked(&self) -> bool {
+    pub(crate) fn is_mem_tracked(&self) -> bool {
         self.mem_tracker.is_some()
     }
 
@@ -215,7 +215,7 @@ impl<T: Clone> Buffer<T> {
     /// This may panic, if memory tracker is not set, use method above to check if
     /// memory tracker is available.
     #[inline]
-    pub fn mem_tracker(&self) -> &MemTrackerPtr {
+    pub(crate) fn mem_tracker(&self) -> &MemTrackerPtr {
         self.mem_tracker.as_ref().unwrap()
     }
 }
@@ -283,7 +283,7 @@ impl<T: Clone> Drop for Buffer<T> {
 /// when all slices are dropped.
 #[allow(clippy::rc_buffer)]
 #[derive(Clone, Debug)]
-pub struct BufferPtr<T> {
+pub(crate) struct BufferPtr<T> {
     data: Arc<Vec<T>>,
     start: usize,
     len: usize,
@@ -293,7 +293,7 @@ pub struct BufferPtr<T> {
 
 impl<T> BufferPtr<T> {
     /// Creates new buffer from a vector.
-    pub fn new(v: Vec<T>) -> Self {
+    pub(crate) fn new(v: Vec<T>) -> Self {
         let len = v.len();
         Self {
             data: Arc::new(v),
@@ -305,7 +305,7 @@ impl<T> BufferPtr<T> {
 
     /// Returns slice of data in this buffer.
     #[inline]
-    pub fn data(&self) -> &[T] {
+    pub(crate) fn data(&self) -> &[T] {
         &self.data[self.start..self.start + self.len]
     }
 
@@ -313,7 +313,7 @@ impl<T> BufferPtr<T> {
     ///
     /// Range should be within current start position and length.
     #[inline]
-    pub fn with_range(mut self, start: usize, len: usize) -> Self {
+    pub(crate) fn with_range(mut self, start: usize, len: usize) -> Self {
         self.set_range(start, len);
         self
     }
@@ -322,44 +322,44 @@ impl<T> BufferPtr<T> {
     ///
     /// Range should be within current start position and length.
     #[inline]
-    pub fn set_range(&mut self, start: usize, len: usize) {
+    pub(crate) fn set_range(&mut self, start: usize, len: usize) {
         assert!(self.start <= start && start + len <= self.start + self.len);
         self.start = start;
         self.len = len;
     }
 
     /// Adds memory tracker to this buffer.
-    pub fn with_mem_tracker(mut self, mc: MemTrackerPtr) -> Self {
+    pub(crate) fn with_mem_tracker(mut self, mc: MemTrackerPtr) -> Self {
         self.mem_tracker = Some(mc);
         self
     }
 
     /// Returns start position of this buffer.
     #[inline]
-    pub fn start(&self) -> usize {
+    pub(crate) fn start(&self) -> usize {
         self.start
     }
 
     /// Returns length of this buffer
     #[inline]
-    pub fn len(&self) -> usize {
+    pub(crate) fn len(&self) -> usize {
         self.len
     }
 
     /// Returns whether this buffer is empty
     #[inline]
-    pub fn is_empty(&self) -> bool {
+    pub(crate) fn is_empty(&self) -> bool {
         self.len == 0
     }
 
     /// Returns `true` if this buffer has memory tracker, `false` otherwise.
-    pub fn is_mem_tracked(&self) -> bool {
+    pub(crate) fn is_mem_tracked(&self) -> bool {
         self.mem_tracker.is_some()
     }
 
     /// Returns a shallow copy of the buffer.
     /// Reference counted pointer to the data is copied.
-    pub fn all(&self) -> BufferPtr<T> {
+    pub(crate) fn all(&self) -> BufferPtr<T> {
         BufferPtr {
             data: Arc::clone(&self.data),
             start: self.start,
@@ -369,7 +369,7 @@ impl<T> BufferPtr<T> {
     }
 
     /// Returns a shallow copy of the buffer that starts with `start` position.
-    pub fn start_from(&self, start: usize) -> BufferPtr<T> {
+    pub(crate) fn start_from(&self, start: usize) -> BufferPtr<T> {
         assert!(start <= self.len);
         BufferPtr {
             data: Arc::clone(&self.data),
@@ -380,7 +380,7 @@ impl<T> BufferPtr<T> {
     }
 
     /// Returns a shallow copy that is a range slice within this buffer.
-    pub fn range(&self, start: usize, len: usize) -> BufferPtr<T> {
+    pub(crate) fn range(&self, start: usize, len: usize) -> BufferPtr<T> {
         assert!(start + len <= self.len);
         BufferPtr {
             data: Arc::clone(&self.data),
diff --git a/native/core/src/parquet/util/mod.rs b/native/core/src/parquet/util/mod.rs
index e71a6e2c7..0ee36728f 100644
--- a/native/core/src/parquet/util/mod.rs
+++ b/native/core/src/parquet/util/mod.rs
@@ -16,10 +16,9 @@
 // under the License.
 
 pub(crate) mod bit_packing;
-pub mod jni;
-pub mod memory;
+pub(crate) mod jni;
+pub(crate) mod memory;
 
 mod buffer;
-pub use buffer::*;
 
-pub mod test_common;
+pub(crate) mod test_common;
diff --git a/native/core/src/parquet/util/test_common/file_util.rs b/native/core/src/parquet/util/test_common/file_util.rs
index 78e42d29e..d8753a8ed 100644
--- a/native/core/src/parquet/util/test_common/file_util.rs
+++ b/native/core/src/parquet/util/test_common/file_util.rs
@@ -18,7 +18,7 @@
 use std::{env, fs, io::Write, path::PathBuf};
 
 /// Returns file handle for a temp file in 'target' directory with a provided content
-pub fn get_temp_file(file_name: &str, content: &[u8]) -> fs::File {
+pub(crate) fn get_temp_file(file_name: &str, content: &[u8]) -> fs::File {
     // build tmp path to a file in "target/debug/testdata"
     let mut path_buf = env::current_dir().unwrap();
     path_buf.push("target");
@@ -41,7 +41,7 @@ pub fn get_temp_file(file_name: &str, content: &[u8]) -> fs::File {
     file.unwrap()
 }
 
-pub fn get_temp_filename() -> PathBuf {
+pub(crate) fn get_temp_filename() -> PathBuf {
     let mut path_buf = env::current_dir().unwrap();
     path_buf.push("target");
     path_buf.push("debug");
diff --git a/native/core/src/parquet/util/test_common/mod.rs b/native/core/src/parquet/util/test_common/mod.rs
index e46d73223..ff00e9107 100644
--- a/native/core/src/parquet/util/test_common/mod.rs
+++ b/native/core/src/parquet/util/test_common/mod.rs
@@ -15,10 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-pub mod file_util;
-pub mod page_util;
-pub mod rand_gen;
+pub(crate) mod file_util;
+pub(crate) mod page_util;
+pub(crate) 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(crate) use self::rand_gen::{random_bools, random_numbers, random_numbers_range};
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 e20cc30cf..62803fb6c 100644
--- a/native/core/src/parquet/util/test_common/page_util.rs
+++ b/native/core/src/parquet/util/test_common/page_util.rs
@@ -35,7 +35,7 @@ use super::random_numbers_range;
 use bytes::Bytes;
 use zstd::zstd_safe::WriteBuf;
 
-pub trait DataPageBuilder {
+pub(crate) trait DataPageBuilder {
     fn add_rep_levels(&mut self, max_level: i16, rep_levels: &[i16]);
     fn add_def_levels(&mut self, max_level: i16, def_levels: &[i16]);
     fn add_values<T: DataType>(&mut self, encoding: Encoding, values: &[T::T]);
@@ -49,7 +49,7 @@ pub trait DataPageBuilder {
 ///   - add_values() for normal data page / add_indices() for dictionary data page
 ///   - consume()
 ///     in order to populate and obtain a data page.
-pub struct DataPageBuilderImpl {
+pub(crate) struct DataPageBuilderImpl {
     desc: ColumnDescPtr,
     encoding: Option<Encoding>,
     num_values: u32,
@@ -63,7 +63,7 @@ impl DataPageBuilderImpl {
     // `num_values` is the number of non-null values to put in the data page.
     // `datapage_v2` flag is used to indicate if the generated data page should use V2
     // format or not.
-    pub fn new(desc: ColumnDescPtr, num_values: u32, datapage_v2: bool) -> Self {
+    pub(crate) fn new(desc: ColumnDescPtr, num_values: u32, datapage_v2: bool) -> Self {
         DataPageBuilderImpl {
             desc,
             encoding: None,
@@ -164,12 +164,12 @@ impl DataPageBuilder for DataPageBuilderImpl {
 }
 
 /// A utility page reader which stores pages in memory.
-pub struct InMemoryPageReader<P: Iterator<Item = Page>> {
+pub(crate) struct InMemoryPageReader<P: Iterator<Item = Page>> {
     page_iter: P,
 }
 
 impl<P: Iterator<Item = Page>> InMemoryPageReader<P> {
-    pub fn new(pages: impl IntoIterator<Item = Page, IntoIter = P>) -> Self {
+    pub(crate) fn new(pages: impl IntoIterator<Item = Page, IntoIter = P>) -> Self {
         Self {
             page_iter: pages.into_iter(),
         }
@@ -200,14 +200,14 @@ 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>>> {
+pub(crate) 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(
+    pub(crate) fn new(
         schema: SchemaDescPtr,
         column_desc: ColumnDescPtr,
         pages: impl IntoIterator<Item = Vec<Page>, IntoIter = I>,
@@ -233,7 +233,7 @@ impl<I: Iterator<Item = Vec<Page>>> Iterator for InMemoryPageIterator<I> {
 impl<I: Iterator<Item = Vec<Page>> + Send> PageIterator for InMemoryPageIterator<I> {}
 
 #[allow(clippy::too_many_arguments)]
-pub fn make_pages<T: DataType>(
+pub(crate) fn make_pages<T: DataType>(
     desc: ColumnDescPtr,
     encoding: Encoding,
     num_pages: usize,
diff --git a/native/core/src/parquet/util/test_common/rand_gen.rs b/native/core/src/parquet/util/test_common/rand_gen.rs
index c876520ab..9de6300c2 100644
--- a/native/core/src/parquet/util/test_common/rand_gen.rs
+++ b/native/core/src/parquet/util/test_common/rand_gen.rs
@@ -20,7 +20,7 @@ use rand::{
     thread_rng, Rng,
 };
 
-pub fn random_bytes(n: usize) -> Vec<u8> {
+pub(crate) fn random_bytes(n: usize) -> Vec<u8> {
     let mut result = vec![];
     let mut rng = thread_rng();
     for _ in 0..n {
@@ -29,7 +29,7 @@ pub fn random_bytes(n: usize) -> Vec<u8> {
     result
 }
 
-pub fn random_bools(n: usize) -> Vec<bool> {
+pub(crate) fn random_bools(n: usize) -> Vec<bool> {
     let mut result = vec![];
     let mut rng = thread_rng();
     for _ in 0..n {
@@ -38,7 +38,7 @@ pub fn random_bools(n: usize) -> Vec<bool> {
     result
 }
 
-pub fn random_numbers<T>(n: usize) -> Vec<T>
+pub(crate) fn random_numbers<T>(n: usize) -> Vec<T>
 where
     Standard: Distribution<T>,
 {
@@ -46,7 +46,7 @@ where
     Standard.sample_iter(&mut rng).take(n).collect()
 }
 
-pub fn random_numbers_range<T>(n: usize, low: T, high: T, result: &mut Vec<T>)
+pub(crate) fn random_numbers_range<T>(n: usize, low: T, high: T, result: &mut Vec<T>)
 where
     T: PartialOrd + SampleUniform + Copy,
 {

From d30245adcee05ba3259e67ca7c68dd0b1ce5cf36 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 5 Dec 2024 17:16:28 -0700
Subject: [PATCH 2/6] clippy

---
 native/core/src/common/bit.rs                         | 2 +-
 native/core/src/parquet/read/column.rs                | 1 +
 native/core/src/parquet/util/test_common/mod.rs       | 4 +---
 native/core/src/parquet/util/test_common/page_util.rs | 2 +-
 4 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/native/core/src/common/bit.rs b/native/core/src/common/bit.rs
index aef5a2100..193d5c887 100644
--- a/native/core/src/common/bit.rs
+++ b/native/core/src/common/bit.rs
@@ -23,6 +23,7 @@ use crate::{
     errors::CometResult as Result,
     likely,
     parquet::{data_type::AsBytes, util::bit_packing::unpack32},
+    parquet::util::test_common::rand_gen::{random_bools, random_numbers},
     unlikely,
 };
 
@@ -1019,7 +1020,6 @@ pub(crate) fn round_upto_power_of_2(num: usize, factor: usize) -> usize {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::parquet::util::test_common::*;
 
     use rand::{
         distributions::{Distribution, Standard},
diff --git a/native/core/src/parquet/read/column.rs b/native/core/src/parquet/read/column.rs
index 2ca9a0940..faeda03d9 100644
--- a/native/core/src/parquet/read/column.rs
+++ b/native/core/src/parquet/read/column.rs
@@ -46,6 +46,7 @@ const DECIMAL_MAX_INT_DIGITS: i32 = 9;
 /// Maximum number of decimal digits an i64 can represent
 const DECIMAL_MAX_LONG_DIGITS: i32 = 18;
 
+#[allow(clippy::enum_variant_names)]
 pub(crate) enum ColumnReader {
     BoolColumnReader(TypedColumnReader<BoolType>),
     Int8ColumnReader(TypedColumnReader<Int8Type>),
diff --git a/native/core/src/parquet/util/test_common/mod.rs b/native/core/src/parquet/util/test_common/mod.rs
index ff00e9107..7b27c4b09 100644
--- a/native/core/src/parquet/util/test_common/mod.rs
+++ b/native/core/src/parquet/util/test_common/mod.rs
@@ -17,6 +17,4 @@
 
 pub(crate) mod file_util;
 pub(crate) mod page_util;
-pub(crate) mod rand_gen;
-
-pub(crate) use self::rand_gen::{random_bools, random_numbers, random_numbers_range};
+pub(crate) mod rand_gen;
\ No newline at end of file
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 62803fb6c..2927f07b1 100644
--- a/native/core/src/parquet/util/test_common/page_util.rs
+++ b/native/core/src/parquet/util/test_common/page_util.rs
@@ -31,7 +31,7 @@ use parquet::{
     schema::types::{ColumnDescPtr, SchemaDescPtr},
 };
 
-use super::random_numbers_range;
+use crate::parquet::util::test_common::rand_gen::random_numbers_range;
 use bytes::Bytes;
 use zstd::zstd_safe::WriteBuf;
 

From 978a03ded776d70aa9dd631468f07a8aae23ae81 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 5 Dec 2024 17:21:01 -0700
Subject: [PATCH 3/6] fmt

---
 native/core/src/common/bit.rs                   | 2 +-
 native/core/src/parquet/util/test_common/mod.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/native/core/src/common/bit.rs b/native/core/src/common/bit.rs
index 193d5c887..3dcb082f0 100644
--- a/native/core/src/common/bit.rs
+++ b/native/core/src/common/bit.rs
@@ -22,8 +22,8 @@ use arrow::buffer::Buffer;
 use crate::{
     errors::CometResult as Result,
     likely,
-    parquet::{data_type::AsBytes, util::bit_packing::unpack32},
     parquet::util::test_common::rand_gen::{random_bools, random_numbers},
+    parquet::{data_type::AsBytes, util::bit_packing::unpack32},
     unlikely,
 };
 
diff --git a/native/core/src/parquet/util/test_common/mod.rs b/native/core/src/parquet/util/test_common/mod.rs
index 7b27c4b09..9806077e0 100644
--- a/native/core/src/parquet/util/test_common/mod.rs
+++ b/native/core/src/parquet/util/test_common/mod.rs
@@ -17,4 +17,4 @@
 
 pub(crate) mod file_util;
 pub(crate) mod page_util;
-pub(crate) mod rand_gen;
\ No newline at end of file
+pub(crate) mod rand_gen;

From 96053bca9e842603368f05794340613d3fb14c6f Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 5 Dec 2024 17:25:29 -0700
Subject: [PATCH 4/6] add CI check

---
 .github/actions/rust-test/action.yaml | 6 ++++++
 native/core/src/common/bit.rs         | 1 -
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/.github/actions/rust-test/action.yaml b/.github/actions/rust-test/action.yaml
index a1cde99ba..9d13a4d27 100644
--- a/.github/actions/rust-test/action.yaml
+++ b/.github/actions/rust-test/action.yaml
@@ -43,6 +43,12 @@ runs:
         cd native
         cargo install cargo-machete && cargo machete
 
+    - name: Check no public items in datafusion-comet crate
+      shell: bash
+      run: |
+        cd native/core
+        cargo rustc -- -D unreachable_pub
+
     - name: Cache Maven dependencies
       uses: actions/cache@v4
       with:
diff --git a/native/core/src/common/bit.rs b/native/core/src/common/bit.rs
index 3dcb082f0..9a4a85e89 100644
--- a/native/core/src/common/bit.rs
+++ b/native/core/src/common/bit.rs
@@ -22,7 +22,6 @@ use arrow::buffer::Buffer;
 use crate::{
     errors::CometResult as Result,
     likely,
-    parquet::util::test_common::rand_gen::{random_bools, random_numbers},
     parquet::{data_type::AsBytes, util::bit_packing::unpack32},
     unlikely,
 };

From 84b01ededf42accaa2a5b9660aa99436362cda8e Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 5 Dec 2024 17:40:33 -0700
Subject: [PATCH 5/6] fix

---
 native/core/src/common/bit.rs                   | 1 +
 native/core/src/parquet/util/test_common/mod.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/native/core/src/common/bit.rs b/native/core/src/common/bit.rs
index 9a4a85e89..f2ff9f7e6 100644
--- a/native/core/src/common/bit.rs
+++ b/native/core/src/common/bit.rs
@@ -1019,6 +1019,7 @@ pub(crate) fn round_upto_power_of_2(num: usize, factor: usize) -> usize {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::parquet::util::test_common::rand_gen::*;
 
     use rand::{
         distributions::{Distribution, Standard},
diff --git a/native/core/src/parquet/util/test_common/mod.rs b/native/core/src/parquet/util/test_common/mod.rs
index 9806077e0..7b27c4b09 100644
--- a/native/core/src/parquet/util/test_common/mod.rs
+++ b/native/core/src/parquet/util/test_common/mod.rs
@@ -17,4 +17,4 @@
 
 pub(crate) mod file_util;
 pub(crate) mod page_util;
-pub(crate) mod rand_gen;
+pub(crate) mod rand_gen;
\ No newline at end of file

From 7702f692b984f03bd0b6e3c326f3c223d0a62bb2 Mon Sep 17 00:00:00 2001
From: Andy Grove <agrove@apache.org>
Date: Thu, 5 Dec 2024 18:02:46 -0700
Subject: [PATCH 6/6] fmt

---
 native/core/src/parquet/util/test_common/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/native/core/src/parquet/util/test_common/mod.rs b/native/core/src/parquet/util/test_common/mod.rs
index 7b27c4b09..9806077e0 100644
--- a/native/core/src/parquet/util/test_common/mod.rs
+++ b/native/core/src/parquet/util/test_common/mod.rs
@@ -17,4 +17,4 @@
 
 pub(crate) mod file_util;
 pub(crate) mod page_util;
-pub(crate) mod rand_gen;
\ No newline at end of file
+pub(crate) mod rand_gen;