Split out arrow-data into a separate crate (#2746)

* Split out arrow-data

* RAT

* Fix integration test

Cargo.toml

@@ -18,6 +18,7 @@
 [workspace]
 members = [
         "arrow",
+        "arrow-data",
         "arrow-schema",
         "arrow-buffer",
         "arrow-flight",

arrow-data/Cargo.toml

@@ -0,0 +1,56 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+[package]
+name = "arrow-data"
+version = "23.0.0"
+description = "Array data abstractions for Apache Arrow"
+homepage = "https://github.com/apache/arrow-rs"
+repository = "https://github.com/apache/arrow-rs"
+authors = ["Apache Arrow <dev@arrow.apache.org>"]
+license = "Apache-2.0"
+keywords = ["arrow"]
+include = [
+    "benches/*.rs",
+    "src/**/*.rs",
+    "Cargo.toml",
+]
+edition = "2021"
+rust-version = "1.62"
+
+[lib]
+name = "arrow_data"
+path = "src/lib.rs"
+bench = false
+
+[features]
+# force_validate runs full data validation for all arrays that are created
+# this is not enabled by default as it is too computationally expensive
+# but is run as part of our CI checks
+force_validate = []
+
+[dependencies]
+
+arrow-buffer = { version = "23.0.0", path = "../arrow-buffer" }
+arrow-schema = { version = "23.0.0", path = "../arrow-schema" }
+
+num = { version = "0.4", default-features = false, features = ["std"] }
+half = { version = "2.0", default-features = false }
+
+[dev-dependencies]
+
+[build-dependencies]

arrow/src/util/bit_iterator.rs → arrow-data/src/bit_iterator.rs

@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::util::bit_chunk_iterator::{UnalignedBitChunk, UnalignedBitChunkIterator};
+use arrow_buffer::bit_chunk_iterator::{UnalignedBitChunk, UnalignedBitChunkIterator};
 use std::result::Result;
 
 /// Iterator of contiguous ranges of set bits within a provided packed bitmask

arrow/src/util/bit_mask.rs → arrow-data/src/bit_mask.rs

@@ -17,8 +17,8 @@
 
 //! Utils for working with packed bit masks
 
-use crate::util::bit_chunk_iterator::BitChunks;
-use crate::util::bit_util::{ceil, get_bit, set_bit};
+use arrow_buffer::bit_chunk_iterator::BitChunks;
+use arrow_buffer::bit_util::{ceil, get_bit, set_bit};
 
 /// Sets all bits on `write_data` in the range `[offset_write..offset_write+len]` to be equal to the
 /// bits in `data` in the range `[offset_read..offset_read+len]`

arrow/src/bitmap.rs → arrow-data/src/bitmap.rs

@@ -17,8 +17,8 @@
 
 //! Defines [Bitmap] for tracking validity bitmaps
 
-use crate::error::{ArrowError, Result};
-use crate::util::bit_util;
+use arrow_buffer::bit_util;
+use arrow_schema::ArrowError;
 use std::mem;
 
 use arrow_buffer::buffer::{buffer_bin_and, buffer_bin_or, Buffer};
@@ -56,6 +56,10 @@ impl Bitmap {
         unsafe { bit_util::get_bit_raw(self.bits.as_ptr(), i) }
     }
 
+    pub fn buffer(&self) -> &Buffer {
+        &self.bits
+    }
+
     pub fn buffer_ref(&self) -> &Buffer {
         &self.bits
     }
@@ -76,9 +80,9 @@ impl Bitmap {
 }
 
 impl<'a, 'b> BitAnd<&'b Bitmap> for &'a Bitmap {
-    type Output = Result<Bitmap>;
+    type Output = Result<Bitmap, ArrowError>;
 
-    fn bitand(self, rhs: &'b Bitmap) -> Result<Bitmap> {
+    fn bitand(self, rhs: &'b Bitmap) -> Result<Bitmap, ArrowError> {
         if self.bits.len() != rhs.bits.len() {
             return Err(ArrowError::ComputeError(
                 "Buffers must be the same size to apply Bitwise AND.".to_string(),
@@ -95,9 +99,9 @@ impl<'a, 'b> BitAnd<&'b Bitmap> for &'a Bitmap {
 }
 
 impl<'a, 'b> BitOr<&'b Bitmap> for &'a Bitmap {
-    type Output = Result<Bitmap>;
+    type Output = Result<Bitmap, ArrowError>;
 
-    fn bitor(self, rhs: &'b Bitmap) -> Result<Bitmap> {
+    fn bitor(self, rhs: &'b Bitmap) -> Result<Bitmap, ArrowError> {
         if self.bits.len() != rhs.bits.len() {
             return Err(ArrowError::ComputeError(
                 "Buffers must be the same size to apply Bitwise OR.".to_string(),