From a602463c56ec517f34251672612dc0f17dd98a74 Mon Sep 17 00:00:00 2001 From: Emil Ernerfeldt Date: Mon, 15 Jan 2024 16:26:32 +0100 Subject: [PATCH] Rename arrow2 -> re_arrow2 --- arrow-odbc-integration-testing/src/lib.rs | 2 +- arrow-odbc-integration-testing/src/read.rs | 12 +++--- arrow-odbc-integration-testing/src/write.rs | 10 ++--- arrow-parquet-integration-testing/src/main.rs | 10 ++--- .../src/c_stream.rs | 6 +-- arrow-pyarrow-integration-testing/src/lib.rs | 8 ++-- benches/aggregate.rs | 6 +-- benches/arithmetic_kernels.rs | 8 ++-- benches/assign_ops.rs | 4 +- benches/avro_read.rs | 6 +-- benches/bitmap.rs | 2 +- benches/bitmap_assign_ops.rs | 4 +- benches/bitmap_ops.rs | 2 +- benches/bitwise.rs | 2 +- benches/cast_kernels.rs | 8 ++-- benches/comparison_kernels.rs | 6 +-- benches/concatenate.rs | 2 +- benches/count_zeros.rs | 2 +- benches/filter_kernels.rs | 12 +++--- benches/growable.rs | 2 +- benches/hash_kernel.rs | 4 +- benches/iter_list.rs | 2 +- benches/iter_utf8.rs | 2 +- benches/length_kernel.rs | 4 +- benches/like_kernels.rs | 6 +-- benches/read_json.rs | 8 ++-- benches/read_parquet.rs | 4 +- benches/slices_iterator.rs | 2 +- benches/sort_kernel.rs | 6 +-- benches/take_kernels.rs | 6 +-- benches/unset_count.rs | 2 +- benches/write_csv.rs | 10 ++--- benches/write_ipc.rs | 14 ++++--- benches/write_json.rs | 8 ++-- benches/write_parquet.rs | 14 ++++--- examples/arithmetics.rs | 10 ++--- examples/avro_kafka.rs | 2 +- examples/avro_read.rs | 6 +-- examples/avro_read_async.rs | 8 ++-- examples/avro_write.rs | 2 +- examples/cow.rs | 4 +- examples/csv_read.rs | 8 ++-- examples/csv_read_async.rs | 4 +- examples/csv_read_parallel.rs | 6 +-- examples/csv_write.rs | 2 +- examples/csv_write_parallel.rs | 2 +- examples/extension.rs | 12 +++--- examples/ffi.rs | 8 ++-- examples/growable.rs | 4 +- examples/io_odbc.rs | 16 ++++---- examples/ipc_file_mmap.rs | 22 +++++----- examples/ipc_file_read.rs | 12 +++--- examples/ipc_file_write.rs | 10 ++--- examples/ipc_pyarrow/src/main.rs | 8 ++-- examples/json_read.rs | 6 +-- examples/json_write.rs | 2 +- examples/metadata.rs | 2 +- examples/ndjson_read.rs | 8 ++-- examples/ndjson_write.rs | 6 +-- examples/orc_read.rs | 6 +-- examples/parquet_read.rs | 4 +- examples/parquet_read_async.rs | 4 +- examples/parquet_read_parallel/src/main.rs | 2 +- examples/parquet_write.rs | 2 +- examples/parquet_write_async.rs | 2 +- examples/parquet_write_parallel/src/main.rs | 2 +- examples/s3/src/main.rs | 6 +-- .../src/bin/arrow-file-to-stream.rs | 6 +-- .../src/bin/arrow-json-integration-test.rs | 10 ++--- .../src/bin/arrow-stream-to-file.rs | 6 +-- .../integration_test.rs | 12 +++--- .../integration_test.rs | 12 +++--- integration-testing/src/lib.rs | 14 +++---- src/array/binary/mod.rs | 6 +-- src/array/boolean/mod.rs | 6 +-- src/array/dictionary/mutable.rs | 2 +- src/array/ord.rs | 4 +- src/array/primitive/mod.rs | 12 +++--- src/array/struct_/mod.rs | 4 +- src/array/utf8/mod.rs | 6 +-- src/bitmap/immutable.rs | 2 +- src/bitmap/mutable.rs | 2 +- src/buffer/immutable.rs | 2 +- src/compute/aggregate/min_max.rs | 4 +- src/compute/arithmetics/basic/add.rs | 40 +++++++++---------- src/compute/arithmetics/basic/div.rs | 16 ++++---- src/compute/arithmetics/basic/mod.rs | 12 +++--- src/compute/arithmetics/basic/mul.rs | 40 +++++++++---------- src/compute/arithmetics/basic/pow.rs | 8 ++-- src/compute/arithmetics/basic/rem.rs | 16 ++++---- src/compute/arithmetics/basic/sub.rs | 40 +++++++++---------- src/compute/arithmetics/decimal/add.rs | 24 +++++------ src/compute/arithmetics/decimal/div.rs | 24 +++++------ src/compute/arithmetics/decimal/mul.rs | 24 +++++------ src/compute/arithmetics/decimal/sub.rs | 24 +++++------ src/compute/arithmetics/time.rs | 18 ++++----- src/compute/boolean.rs | 40 +++++++++---------- src/compute/boolean_kleene.rs | 28 ++++++------- src/compute/comparison/mod.rs | 12 +++--- src/compute/concatenate.rs | 4 +- src/compute/filter.rs | 6 +-- src/compute/hash.rs | 4 +- src/compute/if_then_else.rs | 6 +-- src/compute/length.rs | 4 +- src/compute/like.rs | 16 ++++---- src/compute/merge_sort/mod.rs | 12 +++--- src/compute/nullif.rs | 26 ++++++------ src/compute/regex_match.rs | 4 +- src/compute/sort/lex_sort.rs | 6 +-- src/compute/sort/mod.rs | 4 +- src/compute/substring.rs | 4 +- src/compute/take/mod.rs | 4 +- src/compute/temporal.rs | 8 ++-- src/compute/utf8.rs | 8 ++-- src/compute/window.rs | 4 +- src/datatypes/mod.rs | 2 +- src/io/flight/mod.rs | 2 +- src/io/ipc/mod.rs | 10 ++--- src/io/ipc/write/file_async.rs | 12 +++--- src/io/ipc/write/stream_async.rs | 10 ++--- src/io/parquet/write/mod.rs | 4 +- src/io/parquet/write/sink.rs | 12 +++--- src/types/bit_chunk.rs | 4 +- tests/it/array/binary/mod.rs | 4 +- tests/it/array/binary/mutable.rs | 6 +-- tests/it/array/binary/mutable_values.rs | 6 +-- tests/it/array/binary/to_mutable.rs | 2 +- tests/it/array/boolean/mod.rs | 4 +- tests/it/array/boolean/mutable.rs | 8 ++-- tests/it/array/dictionary/mod.rs | 2 +- tests/it/array/dictionary/mutable.rs | 6 +-- tests/it/array/equal/boolean.rs | 2 +- tests/it/array/equal/dictionary.rs | 2 +- tests/it/array/equal/fixed_size_list.rs | 2 +- tests/it/array/equal/list.rs | 6 +-- tests/it/array/equal/mod.rs | 2 +- tests/it/array/equal/primitive.rs | 2 +- tests/it/array/equal/utf8.rs | 4 +- tests/it/array/fixed_size_binary/mod.rs | 2 +- tests/it/array/fixed_size_binary/mutable.rs | 6 +-- tests/it/array/fixed_size_list/mod.rs | 2 +- tests/it/array/fixed_size_list/mutable.rs | 4 +- tests/it/array/growable/binary.rs | 2 +- tests/it/array/growable/boolean.rs | 4 +- tests/it/array/growable/dictionary.rs | 6 +-- tests/it/array/growable/fixed_binary.rs | 2 +- tests/it/array/growable/fixed_size_list.rs | 2 +- tests/it/array/growable/list.rs | 2 +- tests/it/array/growable/map.rs | 2 +- tests/it/array/growable/mod.rs | 6 +-- tests/it/array/growable/null.rs | 2 +- tests/it/array/growable/primitive.rs | 2 +- tests/it/array/growable/struct_.rs | 6 +-- tests/it/array/growable/union.rs | 2 +- tests/it/array/growable/utf8.rs | 2 +- tests/it/array/list/mod.rs | 6 +-- tests/it/array/list/mutable.rs | 2 +- tests/it/array/map/mod.rs | 2 +- tests/it/array/mod.rs | 6 +-- tests/it/array/ord.rs | 8 ++-- tests/it/array/primitive/fmt.rs | 2 +- tests/it/array/primitive/mod.rs | 2 +- tests/it/array/primitive/mutable.rs | 2 +- tests/it/array/primitive/to_mutable.rs | 6 +-- tests/it/array/struct_/iterator.rs | 6 +-- tests/it/array/struct_/mod.rs | 6 +-- tests/it/array/struct_/mutable.rs | 2 +- tests/it/array/union.rs | 2 +- tests/it/array/utf8/mod.rs | 2 +- tests/it/array/utf8/mutable.rs | 6 +-- tests/it/array/utf8/mutable_values.rs | 6 +-- tests/it/array/utf8/to_mutable.rs | 2 +- tests/it/arrow.rs | 8 ++-- tests/it/bitmap/assign_ops.rs | 2 +- tests/it/bitmap/bitmap_ops.rs | 2 +- tests/it/bitmap/immutable.rs | 2 +- tests/it/bitmap/mod.rs | 2 +- tests/it/bitmap/mutable.rs | 2 +- tests/it/bitmap/utils/bit_chunks_exact.rs | 2 +- tests/it/bitmap/utils/chunk_iter.rs | 4 +- tests/it/bitmap/utils/fmt.rs | 2 +- tests/it/bitmap/utils/iterator.rs | 2 +- tests/it/bitmap/utils/mod.rs | 2 +- tests/it/bitmap/utils/slice_iterator.rs | 4 +- tests/it/bitmap/utils/zip_validity.rs | 2 +- tests/it/buffer/immutable.rs | 2 +- tests/it/compute/aggregate/memory.rs | 2 +- tests/it/compute/aggregate/min_max.rs | 4 +- tests/it/compute/aggregate/sum.rs | 10 ++--- tests/it/compute/arithmetics/basic/add.rs | 8 ++-- tests/it/compute/arithmetics/basic/div.rs | 6 +-- tests/it/compute/arithmetics/basic/mul.rs | 8 ++-- tests/it/compute/arithmetics/basic/pow.rs | 4 +- tests/it/compute/arithmetics/basic/rem.rs | 6 +-- tests/it/compute/arithmetics/basic/sub.rs | 8 ++-- tests/it/compute/arithmetics/decimal/add.rs | 8 ++-- tests/it/compute/arithmetics/decimal/div.rs | 10 ++--- tests/it/compute/arithmetics/decimal/mul.rs | 8 ++-- tests/it/compute/arithmetics/decimal/sub.rs | 8 ++-- tests/it/compute/arithmetics/mod.rs | 10 ++--- tests/it/compute/arithmetics/time.rs | 10 ++--- tests/it/compute/arity_assign.rs | 4 +- tests/it/compute/bitwise.rs | 4 +- tests/it/compute/boolean.rs | 6 +-- tests/it/compute/boolean_kleene.rs | 6 +-- tests/it/compute/cast.rs | 10 ++--- tests/it/compute/comparison.rs | 16 ++++---- tests/it/compute/concatenate.rs | 6 +-- tests/it/compute/contains.rs | 4 +- tests/it/compute/filter.rs | 6 +-- tests/it/compute/hash.rs | 8 ++-- tests/it/compute/if_then_else.rs | 6 +-- tests/it/compute/length.rs | 10 ++--- tests/it/compute/like.rs | 6 +-- tests/it/compute/limit.rs | 4 +- tests/it/compute/merge_sort.rs | 8 ++-- tests/it/compute/partition.rs | 10 ++--- tests/it/compute/regex_match.rs | 8 ++-- tests/it/compute/sort/lex_sort.rs | 4 +- tests/it/compute/sort/mod.rs | 14 +++---- tests/it/compute/sort/row/mod.rs | 2 +- tests/it/compute/substring.rs | 6 +-- tests/it/compute/take.rs | 16 ++++---- tests/it/compute/temporal.rs | 12 +++--- tests/it/compute/utf8.rs | 10 ++--- tests/it/compute/window.rs | 6 +-- tests/it/ffi/data.rs | 8 ++-- tests/it/ffi/mod.rs | 4 +- tests/it/ffi/stream.rs | 6 +-- tests/it/io/avro/read.rs | 12 +++--- tests/it/io/avro/read_async.rs | 6 +-- tests/it/io/avro/write.rs | 16 ++++---- tests/it/io/avro/write_async.rs | 14 +++---- tests/it/io/csv/read.rs | 8 ++-- tests/it/io/csv/read_async.rs | 6 +-- tests/it/io/csv/write.rs | 10 ++--- tests/it/io/flight/mod.rs | 12 +++--- tests/it/io/ipc/common.rs | 2 +- tests/it/io/ipc/mmap.rs | 14 +++---- tests/it/io/ipc/read/file.rs | 6 +-- tests/it/io/ipc/read/stream.rs | 6 +-- tests/it/io/ipc/read_file_async.rs | 4 +- tests/it/io/ipc/read_stream_async.rs | 4 +- tests/it/io/ipc/write/file.rs | 14 +++---- tests/it/io/ipc/write/file_append.rs | 12 +++--- tests/it/io/ipc/write/stream.rs | 16 ++++---- tests/it/io/ipc/write_file_async.rs | 16 ++++---- tests/it/io/ipc/write_stream_async.rs | 16 ++++---- tests/it/io/json/mod.rs | 10 ++--- tests/it/io/json/read.rs | 8 ++-- tests/it/io/json/write.rs | 4 +- tests/it/io/ndjson/mod.rs | 10 ++--- tests/it/io/ndjson/read.rs | 10 ++--- tests/it/io/orc/read.rs | 6 +-- tests/it/io/parquet/deserialize.rs | 2 +- tests/it/io/parquet/integration.rs | 2 +- tests/it/io/parquet/mod.rs | 4 +- tests/it/io/parquet/read.rs | 20 +++++----- tests/it/io/parquet/read_indexes.rs | 10 +++-- tests/it/io/parquet/sample_tests.rs | 4 +- tests/it/io/parquet/write.rs | 4 +- tests/it/io/parquet/write_async.rs | 4 +- tests/it/io/print.rs | 2 +- tests/it/scalar/binary.rs | 2 +- tests/it/scalar/boolean.rs | 2 +- tests/it/scalar/fixed_size_binary.rs | 2 +- tests/it/scalar/fixed_size_list.rs | 2 +- tests/it/scalar/list.rs | 2 +- tests/it/scalar/map.rs | 2 +- tests/it/scalar/mod.rs | 2 +- tests/it/scalar/null.rs | 2 +- tests/it/scalar/primitive.rs | 2 +- tests/it/scalar/struct_.rs | 2 +- tests/it/scalar/utf8.rs | 2 +- tests/it/temporal_conversions.rs | 8 ++-- tests/it/types.rs | 2 +- 276 files changed, 964 insertions(+), 956 deletions(-) diff --git a/arrow-odbc-integration-testing/src/lib.rs b/arrow-odbc-integration-testing/src/lib.rs index bfc24d65dc3..981523fbd71 100644 --- a/arrow-odbc-integration-testing/src/lib.rs +++ b/arrow-odbc-integration-testing/src/lib.rs @@ -3,8 +3,8 @@ mod read; mod write; -use arrow2::io::odbc::api::{Connection, Environment, Error as OdbcError}; use lazy_static::lazy_static; +use re_arrow2::io::odbc::api::{Connection, Environment, Error as OdbcError}; lazy_static! { /// This is an example for using doc comment attributes diff --git a/arrow-odbc-integration-testing/src/read.rs b/arrow-odbc-integration-testing/src/read.rs index a41b1388738..faa9ecb84bb 100644 --- a/arrow-odbc-integration-testing/src/read.rs +++ b/arrow-odbc-integration-testing/src/read.rs @@ -1,11 +1,11 @@ use stdext::function_name; -use arrow2::array::{Array, BinaryArray, BooleanArray, Int32Array, Int64Array, Utf8Array}; -use arrow2::chunk::Chunk; -use arrow2::datatypes::{DataType, Field, TimeUnit}; -use arrow2::error::Result; -use arrow2::io::odbc::api::{Connection, Cursor}; -use arrow2::io::odbc::read::{buffer_from_metadata, deserialize, infer_schema}; +use re_arrow2::array::{Array, BinaryArray, BooleanArray, Int32Array, Int64Array, Utf8Array}; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::{DataType, Field, TimeUnit}; +use re_arrow2::error::Result; +use re_arrow2::io::odbc::api::{Connection, Cursor}; +use re_arrow2::io::odbc::read::{buffer_from_metadata, deserialize, infer_schema}; use super::{setup_empty_table, ENV, MSSQL}; diff --git a/arrow-odbc-integration-testing/src/write.rs b/arrow-odbc-integration-testing/src/write.rs index bcf12761abd..9ca07396080 100644 --- a/arrow-odbc-integration-testing/src/write.rs +++ b/arrow-odbc-integration-testing/src/write.rs @@ -1,10 +1,10 @@ use stdext::function_name; -use arrow2::array::{Array, BinaryArray, BooleanArray, Int32Array, Utf8Array}; -use arrow2::chunk::Chunk; -use arrow2::datatypes::{DataType, Field}; -use arrow2::error::Result; -use arrow2::io::odbc::write::{buffer_from_description, infer_descriptions, serialize}; +use re_arrow2::array::{Array, BinaryArray, BooleanArray, Int32Array, Utf8Array}; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::{DataType, Field}; +use re_arrow2::error::Result; +use re_arrow2::io::odbc::write::{buffer_from_description, infer_descriptions, serialize}; use super::read::read; use super::{setup_empty_table, ENV, MSSQL}; diff --git a/arrow-parquet-integration-testing/src/main.rs b/arrow-parquet-integration-testing/src/main.rs index f9c95dc26b7..02f9feb4c8e 100644 --- a/arrow-parquet-integration-testing/src/main.rs +++ b/arrow-parquet-integration-testing/src/main.rs @@ -1,9 +1,11 @@ use std::fs::File; use std::io::Read; -use arrow2::array::Array; -use arrow2::io::ipc::IpcField; -use arrow2::{ +use clap::Parser; +use flate2::read::GzDecoder; +use re_arrow2::array::Array; +use re_arrow2::io::ipc::IpcField; +use re_arrow2::{ chunk::Chunk, datatypes::{DataType, Schema}, error::Result, @@ -17,8 +19,6 @@ use arrow2::{ }, AHashMap, }; -use clap::Parser; -use flate2::read::GzDecoder; /// Read gzipped JSON file pub fn read_gzip_json( diff --git a/arrow-pyarrow-integration-testing/src/c_stream.rs b/arrow-pyarrow-integration-testing/src/c_stream.rs index 1c512040880..fad93404851 100644 --- a/arrow-pyarrow-integration-testing/src/c_stream.rs +++ b/arrow-pyarrow-integration-testing/src/c_stream.rs @@ -3,9 +3,9 @@ use pyo3::ffi::Py_uintptr_t; use pyo3::prelude::*; -use arrow2::array::{Int32Array, StructArray}; -use arrow2::datatypes::DataType; -use arrow2::ffi; +use re_arrow2::array::{Int32Array, StructArray}; +use re_arrow2::datatypes::DataType; +use re_arrow2::ffi; use super::*; diff --git a/arrow-pyarrow-integration-testing/src/lib.rs b/arrow-pyarrow-integration-testing/src/lib.rs index ddfe8005999..452263a42c8 100644 --- a/arrow-pyarrow-integration-testing/src/lib.rs +++ b/arrow-pyarrow-integration-testing/src/lib.rs @@ -10,7 +10,7 @@ use pyo3::ffi::Py_uintptr_t; use pyo3::prelude::*; use pyo3::wrap_pyfunction; -use arrow2::{array::Array, datatypes::Field, error::Error, ffi}; +use re_arrow2::{array::Array, datatypes::Field, error::Error, ffi}; /// an error that bridges Error with a Python error #[derive(Debug)] @@ -80,8 +80,8 @@ fn to_py_array(array: Box, py: Python) -> PyResult { ))); let array = Box::new(ffi::export_array_to_c(array)); - let schema_ptr: *const arrow2::ffi::ArrowSchema = &*schema; - let array_ptr: *const arrow2::ffi::ArrowArray = &*array; + let schema_ptr: *const re_arrow2::ffi::ArrowSchema = &*schema; + let array_ptr: *const re_arrow2::ffi::ArrowArray = &*array; let pa = py.import("pyarrow")?; @@ -110,7 +110,7 @@ fn to_rust_field(ob: PyObject, py: Python) -> PyResult { fn to_py_field(field: &Field, py: Python) -> PyResult { let schema = Box::new(ffi::export_field_to_c(field)); - let schema_ptr: *const arrow2::ffi::ArrowSchema = &*schema; + let schema_ptr: *const re_arrow2::ffi::ArrowSchema = &*schema; let pa = py.import("pyarrow")?; diff --git a/benches/aggregate.rs b/benches/aggregate.rs index ac5002d31e9..d29ff5cb17c 100644 --- a/benches/aggregate.rs +++ b/benches/aggregate.rs @@ -1,8 +1,8 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::array::*; -use arrow2::compute::aggregate::*; -use arrow2::util::bench_util::*; +use re_arrow2::array::*; +use re_arrow2::compute::aggregate::*; +use re_arrow2::util::bench_util::*; fn bench_sum(arr_a: &dyn Array) { sum(criterion::black_box(arr_a)).unwrap(); diff --git a/benches/arithmetic_kernels.rs b/benches/arithmetic_kernels.rs index 950a08b10fb..4c755c46014 100644 --- a/benches/arithmetic_kernels.rs +++ b/benches/arithmetic_kernels.rs @@ -1,10 +1,10 @@ -use arrow2::compute::arithmetics::basic::NativeArithmetics; use criterion::{criterion_group, criterion_main, Criterion}; +use re_arrow2::compute::arithmetics::basic::NativeArithmetics; -use arrow2::array::*; -use arrow2::util::bench_util::*; -use arrow2::{compute::arithmetics::basic::add, compute::arithmetics::basic::div_scalar}; use num_traits::NumCast; +use re_arrow2::array::*; +use re_arrow2::util::bench_util::*; +use re_arrow2::{compute::arithmetics::basic::add, compute::arithmetics::basic::div_scalar}; use std::ops::{Add, Div}; fn bench_div_scalar(lhs: &PrimitiveArray, rhs: &T) diff --git a/benches/assign_ops.rs b/benches/assign_ops.rs index 5c190e43c5d..ad3061b28a3 100644 --- a/benches/assign_ops.rs +++ b/benches/assign_ops.rs @@ -1,7 +1,7 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::compute::arity_assign::{binary, unary}; -use arrow2::{ +use re_arrow2::compute::arity_assign::{binary, unary}; +use re_arrow2::{ compute::arithmetics::basic::{mul, mul_scalar}, util::bench_util::*, }; diff --git a/benches/avro_read.rs b/benches/avro_read.rs index 37088492df8..c09e5ed84c7 100644 --- a/benches/avro_read.rs +++ b/benches/avro_read.rs @@ -3,11 +3,11 @@ use std::io::Cursor; use avro_rs::types::Record; use criterion::*; -use arrow2::error::Result; -use arrow2::io::avro::avro_schema::read::read_metadata; -use arrow2::io::avro::read; use avro_rs::*; use avro_rs::{Codec, Schema as AvroSchema}; +use re_arrow2::error::Result; +use re_arrow2::io::avro::avro_schema::read::read_metadata; +use re_arrow2::io::avro::read; fn schema() -> AvroSchema { let raw_schema = r#" diff --git a/benches/bitmap.rs b/benches/bitmap.rs index 5fde7fca77f..6adb55427a2 100644 --- a/benches/bitmap.rs +++ b/benches/bitmap.rs @@ -2,7 +2,7 @@ use std::iter::FromIterator; use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::bitmap::*; +use re_arrow2::bitmap::*; fn add_benchmark(c: &mut Criterion) { (10..=20).step_by(2).for_each(|log2_size| { diff --git a/benches/bitmap_assign_ops.rs b/benches/bitmap_assign_ops.rs index 926be0a60e9..a926f4da266 100644 --- a/benches/bitmap_assign_ops.rs +++ b/benches/bitmap_assign_ops.rs @@ -1,7 +1,7 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::bitmap::{binary_assign, unary_assign}; -use arrow2::bitmap::{Bitmap, MutableBitmap}; +use re_arrow2::bitmap::{binary_assign, unary_assign}; +use re_arrow2::bitmap::{Bitmap, MutableBitmap}; fn add_benchmark(c: &mut Criterion) { (10..=20).step_by(2).for_each(|log2_size| { diff --git a/benches/bitmap_ops.rs b/benches/bitmap_ops.rs index 85a6db602b9..985d1f5b5c4 100644 --- a/benches/bitmap_ops.rs +++ b/benches/bitmap_ops.rs @@ -1,6 +1,6 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::bitmap::Bitmap; +use re_arrow2::bitmap::Bitmap; fn bench_arrow2(lhs: &Bitmap, rhs: &Bitmap) { let r = lhs | rhs; diff --git a/benches/bitwise.rs b/benches/bitwise.rs index 704e32aac77..d45aa8661a9 100644 --- a/benches/bitwise.rs +++ b/benches/bitwise.rs @@ -3,7 +3,7 @@ use std::ops::{BitAnd, BitOr, BitXor, Not}; use criterion::{criterion_group, criterion_main, Criterion}; use num_traits::NumCast; -use arrow2::{ +use re_arrow2::{ array::PrimitiveArray, compute::bitwise::*, types::NativeType, util::bench_util::create_primitive_array_with_seed, }; diff --git a/benches/cast_kernels.rs b/benches/cast_kernels.rs index 2367ef03d03..036f7e7a2ac 100644 --- a/benches/cast_kernels.rs +++ b/benches/cast_kernels.rs @@ -19,10 +19,10 @@ use criterion::{criterion_group, criterion_main, Criterion}; use rand::distributions::Uniform; use rand::Rng; -use arrow2::array::*; -use arrow2::compute::cast; -use arrow2::datatypes::*; -use arrow2::util::bench_util::*; +use re_arrow2::array::*; +use re_arrow2::compute::cast; +use re_arrow2::datatypes::*; +use re_arrow2::util::bench_util::*; fn build_utf8_date_array(size: usize, with_nulls: bool) -> Utf8Array { use chrono::NaiveDate; diff --git a/benches/comparison_kernels.rs b/benches/comparison_kernels.rs index cbea8f8f74d..c609cfa53fd 100644 --- a/benches/comparison_kernels.rs +++ b/benches/comparison_kernels.rs @@ -1,8 +1,8 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::compute::comparison::{eq, eq_scalar}; -use arrow2::scalar::*; -use arrow2::util::bench_util::*; +use re_arrow2::compute::comparison::{eq, eq_scalar}; +use re_arrow2::scalar::*; +use re_arrow2::util::bench_util::*; fn add_benchmark(c: &mut Criterion) { (10..=20).step_by(2).for_each(|log2_size| { diff --git a/benches/concatenate.rs b/benches/concatenate.rs index b2e3713d447..6892173472f 100644 --- a/benches/concatenate.rs +++ b/benches/concatenate.rs @@ -1,6 +1,6 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::{ +use re_arrow2::{ compute::concatenate::concatenate, util::bench_util::{create_boolean_array, create_primitive_array}, }; diff --git a/benches/count_zeros.rs b/benches/count_zeros.rs index 38d1570d213..7d7ad6b5909 100644 --- a/benches/count_zeros.rs +++ b/benches/count_zeros.rs @@ -1,6 +1,6 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::bitmap::utils::count_zeros; +use re_arrow2::bitmap::utils::count_zeros; fn add_benchmark(c: &mut Criterion) { (10..=20).step_by(2).for_each(|log2_size| { diff --git a/benches/filter_kernels.rs b/benches/filter_kernels.rs index 97e8dc320cd..5f7386b83f1 100644 --- a/benches/filter_kernels.rs +++ b/benches/filter_kernels.rs @@ -16,11 +16,13 @@ // under the License. use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::array::*; -use arrow2::chunk::Chunk; -use arrow2::compute::filter::{build_filter, filter, filter_chunk, Filter}; -use arrow2::datatypes::DataType; -use arrow2::util::bench_util::{create_boolean_array, create_primitive_array, create_string_array}; +use re_arrow2::array::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::compute::filter::{build_filter, filter, filter_chunk, Filter}; +use re_arrow2::datatypes::DataType; +use re_arrow2::util::bench_util::{ + create_boolean_array, create_primitive_array, create_string_array, +}; fn bench_filter(data_array: &dyn Array, filter_array: &BooleanArray) { criterion::black_box(filter(data_array, filter_array).unwrap()); diff --git a/benches/growable.rs b/benches/growable.rs index ca7ac8a9045..ff7a7232c67 100644 --- a/benches/growable.rs +++ b/benches/growable.rs @@ -1,6 +1,6 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::{ +use re_arrow2::{ array::growable::{Growable, GrowablePrimitive}, util::bench_util::create_primitive_array, }; diff --git a/benches/hash_kernel.rs b/benches/hash_kernel.rs index 81119b3aaf9..67005b977ea 100644 --- a/benches/hash_kernel.rs +++ b/benches/hash_kernel.rs @@ -1,7 +1,7 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::compute::hash::hash; -use arrow2::util::bench_util::*; +use re_arrow2::compute::hash::hash; +use re_arrow2::util::bench_util::*; fn add_benchmark(c: &mut Criterion) { let log2_size = 10; diff --git a/benches/iter_list.rs b/benches/iter_list.rs index 43b7698f3e5..1cc9d47f0c4 100644 --- a/benches/iter_list.rs +++ b/benches/iter_list.rs @@ -2,7 +2,7 @@ use std::iter::FromIterator; use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::{ +use re_arrow2::{ array::{ListArray, PrimitiveArray}, bitmap::Bitmap, buffer::Buffer, diff --git a/benches/iter_utf8.rs b/benches/iter_utf8.rs index d80ba123890..402e27077f1 100644 --- a/benches/iter_utf8.rs +++ b/benches/iter_utf8.rs @@ -1,6 +1,6 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::array::Utf8Array; +use re_arrow2::array::Utf8Array; fn add_benchmark(c: &mut Criterion) { (10..=20).step_by(2).for_each(|log2_size| { diff --git a/benches/length_kernel.rs b/benches/length_kernel.rs index a5fc2ab08d4..3bccaec7088 100644 --- a/benches/length_kernel.rs +++ b/benches/length_kernel.rs @@ -17,8 +17,8 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::array::*; -use arrow2::compute::length::length; +use re_arrow2::array::*; +use re_arrow2::compute::length::length; fn bench_length(array: &Utf8Array) { criterion::black_box(length(array).unwrap()); diff --git a/benches/like_kernels.rs b/benches/like_kernels.rs index 24f700244cc..c37cfe12235 100644 --- a/benches/like_kernels.rs +++ b/benches/like_kernels.rs @@ -1,8 +1,8 @@ -use arrow2::util::bench_util::create_string_array; use criterion::{criterion_group, criterion_main, Criterion}; +use re_arrow2::util::bench_util::create_string_array; -use arrow2::array::*; -use arrow2::compute::like::like_utf8_scalar; +use re_arrow2::array::*; +use re_arrow2::compute::like::like_utf8_scalar; fn bench_like(array: &Utf8Array, pattern: &str) { criterion::black_box(like_utf8_scalar(array, pattern).unwrap()); diff --git a/benches/read_json.rs b/benches/read_json.rs index 0da79b9437a..4a9dbaedd85 100644 --- a/benches/read_json.rs +++ b/benches/read_json.rs @@ -1,9 +1,9 @@ -use arrow2::array::Array; -use arrow2::datatypes::DataType; use criterion::{criterion_group, criterion_main, Criterion}; +use re_arrow2::array::Array; +use re_arrow2::datatypes::DataType; -use arrow2::io::json::{read, write}; -use arrow2::util::bench_util::*; +use re_arrow2::io::json::{read, write}; +use re_arrow2::util::bench_util::*; fn prep(array: impl Array + 'static) -> (Vec, DataType) { let mut data = vec![]; diff --git a/benches/read_parquet.rs b/benches/read_parquet.rs index 5aa16963601..1ab57bb2a67 100644 --- a/benches/read_parquet.rs +++ b/benches/read_parquet.rs @@ -3,8 +3,8 @@ use std::{fs, io::Cursor, path::PathBuf}; use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::error::Result; -use arrow2::io::parquet::read; +use re_arrow2::error::Result; +use re_arrow2::io::parquet::read; fn to_buffer( size: usize, diff --git a/benches/slices_iterator.rs b/benches/slices_iterator.rs index cea662d16a9..353ce8ae81e 100644 --- a/benches/slices_iterator.rs +++ b/benches/slices_iterator.rs @@ -1,6 +1,6 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::bitmap::{utils::SlicesIterator, Bitmap}; +use re_arrow2::bitmap::{utils::SlicesIterator, Bitmap}; fn bench_slices(lhs: &Bitmap) { let set_count = lhs.len() - lhs.unset_bits(); diff --git a/benches/sort_kernel.rs b/benches/sort_kernel.rs index 562d7d7b444..61ff3fdd029 100644 --- a/benches/sort_kernel.rs +++ b/benches/sort_kernel.rs @@ -17,9 +17,9 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::array::*; -use arrow2::compute::sort::{lexsort, sort, sort_to_indices, SortColumn, SortOptions}; -use arrow2::util::bench_util::*; +use re_arrow2::array::*; +use re_arrow2::compute::sort::{lexsort, sort, sort_to_indices, SortColumn, SortOptions}; +use re_arrow2::util::bench_util::*; fn bench_lexsort(arr_a: &dyn Array, array_b: &dyn Array) { let columns = vec![ diff --git a/benches/take_kernels.rs b/benches/take_kernels.rs index f18e091d12a..40f3e05865b 100644 --- a/benches/take_kernels.rs +++ b/benches/take_kernels.rs @@ -2,9 +2,9 @@ use rand::{rngs::StdRng, Rng, SeedableRng}; use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::array::*; -use arrow2::compute::take; -use arrow2::util::bench_util::*; +use re_arrow2::array::*; +use re_arrow2::compute::take; +use re_arrow2::util::bench_util::*; fn create_random_index(size: usize, null_density: f32) -> PrimitiveArray { let mut rng = StdRng::seed_from_u64(42); diff --git a/benches/unset_count.rs b/benches/unset_count.rs index 38d1570d213..7d7ad6b5909 100644 --- a/benches/unset_count.rs +++ b/benches/unset_count.rs @@ -1,6 +1,6 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::bitmap::utils::count_zeros; +use re_arrow2::bitmap::utils::count_zeros; fn add_benchmark(c: &mut Criterion) { (10..=20).step_by(2).for_each(|log2_size| { diff --git a/benches/write_csv.rs b/benches/write_csv.rs index 7778b0781f4..494d66dd8d3 100644 --- a/benches/write_csv.rs +++ b/benches/write_csv.rs @@ -1,10 +1,10 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::array::*; -use arrow2::chunk::Chunk; -use arrow2::error::Result; -use arrow2::io::csv::write; -use arrow2::util::bench_util::*; +use re_arrow2::array::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::error::Result; +use re_arrow2::io::csv::write; +use re_arrow2::util::bench_util::*; type ChunkBox = Chunk>; diff --git a/benches/write_ipc.rs b/benches/write_ipc.rs index 346ad783468..7746baf5fcb 100644 --- a/benches/write_ipc.rs +++ b/benches/write_ipc.rs @@ -1,12 +1,14 @@ use criterion::{criterion_group, criterion_main, Criterion}; use std::io::Cursor; -use arrow2::array::*; -use arrow2::chunk::Chunk; -use arrow2::datatypes::Field; -use arrow2::error::Result; -use arrow2::io::ipc::write::*; -use arrow2::util::bench_util::{create_boolean_array, create_primitive_array, create_string_array}; +use re_arrow2::array::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::Field; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::write::*; +use re_arrow2::util::bench_util::{ + create_boolean_array, create_primitive_array, create_string_array, +}; fn write(array: &dyn Array) -> Result<()> { let field = Field::new("c1", array.data_type().clone(), true); diff --git a/benches/write_json.rs b/benches/write_json.rs index d4f464040eb..272d5b1e3d1 100644 --- a/benches/write_json.rs +++ b/benches/write_json.rs @@ -1,9 +1,9 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::array::*; -use arrow2::error::Error; -use arrow2::io::json::write; -use arrow2::util::bench_util::*; +use re_arrow2::array::*; +use re_arrow2::error::Error; +use re_arrow2::io::json::write; +use re_arrow2::util::bench_util::*; fn write_array(array: Box) -> Result<(), Error> { let mut writer = vec![]; diff --git a/benches/write_parquet.rs b/benches/write_parquet.rs index 7062ab919d9..955b4d3e4f8 100644 --- a/benches/write_parquet.rs +++ b/benches/write_parquet.rs @@ -1,11 +1,13 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use arrow2::array::{clone, Array}; -use arrow2::chunk::Chunk; -use arrow2::datatypes::{Field, Schema}; -use arrow2::error::Result; -use arrow2::io::parquet::write::*; -use arrow2::util::bench_util::{create_boolean_array, create_primitive_array, create_string_array}; +use re_arrow2::array::{clone, Array}; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::{Field, Schema}; +use re_arrow2::error::Result; +use re_arrow2::io::parquet::write::*; +use re_arrow2::util::bench_util::{ + create_boolean_array, create_primitive_array, create_string_array, +}; type ChunkBox = Chunk>; diff --git a/examples/arithmetics.rs b/examples/arithmetics.rs index fe931b07e3e..d129891107c 100644 --- a/examples/arithmetics.rs +++ b/examples/arithmetics.rs @@ -1,8 +1,8 @@ -use arrow2::array::{Array, PrimitiveArray}; -use arrow2::compute::arithmetics::basic::*; -use arrow2::compute::arithmetics::{add as dyn_add, can_add}; -use arrow2::compute::arity::{binary, unary}; -use arrow2::datatypes::DataType; +use re_arrow2::array::{Array, PrimitiveArray}; +use re_arrow2::compute::arithmetics::basic::*; +use re_arrow2::compute::arithmetics::{add as dyn_add, can_add}; +use re_arrow2::compute::arity::{binary, unary}; +use re_arrow2::datatypes::DataType; fn main() { // say we have two arrays diff --git a/examples/avro_kafka.rs b/examples/avro_kafka.rs index 7645024939e..3211d759058 100644 --- a/examples/avro_kafka.rs +++ b/examples/avro_kafka.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ datatypes::{DataType, Field}, error::Error, io::avro, diff --git a/examples/avro_read.rs b/examples/avro_read.rs index 6f45afae32f..e8ab2fd5e15 100644 --- a/examples/avro_read.rs +++ b/examples/avro_read.rs @@ -1,9 +1,9 @@ use std::fs::File; use std::io::BufReader; -use arrow2::error::Result; -use arrow2::io::avro::avro_schema; -use arrow2::io::avro::read; +use re_arrow2::error::Result; +use re_arrow2::io::avro::avro_schema; +use re_arrow2::io::avro::read; fn main() -> Result<()> { use std::env; diff --git a/examples/avro_read_async.rs b/examples/avro_read_async.rs index ac7ad0b6450..63b82a3bebe 100644 --- a/examples/avro_read_async.rs +++ b/examples/avro_read_async.rs @@ -5,10 +5,10 @@ use futures::StreamExt; use tokio::fs::File; use tokio_util::compat::*; -use arrow2::error::Result; -use arrow2::io::avro::avro_schema::file::Block; -use arrow2::io::avro::avro_schema::read_async::{block_stream, decompress_block, read_metadata}; -use arrow2::io::avro::read::{deserialize, infer_schema}; +use re_arrow2::error::Result; +use re_arrow2::io::avro::avro_schema::file::Block; +use re_arrow2::io::avro::avro_schema::read_async::{block_stream, decompress_block, read_metadata}; +use re_arrow2::io::avro::read::{deserialize, infer_schema}; #[tokio::main(flavor = "current_thread")] async fn main() -> Result<()> { diff --git a/examples/avro_write.rs b/examples/avro_write.rs index 6042172913a..8b6bda2253c 100644 --- a/examples/avro_write.rs +++ b/examples/avro_write.rs @@ -1,6 +1,6 @@ use std::fs::File; -use arrow2::{ +use re_arrow2::{ array::{Array, Int32Array}, datatypes::{Field, Schema}, error::Result, diff --git a/examples/cow.rs b/examples/cow.rs index 65e3920727c..0b23407e617 100644 --- a/examples/cow.rs +++ b/examples/cow.rs @@ -1,6 +1,6 @@ // This example demos how to operate on arrays in-place. -use arrow2::array::{Array, PrimitiveArray}; -use arrow2::compute::arity_assign; +use re_arrow2::array::{Array, PrimitiveArray}; +use re_arrow2::compute::arity_assign; fn main() { // say we have have received an `Array` diff --git a/examples/csv_read.rs b/examples/csv_read.rs index 21addf9d0fe..b3a11ea8c57 100644 --- a/examples/csv_read.rs +++ b/examples/csv_read.rs @@ -1,7 +1,7 @@ -use arrow2::array::Array; -use arrow2::chunk::Chunk; -use arrow2::error::Result; -use arrow2::io::csv::read; +use re_arrow2::array::Array; +use re_arrow2::chunk::Chunk; +use re_arrow2::error::Result; +use re_arrow2::io::csv::read; fn read_path(path: &str, projection: Option<&[usize]>) -> Result>> { // Create a CSV reader. This is typically created on the thread that reads the file and diff --git a/examples/csv_read_async.rs b/examples/csv_read_async.rs index 10d5377fe16..638f8e88e62 100644 --- a/examples/csv_read_async.rs +++ b/examples/csv_read_async.rs @@ -1,8 +1,8 @@ use tokio::fs::File; use tokio_util::compat::*; -use arrow2::error::Result; -use arrow2::io::csv::read_async::*; +use re_arrow2::error::Result; +use re_arrow2::io::csv::read_async::*; #[tokio::main(flavor = "current_thread")] async fn main() -> Result<()> { diff --git a/examples/csv_read_parallel.rs b/examples/csv_read_parallel.rs index 0c3f6e2b106..0bfd625133e 100644 --- a/examples/csv_read_parallel.rs +++ b/examples/csv_read_parallel.rs @@ -3,9 +3,9 @@ use crossbeam_channel::unbounded; use std::thread; use std::time::SystemTime; -use arrow2::array::Array; -use arrow2::chunk::Chunk; -use arrow2::{error::Result, io::csv::read}; +use re_arrow2::array::Array; +use re_arrow2::chunk::Chunk; +use re_arrow2::{error::Result, io::csv::read}; fn parallel_read(path: &str) -> Result>>> { let batch_size = 100; diff --git a/examples/csv_write.rs b/examples/csv_write.rs index 6a40fb7b515..76549a31640 100644 --- a/examples/csv_write.rs +++ b/examples/csv_write.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::{Array, Int32Array}, chunk::Chunk, error::Result, diff --git a/examples/csv_write_parallel.rs b/examples/csv_write_parallel.rs index 65a7e74e5c3..3023b409717 100644 --- a/examples/csv_write_parallel.rs +++ b/examples/csv_write_parallel.rs @@ -3,7 +3,7 @@ use std::sync::mpsc; use std::sync::mpsc::{Receiver, Sender}; use std::thread; -use arrow2::{ +use re_arrow2::{ array::{Array, Int32Array}, chunk::Chunk, error::Result, diff --git a/examples/extension.rs b/examples/extension.rs index c0aea843166..81f0ab3f8d1 100644 --- a/examples/extension.rs +++ b/examples/extension.rs @@ -1,11 +1,11 @@ use std::io::{Cursor, Seek, Write}; -use arrow2::array::*; -use arrow2::chunk::Chunk; -use arrow2::datatypes::*; -use arrow2::error::Result; -use arrow2::io::ipc::read; -use arrow2::io::ipc::write; +use re_arrow2::array::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::*; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read; +use re_arrow2::io::ipc::write; fn main() -> Result<()> { // declare an extension. diff --git a/examples/ffi.rs b/examples/ffi.rs index ed5b9cd87e7..f1f88e62555 100644 --- a/examples/ffi.rs +++ b/examples/ffi.rs @@ -1,7 +1,7 @@ -use arrow2::array::{Array, PrimitiveArray}; -use arrow2::datatypes::Field; -use arrow2::error::Result; -use arrow2::ffi; +use re_arrow2::array::{Array, PrimitiveArray}; +use re_arrow2::datatypes::Field; +use re_arrow2::error::Result; +use re_arrow2::ffi; fn export(array: Box) -> (ffi::ArrowArray, ffi::ArrowSchema) { // importing an array requires an associated field so that the consumer knows its datatype. diff --git a/examples/growable.rs b/examples/growable.rs index cb1e20fcb7e..31ca322a644 100644 --- a/examples/growable.rs +++ b/examples/growable.rs @@ -1,5 +1,5 @@ -use arrow2::array::growable::{Growable, GrowablePrimitive}; -use arrow2::array::PrimitiveArray; +use re_arrow2::array::growable::{Growable, GrowablePrimitive}; +use re_arrow2::array::PrimitiveArray; fn main() { // say we have two sorted arrays diff --git a/examples/io_odbc.rs b/examples/io_odbc.rs index 9305fab6e24..d103b5ac4ca 100644 --- a/examples/io_odbc.rs +++ b/examples/io_odbc.rs @@ -5,14 +5,14 @@ //! sudo apt install libsqliteodbc sqlite3 unixodbc-dev //! sudo sed --in-place 's/libsqlite3odbc.so/\/usr\/lib\/x86_64-linux-gnu\/odbc\/libsqlite3odbc.so/' /etc/odbcinst.ini //! ``` -use arrow2::array::{Array, Int32Array, Utf8Array}; -use arrow2::chunk::Chunk; -use arrow2::datatypes::{DataType, Field}; -use arrow2::error::Result; -use arrow2::io::odbc::api; -use arrow2::io::odbc::api::Cursor; -use arrow2::io::odbc::read; -use arrow2::io::odbc::write; +use re_arrow2::array::{Array, Int32Array, Utf8Array}; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::{DataType, Field}; +use re_arrow2::error::Result; +use re_arrow2::io::odbc::api; +use re_arrow2::io::odbc::api::Cursor; +use re_arrow2::io::odbc::read; +use re_arrow2::io::odbc::write; fn main() -> Result<()> { let connector = "Driver={SQLite3};Database=sqlite-test.db"; diff --git a/examples/ipc_file_mmap.rs b/examples/ipc_file_mmap.rs index e51b49de5be..26081c210ba 100644 --- a/examples/ipc_file_mmap.rs +++ b/examples/ipc_file_mmap.rs @@ -1,10 +1,10 @@ //! Example showing how to memory map an Arrow IPC file into a [`Chunk`]. use std::sync::Arc; -use arrow2::array::{Array, BooleanArray}; -use arrow2::chunk::Chunk; -use arrow2::datatypes::{Field, Schema}; -use arrow2::error::Error; +use re_arrow2::array::{Array, BooleanArray}; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::{Field, Schema}; +use re_arrow2::error::Error; // Arrow2 requires something that implements `AsRef<[u8]>`, which // `Mmap` supports. Here we mock it @@ -22,12 +22,12 @@ impl AsRef<[u8]> for Mmap { fn write( chunks: &[Chunk>], schema: &Schema, - ipc_fields: Option>, - compression: Option, + ipc_fields: Option>, + compression: Option, ) -> Result, Error> { let result = vec![]; - let options = arrow2::io::ipc::write::WriteOptions { compression }; - let mut writer = arrow2::io::ipc::write::FileWriter::try_new( + let options = re_arrow2::io::ipc::write::WriteOptions { compression }; + let mut writer = re_arrow2::io::ipc::write::FileWriter::try_new( result, schema.clone(), ipc_fields.clone(), @@ -49,16 +49,16 @@ fn check_round_trip(array: Box) -> Result<(), Error> { // we first read the files' metadata let metadata = - arrow2::io::ipc::read::read_file_metadata(&mut std::io::Cursor::new(data.as_ref()))?; + re_arrow2::io::ipc::read::read_file_metadata(&mut std::io::Cursor::new(data.as_ref()))?; // next we mmap the dictionaries // Safety: `write` above guarantees that this is a valid Arrow IPC file let dictionaries = - unsafe { arrow2::mmap::mmap_dictionaries_unchecked(&metadata, data.clone())? }; + unsafe { re_arrow2::mmap::mmap_dictionaries_unchecked(&metadata, data.clone())? }; // and finally mmap a chunk (0 in this case). // Safety: `write` above guarantees that this is a valid Arrow IPC file - let new_array = unsafe { arrow2::mmap::mmap_unchecked(&metadata, &dictionaries, data, 0)? }; + let new_array = unsafe { re_arrow2::mmap::mmap_unchecked(&metadata, &dictionaries, data, 0)? }; assert_eq!(new_array.into_arrays()[0], array); Ok(()) } diff --git a/examples/ipc_file_read.rs b/examples/ipc_file_read.rs index c171a5d18db..93e1ff47af3 100644 --- a/examples/ipc_file_read.rs +++ b/examples/ipc_file_read.rs @@ -1,11 +1,11 @@ use std::fs::File; -use arrow2::array::Array; -use arrow2::chunk::Chunk; -use arrow2::datatypes::Schema; -use arrow2::error::Result; -use arrow2::io::ipc::read; -use arrow2::io::print; +use re_arrow2::array::Array; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::Schema; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read; +use re_arrow2::io::print; /// Simplest way: read all record batches from the file. This can be used e.g. for random access. #[allow(clippy::type_complexity)] diff --git a/examples/ipc_file_write.rs b/examples/ipc_file_write.rs index 0629faa80a0..624f5a2dd6f 100644 --- a/examples/ipc_file_write.rs +++ b/examples/ipc_file_write.rs @@ -1,10 +1,10 @@ use std::fs::File; -use arrow2::array::{Array, Int32Array, Utf8Array}; -use arrow2::chunk::Chunk; -use arrow2::datatypes::{DataType, Field, Schema}; -use arrow2::error::Result; -use arrow2::io::ipc::write; +use re_arrow2::array::{Array, Int32Array, Utf8Array}; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::{DataType, Field, Schema}; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::write; fn write_batches(path: &str, schema: Schema, chunks: &[Chunk>]) -> Result<()> { let file = File::create(path)?; diff --git a/examples/ipc_pyarrow/src/main.rs b/examples/ipc_pyarrow/src/main.rs index ce92e4e1b21..904f323ea0e 100644 --- a/examples/ipc_pyarrow/src/main.rs +++ b/examples/ipc_pyarrow/src/main.rs @@ -2,10 +2,10 @@ use std::net::TcpStream; use std::thread; use std::time::Duration; -use arrow2::array::{Array, Int64Array}; -use arrow2::datatypes::DataType; -use arrow2::error::Result; -use arrow2::io::ipc::read; +use re_arrow2::array::{Array, Int64Array}; +use re_arrow2::datatypes::DataType; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read; fn main() -> Result<()> { const ADDRESS: &str = "127.0.0.1:12989"; diff --git a/examples/json_read.rs b/examples/json_read.rs index edea82f2755..15c1f0964e3 100644 --- a/examples/json_read.rs +++ b/examples/json_read.rs @@ -1,9 +1,9 @@ /// Example of reading a JSON file. use std::fs; -use arrow2::array::Array; -use arrow2::error::Result; -use arrow2::io::json::read; +use re_arrow2::array::Array; +use re_arrow2::error::Result; +use re_arrow2::io::json::read; fn read_path(path: &str) -> Result> { // read the file into memory (IO-bounded) diff --git a/examples/json_write.rs b/examples/json_write.rs index 1e86f0560b6..6576ef35fb3 100644 --- a/examples/json_write.rs +++ b/examples/json_write.rs @@ -1,6 +1,6 @@ use std::fs::File; -use arrow2::{ +use re_arrow2::{ array::{Array, Int32Array}, error::Error, io::json::write, diff --git a/examples/metadata.rs b/examples/metadata.rs index c56849daead..2e9949d5784 100644 --- a/examples/metadata.rs +++ b/examples/metadata.rs @@ -1,4 +1,4 @@ -use arrow2::datatypes::{DataType, Field, Metadata, Schema}; +use re_arrow2::datatypes::{DataType, Field, Metadata, Schema}; fn main() { // two data types (logical types) diff --git a/examples/ndjson_read.rs b/examples/ndjson_read.rs index bd242d22df0..8edffdb2f27 100644 --- a/examples/ndjson_read.rs +++ b/examples/ndjson_read.rs @@ -1,10 +1,10 @@ use std::fs::File; use std::io::{BufReader, Seek}; -use arrow2::array::Array; -use arrow2::error::Result; -use arrow2::io::ndjson::read; -use arrow2::io::ndjson::read::FallibleStreamingIterator; +use re_arrow2::array::Array; +use re_arrow2::error::Result; +use re_arrow2::io::ndjson::read; +use re_arrow2::io::ndjson::read::FallibleStreamingIterator; fn read_path(path: &str) -> Result>> { let batch_size = 1024; // number of rows per array diff --git a/examples/ndjson_write.rs b/examples/ndjson_write.rs index 91a0e1a9ed7..ed5cd690fb2 100644 --- a/examples/ndjson_write.rs +++ b/examples/ndjson_write.rs @@ -1,8 +1,8 @@ use std::fs::File; -use arrow2::array::{Array, Int32Array}; -use arrow2::error::Result; -use arrow2::io::ndjson::write; +use re_arrow2::array::{Array, Int32Array}; +use re_arrow2::error::Result; +use re_arrow2::io::ndjson::write; fn write_path(path: &str, array: Box) -> Result<()> { let writer = File::create(path)?; diff --git a/examples/orc_read.rs b/examples/orc_read.rs index f1a5acee4dd..4149ba14842 100644 --- a/examples/orc_read.rs +++ b/examples/orc_read.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::error::Error; -use arrow2::io::orc::{format, read}; +use re_arrow2::array::*; +use re_arrow2::error::Error; +use re_arrow2::io::orc::{format, read}; fn deserialize_column(path: &str, column_name: &str) -> Result, Error> { // open the file diff --git a/examples/parquet_read.rs b/examples/parquet_read.rs index eefb2d23d6d..4b839bb20ad 100644 --- a/examples/parquet_read.rs +++ b/examples/parquet_read.rs @@ -1,8 +1,8 @@ use std::fs::File; use std::time::SystemTime; -use arrow2::error::Error; -use arrow2::io::parquet::read; +use re_arrow2::error::Error; +use re_arrow2::io::parquet::read; fn main() -> Result<(), Error> { // say we have a file diff --git a/examples/parquet_read_async.rs b/examples/parquet_read_async.rs index 8056b853cca..a431f6b5966 100644 --- a/examples/parquet_read_async.rs +++ b/examples/parquet_read_async.rs @@ -5,8 +5,8 @@ use tokio::fs::File; use tokio::io::BufReader; use tokio_util::compat::*; -use arrow2::error::Result; -use arrow2::io::parquet::read::{self, RowGroupDeserializer}; +use re_arrow2::error::Result; +use re_arrow2::io::parquet::read::{self, RowGroupDeserializer}; #[tokio::main(flavor = "current_thread")] async fn main() -> Result<()> { diff --git a/examples/parquet_read_parallel/src/main.rs b/examples/parquet_read_parallel/src/main.rs index 6ab26d61f7d..7e293b9efc1 100644 --- a/examples/parquet_read_parallel/src/main.rs +++ b/examples/parquet_read_parallel/src/main.rs @@ -6,7 +6,7 @@ use std::time::SystemTime; use log::trace; use rayon::prelude::*; -use arrow2::{ +use re_arrow2::{ array::Array, chunk::Chunk, error::Result, diff --git a/examples/parquet_write.rs b/examples/parquet_write.rs index 1387f615ebc..6b816a51b48 100644 --- a/examples/parquet_write.rs +++ b/examples/parquet_write.rs @@ -1,6 +1,6 @@ use std::fs::File; -use arrow2::{ +use re_arrow2::{ array::{Array, Int32Array}, chunk::Chunk, datatypes::{Field, Schema}, diff --git a/examples/parquet_write_async.rs b/examples/parquet_write_async.rs index db2ae9e08ca..772d486b88c 100644 --- a/examples/parquet_write_async.rs +++ b/examples/parquet_write_async.rs @@ -1,7 +1,7 @@ use futures::SinkExt; use tokio::fs::File; -use arrow2::{ +use re_arrow2::{ array::{Array, Int32Array}, chunk::Chunk, datatypes::{Field, Schema}, diff --git a/examples/parquet_write_parallel/src/main.rs b/examples/parquet_write_parallel/src/main.rs index 6c87be6143a..743c42ffabb 100644 --- a/examples/parquet_write_parallel/src/main.rs +++ b/examples/parquet_write_parallel/src/main.rs @@ -3,7 +3,7 @@ use std::collections::VecDeque; use rayon::prelude::*; -use arrow2::{ +use re_arrow2::{ array::*, chunk::Chunk as AChunk, datatypes::*, diff --git a/examples/s3/src/main.rs b/examples/s3/src/main.rs index d3f668d4421..fc708cc7308 100644 --- a/examples/s3/src/main.rs +++ b/examples/s3/src/main.rs @@ -1,8 +1,8 @@ -use arrow2::array::{Array, Int64Array}; -use arrow2::error::Result; -use arrow2::io::parquet::read; use futures::future::BoxFuture; use range_reader::{RangeOutput, RangedAsyncReader}; +use re_arrow2::array::{Array, Int64Array}; +use re_arrow2::error::Result; +use re_arrow2::io::parquet::read; use s3::Bucket; #[tokio::main] diff --git a/integration-testing/src/bin/arrow-file-to-stream.rs b/integration-testing/src/bin/arrow-file-to-stream.rs index c63606e28c3..2645bb2d2f7 100644 --- a/integration-testing/src/bin/arrow-file-to-stream.rs +++ b/integration-testing/src/bin/arrow-file-to-stream.rs @@ -15,10 +15,10 @@ // specific language governing permissions and limitations // under the License. -use arrow2::error::Result; -use arrow2::io::ipc::read; -use arrow2::io::ipc::write; use clap::Parser; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read; +use re_arrow2::io::ipc::write; use std::fs::File; #[derive(Debug, Parser)] diff --git a/integration-testing/src/bin/arrow-json-integration-test.rs b/integration-testing/src/bin/arrow-json-integration-test.rs index 6c1dea1e2b1..a8caf86ceb7 100644 --- a/integration-testing/src/bin/arrow-json-integration-test.rs +++ b/integration-testing/src/bin/arrow-json-integration-test.rs @@ -1,15 +1,15 @@ use std::fs::File; -use arrow2::io::json_integration::ArrowJson; use clap::Parser; +use re_arrow2::io::json_integration::ArrowJson; -use arrow2::io::ipc::read; -use arrow2::io::ipc::write; -use arrow2::{ +use arrow_integration_testing::read_json_file; +use re_arrow2::io::ipc::read; +use re_arrow2::io::ipc::write; +use re_arrow2::{ error::{Error, Result}, io::json_integration::write as json_write, }; -use arrow_integration_testing::read_json_file; #[derive(Debug, Clone, clap::ArgEnum)] #[clap(rename_all = "SCREAMING_SNAKE_CASE")] diff --git a/integration-testing/src/bin/arrow-stream-to-file.rs b/integration-testing/src/bin/arrow-stream-to-file.rs index bd431e73c07..a7c121b897c 100644 --- a/integration-testing/src/bin/arrow-stream-to-file.rs +++ b/integration-testing/src/bin/arrow-stream-to-file.rs @@ -17,9 +17,9 @@ use std::io; -use arrow2::error::Result; -use arrow2::io::ipc::read; -use arrow2::io::ipc::write; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read; +use re_arrow2::io::ipc::write; fn main() -> Result<()> { let mut reader = io::stdin(); diff --git a/integration-testing/src/flight_client_scenarios/integration_test.rs b/integration-testing/src/flight_client_scenarios/integration_test.rs index 8955a3e121d..94e389b28d2 100644 --- a/integration-testing/src/flight_client_scenarios/integration_test.rs +++ b/integration-testing/src/flight_client_scenarios/integration_test.rs @@ -17,7 +17,12 @@ use crate::{read_json_file, ArrowFile}; -use arrow2::{ +use arrow_format::flight::data::{ + flight_descriptor::DescriptorType, FlightData, FlightDescriptor, Location, Ticket, +}; +use arrow_format::flight::service::flight_service_client::FlightServiceClient; +use futures::{stream::BoxStream, StreamExt, TryStreamExt}; +use re_arrow2::{ array::Array, chunk::Chunk, datatypes::*, @@ -26,11 +31,6 @@ use arrow2::{ ipc::{read::Dictionaries, write, IpcField, IpcSchema}, }, }; -use arrow_format::flight::data::{ - flight_descriptor::DescriptorType, FlightData, FlightDescriptor, Location, Ticket, -}; -use arrow_format::flight::service::flight_service_client::FlightServiceClient; -use futures::{stream::BoxStream, StreamExt, TryStreamExt}; use tonic::{Request, Streaming}; type Error = Box; diff --git a/integration-testing/src/flight_server_scenarios/integration_test.rs b/integration-testing/src/flight_server_scenarios/integration_test.rs index 89df0a041b5..448a9363822 100644 --- a/integration-testing/src/flight_server_scenarios/integration_test.rs +++ b/integration-testing/src/flight_server_scenarios/integration_test.rs @@ -27,15 +27,15 @@ use arrow_format::flight::data::flight_descriptor::*; use arrow_format::flight::data::*; use arrow_format::flight::service::flight_service_server::*; -use arrow2::array::Array; -use arrow2::chunk::Chunk; -use arrow2::datatypes::Schema; -use arrow2::io::flight::{ +use re_arrow2::array::Array; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::Schema; +use re_arrow2::io::flight::{ deserialize_message, deserialize_schemas, serialize_batch, serialize_schema, serialize_schema_to_info, }; -use arrow2::io::ipc; -use arrow2::io::ipc::read::Dictionaries; +use re_arrow2::io::ipc; +use re_arrow2::io::ipc::read::Dictionaries; use super::{Result, TonicStream}; diff --git a/integration-testing/src/lib.rs b/integration-testing/src/lib.rs index e36ad7eef03..58099081c41 100644 --- a/integration-testing/src/lib.rs +++ b/integration-testing/src/lib.rs @@ -17,15 +17,15 @@ //! Common code used in the integration test binaries -use arrow2::array::Array; -use arrow2::io::ipc::IpcField; +use re_arrow2::array::Array; +use re_arrow2::io::ipc::IpcField; use serde_json::Value; -use arrow2::chunk::Chunk; -use arrow2::AHashMap; -use arrow2::datatypes::*; -use arrow2::error::Result; -use arrow2::io::json_integration::{read, ArrowJsonBatch, ArrowJsonDictionaryBatch}; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::*; +use re_arrow2::error::Result; +use re_arrow2::io::json_integration::{read, ArrowJsonBatch, ArrowJsonDictionaryBatch}; +use re_arrow2::AHashMap; use std::fs::File; use std::io::BufReader; diff --git a/src/array/binary/mod.rs b/src/array/binary/mod.rs index 7247decb300..00f50e34716 100644 --- a/src/array/binary/mod.rs +++ b/src/array/binary/mod.rs @@ -33,9 +33,9 @@ mod data; /// The size of this struct is `O(1)`, as all data is stored behind an [`std::sync::Arc`]. /// # Example /// ``` -/// use arrow2::array::BinaryArray; -/// use arrow2::bitmap::Bitmap; -/// use arrow2::buffer::Buffer; +/// use re_arrow2::array::BinaryArray; +/// use re_arrow2::bitmap::Bitmap; +/// use re_arrow2::buffer::Buffer; /// /// let array = BinaryArray::::from([Some([1, 2].as_ref()), None, Some([3].as_ref())]); /// assert_eq!(array.value(0), &[1, 2]); diff --git a/src/array/boolean/mod.rs b/src/array/boolean/mod.rs index 0b634ee90e3..cd7f040b88c 100644 --- a/src/array/boolean/mod.rs +++ b/src/array/boolean/mod.rs @@ -34,9 +34,9 @@ pub use mutable::*; /// The size of this struct is `O(1)`, as all data is stored behind an [`std::sync::Arc`]. /// # Example /// ``` -/// use arrow2::array::BooleanArray; -/// use arrow2::bitmap::Bitmap; -/// use arrow2::buffer::Buffer; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::bitmap::Bitmap; +/// use re_arrow2::buffer::Buffer; /// /// let array = BooleanArray::from([Some(true), None, Some(false)]); /// assert_eq!(array.value(0), true); diff --git a/src/array/dictionary/mutable.rs b/src/array/dictionary/mutable.rs index 4dde9494631..04822135e22 100644 --- a/src/array/dictionary/mutable.rs +++ b/src/array/dictionary/mutable.rs @@ -17,7 +17,7 @@ use super::{DictionaryArray, DictionaryKey}; /// # Example /// Building a UTF8 dictionary with `i32` keys. /// ``` -/// # use arrow2::array::{MutableDictionaryArray, MutableUtf8Array, TryPush}; +/// # use re_arrow2::array::{MutableDictionaryArray, MutableUtf8Array, TryPush}; /// # fn main() -> Result<(), Box> { /// let mut array: MutableDictionaryArray> = MutableDictionaryArray::new(); /// array.try_push(Some("A"))?; diff --git a/src/array/ord.rs b/src/array/ord.rs index 439efa1e21e..823873765bf 100644 --- a/src/array/ord.rs +++ b/src/array/ord.rs @@ -161,9 +161,9 @@ macro_rules! dyn_dict { /// between two [`Array`]. /// # Example /// ``` -/// use arrow2::array::{ord::build_compare, PrimitiveArray}; +/// use re_arrow2::array::{ord::build_compare, PrimitiveArray}; /// -/// # fn main() -> arrow2::error::Result<()> { +/// # fn main() -> re_arrow2::error::Result<()> { /// let array1 = PrimitiveArray::from_slice([1, 2]); /// let array2 = PrimitiveArray::from_slice([3, 4]); /// diff --git a/src/array/primitive/mod.rs b/src/array/primitive/mod.rs index 04b74a3529b..eb52ea3d5dd 100644 --- a/src/array/primitive/mod.rs +++ b/src/array/primitive/mod.rs @@ -35,9 +35,9 @@ pub use mutable::*; /// The size of this struct is `O(1)`, as all data is stored behind an [`std::sync::Arc`]. /// # Example /// ``` -/// use arrow2::array::PrimitiveArray; -/// use arrow2::bitmap::Bitmap; -/// use arrow2::buffer::Buffer; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::bitmap::Bitmap; +/// use re_arrow2::buffer::Buffer; /// /// let array = PrimitiveArray::from([Some(1i32), None, Some(10)]); /// assert_eq!(array.value(0), 1); @@ -102,8 +102,8 @@ impl PrimitiveArray { /// Used to change the arrays' logical type (see example). /// # Example /// ``` - /// use arrow2::array::Int32Array; - /// use arrow2::datatypes::DataType; + /// use re_arrow2::array::Int32Array; + /// use re_arrow2::datatypes::DataType; /// /// let array = Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Date32); /// assert_eq!( @@ -133,7 +133,7 @@ impl PrimitiveArray { /// This function is `O(1)`. /// # Examples /// ``` - /// use arrow2::array::PrimitiveArray; + /// use re_arrow2::array::PrimitiveArray; /// /// let array = PrimitiveArray::from_vec(vec![1, 2, 3]); /// assert_eq!(format!("{:?}", array), "Int32[1, 2, 3]"); diff --git a/src/array/struct_/mod.rs b/src/array/struct_/mod.rs index ed4e89aa47c..5ba1944d274 100644 --- a/src/array/struct_/mod.rs +++ b/src/array/struct_/mod.rs @@ -20,8 +20,8 @@ pub use mutable::*; /// multiple [`Array`] with the same number of rows. /// # Example /// ``` -/// use arrow2::array::*; -/// use arrow2::datatypes::*; +/// use re_arrow2::array::*; +/// use re_arrow2::datatypes::*; /// let boolean = BooleanArray::from_slice(&[false, false, true, true]).boxed(); /// let int = Int32Array::from_slice(&[42, 28, 19, 31]).boxed(); /// diff --git a/src/array/utf8/mod.rs b/src/array/utf8/mod.rs index 9440ae43304..fdc5b9a5355 100644 --- a/src/array/utf8/mod.rs +++ b/src/array/utf8/mod.rs @@ -42,9 +42,9 @@ impl> AsRef<[u8]> for StrAsBytes { /// Cloning and slicing this struct is `O(1)`. /// # Example /// ``` -/// use arrow2::bitmap::Bitmap; -/// use arrow2::buffer::Buffer; -/// use arrow2::array::Utf8Array; +/// use re_arrow2::bitmap::Bitmap; +/// use re_arrow2::buffer::Buffer; +/// use re_arrow2::array::Utf8Array; /// # fn main() { /// let array = Utf8Array::::from([Some("hi"), None, Some("there")]); /// assert_eq!(array.value(0), "hi"); diff --git a/src/bitmap/immutable.rs b/src/bitmap/immutable.rs index 6883d3312fb..49a8f14e809 100644 --- a/src/bitmap/immutable.rs +++ b/src/bitmap/immutable.rs @@ -15,7 +15,7 @@ use super::{ /// /// # Examples /// ``` -/// use arrow2::bitmap::{Bitmap, MutableBitmap}; +/// use re_arrow2::bitmap::{Bitmap, MutableBitmap}; /// /// let bitmap = Bitmap::from([true, false, true]); /// assert_eq!(bitmap.iter().collect::>(), vec![true, false, true]); diff --git a/src/bitmap/mutable.rs b/src/bitmap/mutable.rs index 31834f21657..c2d2b5d50c3 100644 --- a/src/bitmap/mutable.rs +++ b/src/bitmap/mutable.rs @@ -22,7 +22,7 @@ use super::Bitmap; /// A [`MutableBitmap`] can be converted to a [`Bitmap`] at `O(1)`. /// # Examples /// ``` -/// use arrow2::bitmap::MutableBitmap; +/// use re_arrow2::bitmap::MutableBitmap; /// /// let bitmap = MutableBitmap::from([true, false, true]); /// assert_eq!(bitmap.iter().collect::>(), vec![true, false, true]); diff --git a/src/buffer/immutable.rs b/src/buffer/immutable.rs index 0da4a41ace4..f3824d483f1 100644 --- a/src/buffer/immutable.rs +++ b/src/buffer/immutable.rs @@ -17,7 +17,7 @@ use super::IntoIter; /// /// # Examples /// ``` -/// use arrow2::buffer::Buffer; +/// use re_arrow2::buffer::Buffer; /// /// let mut buffer: Buffer = vec![1, 2, 3].into(); /// assert_eq!(buffer.as_ref(), [1, 2, 3].as_ref()); diff --git a/src/compute/aggregate/min_max.rs b/src/compute/aggregate/min_max.rs index da064d9b013..7b88f510003 100644 --- a/src/compute/aggregate/min_max.rs +++ b/src/compute/aggregate/min_max.rs @@ -255,7 +255,7 @@ pub fn min_string(array: &Utf8Array) -> Option<&str> { /// Returns the minimum value in the boolean array. /// /// ``` -/// use arrow2::{ +/// use re_arrow2::{ /// array::BooleanArray, /// compute::aggregate::min_boolean, /// }; @@ -283,7 +283,7 @@ pub fn min_boolean(array: &BooleanArray) -> Option { /// Returns the maximum value in the boolean array /// /// ``` -/// use arrow2::{ +/// use re_arrow2::{ /// array::BooleanArray, /// compute::aggregate::max_boolean, /// }; diff --git a/src/compute/arithmetics/basic/add.rs b/src/compute/arithmetics/basic/add.rs index 81f5b7bb039..74012171225 100644 --- a/src/compute/arithmetics/basic/add.rs +++ b/src/compute/arithmetics/basic/add.rs @@ -23,8 +23,8 @@ use super::NativeArithmetics; /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::add; -/// use arrow2::array::PrimitiveArray; +/// use re_arrow2::compute::arithmetics::basic::add; +/// use re_arrow2::array::PrimitiveArray; /// /// let a = PrimitiveArray::from([None, Some(6), None, Some(6)]); /// let b = PrimitiveArray::from([Some(5), None, None, Some(6)]); @@ -44,8 +44,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::wrapping_add; -/// use arrow2::array::PrimitiveArray; +/// use re_arrow2::compute::arithmetics::basic::wrapping_add; +/// use re_arrow2::array::PrimitiveArray; /// /// let a = PrimitiveArray::from([Some(-100i8), Some(100i8), Some(100i8)]); /// let b = PrimitiveArray::from([Some(0i8), Some(100i8), Some(0i8)]); @@ -67,8 +67,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_add; -/// use arrow2::array::PrimitiveArray; +/// use re_arrow2::compute::arithmetics::basic::checked_add; +/// use re_arrow2::array::PrimitiveArray; /// /// let a = PrimitiveArray::from([Some(100i8), Some(100i8), Some(100i8)]); /// let b = PrimitiveArray::from([Some(0i8), Some(100i8), Some(0i8)]); @@ -91,8 +91,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::saturating_add; -/// use arrow2::array::PrimitiveArray; +/// use re_arrow2::compute::arithmetics::basic::saturating_add; +/// use re_arrow2::array::PrimitiveArray; /// /// let a = PrimitiveArray::from([Some(100i8)]); /// let b = PrimitiveArray::from([Some(100i8)]); @@ -116,8 +116,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::overflowing_add; -/// use arrow2::array::PrimitiveArray; +/// use re_arrow2::compute::arithmetics::basic::overflowing_add; +/// use re_arrow2::array::PrimitiveArray; /// /// let a = PrimitiveArray::from([Some(1i8), Some(100i8)]); /// let b = PrimitiveArray::from([Some(1i8), Some(100i8)]); @@ -191,8 +191,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::add_scalar; -/// use arrow2::array::PrimitiveArray; +/// use re_arrow2::compute::arithmetics::basic::add_scalar; +/// use re_arrow2::array::PrimitiveArray; /// /// let a = PrimitiveArray::from([None, Some(6), None, Some(6)]); /// let result = add_scalar(&a, &1i32); @@ -212,8 +212,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::wrapping_add_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::wrapping_add_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[None, Some(100)]); /// let result = wrapping_add_scalar(&a, &100i8); @@ -233,8 +233,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_add_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::checked_add_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[None, Some(100), None, Some(100)]); /// let result = checked_add_scalar(&a, &100i8); @@ -257,8 +257,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::saturating_add_scalar; -/// use arrow2::array::PrimitiveArray; +/// use re_arrow2::compute::arithmetics::basic::saturating_add_scalar; +/// use re_arrow2::array::PrimitiveArray; /// /// let a = PrimitiveArray::from([Some(100i8)]); /// let result = saturating_add_scalar(&a, &100i8); @@ -282,8 +282,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::overflowing_add_scalar; -/// use arrow2::array::PrimitiveArray; +/// use re_arrow2::compute::arithmetics::basic::overflowing_add_scalar; +/// use re_arrow2::array::PrimitiveArray; /// /// let a = PrimitiveArray::from([Some(1i8), Some(100i8)]); /// let (result, overflow) = overflowing_add_scalar(&a, &100i8); diff --git a/src/compute/arithmetics/basic/div.rs b/src/compute/arithmetics/basic/div.rs index b7f22a0d771..cf53757e9de 100644 --- a/src/compute/arithmetics/basic/div.rs +++ b/src/compute/arithmetics/basic/div.rs @@ -23,8 +23,8 @@ use super::NativeArithmetics; /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::div; -/// use arrow2::array::Int32Array; +/// use re_arrow2::compute::arithmetics::basic::div; +/// use re_arrow2::array::Int32Array; /// /// let a = Int32Array::from(&[Some(10), Some(1), Some(6)]); /// let b = Int32Array::from(&[Some(5), None, Some(6)]); @@ -55,8 +55,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_div; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::checked_div; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(-100i8), Some(10i8)]); /// let b = Int8Array::from(&[Some(100i8), Some(0i8)]); @@ -98,8 +98,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::div_scalar; -/// use arrow2::array::Int32Array; +/// use re_arrow2::compute::arithmetics::basic::div_scalar; +/// use re_arrow2::array::Int32Array; /// /// let a = Int32Array::from(&[None, Some(6), None, Some(6)]); /// let result = div_scalar(&a, &2i32); @@ -170,8 +170,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_div_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::checked_div_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(-100i8)]); /// let result = checked_div_scalar(&a, &100i8); diff --git a/src/compute/arithmetics/basic/mod.rs b/src/compute/arithmetics/basic/mod.rs index 22ed09baf6e..459a3f71e89 100644 --- a/src/compute/arithmetics/basic/mod.rs +++ b/src/compute/arithmetics/basic/mod.rs @@ -46,8 +46,8 @@ impl NativeArithmetics for f64 {} /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::negate; -/// use arrow2::array::PrimitiveArray; +/// use re_arrow2::compute::arithmetics::basic::negate; +/// use re_arrow2::array::PrimitiveArray; /// /// let a = PrimitiveArray::from([None, Some(6), None, Some(7)]); /// let result = negate(&a); @@ -65,8 +65,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_negate; -/// use arrow2::array::{Array, PrimitiveArray}; +/// use re_arrow2::compute::arithmetics::basic::checked_negate; +/// use re_arrow2::array::{Array, PrimitiveArray}; /// /// let a = PrimitiveArray::from([None, Some(6), Some(i8::MIN), Some(7)]); /// let result = checked_negate(&a); @@ -85,8 +85,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::wrapping_negate; -/// use arrow2::array::{Array, PrimitiveArray}; +/// use re_arrow2::compute::arithmetics::basic::wrapping_negate; +/// use re_arrow2::array::{Array, PrimitiveArray}; /// /// let a = PrimitiveArray::from([None, Some(6), Some(i8::MIN), Some(7)]); /// let result = wrapping_negate(&a); diff --git a/src/compute/arithmetics/basic/mul.rs b/src/compute/arithmetics/basic/mul.rs index a3b405b845f..c37b1eed1ac 100644 --- a/src/compute/arithmetics/basic/mul.rs +++ b/src/compute/arithmetics/basic/mul.rs @@ -23,8 +23,8 @@ use super::NativeArithmetics; /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::mul; -/// use arrow2::array::Int32Array; +/// use re_arrow2::compute::arithmetics::basic::mul; +/// use re_arrow2::array::Int32Array; /// /// let a = Int32Array::from(&[None, Some(6), None, Some(6)]); /// let b = Int32Array::from(&[Some(5), None, None, Some(6)]); @@ -44,8 +44,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::wrapping_mul; -/// use arrow2::array::PrimitiveArray; +/// use re_arrow2::compute::arithmetics::basic::wrapping_mul; +/// use re_arrow2::array::PrimitiveArray; /// /// let a = PrimitiveArray::from([Some(100i8), Some(0x10i8), Some(100i8)]); /// let b = PrimitiveArray::from([Some(0i8), Some(0x10i8), Some(0i8)]); @@ -68,8 +68,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_mul; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::checked_mul; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(100i8), Some(100i8), Some(100i8)]); /// let b = Int8Array::from(&[Some(1i8), Some(100i8), Some(1i8)]); @@ -92,8 +92,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::saturating_mul; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::saturating_mul; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(-100i8)]); /// let b = Int8Array::from(&[Some(100i8)]); @@ -117,8 +117,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::overflowing_mul; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::overflowing_mul; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(1i8), Some(-100i8)]); /// let b = Int8Array::from(&[Some(1i8), Some(100i8)]); @@ -192,8 +192,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::mul_scalar; -/// use arrow2::array::Int32Array; +/// use re_arrow2::compute::arithmetics::basic::mul_scalar; +/// use re_arrow2::array::Int32Array; /// /// let a = Int32Array::from(&[None, Some(6), None, Some(6)]); /// let result = mul_scalar(&a, &2i32); @@ -213,8 +213,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::wrapping_mul_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::wrapping_mul_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[None, Some(0x10)]); /// let result = wrapping_mul_scalar(&a, &0x10); @@ -234,8 +234,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_mul_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::checked_mul_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[None, Some(100), None, Some(100)]); /// let result = checked_mul_scalar(&a, &100i8); @@ -258,8 +258,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::saturating_mul_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::saturating_mul_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(-100i8)]); /// let result = saturating_mul_scalar(&a, &100i8); @@ -283,8 +283,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::overflowing_mul_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::overflowing_mul_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(1i8), Some(100i8)]); /// let (result, overflow) = overflowing_mul_scalar(&a, &100i8); diff --git a/src/compute/arithmetics/basic/pow.rs b/src/compute/arithmetics/basic/pow.rs index 1b67970a030..c3c2467832c 100644 --- a/src/compute/arithmetics/basic/pow.rs +++ b/src/compute/arithmetics/basic/pow.rs @@ -13,8 +13,8 @@ use super::NativeArithmetics; /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::powf_scalar; -/// use arrow2::array::Float32Array; +/// use re_arrow2::compute::arithmetics::basic::powf_scalar; +/// use re_arrow2::array::Float32Array; /// /// let a = Float32Array::from(&[Some(2f32), None]); /// let actual = powf_scalar(&a, 2.0); @@ -34,8 +34,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_powf_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::checked_powf_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(1i8), None, Some(7i8)]); /// let actual = checked_powf_scalar(&a, 8usize); diff --git a/src/compute/arithmetics/basic/rem.rs b/src/compute/arithmetics/basic/rem.rs index 79a6055b8fd..0f584c87110 100644 --- a/src/compute/arithmetics/basic/rem.rs +++ b/src/compute/arithmetics/basic/rem.rs @@ -21,8 +21,8 @@ use super::NativeArithmetics; /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::rem; -/// use arrow2::array::Int32Array; +/// use re_arrow2::compute::arithmetics::basic::rem; +/// use re_arrow2::array::Int32Array; /// /// let a = Int32Array::from(&[Some(10), Some(7)]); /// let b = Int32Array::from(&[Some(5), Some(6)]); @@ -43,8 +43,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_rem; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::checked_rem; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(-100i8), Some(10i8)]); /// let b = Int8Array::from(&[Some(100i8), Some(0i8)]); @@ -84,8 +84,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::rem_scalar; -/// use arrow2::array::Int32Array; +/// use re_arrow2::compute::arithmetics::basic::rem_scalar; +/// use re_arrow2::array::Int32Array; /// /// let a = Int32Array::from(&[None, Some(6), None, Some(7)]); /// let result = rem_scalar(&a, &2i32); @@ -164,8 +164,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_rem_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::checked_rem_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(-100i8)]); /// let result = checked_rem_scalar(&a, &100i8); diff --git a/src/compute/arithmetics/basic/sub.rs b/src/compute/arithmetics/basic/sub.rs index c2c84cae6ee..c369973f4b7 100644 --- a/src/compute/arithmetics/basic/sub.rs +++ b/src/compute/arithmetics/basic/sub.rs @@ -23,8 +23,8 @@ use super::NativeArithmetics; /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::sub; -/// use arrow2::array::Int32Array; +/// use re_arrow2::compute::arithmetics::basic::sub; +/// use re_arrow2::array::Int32Array; /// /// let a = Int32Array::from(&[None, Some(6), None, Some(6)]); /// let b = Int32Array::from(&[Some(5), None, None, Some(6)]); @@ -44,8 +44,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::wrapping_sub; -/// use arrow2::array::PrimitiveArray; +/// use re_arrow2::compute::arithmetics::basic::wrapping_sub; +/// use re_arrow2::array::PrimitiveArray; /// /// let a = PrimitiveArray::from([Some(-100i8), Some(-100i8), Some(100i8)]); /// let b = PrimitiveArray::from([Some(0i8), Some(100i8), Some(0i8)]); @@ -67,8 +67,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_sub; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::checked_sub; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(100i8), Some(-100i8), Some(100i8)]); /// let b = Int8Array::from(&[Some(1i8), Some(100i8), Some(0i8)]); @@ -91,8 +91,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::saturating_sub; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::saturating_sub; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(-100i8)]); /// let b = Int8Array::from(&[Some(100i8)]); @@ -116,8 +116,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::overflowing_sub; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::overflowing_sub; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(1i8), Some(-100i8)]); /// let b = Int8Array::from(&[Some(1i8), Some(100i8)]); @@ -191,8 +191,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::sub_scalar; -/// use arrow2::array::Int32Array; +/// use re_arrow2::compute::arithmetics::basic::sub_scalar; +/// use re_arrow2::array::Int32Array; /// /// let a = Int32Array::from(&[None, Some(6), None, Some(6)]); /// let result = sub_scalar(&a, &1i32); @@ -212,8 +212,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::wrapping_sub_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::wrapping_sub_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[None, Some(-100)]); /// let result = wrapping_sub_scalar(&a, &100i8); @@ -233,8 +233,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::checked_sub_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::checked_sub_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[None, Some(-100), None, Some(-100)]); /// let result = checked_sub_scalar(&a, &100i8); @@ -257,8 +257,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::saturating_sub_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::saturating_sub_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(-100i8)]); /// let result = saturating_sub_scalar(&a, &100i8); @@ -282,8 +282,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::basic::overflowing_sub_scalar; -/// use arrow2::array::Int8Array; +/// use re_arrow2::compute::arithmetics::basic::overflowing_sub_scalar; +/// use re_arrow2::array::Int8Array; /// /// let a = Int8Array::from(&[Some(1i8), Some(-100i8)]); /// let (result, overflow) = overflowing_sub_scalar(&a, &100i8); diff --git a/src/compute/arithmetics/decimal/add.rs b/src/compute/arithmetics/decimal/add.rs index 9f6f529e887..0d9b554c1ba 100644 --- a/src/compute/arithmetics/decimal/add.rs +++ b/src/compute/arithmetics/decimal/add.rs @@ -23,9 +23,9 @@ use super::{adjusted_precision_scale, get_parameters, max_value, number_digits}; /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::add; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::add; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(1i128), Some(1i128), None, Some(2i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(1i128), Some(2i128), None, Some(2i128)]).to(DataType::Decimal(5, 2)); @@ -61,9 +61,9 @@ pub fn add(lhs: &PrimitiveArray, rhs: &PrimitiveArray) -> PrimitiveA /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::saturating_add; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::saturating_add; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(99000i128), Some(11100i128), None, Some(22200i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(01000i128), Some(22200i128), None, Some(11100i128)]).to(DataType::Decimal(5, 2)); @@ -105,9 +105,9 @@ pub fn saturating_add( /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::checked_add; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::checked_add; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(99000i128), Some(11100i128), None, Some(22200i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(01000i128), Some(22200i128), None, Some(11100i128)]).to(DataType::Decimal(5, 2)); @@ -169,9 +169,9 @@ impl ArraySaturatingAdd> for PrimitiveArray { /// ``` /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::adaptive_add; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::adaptive_add; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(11111_11i128)]).to(DataType::Decimal(7, 2)); /// let b = PrimitiveArray::from([Some(11111_111i128)]).to(DataType::Decimal(8, 3)); diff --git a/src/compute/arithmetics/decimal/div.rs b/src/compute/arithmetics/decimal/div.rs index 159c27de2b1..fcfa584b886 100644 --- a/src/compute/arithmetics/decimal/div.rs +++ b/src/compute/arithmetics/decimal/div.rs @@ -23,9 +23,9 @@ use super::{adjusted_precision_scale, get_parameters, max_value, number_digits}; /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::div; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::div; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(1_00i128), Some(4_00i128), Some(6_00i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(1_00i128), Some(2_00i128), Some(2_00i128)]).to(DataType::Decimal(5, 2)); @@ -117,9 +117,9 @@ pub fn div_scalar(lhs: &PrimitiveArray, rhs: &PrimitiveScalar) -> Pr /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::saturating_div; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::saturating_div; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(999_99i128), Some(4_00i128), Some(6_00i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(000_01i128), Some(2_00i128), Some(2_00i128)]).to(DataType::Decimal(5, 2)); @@ -166,9 +166,9 @@ pub fn saturating_div( /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::checked_div; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::checked_div; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(1_00i128), Some(4_00i128), Some(6_00i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(000_00i128), None, Some(2_00i128)]).to(DataType::Decimal(5, 2)); @@ -228,9 +228,9 @@ impl ArrayCheckedDiv> for PrimitiveArray { /// ``` /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::adaptive_div; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::adaptive_div; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(1000_00i128)]).to(DataType::Decimal(7, 2)); /// let b = PrimitiveArray::from([Some(10_0000i128)]).to(DataType::Decimal(6, 4)); diff --git a/src/compute/arithmetics/decimal/mul.rs b/src/compute/arithmetics/decimal/mul.rs index ac702d2cb3c..b15a8789b01 100644 --- a/src/compute/arithmetics/decimal/mul.rs +++ b/src/compute/arithmetics/decimal/mul.rs @@ -22,9 +22,9 @@ use super::{adjusted_precision_scale, get_parameters, max_value, number_digits}; /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::mul; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::mul; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(1_00i128), Some(1_00i128), None, Some(2_00i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(1_00i128), Some(2_00i128), None, Some(2_00i128)]).to(DataType::Decimal(5, 2)); @@ -121,9 +121,9 @@ pub fn mul_scalar(lhs: &PrimitiveArray, rhs: &PrimitiveScalar) -> Pr /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::saturating_mul; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::saturating_mul; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(999_99i128), Some(1_00i128), None, Some(2_00i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(10_00i128), Some(2_00i128), None, Some(2_00i128)]).to(DataType::Decimal(5, 2)); @@ -171,9 +171,9 @@ pub fn saturating_mul( /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::checked_mul; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::checked_mul; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(999_99i128), Some(1_00i128), None, Some(2_00i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(10_00i128), Some(2_00i128), None, Some(2_00i128)]).to(DataType::Decimal(5, 2)); @@ -240,9 +240,9 @@ impl ArraySaturatingMul> for PrimitiveArray { /// ``` /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::adaptive_mul; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::adaptive_mul; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(11111_0i128), Some(1_0i128)]).to(DataType::Decimal(6, 1)); /// let b = PrimitiveArray::from([Some(10_002i128), Some(2_000i128)]).to(DataType::Decimal(5, 3)); diff --git a/src/compute/arithmetics/decimal/sub.rs b/src/compute/arithmetics/decimal/sub.rs index 84afd205433..06bdb98640d 100644 --- a/src/compute/arithmetics/decimal/sub.rs +++ b/src/compute/arithmetics/decimal/sub.rs @@ -20,9 +20,9 @@ use super::{adjusted_precision_scale, get_parameters, max_value, number_digits}; /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::sub; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::sub; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(1i128), Some(1i128), None, Some(2i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(1i128), Some(2i128), None, Some(2i128)]).to(DataType::Decimal(5, 2)); @@ -59,9 +59,9 @@ pub fn sub(lhs: &PrimitiveArray, rhs: &PrimitiveArray) -> PrimitiveA /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::saturating_sub; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::saturating_sub; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(-99000i128), Some(11100i128), None, Some(22200i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(01000i128), Some(22200i128), None, Some(11100i128)]).to(DataType::Decimal(5, 2)); @@ -125,9 +125,9 @@ impl ArraySaturatingSub> for PrimitiveArray { /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::checked_sub; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::checked_sub; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(-99000i128), Some(11100i128), None, Some(22200i128)]).to(DataType::Decimal(5, 2)); /// let b = PrimitiveArray::from([Some(01000i128), Some(22200i128), None, Some(11100i128)]).to(DataType::Decimal(5, 2)); @@ -168,9 +168,9 @@ pub fn checked_sub(lhs: &PrimitiveArray, rhs: &PrimitiveArray) -> Pr /// ``` /// # Examples /// ``` -/// use arrow2::compute::arithmetics::decimal::adaptive_sub; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::compute::arithmetics::decimal::adaptive_sub; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::DataType; /// /// let a = PrimitiveArray::from([Some(99_9999i128)]).to(DataType::Decimal(6, 4)); /// let b = PrimitiveArray::from([Some(-00_0001i128)]).to(DataType::Decimal(6, 4)); diff --git a/src/compute/arithmetics/time.rs b/src/compute/arithmetics/time.rs index 1cb0446fba7..3b5c471a787 100644 --- a/src/compute/arithmetics/time.rs +++ b/src/compute/arithmetics/time.rs @@ -69,9 +69,9 @@ fn create_scale(lhs: &DataType, rhs: &DataType) -> Result { /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::time::add_duration; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::{DataType, TimeUnit}; +/// use re_arrow2::compute::arithmetics::time::add_duration; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::{DataType, TimeUnit}; /// /// let timestamp = PrimitiveArray::from([ /// Some(100000i64), @@ -149,9 +149,9 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::time::subtract_duration; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::{DataType, TimeUnit}; +/// use re_arrow2::compute::arithmetics::time::subtract_duration; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::{DataType, TimeUnit}; /// /// let timestamp = PrimitiveArray::from([ /// Some(100000i64), @@ -228,9 +228,9 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::arithmetics::time::subtract_timestamps; -/// use arrow2::array::PrimitiveArray; -/// use arrow2::datatypes::{DataType, TimeUnit}; +/// use re_arrow2::compute::arithmetics::time::subtract_timestamps; +/// use re_arrow2::array::PrimitiveArray; +/// use re_arrow2::datatypes::{DataType, TimeUnit}; /// let timestamp_a = PrimitiveArray::from([ /// Some(100_010i64), /// Some(200_020i64), diff --git a/src/compute/boolean.rs b/src/compute/boolean.rs index e34b90c6378..b1bdc8402e8 100644 --- a/src/compute/boolean.rs +++ b/src/compute/boolean.rs @@ -39,8 +39,8 @@ where /// This function panics iff the arrays have different lengths. /// # Examples /// ```rust -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean::and; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean::and; /// /// let a = BooleanArray::from(&[Some(false), Some(true), None]); /// let b = BooleanArray::from(&[Some(true), Some(true), Some(false)]); @@ -81,8 +81,8 @@ pub fn and(lhs: &BooleanArray, rhs: &BooleanArray) -> BooleanArray { /// This function panics iff the arrays have different lengths. /// # Examples /// ```rust -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean::or; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean::or; /// /// let a = BooleanArray::from(vec![Some(false), Some(true), None]); /// let b = BooleanArray::from(vec![Some(true), Some(true), Some(false)]); @@ -122,8 +122,8 @@ pub fn or(lhs: &BooleanArray, rhs: &BooleanArray) -> BooleanArray { /// null. /// # Example /// ```rust -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean::not; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean::not; /// /// let a = BooleanArray::from(vec![Some(false), Some(true), None]); /// let not_a = not(&a); @@ -138,8 +138,8 @@ pub fn not(array: &BooleanArray) -> BooleanArray { /// Returns a non-null [`BooleanArray`] with whether each value of the array is null. /// # Example /// ```rust -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean::is_null; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean::is_null; /// # fn main() { /// let a = BooleanArray::from(vec![Some(false), Some(true), None]); /// let a_is_null = is_null(&a); @@ -160,8 +160,8 @@ pub fn is_null(input: &dyn Array) -> BooleanArray { /// Returns a non-null [`BooleanArray`] with whether each value of the array is not null. /// # Example /// ```rust -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean::is_not_null; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean::is_not_null; /// /// let a = BooleanArray::from(&vec![Some(false), Some(true), None]); /// let a_is_not_null = is_not_null(&a); @@ -183,9 +183,9 @@ pub fn is_not_null(input: &dyn Array) -> BooleanArray { /// is null then the result is also null. /// # Example /// ```rust -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean::and_scalar; -/// use arrow2::scalar::BooleanScalar; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean::and_scalar; +/// use re_arrow2::scalar::BooleanScalar; /// /// let array = BooleanArray::from_slice(&[false, false, true, true]); /// let scalar = BooleanScalar::new(Some(true)); @@ -208,9 +208,9 @@ pub fn and_scalar(array: &BooleanArray, scalar: &BooleanScalar) -> BooleanArray /// is null then the result is also null. /// # Example /// ```rust -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean::or_scalar; -/// use arrow2::scalar::BooleanScalar; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean::or_scalar; +/// use re_arrow2::scalar::BooleanScalar; /// # fn main() { /// let array = BooleanArray::from_slice(&[false, false, true, true]); /// let scalar = BooleanScalar::new(Some(true)); @@ -237,8 +237,8 @@ pub fn or_scalar(array: &BooleanArray, scalar: &BooleanScalar) -> BooleanArray { /// # Example /// /// ``` -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean::any; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean::any; /// /// let a = BooleanArray::from(&[Some(true), Some(false)]); /// let b = BooleanArray::from(&[Some(false), Some(false)]); @@ -266,8 +266,8 @@ pub fn any(array: &BooleanArray) -> bool { /// # Example /// /// ``` -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean::all; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean::all; /// /// let a = BooleanArray::from(&[Some(true), Some(true)]); /// let b = BooleanArray::from(&[Some(false), Some(true)]); diff --git a/src/compute/boolean_kleene.rs b/src/compute/boolean_kleene.rs index b19efeaa78d..a9d1dc0fa3c 100644 --- a/src/compute/boolean_kleene.rs +++ b/src/compute/boolean_kleene.rs @@ -12,8 +12,8 @@ use crate::{ /// # Example /// /// ```rust -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean_kleene::or; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean_kleene::or; /// /// let a = BooleanArray::from(&[Some(true), Some(false), None]); /// let b = BooleanArray::from(&[None, None, None]); @@ -95,8 +95,8 @@ pub fn or(lhs: &BooleanArray, rhs: &BooleanArray) -> BooleanArray { /// # Example /// /// ```rust -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean_kleene::and; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean_kleene::and; /// /// let a = BooleanArray::from(&[Some(true), Some(false), None]); /// let b = BooleanArray::from(&[None, None, None]); @@ -175,9 +175,9 @@ pub fn and(lhs: &BooleanArray, rhs: &BooleanArray) -> BooleanArray { /// # Example /// /// ```rust -/// use arrow2::array::BooleanArray; -/// use arrow2::scalar::BooleanScalar; -/// use arrow2::compute::boolean_kleene::or_scalar; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::scalar::BooleanScalar; +/// use re_arrow2::compute::boolean_kleene::or_scalar; /// /// let array = BooleanArray::from(&[Some(true), Some(false), None]); /// let scalar = BooleanScalar::new(Some(false)); @@ -207,9 +207,9 @@ pub fn or_scalar(array: &BooleanArray, scalar: &BooleanScalar) -> BooleanArray { /// # Example /// /// ```rust -/// use arrow2::array::BooleanArray; -/// use arrow2::scalar::BooleanScalar; -/// use arrow2::compute::boolean_kleene::and_scalar; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::scalar::BooleanScalar; +/// use re_arrow2::compute::boolean_kleene::and_scalar; /// /// let array = BooleanArray::from(&[Some(true), Some(false), None]); /// let scalar = BooleanScalar::new(None); @@ -242,8 +242,8 @@ pub fn and_scalar(array: &BooleanArray, scalar: &BooleanScalar) -> BooleanArray /// # Example /// /// ``` -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean_kleene::any; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean_kleene::any; /// /// let a = BooleanArray::from(&[Some(true), Some(false)]); /// let b = BooleanArray::from(&[Some(false), Some(false)]); @@ -276,8 +276,8 @@ pub fn any(array: &BooleanArray) -> Option { /// # Example /// /// ``` -/// use arrow2::array::BooleanArray; -/// use arrow2::compute::boolean_kleene::all; +/// use re_arrow2::array::BooleanArray; +/// use re_arrow2::compute::boolean_kleene::all; /// /// let a = BooleanArray::from(&[Some(true), Some(true)]); /// let b = BooleanArray::from(&[Some(false), Some(true)]); diff --git a/src/compute/comparison/mod.rs b/src/compute/comparison/mod.rs index b364ed88222..acfd44b619c 100644 --- a/src/compute/comparison/mod.rs +++ b/src/compute/comparison/mod.rs @@ -14,8 +14,8 @@ //! //! Compare two [`PrimitiveArray`]s: //! ``` -//! use arrow2::array::{BooleanArray, PrimitiveArray}; -//! use arrow2::compute::comparison::primitive::gt; +//! use re_arrow2::array::{BooleanArray, PrimitiveArray}; +//! use re_arrow2::compute::comparison::primitive::gt; //! //! let array1 = PrimitiveArray::::from([Some(1), None, Some(2)]); //! let array2 = PrimitiveArray::::from([Some(1), Some(3), Some(1)]); @@ -25,8 +25,8 @@ //! //! Compare two dynamically-typed [`Array`]s (trait objects): //! ``` -//! use arrow2::array::{Array, BooleanArray, PrimitiveArray}; -//! use arrow2::compute::comparison::eq; +//! use re_arrow2::array::{Array, BooleanArray, PrimitiveArray}; +//! use re_arrow2::compute::comparison::eq; //! //! let array1: &dyn Array = &PrimitiveArray::::from(&[Some(10.0), None, Some(20.0)]); //! let array2: &dyn Array = &PrimitiveArray::::from(&[Some(10.0), None, Some(10.0)]); @@ -36,8 +36,8 @@ //! //! Compare (not equal) a [`Utf8Array`] to a word: //! ``` -//! use arrow2::array::{BooleanArray, Utf8Array}; -//! use arrow2::compute::comparison::utf8::neq_scalar; +//! use re_arrow2::array::{BooleanArray, Utf8Array}; +//! use re_arrow2::compute::comparison::utf8::neq_scalar; //! //! let array = Utf8Array::::from([Some("compute"), None, Some("compare")]); //! let result = neq_scalar(&array, "compare"); diff --git a/src/compute/concatenate.rs b/src/compute/concatenate.rs index 1cab5767164..46ea9a08cb0 100644 --- a/src/compute/concatenate.rs +++ b/src/compute/concatenate.rs @@ -3,8 +3,8 @@ //! Example: //! //! ``` -//! use arrow2::array::Utf8Array; -//! use arrow2::compute::concatenate::concatenate; +//! use re_arrow2::array::Utf8Array; +//! use re_arrow2::compute::concatenate::concatenate; //! //! let arr = concatenate(&[ //! &Utf8Array::::from_slice(["hello", "world"]), diff --git a/src/compute/filter.rs b/src/compute/filter.rs index 7ba260e702f..36171aa1f9c 100644 --- a/src/compute/filter.rs +++ b/src/compute/filter.rs @@ -258,9 +258,9 @@ pub fn build_filter(filter: &BooleanArray) -> Result { /// /// # Example /// ```rust -/// # use arrow2::array::{Int32Array, PrimitiveArray, BooleanArray}; -/// # use arrow2::error::Result; -/// # use arrow2::compute::filter::filter; +/// # use re_arrow2::array::{Int32Array, PrimitiveArray, BooleanArray}; +/// # use re_arrow2::error::Result; +/// # use re_arrow2::compute::filter::filter; /// # fn main() -> Result<()> { /// let array = PrimitiveArray::from_slice([5, 6, 7, 8, 9]); /// let filter_array = BooleanArray::from_slice(&vec![true, false, false, true, false]); diff --git a/src/compute/hash.rs b/src/compute/hash.rs index 5f914917507..d8760a2ffe6 100644 --- a/src/compute/hash.rs +++ b/src/compute/hash.rs @@ -125,8 +125,8 @@ pub fn hash(array: &dyn Array) -> Result> { /// /// # Examples /// ``` -/// use arrow2::compute::hash::can_hash; -/// use arrow2::datatypes::{DataType}; +/// use re_arrow2::compute::hash::can_hash; +/// use re_arrow2::datatypes::{DataType}; /// /// let data_type = DataType::Int8; /// assert_eq!(can_hash(&data_type), true); diff --git a/src/compute/if_then_else.rs b/src/compute/if_then_else.rs index 86c46b29d04..630325a8c53 100644 --- a/src/compute/if_then_else.rs +++ b/src/compute/if_then_else.rs @@ -7,9 +7,9 @@ use crate::error::{Error, Result}; /// Returns `None` if the predicate is `None`. /// # Example /// ```rust -/// # use arrow2::error::Result; -/// use arrow2::compute::if_then_else::if_then_else; -/// use arrow2::array::{Int32Array, BooleanArray}; +/// # use re_arrow2::error::Result; +/// use re_arrow2::compute::if_then_else::if_then_else; +/// use re_arrow2::array::{Int32Array, BooleanArray}; /// /// # fn main() -> Result<()> { /// let lhs = Int32Array::from_slice(&[1, 2, 3]); diff --git a/src/compute/length.rs b/src/compute/length.rs index 9dc7e0b1c12..24b0e7e3e95 100644 --- a/src/compute/length.rs +++ b/src/compute/length.rs @@ -68,8 +68,8 @@ pub fn length(array: &dyn Array) -> Result> { /// /// # Examples /// ``` -/// use arrow2::compute::length::can_length; -/// use arrow2::datatypes::{DataType}; +/// use re_arrow2::compute::length::can_length; +/// use re_arrow2::datatypes::{DataType}; /// /// let data_type = DataType::Utf8; /// assert_eq!(can_length(&data_type), true); diff --git a/src/compute/like.rs b/src/compute/like.rs index d52e9c5e9ff..d8c4f84ddb6 100644 --- a/src/compute/like.rs +++ b/src/compute/like.rs @@ -109,8 +109,8 @@ fn a_like_utf8 bool>( /// * any of the patterns is not valid /// # Example /// ``` -/// use arrow2::array::{Utf8Array, BooleanArray}; -/// use arrow2::compute::like::like_utf8; +/// use re_arrow2::array::{Utf8Array, BooleanArray}; +/// use re_arrow2::compute::like::like_utf8; /// /// let strings = Utf8Array::::from_slice(&["Arrow", "Arrow", "Arrow", "Arrow", "Ar"]); /// let patterns = Utf8Array::::from_slice(&["A%", "B%", "%r_ow", "A_", "A_"]); @@ -190,8 +190,8 @@ fn a_like_utf8_scalar bool>( /// * any of the patterns is not valid /// # Example /// ``` -/// use arrow2::array::{Utf8Array, BooleanArray}; -/// use arrow2::compute::like::like_utf8_scalar; +/// use re_arrow2::array::{Utf8Array, BooleanArray}; +/// use re_arrow2::compute::like::like_utf8_scalar; /// /// let array = Utf8Array::::from_slice(&["Arrow", "Arrow", "Arrow", "BA"]); /// @@ -267,8 +267,8 @@ fn a_like_binary bool>( /// * any of the patterns is not valid /// # Example /// ``` -/// use arrow2::array::{BinaryArray, BooleanArray}; -/// use arrow2::compute::like::like_binary; +/// use re_arrow2::array::{BinaryArray, BooleanArray}; +/// use re_arrow2::compute::like::like_binary; /// /// let strings = BinaryArray::::from_slice(&["Arrow", "Arrow", "Arrow", "Arrow", "Ar"]); /// let patterns = BinaryArray::::from_slice(&["A%", "B%", "%r_ow", "A_", "A_"]); @@ -341,8 +341,8 @@ fn a_like_binary_scalar bool>( /// * any of the patterns is not valid /// # Example /// ``` -/// use arrow2::array::{BinaryArray, BooleanArray}; -/// use arrow2::compute::like::like_binary_scalar; +/// use re_arrow2::array::{BinaryArray, BooleanArray}; +/// use re_arrow2::compute::like::like_binary_scalar; /// /// let array = BinaryArray::::from_slice(&["Arrow", "Arrow", "Arrow", "BA"]); /// diff --git a/src/compute/merge_sort/mod.rs b/src/compute/merge_sort/mod.rs index f57b09bb4a2..8038e3f5c36 100644 --- a/src/compute/merge_sort/mod.rs +++ b/src/compute/merge_sort/mod.rs @@ -127,9 +127,9 @@ pub fn take_arrays>( /// * the arrays have a [`crate::datatypes::DataType`] that has no order relationship /// # Example /// ```rust -/// use arrow2::array::Int32Array; -/// use arrow2::compute::merge_sort::{merge_sort, SortOptions}; -/// # use arrow2::error::Result; +/// use re_arrow2::array::Int32Array; +/// use re_arrow2::compute::merge_sort::{merge_sort, SortOptions}; +/// # use re_arrow2::error::Result; /// # fn main() -> Result<()> { /// let a = Int32Array::from_slice(&[2, 4, 6]); /// let b = Int32Array::from_slice(&[0, 1, 3]); @@ -166,9 +166,9 @@ pub fn merge_sort( /// In other words, `pairs.i.0[j]` must be an array coming from a batch of equal len arrays. /// # Example /// ```rust -/// use arrow2::array::Int32Array; -/// use arrow2::compute::merge_sort::{slices, SortOptions}; -/// # use arrow2::error::Result; +/// use re_arrow2::array::Int32Array; +/// use re_arrow2::compute::merge_sort::{slices, SortOptions}; +/// # use re_arrow2::error::Result; /// # fn main() -> Result<()> { /// let a = Int32Array::from_slice(&[2, 4, 6]); /// let b = Int32Array::from_slice(&[0, 1, 3]); diff --git a/src/compute/nullif.rs b/src/compute/nullif.rs index b93e518da7f..4ef377c7705 100644 --- a/src/compute/nullif.rs +++ b/src/compute/nullif.rs @@ -19,9 +19,9 @@ use super::utils::combine_validities; /// * The arguments do not have the same length /// # Example /// ```rust -/// # use arrow2::array::Int32Array; -/// # use arrow2::datatypes::DataType; -/// # use arrow2::compute::nullif::primitive_nullif; +/// # use re_arrow2::array::Int32Array; +/// # use re_arrow2::datatypes::DataType; +/// # use re_arrow2::compute::nullif::primitive_nullif; /// # fn main() { /// let lhs = Int32Array::from(&[None, None, Some(1), Some(1), Some(1)]); /// let rhs = Int32Array::from(&[None, Some(1), None, Some(1), Some(0)]); @@ -53,9 +53,9 @@ where /// * The arguments do not have the same logical type /// # Example /// ```rust -/// # use arrow2::array::Int32Array; -/// # use arrow2::datatypes::DataType; -/// # use arrow2::compute::nullif::primitive_nullif_scalar; +/// # use re_arrow2::array::Int32Array; +/// # use re_arrow2::datatypes::DataType; +/// # use re_arrow2::compute::nullif::primitive_nullif_scalar; /// # fn main() { /// let lhs = Int32Array::from(&[None, None, Some(1), Some(0), Some(1)]); /// let result = primitive_nullif_scalar(&lhs, 0); @@ -89,9 +89,9 @@ where /// * The physical type is not supported for this operation (use [`can_nullif`] to check) /// # Example /// ```rust -/// # use arrow2::array::Int32Array; -/// # use arrow2::datatypes::DataType; -/// # use arrow2::compute::nullif::nullif; +/// # use re_arrow2::array::Int32Array; +/// # use re_arrow2::datatypes::DataType; +/// # use re_arrow2::compute::nullif::nullif; /// # fn main() { /// let lhs = Int32Array::from(&[None, None, Some(1), Some(1), Some(1)]); /// let rhs = Int32Array::from(&[None, Some(1), None, Some(1), Some(0)]); @@ -127,10 +127,10 @@ pub fn nullif(lhs: &dyn Array, rhs: &dyn Array) -> Box { /// * The physical type is not supported for this operation (use [`can_nullif`] to check) /// # Example /// ```rust -/// # use arrow2::array::Int32Array; -/// # use arrow2::scalar::PrimitiveScalar; -/// # use arrow2::datatypes::DataType; -/// # use arrow2::compute::nullif::nullif_scalar; +/// # use re_arrow2::array::Int32Array; +/// # use re_arrow2::scalar::PrimitiveScalar; +/// # use re_arrow2::datatypes::DataType; +/// # use re_arrow2::compute::nullif::nullif_scalar; /// # fn main() { /// let lhs = Int32Array::from(&[None, None, Some(1), Some(0), Some(1)]); /// let rhs = PrimitiveScalar::::from(Some(0)); diff --git a/src/compute/regex_match.rs b/src/compute/regex_match.rs index f0cd2acadec..fcddab6d556 100644 --- a/src/compute/regex_match.rs +++ b/src/compute/regex_match.rs @@ -50,8 +50,8 @@ pub fn regex_match(values: &Utf8Array, regex: &Utf8Array) -> Re /// Regex matches /// # Example /// ``` -/// use arrow2::array::{Utf8Array, BooleanArray}; -/// use arrow2::compute::regex_match::regex_match_scalar; +/// use re_arrow2::array::{Utf8Array, BooleanArray}; +/// use re_arrow2::compute::regex_match::regex_match_scalar; /// /// let strings = Utf8Array::::from_slice(&vec!["ArAow", "A_B", "AAA"]); /// diff --git a/src/compute/sort/lex_sort.rs b/src/compute/sort/lex_sort.rs index c598cfd3abd..fc5a9abb4d1 100644 --- a/src/compute/sort/lex_sort.rs +++ b/src/compute/sort/lex_sort.rs @@ -32,9 +32,9 @@ pub struct SortColumn<'a> { /// /// ``` /// use std::convert::From; -/// use arrow2::array::{Utf8Array, Int64Array, Array}; -/// use arrow2::compute::sort::{SortColumn, SortOptions, lexsort}; -/// use arrow2::datatypes::DataType; +/// use re_arrow2::array::{Utf8Array, Int64Array, Array}; +/// use re_arrow2::compute::sort::{SortColumn, SortOptions, lexsort}; +/// use re_arrow2::datatypes::DataType; /// /// let int64 = Int64Array::from(&[None, Some(-2), Some(89), Some(-64), Some(101)]); /// let utf8 = Utf8Array::::from(&vec![Some("hello"), Some("world"), Some(","), Some("foobar"), Some("!")]); diff --git a/src/compute/sort/mod.rs b/src/compute/sort/mod.rs index be85c9f6cbd..068020c6a6b 100644 --- a/src/compute/sort/mod.rs +++ b/src/compute/sort/mod.rs @@ -230,8 +230,8 @@ fn sort_dict( /// /// # Examples /// ``` -/// use arrow2::compute::sort::can_sort; -/// use arrow2::datatypes::{DataType}; +/// use re_arrow2::compute::sort::can_sort; +/// use re_arrow2::datatypes::{DataType}; /// /// let data_type = DataType::Int8; /// assert_eq!(can_sort(&data_type), true); diff --git a/src/compute/substring.rs b/src/compute/substring.rs index 2919b3037b9..376b7af6aa6 100644 --- a/src/compute/substring.rs +++ b/src/compute/substring.rs @@ -171,8 +171,8 @@ pub fn substring(array: &dyn Array, start: i64, length: &Option) -> Result< /// /// # Examples /// ``` -/// use arrow2::compute::substring::can_substring; -/// use arrow2::datatypes::{DataType}; +/// use re_arrow2::compute::substring::can_substring; +/// use re_arrow2::datatypes::{DataType}; /// /// let data_type = DataType::Utf8; /// assert_eq!(can_substring(&data_type), true); diff --git a/src/compute/take/mod.rs b/src/compute/take/mod.rs index 3acf47dc7a1..73d4d67faa6 100644 --- a/src/compute/take/mod.rs +++ b/src/compute/take/mod.rs @@ -103,8 +103,8 @@ pub fn take(values: &dyn Array, indices: &PrimitiveArray) -> Result /// /// # Examples /// ``` -/// use arrow2::compute::take::can_take; -/// use arrow2::datatypes::{DataType}; +/// use re_arrow2::compute::take::can_take; +/// use re_arrow2::datatypes::{DataType}; /// /// let data_type = DataType::Int8; /// assert_eq!(can_take(&data_type), true); diff --git a/src/compute/temporal.rs b/src/compute/temporal.rs index 60e573da4ba..410ae0eeb1a 100644 --- a/src/compute/temporal.rs +++ b/src/compute/temporal.rs @@ -331,8 +331,8 @@ where /// /// # Examples /// ``` -/// use arrow2::compute::temporal::can_year; -/// use arrow2::datatypes::{DataType}; +/// use re_arrow2::compute::temporal::can_year; +/// use re_arrow2::datatypes::{DataType}; /// /// assert_eq!(can_year(&DataType::Date32), true); /// assert_eq!(can_year(&DataType::Int8), false); @@ -372,8 +372,8 @@ fn can_date(data_type: &DataType) -> bool { /// /// # Examples /// ``` -/// use arrow2::compute::temporal::can_hour; -/// use arrow2::datatypes::{DataType, TimeUnit}; +/// use re_arrow2::compute::temporal::can_hour; +/// use re_arrow2::datatypes::{DataType, TimeUnit}; /// /// assert_eq!(can_hour(&DataType::Time32(TimeUnit::Second)), true); /// assert_eq!(can_hour(&DataType::Int8), false); diff --git a/src/compute/utf8.rs b/src/compute/utf8.rs index 2e480016ef5..6ffb71b438c 100644 --- a/src/compute/utf8.rs +++ b/src/compute/utf8.rs @@ -44,8 +44,8 @@ pub fn upper(array: &dyn Array) -> Result> { /// /// # Examples /// ``` -/// use arrow2::compute::utf8::can_upper; -/// use arrow2::datatypes::{DataType}; +/// use re_arrow2::compute::utf8::can_upper; +/// use re_arrow2::datatypes::{DataType}; /// /// let data_type = DataType::Utf8; /// assert_eq!(can_upper(&data_type), true); @@ -86,8 +86,8 @@ pub fn lower(array: &dyn Array) -> Result> { /// /// # Examples /// ``` -/// use arrow2::compute::utf8::can_lower; -/// use arrow2::datatypes::{DataType}; +/// use re_arrow2::compute::utf8::can_lower; +/// use re_arrow2::datatypes::{DataType}; /// /// let data_type = DataType::Utf8; /// assert_eq!(can_lower(&data_type), true); diff --git a/src/compute/window.rs b/src/compute/window.rs index b9200fe3a37..2ebb8fb6265 100644 --- a/src/compute/window.rs +++ b/src/compute/window.rs @@ -30,8 +30,8 @@ use crate::{ /// a negative value shifts the array to the left. /// # Examples /// ``` -/// use arrow2::array::Int32Array; -/// use arrow2::compute::window::shift; +/// use re_arrow2::array::Int32Array; +/// use re_arrow2::compute::window::shift; /// /// let array = Int32Array::from(&[Some(1), None, Some(3)]); /// let result = shift(&array, -1).unwrap(); diff --git a/src/datatypes/mod.rs b/src/datatypes/mod.rs index a8090a29035..17bc65ae04c 100644 --- a/src/datatypes/mod.rs +++ b/src/datatypes/mod.rs @@ -32,7 +32,7 @@ pub trait ArcExt { /// /// ``` /// # use std::{ptr, sync::Arc}; - /// # use arrow2::datatype::ArcExt; + /// # use re_arrow2::datatype::ArcExt; /// let inner = String::from("test"); /// let ptr = inner.as_ptr(); /// diff --git a/src/io/flight/mod.rs b/src/io/flight/mod.rs index 943f1487304..4d27dbe8b9f 100644 --- a/src/io/flight/mod.rs +++ b/src/io/flight/mod.rs @@ -30,7 +30,7 @@ pub fn serialize_batch( options: &WriteOptions, ) -> Result<(Vec, FlightData)> { if fields.len() != chunk.arrays().len() { - return Err(Error::InvalidArgumentError("The argument `fields` must be consistent with the columns' schema. Use e.g. &arrow2::io::flight::default_ipc_fields(&schema.fields)".to_string())); + return Err(Error::InvalidArgumentError("The argument `fields` must be consistent with the columns' schema. Use e.g. &re_arrow2::io::flight::default_ipc_fields(&schema.fields)".to_string())); } let mut dictionary_tracker = DictionaryTracker { diff --git a/src/io/ipc/mod.rs b/src/io/ipc/mod.rs index 2bb233a1474..f708251849a 100644 --- a/src/io/ipc/mod.rs +++ b/src/io/ipc/mod.rs @@ -29,12 +29,12 @@ //! # Examples //! Read and write to a file: //! ``` -//! use arrow2::io::ipc::{{read::{FileReader, read_file_metadata}}, {write::{FileWriter, WriteOptions}}}; +//! use re_arrow2::io::ipc::{{read::{FileReader, read_file_metadata}}, {write::{FileWriter, WriteOptions}}}; //! # use std::fs::File; -//! # use arrow2::datatypes::{Field, Schema, DataType}; -//! # use arrow2::array::{Int32Array, Array}; -//! # use arrow2::chunk::Chunk; -//! # use arrow2::error::Error; +//! # use re_arrow2::datatypes::{Field, Schema, DataType}; +//! # use re_arrow2::array::{Int32Array, Array}; +//! # use re_arrow2::chunk::Chunk; +//! # use re_arrow2::error::Error; //! // Setup the writer //! let path = "example.arrow".to_string(); //! let mut file = File::create(&path)?; diff --git a/src/io/ipc/write/file_async.rs b/src/io/ipc/write/file_async.rs index 6bf77536640..9141e968644 100644 --- a/src/io/ipc/write/file_async.rs +++ b/src/io/ipc/write/file_async.rs @@ -24,11 +24,11 @@ type WriteOutput = (usize, Option, Vec, Option); /// /// ``` /// use futures::{SinkExt, TryStreamExt, io::Cursor}; -/// use arrow2::array::{Array, Int32Array}; -/// use arrow2::datatypes::{DataType, Field, Schema}; -/// use arrow2::chunk::Chunk; -/// use arrow2::io::ipc::write::file_async::FileSink; -/// use arrow2::io::ipc::read::file_async::{read_file_metadata_async, FileStream}; +/// use re_arrow2::array::{Array, Int32Array}; +/// use re_arrow2::datatypes::{DataType, Field, Schema}; +/// use re_arrow2::chunk::Chunk; +/// use re_arrow2::io::ipc::write::file_async::FileSink; +/// use re_arrow2::io::ipc::read::file_async::{read_file_metadata_async, FileStream}; /// # futures::executor::block_on(async move { /// let schema = Schema::from(vec![ /// Field::new("values", DataType::Int32, true), @@ -56,7 +56,7 @@ type WriteOutput = (usize, Option, Vec, Option); /// let metadata = read_file_metadata_async(&mut buffer).await?; /// let mut stream = FileStream::new(buffer, metadata, None, None); /// let chunks = stream.try_collect::>().await?; -/// # arrow2::error::Result::Ok(()) +/// # re_arrow2::error::Result::Ok(()) /// # }).unwrap(); /// ``` pub struct FileSink<'a, W: AsyncWrite + Unpin + Send + 'a> { diff --git a/src/io/ipc/write/stream_async.rs b/src/io/ipc/write/stream_async.rs index df651461fea..75727a1c799 100644 --- a/src/io/ipc/write/stream_async.rs +++ b/src/io/ipc/write/stream_async.rs @@ -21,10 +21,10 @@ use crate::error::{Error, Result}; /// /// ``` /// use futures::SinkExt; -/// use arrow2::array::{Array, Int32Array}; -/// use arrow2::datatypes::{DataType, Field, Schema}; -/// use arrow2::chunk::Chunk; -/// # use arrow2::io::ipc::write::stream_async::StreamSink; +/// use re_arrow2::array::{Array, Int32Array}; +/// use re_arrow2::datatypes::{DataType, Field, Schema}; +/// use re_arrow2::chunk::Chunk; +/// # use re_arrow2::io::ipc::write::stream_async::StreamSink; /// # futures::executor::block_on(async move { /// let schema = Schema::from(vec![ /// Field::new("values", DataType::Int32, true), @@ -44,7 +44,7 @@ use crate::error::{Error, Result}; /// sink.feed(chunk.into()).await?; /// } /// sink.close().await?; -/// # arrow2::error::Result::Ok(()) +/// # re_arrow2::error::Result::Ok(()) /// # }).unwrap(); /// ``` pub struct StreamSink<'a, W: AsyncWrite + Unpin + Send + 'a> { diff --git a/src/io/parquet/write/mod.rs b/src/io/parquet/write/mod.rs index f6ab4c21f16..2b7ef4f76d0 100644 --- a/src/io/parquet/write/mod.rs +++ b/src/io/parquet/write/mod.rs @@ -872,8 +872,8 @@ fn transverse_recursive T + Clone>( /// This is used to assign an [`Encoding`] to every parquet column based on the columns' type (see example) /// # Example /// ``` -/// use arrow2::io::parquet::write::{transverse, Encoding}; -/// use arrow2::datatypes::{DataType, Field}; +/// use re_arrow2::io::parquet::write::{transverse, Encoding}; +/// use re_arrow2::datatypes::{DataType, Field}; /// /// let dt = DataType::Struct(vec![ /// Field::new("a", DataType::Int64, true), diff --git a/src/io/parquet/write/sink.rs b/src/io/parquet/write/sink.rs index 1eeb83e21b2..bec103deed0 100644 --- a/src/io/parquet/write/sink.rs +++ b/src/io/parquet/write/sink.rs @@ -20,11 +20,11 @@ use super::{Encoding, SchemaDescriptor, WriteOptions}; /// /// ``` /// use futures::SinkExt; -/// use arrow2::array::{Array, Int32Array}; -/// use arrow2::datatypes::{DataType, Field, Schema}; -/// use arrow2::chunk::Chunk; -/// use arrow2::io::parquet::write::{Encoding, WriteOptions, CompressionOptions, Version}; -/// # use arrow2::io::parquet::write::FileSink; +/// use re_arrow2::array::{Array, Int32Array}; +/// use re_arrow2::datatypes::{DataType, Field, Schema}; +/// use re_arrow2::chunk::Chunk; +/// use re_arrow2::io::parquet::write::{Encoding, WriteOptions, CompressionOptions, Version}; +/// # use re_arrow2::io::parquet::write::FileSink; /// # futures::executor::block_on(async move { /// /// let schema = Schema::from(vec![ @@ -53,7 +53,7 @@ use super::{Encoding, SchemaDescriptor, WriteOptions}; /// } /// sink.metadata.insert(String::from("key"), Some(String::from("value"))); /// sink.close().await?; -/// # arrow2::error::Result::Ok(()) +/// # re_arrow2::error::Result::Ok(()) /// # }).unwrap(); /// ``` pub struct FileSink<'a, W: AsyncWrite + Send + Unpin> { diff --git a/src/types/bit_chunk.rs b/src/types/bit_chunk.rs index 796a608b1b8..a4dc51c43ab 100644 --- a/src/types/bit_chunk.rs +++ b/src/types/bit_chunk.rs @@ -56,7 +56,7 @@ bit_chunk!(u64); /// to the first slot, as defined by the arrow specification. /// # Example /// ``` -/// use arrow2::types::BitChunkIter; +/// use re_arrow2::types::BitChunkIter; /// let a = 0b00010000u8; /// let iter = BitChunkIter::new(a, 7); /// let r = iter.collect::>(); @@ -109,7 +109,7 @@ unsafe impl crate::trusted_len::TrustedLen for BitChunkIter {} /// See for details /// # Example /// ``` -/// use arrow2::types::BitChunkOnes; +/// use re_arrow2::types::BitChunkOnes; /// let a = 0b00010000u8; /// let iter = BitChunkOnes::new(a); /// let r = iter.collect::>(); diff --git a/tests/it/array/binary/mod.rs b/tests/it/array/binary/mod.rs index 1418fce8918..bb6e374c415 100644 --- a/tests/it/array/binary/mod.rs +++ b/tests/it/array/binary/mod.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::{Array, BinaryArray}, bitmap::Bitmap, buffer::Buffer, @@ -74,7 +74,7 @@ fn try_from_trusted_len_iter() { let iter = std::iter::repeat(b"hello".as_ref()) .take(2) .map(Some) - .map(arrow2::error::Result::Ok); + .map(re_arrow2::error::Result::Ok); let a = BinaryArray::::try_from_trusted_len_iter(iter).unwrap(); assert_eq!(a.len(), 2); } diff --git a/tests/it/array/binary/mutable.rs b/tests/it/array/binary/mutable.rs index 0d388b24162..a62462c316d 100644 --- a/tests/it/array/binary/mutable.rs +++ b/tests/it/array/binary/mutable.rs @@ -1,8 +1,8 @@ use std::ops::Deref; -use arrow2::array::{BinaryArray, MutableArray, MutableBinaryArray, TryExtendFromSelf}; -use arrow2::bitmap::Bitmap; -use arrow2::error::Error; +use re_arrow2::array::{BinaryArray, MutableArray, MutableBinaryArray, TryExtendFromSelf}; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::error::Error; #[test] fn new() { diff --git a/tests/it/array/binary/mutable_values.rs b/tests/it/array/binary/mutable_values.rs index 0bf532bc21c..25cd6abc15a 100644 --- a/tests/it/array/binary/mutable_values.rs +++ b/tests/it/array/binary/mutable_values.rs @@ -1,6 +1,6 @@ -use arrow2::array::MutableArray; -use arrow2::array::MutableBinaryValuesArray; -use arrow2::datatypes::DataType; +use re_arrow2::array::MutableArray; +use re_arrow2::array::MutableBinaryValuesArray; +use re_arrow2::datatypes::DataType; #[test] fn capacity() { diff --git a/tests/it/array/binary/to_mutable.rs b/tests/it/array/binary/to_mutable.rs index 1773c83a362..56ddba21a7e 100644 --- a/tests/it/array/binary/to_mutable.rs +++ b/tests/it/array/binary/to_mutable.rs @@ -1,4 +1,4 @@ -use arrow2::{array::BinaryArray, bitmap::Bitmap, buffer::Buffer, datatypes::DataType}; +use re_arrow2::{array::BinaryArray, bitmap::Bitmap, buffer::Buffer, datatypes::DataType}; #[test] fn not_shared() { diff --git a/tests/it/array/boolean/mod.rs b/tests/it/array/boolean/mod.rs index cd6ad0c77af..f78bd39d23a 100644 --- a/tests/it/array/boolean/mod.rs +++ b/tests/it/array/boolean/mod.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::{Array, BooleanArray}, bitmap::Bitmap, datatypes::DataType, @@ -109,7 +109,7 @@ fn try_from_trusted_len_iter() { let iter = std::iter::repeat(true) .take(2) .map(Some) - .map(arrow2::error::Result::Ok); + .map(re_arrow2::error::Result::Ok); let a = BooleanArray::try_from_trusted_len_iter(iter.clone()).unwrap(); assert_eq!(a.len(), 2); let a = unsafe { BooleanArray::try_from_trusted_len_iter_unchecked(iter).unwrap() }; diff --git a/tests/it/array/boolean/mutable.rs b/tests/it/array/boolean/mutable.rs index 1f1d85631a5..cbd3c94ed47 100644 --- a/tests/it/array/boolean/mutable.rs +++ b/tests/it/array/boolean/mutable.rs @@ -1,7 +1,7 @@ -use arrow2::array::{MutableArray, MutableBooleanArray, TryExtendFromSelf}; -use arrow2::bitmap::MutableBitmap; -use arrow2::datatypes::DataType; -use arrow2::error::Result; +use re_arrow2::array::{MutableArray, MutableBooleanArray, TryExtendFromSelf}; +use re_arrow2::bitmap::MutableBitmap; +use re_arrow2::datatypes::DataType; +use re_arrow2::error::Result; #[test] fn set() { diff --git a/tests/it/array/dictionary/mod.rs b/tests/it/array/dictionary/mod.rs index 0a2e882465a..d18ac327a1b 100644 --- a/tests/it/array/dictionary/mod.rs +++ b/tests/it/array/dictionary/mod.rs @@ -2,7 +2,7 @@ mod mutable; use std::sync::Arc; -use arrow2::{array::*, datatypes::DataType}; +use re_arrow2::{array::*, datatypes::DataType}; #[test] fn try_new_ok() { diff --git a/tests/it/array/dictionary/mutable.rs b/tests/it/array/dictionary/mutable.rs index a7845114d9b..450172ae1c3 100644 --- a/tests/it/array/dictionary/mutable.rs +++ b/tests/it/array/dictionary/mutable.rs @@ -3,9 +3,9 @@ use std::collections::HashSet; use std::fmt::Debug; use std::hash::Hash; -use arrow2::array::indexable::{AsIndexed, Indexable}; -use arrow2::array::*; -use arrow2::error::Result; +use re_arrow2::array::indexable::{AsIndexed, Indexable}; +use re_arrow2::array::*; +use re_arrow2::error::Result; #[test] fn primitive() -> Result<()> { diff --git a/tests/it/array/equal/boolean.rs b/tests/it/array/equal/boolean.rs index 9a43f226e6c..0e102f39d8f 100644 --- a/tests/it/array/equal/boolean.rs +++ b/tests/it/array/equal/boolean.rs @@ -1,4 +1,4 @@ -use arrow2::array::*; +use re_arrow2::array::*; use super::test_equal; diff --git a/tests/it/array/equal/dictionary.rs b/tests/it/array/equal/dictionary.rs index 8e25d083e1a..18b0ee47470 100644 --- a/tests/it/array/equal/dictionary.rs +++ b/tests/it/array/equal/dictionary.rs @@ -1,4 +1,4 @@ -use arrow2::array::*; +use re_arrow2::array::*; use super::test_equal; diff --git a/tests/it/array/equal/fixed_size_list.rs b/tests/it/array/equal/fixed_size_list.rs index 3df32c574f2..864e4f5b47c 100644 --- a/tests/it/array/equal/fixed_size_list.rs +++ b/tests/it/array/equal/fixed_size_list.rs @@ -1,4 +1,4 @@ -use arrow2::array::{ +use re_arrow2::array::{ FixedSizeListArray, MutableFixedSizeListArray, MutablePrimitiveArray, TryExtend, }; diff --git a/tests/it/array/equal/list.rs b/tests/it/array/equal/list.rs index d54c59de6e9..70676c020d1 100644 --- a/tests/it/array/equal/list.rs +++ b/tests/it/array/equal/list.rs @@ -1,6 +1,6 @@ -use arrow2::array::{Int32Array, ListArray, MutableListArray, MutablePrimitiveArray, TryExtend}; -use arrow2::bitmap::Bitmap; -use arrow2::datatypes::DataType; +use re_arrow2::array::{Int32Array, ListArray, MutableListArray, MutablePrimitiveArray, TryExtend}; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::datatypes::DataType; use super::test_equal; diff --git a/tests/it/array/equal/mod.rs b/tests/it/array/equal/mod.rs index f479b478843..c78a84748d5 100644 --- a/tests/it/array/equal/mod.rs +++ b/tests/it/array/equal/mod.rs @@ -1,4 +1,4 @@ -use arrow2::array::*; +use re_arrow2::array::*; mod dictionary; mod fixed_size_list; diff --git a/tests/it/array/equal/primitive.rs b/tests/it/array/equal/primitive.rs index 58793bc8c3b..62c96daba8d 100644 --- a/tests/it/array/equal/primitive.rs +++ b/tests/it/array/equal/primitive.rs @@ -1,4 +1,4 @@ -use arrow2::array::*; +use re_arrow2::array::*; use super::test_equal; diff --git a/tests/it/array/equal/utf8.rs b/tests/it/array/equal/utf8.rs index 7d4e725c0bf..712bf221c7c 100644 --- a/tests/it/array/equal/utf8.rs +++ b/tests/it/array/equal/utf8.rs @@ -1,5 +1,5 @@ -use arrow2::array::*; -use arrow2::offset::Offset; +use re_arrow2::array::*; +use re_arrow2::offset::Offset; use super::{binary_cases, test_equal}; diff --git a/tests/it/array/fixed_size_binary/mod.rs b/tests/it/array/fixed_size_binary/mod.rs index cf322086a2d..5572639f52e 100644 --- a/tests/it/array/fixed_size_binary/mod.rs +++ b/tests/it/array/fixed_size_binary/mod.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use arrow2::{array::FixedSizeBinaryArray, bitmap::Bitmap, buffer::Buffer, datatypes::DataType}; +use re_arrow2::{array::FixedSizeBinaryArray, bitmap::Bitmap, buffer::Buffer, datatypes::DataType}; mod mutable; diff --git a/tests/it/array/fixed_size_binary/mutable.rs b/tests/it/array/fixed_size_binary/mutable.rs index ad2ea25b3fd..cb402a67de2 100644 --- a/tests/it/array/fixed_size_binary/mutable.rs +++ b/tests/it/array/fixed_size_binary/mutable.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::bitmap::{Bitmap, MutableBitmap}; -use arrow2::datatypes::DataType; +use re_arrow2::array::*; +use re_arrow2::bitmap::{Bitmap, MutableBitmap}; +use re_arrow2::datatypes::DataType; #[test] fn basic() { diff --git a/tests/it/array/fixed_size_list/mod.rs b/tests/it/array/fixed_size_list/mod.rs index f538c65dd68..394022ed141 100644 --- a/tests/it/array/fixed_size_list/mod.rs +++ b/tests/it/array/fixed_size_list/mod.rs @@ -2,7 +2,7 @@ mod mutable; use std::sync::Arc; -use arrow2::{ +use re_arrow2::{ array::*, bitmap::Bitmap, datatypes::{DataType, Field}, diff --git a/tests/it/array/fixed_size_list/mutable.rs b/tests/it/array/fixed_size_list/mutable.rs index a267352eb70..0d113833538 100644 --- a/tests/it/array/fixed_size_list/mutable.rs +++ b/tests/it/array/fixed_size_list/mutable.rs @@ -1,7 +1,7 @@ use std::sync::Arc; -use arrow2::array::*; -use arrow2::datatypes::{DataType, Field}; +use re_arrow2::array::*; +use re_arrow2::datatypes::{DataType, Field}; #[test] fn primitive() { diff --git a/tests/it/array/growable/binary.rs b/tests/it/array/growable/binary.rs index 5b8bb3e9349..3f818a876f1 100644 --- a/tests/it/array/growable/binary.rs +++ b/tests/it/array/growable/binary.rs @@ -1,4 +1,4 @@ -use arrow2::array::{ +use re_arrow2::array::{ growable::{Growable, GrowableBinary}, BinaryArray, }; diff --git a/tests/it/array/growable/boolean.rs b/tests/it/array/growable/boolean.rs index b52110b5d94..22291a9b896 100644 --- a/tests/it/array/growable/boolean.rs +++ b/tests/it/array/growable/boolean.rs @@ -1,5 +1,5 @@ -use arrow2::array::growable::{Growable, GrowableBoolean}; -use arrow2::array::BooleanArray; +use re_arrow2::array::growable::{Growable, GrowableBoolean}; +use re_arrow2::array::BooleanArray; #[test] fn test_bool() { diff --git a/tests/it/array/growable/dictionary.rs b/tests/it/array/growable/dictionary.rs index d4c75922de2..9b60691b190 100644 --- a/tests/it/array/growable/dictionary.rs +++ b/tests/it/array/growable/dictionary.rs @@ -1,6 +1,6 @@ -use arrow2::array::growable::{Growable, GrowableDictionary}; -use arrow2::array::*; -use arrow2::error::Result; +use re_arrow2::array::growable::{Growable, GrowableDictionary}; +use re_arrow2::array::*; +use re_arrow2::error::Result; #[test] fn test_single() -> Result<()> { diff --git a/tests/it/array/growable/fixed_binary.rs b/tests/it/array/growable/fixed_binary.rs index c3bcb630551..31743d6c310 100644 --- a/tests/it/array/growable/fixed_binary.rs +++ b/tests/it/array/growable/fixed_binary.rs @@ -1,4 +1,4 @@ -use arrow2::array::{ +use re_arrow2::array::{ growable::{Growable, GrowableFixedSizeBinary}, FixedSizeBinaryArray, }; diff --git a/tests/it/array/growable/fixed_size_list.rs b/tests/it/array/growable/fixed_size_list.rs index d48e40338c5..91193871f31 100644 --- a/tests/it/array/growable/fixed_size_list.rs +++ b/tests/it/array/growable/fixed_size_list.rs @@ -1,4 +1,4 @@ -use arrow2::array::{ +use re_arrow2::array::{ growable::{Growable, GrowableFixedSizeList}, FixedSizeListArray, MutableFixedSizeListArray, MutablePrimitiveArray, TryExtend, }; diff --git a/tests/it/array/growable/list.rs b/tests/it/array/growable/list.rs index 5709aaf929a..ac578d86aa4 100644 --- a/tests/it/array/growable/list.rs +++ b/tests/it/array/growable/list.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use arrow2::{ +use re_arrow2::{ array::{ growable::{Growable, GrowableList}, Array, ListArray, MutableListArray, MutablePrimitiveArray, TryExtend, diff --git a/tests/it/array/growable/map.rs b/tests/it/array/growable/map.rs index c1c367dcbcd..04baf3117a0 100644 --- a/tests/it/array/growable/map.rs +++ b/tests/it/array/growable/map.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::{ growable::{Growable, GrowableMap}, Array, MapArray, PrimitiveArray, StructArray, Utf8Array, diff --git a/tests/it/array/growable/mod.rs b/tests/it/array/growable/mod.rs index d614f1b411e..4597f06321b 100644 --- a/tests/it/array/growable/mod.rs +++ b/tests/it/array/growable/mod.rs @@ -13,9 +13,9 @@ mod utf8; use std::sync::Arc; -use arrow2::array::growable::make_growable; -use arrow2::array::*; -use arrow2::datatypes::{DataType, Field}; +use re_arrow2::array::growable::make_growable; +use re_arrow2::array::*; +use re_arrow2::datatypes::{DataType, Field}; #[test] fn test_make_growable() { diff --git a/tests/it/array/growable/null.rs b/tests/it/array/growable/null.rs index 1298f3f5686..a27691f51fd 100644 --- a/tests/it/array/growable/null.rs +++ b/tests/it/array/growable/null.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::{ growable::{Growable, GrowableNull}, NullArray, diff --git a/tests/it/array/growable/primitive.rs b/tests/it/array/growable/primitive.rs index f308a0c49b5..f0fcd0b1efa 100644 --- a/tests/it/array/growable/primitive.rs +++ b/tests/it/array/growable/primitive.rs @@ -1,4 +1,4 @@ -use arrow2::array::{ +use re_arrow2::array::{ growable::{Growable, GrowablePrimitive}, PrimitiveArray, }; diff --git a/tests/it/array/growable/struct_.rs b/tests/it/array/growable/struct_.rs index 16d600dfe24..1408cf978f1 100644 --- a/tests/it/array/growable/struct_.rs +++ b/tests/it/array/growable/struct_.rs @@ -1,9 +1,9 @@ -use arrow2::array::{ +use re_arrow2::array::{ growable::{Growable, GrowableStruct}, Array, PrimitiveArray, StructArray, Utf8Array, }; -use arrow2::bitmap::Bitmap; -use arrow2::datatypes::{DataType, Field}; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::datatypes::{DataType, Field}; fn some_values() -> (DataType, Vec>) { let strings: Box = Box::new(Utf8Array::::from([ diff --git a/tests/it/array/growable/union.rs b/tests/it/array/growable/union.rs index 65185ffecff..6d151c7f4d6 100644 --- a/tests/it/array/growable/union.rs +++ b/tests/it/array/growable/union.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::{ growable::{Growable, GrowableUnion}, *, diff --git a/tests/it/array/growable/utf8.rs b/tests/it/array/growable/utf8.rs index 2568116dc3a..1a2d59a3dd5 100644 --- a/tests/it/array/growable/utf8.rs +++ b/tests/it/array/growable/utf8.rs @@ -1,4 +1,4 @@ -use arrow2::array::{ +use re_arrow2::array::{ growable::{Growable, GrowableUtf8}, Utf8Array, }; diff --git a/tests/it/array/list/mod.rs b/tests/it/array/list/mod.rs index 4cbf4dbbece..887ba9cf5ce 100644 --- a/tests/it/array/list/mod.rs +++ b/tests/it/array/list/mod.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::buffer::Buffer; -use arrow2::datatypes::DataType; +use re_arrow2::array::*; +use re_arrow2::buffer::Buffer; +use re_arrow2::datatypes::DataType; mod mutable; diff --git a/tests/it/array/list/mutable.rs b/tests/it/array/list/mutable.rs index e72167277fa..b35403c6e4b 100644 --- a/tests/it/array/list/mutable.rs +++ b/tests/it/array/list/mutable.rs @@ -1,4 +1,4 @@ -use arrow2::{array::*, bitmap::Bitmap, buffer::Buffer, datatypes::DataType}; +use re_arrow2::{array::*, bitmap::Bitmap, buffer::Buffer, datatypes::DataType}; #[test] fn basics() { diff --git a/tests/it/array/map/mod.rs b/tests/it/array/map/mod.rs index 1a6bbe2ffa3..2c84dfab221 100644 --- a/tests/it/array/map/mod.rs +++ b/tests/it/array/map/mod.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use arrow2::{ +use re_arrow2::{ array::*, datatypes::{DataType, Field}, }; diff --git a/tests/it/array/mod.rs b/tests/it/array/mod.rs index 188f6081c50..d08f31cf9f5 100644 --- a/tests/it/array/mod.rs +++ b/tests/it/array/mod.rs @@ -15,9 +15,9 @@ mod utf8; use std::sync::Arc; -use arrow2::array::{clone, new_empty_array, new_null_array, Array, PrimitiveArray}; -use arrow2::bitmap::Bitmap; -use arrow2::datatypes::{DataType, Field, UnionMode}; +use re_arrow2::array::{clone, new_empty_array, new_null_array, Array, PrimitiveArray}; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::datatypes::{DataType, Field, UnionMode}; #[test] fn nulls() { diff --git a/tests/it/array/ord.rs b/tests/it/array/ord.rs index 3ce249af451..096916d4975 100644 --- a/tests/it/array/ord.rs +++ b/tests/it/array/ord.rs @@ -1,9 +1,9 @@ use std::cmp::Ordering; -use arrow2::array::ord::build_compare; -use arrow2::array::*; -use arrow2::datatypes::DataType; -use arrow2::error::Result; +use re_arrow2::array::ord::build_compare; +use re_arrow2::array::*; +use re_arrow2::datatypes::DataType; +use re_arrow2::error::Result; #[test] fn i32() -> Result<()> { diff --git a/tests/it/array/primitive/fmt.rs b/tests/it/array/primitive/fmt.rs index 54acc56bdad..f17aaf0b6c1 100644 --- a/tests/it/array/primitive/fmt.rs +++ b/tests/it/array/primitive/fmt.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use arrow2::{ +use re_arrow2::{ array::*, datatypes::*, types::{days_ms, months_days_ns}, diff --git a/tests/it/array/primitive/mod.rs b/tests/it/array/primitive/mod.rs index e8a78435311..2c84b763c2b 100644 --- a/tests/it/array/primitive/mod.rs +++ b/tests/it/array/primitive/mod.rs @@ -1,6 +1,6 @@ use std::iter::FromIterator; -use arrow2::{array::*, bitmap::Bitmap, buffer::Buffer, datatypes::*, types::months_days_ns}; +use re_arrow2::{array::*, bitmap::Bitmap, buffer::Buffer, datatypes::*, types::months_days_ns}; mod fmt; mod mutable; diff --git a/tests/it/array/primitive/mutable.rs b/tests/it/array/primitive/mutable.rs index d7e0b86c061..368409fdf73 100644 --- a/tests/it/array/primitive/mutable.rs +++ b/tests/it/array/primitive/mutable.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::*, bitmap::{Bitmap, MutableBitmap}, datatypes::DataType, diff --git a/tests/it/array/primitive/to_mutable.rs b/tests/it/array/primitive/to_mutable.rs index ee3a1f8ee34..524723e1fbd 100644 --- a/tests/it/array/primitive/to_mutable.rs +++ b/tests/it/array/primitive/to_mutable.rs @@ -1,7 +1,7 @@ -use arrow2::array::PrimitiveArray; -use arrow2::bitmap::Bitmap; -use arrow2::datatypes::DataType; use either::Either; +use re_arrow2::array::PrimitiveArray; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::datatypes::DataType; #[test] fn array_to_mutable() { diff --git a/tests/it/array/struct_/iterator.rs b/tests/it/array/struct_/iterator.rs index a7190986e2e..921cf3fd9b5 100644 --- a/tests/it/array/struct_/iterator.rs +++ b/tests/it/array/struct_/iterator.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::datatypes::*; -use arrow2::scalar::new_scalar; +use re_arrow2::array::*; +use re_arrow2::datatypes::*; +use re_arrow2::scalar::new_scalar; #[test] fn test_simple_iter() { diff --git a/tests/it/array/struct_/mod.rs b/tests/it/array/struct_/mod.rs index 5e467b03796..47c30298427 100644 --- a/tests/it/array/struct_/mod.rs +++ b/tests/it/array/struct_/mod.rs @@ -1,9 +1,9 @@ mod iterator; mod mutable; -use arrow2::array::*; -use arrow2::bitmap::Bitmap; -use arrow2::datatypes::*; +use re_arrow2::array::*; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::datatypes::*; #[test] fn debug() { diff --git a/tests/it/array/struct_/mutable.rs b/tests/it/array/struct_/mutable.rs index fdc6f5f204d..9aad50d7315 100644 --- a/tests/it/array/struct_/mutable.rs +++ b/tests/it/array/struct_/mutable.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use arrow2::{ +use re_arrow2::{ array::*, datatypes::{DataType, Field}, }; diff --git a/tests/it/array/union.rs b/tests/it/array/union.rs index 32e3dca0b77..ba63934fc61 100644 --- a/tests/it/array/union.rs +++ b/tests/it/array/union.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::*, buffer::Buffer, datatypes::*, diff --git a/tests/it/array/utf8/mod.rs b/tests/it/array/utf8/mod.rs index 9a437bb8681..7a35c2639df 100644 --- a/tests/it/array/utf8/mod.rs +++ b/tests/it/array/utf8/mod.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::*, bitmap::Bitmap, buffer::Buffer, datatypes::DataType, error::Result, offset::OffsetsBuffer, }; diff --git a/tests/it/array/utf8/mutable.rs b/tests/it/array/utf8/mutable.rs index b33fb59966e..04699a9feaf 100644 --- a/tests/it/array/utf8/mutable.rs +++ b/tests/it/array/utf8/mutable.rs @@ -1,6 +1,6 @@ -use arrow2::array::{MutableArray, MutableUtf8Array, TryExtendFromSelf, Utf8Array}; -use arrow2::bitmap::Bitmap; -use arrow2::datatypes::DataType; +use re_arrow2::array::{MutableArray, MutableUtf8Array, TryExtendFromSelf, Utf8Array}; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::datatypes::DataType; #[test] fn capacities() { diff --git a/tests/it/array/utf8/mutable_values.rs b/tests/it/array/utf8/mutable_values.rs index 6bf04726a36..fde91fe1861 100644 --- a/tests/it/array/utf8/mutable_values.rs +++ b/tests/it/array/utf8/mutable_values.rs @@ -1,6 +1,6 @@ -use arrow2::array::MutableArray; -use arrow2::array::MutableUtf8ValuesArray; -use arrow2::datatypes::DataType; +use re_arrow2::array::MutableArray; +use re_arrow2::array::MutableUtf8ValuesArray; +use re_arrow2::datatypes::DataType; #[test] fn capacity() { diff --git a/tests/it/array/utf8/to_mutable.rs b/tests/it/array/utf8/to_mutable.rs index 97ee0fb2055..a181b9306b8 100644 --- a/tests/it/array/utf8/to_mutable.rs +++ b/tests/it/array/utf8/to_mutable.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::Utf8Array, bitmap::Bitmap, buffer::Buffer, datatypes::DataType, offset::OffsetsBuffer, }; diff --git a/tests/it/arrow.rs b/tests/it/arrow.rs index cace8255567..7da7c92cf6b 100644 --- a/tests/it/arrow.rs +++ b/tests/it/arrow.rs @@ -1,12 +1,12 @@ use std::sync::Arc; -use arrow2::array::*; -use arrow2::bitmap::Bitmap; -use arrow2::datatypes::{DataType, Field, IntegerType, TimeUnit, UnionMode}; -use arrow2::offset::Offsets; use arrow_array::ArrayRef; use arrow_data::ArrayDataBuilder; use proptest::num::i32; +use re_arrow2::array::*; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::datatypes::{DataType, Field, IntegerType, TimeUnit, UnionMode}; +use re_arrow2::offset::Offsets; fn test_arrow2_roundtrip(array: &dyn arrow_array::Array) { let arrow2 = Box::::from(array); diff --git a/tests/it/bitmap/assign_ops.rs b/tests/it/bitmap/assign_ops.rs index 5f367a7990c..1520457ffa4 100644 --- a/tests/it/bitmap/assign_ops.rs +++ b/tests/it/bitmap/assign_ops.rs @@ -1,6 +1,6 @@ use proptest::prelude::*; -use arrow2::bitmap::{binary_assign, unary_assign, Bitmap, MutableBitmap}; +use re_arrow2::bitmap::{binary_assign, unary_assign, Bitmap, MutableBitmap}; use crate::bitmap::bitmap_strategy; diff --git a/tests/it/bitmap/bitmap_ops.rs b/tests/it/bitmap/bitmap_ops.rs index 9454af49965..dc749991118 100644 --- a/tests/it/bitmap/bitmap_ops.rs +++ b/tests/it/bitmap/bitmap_ops.rs @@ -1,6 +1,6 @@ use proptest::prelude::*; -use arrow2::bitmap::{and, or, xor, Bitmap}; +use re_arrow2::bitmap::{and, or, xor, Bitmap}; use crate::bitmap::bitmap_strategy; diff --git a/tests/it/bitmap/immutable.rs b/tests/it/bitmap/immutable.rs index cc003009e06..5c732cb9de5 100644 --- a/tests/it/bitmap/immutable.rs +++ b/tests/it/bitmap/immutable.rs @@ -1,4 +1,4 @@ -use arrow2::bitmap::Bitmap; +use re_arrow2::bitmap::Bitmap; #[test] fn as_slice() { diff --git a/tests/it/bitmap/mod.rs b/tests/it/bitmap/mod.rs index 04026e4ac43..9ae3b525d52 100644 --- a/tests/it/bitmap/mod.rs +++ b/tests/it/bitmap/mod.rs @@ -6,7 +6,7 @@ mod utils; use proptest::prelude::*; -use arrow2::bitmap::Bitmap; +use re_arrow2::bitmap::Bitmap; /// Returns a strategy of an arbitrary sliced [`Bitmap`] of size up to 1000 pub(crate) fn bitmap_strategy() -> impl Strategy { diff --git a/tests/it/bitmap/mutable.rs b/tests/it/bitmap/mutable.rs index 960c6303e66..f0dff4eafab 100644 --- a/tests/it/bitmap/mutable.rs +++ b/tests/it/bitmap/mutable.rs @@ -1,4 +1,4 @@ -use arrow2::bitmap::{Bitmap, MutableBitmap}; +use re_arrow2::bitmap::{Bitmap, MutableBitmap}; #[test] fn from_slice() { diff --git a/tests/it/bitmap/utils/bit_chunks_exact.rs b/tests/it/bitmap/utils/bit_chunks_exact.rs index 56ac806f16b..dc4887bd9d5 100644 --- a/tests/it/bitmap/utils/bit_chunks_exact.rs +++ b/tests/it/bitmap/utils/bit_chunks_exact.rs @@ -1,4 +1,4 @@ -use arrow2::bitmap::utils::BitChunksExact; +use re_arrow2::bitmap::utils::BitChunksExact; #[test] fn basics() { diff --git a/tests/it/bitmap/utils/chunk_iter.rs b/tests/it/bitmap/utils/chunk_iter.rs index 3bbad3f88cf..c5e3674c728 100644 --- a/tests/it/bitmap/utils/chunk_iter.rs +++ b/tests/it/bitmap/utils/chunk_iter.rs @@ -1,5 +1,5 @@ -use arrow2::bitmap::utils::BitChunks; -use arrow2::types::BitChunkIter; +use re_arrow2::bitmap::utils::BitChunks; +use re_arrow2::types::BitChunkIter; #[test] fn basics() { diff --git a/tests/it/bitmap/utils/fmt.rs b/tests/it/bitmap/utils/fmt.rs index 36e748bfe1b..c5b46b5fcb0 100644 --- a/tests/it/bitmap/utils/fmt.rs +++ b/tests/it/bitmap/utils/fmt.rs @@ -1,4 +1,4 @@ -use arrow2::bitmap::utils::fmt; +use re_arrow2::bitmap::utils::fmt; struct A<'a>(&'a [u8], usize, usize); diff --git a/tests/it/bitmap/utils/iterator.rs b/tests/it/bitmap/utils/iterator.rs index 1f1d56d39d0..93cbdd664c5 100644 --- a/tests/it/bitmap/utils/iterator.rs +++ b/tests/it/bitmap/utils/iterator.rs @@ -1,4 +1,4 @@ -use arrow2::bitmap::utils::BitmapIter; +use re_arrow2::bitmap::utils::BitmapIter; #[test] fn basic() { diff --git a/tests/it/bitmap/utils/mod.rs b/tests/it/bitmap/utils/mod.rs index 9b138d82eb8..1c99753ffb8 100644 --- a/tests/it/bitmap/utils/mod.rs +++ b/tests/it/bitmap/utils/mod.rs @@ -1,6 +1,6 @@ use proptest::prelude::*; -use arrow2::bitmap::utils::*; +use re_arrow2::bitmap::utils::*; use crate::bitmap::bitmap_strategy; diff --git a/tests/it/bitmap/utils/slice_iterator.rs b/tests/it/bitmap/utils/slice_iterator.rs index cab565456d8..040c1c7d687 100644 --- a/tests/it/bitmap/utils/slice_iterator.rs +++ b/tests/it/bitmap/utils/slice_iterator.rs @@ -1,7 +1,7 @@ use proptest::prelude::*; -use arrow2::bitmap::utils::SlicesIterator; -use arrow2::bitmap::Bitmap; +use re_arrow2::bitmap::utils::SlicesIterator; +use re_arrow2::bitmap::Bitmap; use crate::bitmap::bitmap_strategy; diff --git a/tests/it/bitmap/utils/zip_validity.rs b/tests/it/bitmap/utils/zip_validity.rs index dc162962202..df29abbbcce 100644 --- a/tests/it/bitmap/utils/zip_validity.rs +++ b/tests/it/bitmap/utils/zip_validity.rs @@ -1,4 +1,4 @@ -use arrow2::bitmap::{ +use re_arrow2::bitmap::{ utils::{BitmapIter, ZipValidity}, Bitmap, }; diff --git a/tests/it/buffer/immutable.rs b/tests/it/buffer/immutable.rs index 550b2ee1709..4fa3a60955e 100644 --- a/tests/it/buffer/immutable.rs +++ b/tests/it/buffer/immutable.rs @@ -1,4 +1,4 @@ -use arrow2::buffer::Buffer; +use re_arrow2::buffer::Buffer; #[test] fn new() { diff --git a/tests/it/compute/aggregate/memory.rs b/tests/it/compute/aggregate/memory.rs index 1c5133aa030..000ef45dcb4 100644 --- a/tests/it/compute/aggregate/memory.rs +++ b/tests/it/compute/aggregate/memory.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::*, compute::aggregate::estimated_bytes_size, datatypes::{DataType, Field}, diff --git a/tests/it/compute/aggregate/min_max.rs b/tests/it/compute/aggregate/min_max.rs index ba27c73adeb..2a219dc95c2 100644 --- a/tests/it/compute/aggregate/min_max.rs +++ b/tests/it/compute/aggregate/min_max.rs @@ -1,8 +1,8 @@ -use arrow2::compute::aggregate::{ +use re_arrow2::compute::aggregate::{ max_binary, max_boolean, max_primitive, max_string, min_binary, min_boolean, min_primitive, min_string, }; -use arrow2::{array::*, datatypes::DataType}; +use re_arrow2::{array::*, datatypes::DataType}; #[test] fn test_primitive_array_min_max() { diff --git a/tests/it/compute/aggregate/sum.rs b/tests/it/compute/aggregate/sum.rs index 8c12d1d38c5..53b3ff970c2 100644 --- a/tests/it/compute/aggregate/sum.rs +++ b/tests/it/compute/aggregate/sum.rs @@ -1,8 +1,8 @@ -use arrow2::array::*; -use arrow2::compute::aggregate::{sum, sum_primitive}; -use arrow2::compute::arithmetics; -use arrow2::datatypes::DataType; -use arrow2::scalar::{PrimitiveScalar, Scalar}; +use re_arrow2::array::*; +use re_arrow2::compute::aggregate::{sum, sum_primitive}; +use re_arrow2::compute::arithmetics; +use re_arrow2::datatypes::DataType; +use re_arrow2::scalar::{PrimitiveScalar, Scalar}; #[test] fn test_primitive_array_sum() { diff --git a/tests/it/compute/arithmetics/basic/add.rs b/tests/it/compute/arithmetics/basic/add.rs index 45a4945bd1b..be16619c2ba 100644 --- a/tests/it/compute/arithmetics/basic/add.rs +++ b/tests/it/compute/arithmetics/basic/add.rs @@ -1,7 +1,7 @@ -use arrow2::array::*; -use arrow2::bitmap::Bitmap; -use arrow2::compute::arithmetics::basic::*; -use arrow2::compute::arithmetics::{ +use re_arrow2::array::*; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::compute::arithmetics::basic::*; +use re_arrow2::compute::arithmetics::{ ArrayAdd, ArrayCheckedAdd, ArrayOverflowingAdd, ArraySaturatingAdd, }; diff --git a/tests/it/compute/arithmetics/basic/div.rs b/tests/it/compute/arithmetics/basic/div.rs index 6160f2eea18..3c425417883 100644 --- a/tests/it/compute/arithmetics/basic/div.rs +++ b/tests/it/compute/arithmetics/basic/div.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::compute::arithmetics::basic::*; -use arrow2::compute::arithmetics::{ArrayCheckedDiv, ArrayDiv}; +use re_arrow2::array::*; +use re_arrow2::compute::arithmetics::basic::*; +use re_arrow2::compute::arithmetics::{ArrayCheckedDiv, ArrayDiv}; #[test] #[should_panic] diff --git a/tests/it/compute/arithmetics/basic/mul.rs b/tests/it/compute/arithmetics/basic/mul.rs index b8416e3e0c2..c2f14e1ff76 100644 --- a/tests/it/compute/arithmetics/basic/mul.rs +++ b/tests/it/compute/arithmetics/basic/mul.rs @@ -1,7 +1,7 @@ -use arrow2::array::*; -use arrow2::bitmap::Bitmap; -use arrow2::compute::arithmetics::basic::*; -use arrow2::compute::arithmetics::{ +use re_arrow2::array::*; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::compute::arithmetics::basic::*; +use re_arrow2::compute::arithmetics::{ ArrayCheckedMul, ArrayMul, ArrayOverflowingMul, ArraySaturatingMul, }; diff --git a/tests/it/compute/arithmetics/basic/pow.rs b/tests/it/compute/arithmetics/basic/pow.rs index e6ce52b03fb..f0874cfa1bf 100644 --- a/tests/it/compute/arithmetics/basic/pow.rs +++ b/tests/it/compute/arithmetics/basic/pow.rs @@ -1,5 +1,5 @@ -use arrow2::array::*; -use arrow2::compute::arithmetics::basic::*; +use re_arrow2::array::*; +use re_arrow2::compute::arithmetics::basic::*; #[test] fn test_raise_power_scalar() { diff --git a/tests/it/compute/arithmetics/basic/rem.rs b/tests/it/compute/arithmetics/basic/rem.rs index 666cb3fd624..155e2c9eb60 100644 --- a/tests/it/compute/arithmetics/basic/rem.rs +++ b/tests/it/compute/arithmetics/basic/rem.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::compute::arithmetics::basic::*; -use arrow2::compute::arithmetics::{ArrayCheckedRem, ArrayRem}; +use re_arrow2::array::*; +use re_arrow2::compute::arithmetics::basic::*; +use re_arrow2::compute::arithmetics::{ArrayCheckedRem, ArrayRem}; #[test] #[should_panic] diff --git a/tests/it/compute/arithmetics/basic/sub.rs b/tests/it/compute/arithmetics/basic/sub.rs index 3822bf705b9..b1b123c1a14 100644 --- a/tests/it/compute/arithmetics/basic/sub.rs +++ b/tests/it/compute/arithmetics/basic/sub.rs @@ -1,7 +1,7 @@ -use arrow2::array::*; -use arrow2::bitmap::Bitmap; -use arrow2::compute::arithmetics::basic::*; -use arrow2::compute::arithmetics::{ +use re_arrow2::array::*; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::compute::arithmetics::basic::*; +use re_arrow2::compute::arithmetics::{ ArrayCheckedSub, ArrayOverflowingSub, ArraySaturatingSub, ArraySub, }; diff --git a/tests/it/compute/arithmetics/decimal/add.rs b/tests/it/compute/arithmetics/decimal/add.rs index 45af77b1519..9fb11e6f829 100644 --- a/tests/it/compute/arithmetics/decimal/add.rs +++ b/tests/it/compute/arithmetics/decimal/add.rs @@ -1,9 +1,9 @@ #![allow(clippy::zero_prefixed_literal, clippy::inconsistent_digit_grouping)] -use arrow2::array::*; -use arrow2::compute::arithmetics::decimal::{adaptive_add, add, checked_add, saturating_add}; -use arrow2::compute::arithmetics::{ArrayAdd, ArrayCheckedAdd, ArraySaturatingAdd}; -use arrow2::datatypes::DataType; +use re_arrow2::array::*; +use re_arrow2::compute::arithmetics::decimal::{adaptive_add, add, checked_add, saturating_add}; +use re_arrow2::compute::arithmetics::{ArrayAdd, ArrayCheckedAdd, ArraySaturatingAdd}; +use re_arrow2::datatypes::DataType; #[test] fn test_add_normal() { diff --git a/tests/it/compute/arithmetics/decimal/div.rs b/tests/it/compute/arithmetics/decimal/div.rs index 39138d05dda..43d40463483 100644 --- a/tests/it/compute/arithmetics/decimal/div.rs +++ b/tests/it/compute/arithmetics/decimal/div.rs @@ -1,12 +1,12 @@ #![allow(clippy::zero_prefixed_literal, clippy::inconsistent_digit_grouping)] -use arrow2::array::*; -use arrow2::compute::arithmetics::decimal::{ +use re_arrow2::array::*; +use re_arrow2::compute::arithmetics::decimal::{ adaptive_div, checked_div, div, div_scalar, saturating_div, }; -use arrow2::compute::arithmetics::{ArrayCheckedDiv, ArrayDiv}; -use arrow2::datatypes::DataType; -use arrow2::scalar::PrimitiveScalar; +use re_arrow2::compute::arithmetics::{ArrayCheckedDiv, ArrayDiv}; +use re_arrow2::datatypes::DataType; +use re_arrow2::scalar::PrimitiveScalar; #[test] fn test_divide_normal() { diff --git a/tests/it/compute/arithmetics/decimal/mul.rs b/tests/it/compute/arithmetics/decimal/mul.rs index a4b4a71b257..cfd35155abb 100644 --- a/tests/it/compute/arithmetics/decimal/mul.rs +++ b/tests/it/compute/arithmetics/decimal/mul.rs @@ -1,9 +1,9 @@ #![allow(clippy::zero_prefixed_literal, clippy::inconsistent_digit_grouping)] -use arrow2::array::*; -use arrow2::compute::arithmetics::decimal::{adaptive_mul, checked_mul, mul, saturating_mul}; -use arrow2::compute::arithmetics::{ArrayCheckedMul, ArrayMul, ArraySaturatingMul}; -use arrow2::datatypes::DataType; +use re_arrow2::array::*; +use re_arrow2::compute::arithmetics::decimal::{adaptive_mul, checked_mul, mul, saturating_mul}; +use re_arrow2::compute::arithmetics::{ArrayCheckedMul, ArrayMul, ArraySaturatingMul}; +use re_arrow2::datatypes::DataType; #[test] fn test_multiply_normal() { diff --git a/tests/it/compute/arithmetics/decimal/sub.rs b/tests/it/compute/arithmetics/decimal/sub.rs index 343149a5646..315dab499f4 100644 --- a/tests/it/compute/arithmetics/decimal/sub.rs +++ b/tests/it/compute/arithmetics/decimal/sub.rs @@ -1,9 +1,9 @@ #![allow(clippy::zero_prefixed_literal, clippy::inconsistent_digit_grouping)] -use arrow2::array::*; -use arrow2::compute::arithmetics::decimal::{adaptive_sub, checked_sub, saturating_sub, sub}; -use arrow2::compute::arithmetics::{ArrayCheckedSub, ArraySaturatingSub, ArraySub}; -use arrow2::datatypes::DataType; +use re_arrow2::array::*; +use re_arrow2::compute::arithmetics::decimal::{adaptive_sub, checked_sub, saturating_sub, sub}; +use re_arrow2::compute::arithmetics::{ArrayCheckedSub, ArraySaturatingSub, ArraySub}; +use re_arrow2::datatypes::DataType; #[test] fn test_subtract_normal() { diff --git a/tests/it/compute/arithmetics/mod.rs b/tests/it/compute/arithmetics/mod.rs index a7060ab3281..921f667a67b 100644 --- a/tests/it/compute/arithmetics/mod.rs +++ b/tests/it/compute/arithmetics/mod.rs @@ -2,11 +2,11 @@ mod basic; mod decimal; mod time; -use arrow2::array::*; -use arrow2::compute::arithmetics::*; -use arrow2::datatypes::DataType::*; -use arrow2::datatypes::{IntervalUnit, TimeUnit}; -use arrow2::scalar::PrimitiveScalar; +use re_arrow2::array::*; +use re_arrow2::compute::arithmetics::*; +use re_arrow2::datatypes::DataType::*; +use re_arrow2::datatypes::{IntervalUnit, TimeUnit}; +use re_arrow2::scalar::PrimitiveScalar; #[test] fn test_add() { diff --git a/tests/it/compute/arithmetics/time.rs b/tests/it/compute/arithmetics/time.rs index 2c4d8a4a023..6b4716952d7 100644 --- a/tests/it/compute/arithmetics/time.rs +++ b/tests/it/compute/arithmetics/time.rs @@ -1,8 +1,8 @@ -use arrow2::array::*; -use arrow2::compute::arithmetics::time::*; -use arrow2::datatypes::{DataType, TimeUnit}; -use arrow2::scalar::*; -use arrow2::types::months_days_ns; +use re_arrow2::array::*; +use re_arrow2::compute::arithmetics::time::*; +use re_arrow2::datatypes::{DataType, TimeUnit}; +use re_arrow2::scalar::*; +use re_arrow2::types::months_days_ns; #[test] fn test_adding_timestamp() { diff --git a/tests/it/compute/arity_assign.rs b/tests/it/compute/arity_assign.rs index b3581e2fa3e..b4826f6971d 100644 --- a/tests/it/compute/arity_assign.rs +++ b/tests/it/compute/arity_assign.rs @@ -1,5 +1,5 @@ -use arrow2::array::Int32Array; -use arrow2::compute::arity_assign::{binary, unary}; +use re_arrow2::array::Int32Array; +use re_arrow2::compute::arity_assign::{binary, unary}; #[test] fn test_unary_assign() { diff --git a/tests/it/compute/bitwise.rs b/tests/it/compute/bitwise.rs index 3d44e58f219..5edb1ad9b3a 100644 --- a/tests/it/compute/bitwise.rs +++ b/tests/it/compute/bitwise.rs @@ -1,5 +1,5 @@ -use arrow2::array::*; -use arrow2::compute::bitwise::*; +use re_arrow2::array::*; +use re_arrow2::compute::bitwise::*; #[test] fn test_xor() { diff --git a/tests/it/compute/boolean.rs b/tests/it/compute/boolean.rs index ae4c0fde85b..f1278139192 100644 --- a/tests/it/compute/boolean.rs +++ b/tests/it/compute/boolean.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::compute::boolean::*; -use arrow2::scalar::BooleanScalar; +use re_arrow2::array::*; +use re_arrow2::compute::boolean::*; +use re_arrow2::scalar::BooleanScalar; use std::iter::FromIterator; #[test] diff --git a/tests/it/compute/boolean_kleene.rs b/tests/it/compute/boolean_kleene.rs index 902e5b425ac..79a3004059f 100644 --- a/tests/it/compute/boolean_kleene.rs +++ b/tests/it/compute/boolean_kleene.rs @@ -1,6 +1,6 @@ -use arrow2::array::BooleanArray; -use arrow2::compute::boolean_kleene::*; -use arrow2::scalar::BooleanScalar; +use re_arrow2::array::BooleanArray; +use re_arrow2::compute::boolean_kleene::*; +use re_arrow2::scalar::BooleanScalar; #[test] fn and_generic() { diff --git a/tests/it/compute/cast.rs b/tests/it/compute/cast.rs index 7d91df863bb..415f09eacb2 100644 --- a/tests/it/compute/cast.rs +++ b/tests/it/compute/cast.rs @@ -1,10 +1,10 @@ use std::sync::Arc; -use arrow2::array::*; -use arrow2::compute::cast::{can_cast_types, cast, CastOptions}; -use arrow2::datatypes::DataType::LargeList; -use arrow2::datatypes::*; -use arrow2::types::{days_ms, months_days_ns, NativeType}; +use re_arrow2::array::*; +use re_arrow2::compute::cast::{can_cast_types, cast, CastOptions}; +use re_arrow2::datatypes::DataType::LargeList; +use re_arrow2::datatypes::*; +use re_arrow2::types::{days_ms, months_days_ns, NativeType}; #[test] fn i32_to_f64() { diff --git a/tests/it/compute/comparison.rs b/tests/it/compute/comparison.rs index 9e60fb071a4..d20ca74e252 100644 --- a/tests/it/compute/comparison.rs +++ b/tests/it/compute/comparison.rs @@ -1,14 +1,14 @@ use std::sync::Arc; -use arrow2::array::*; -use arrow2::bitmap::Bitmap; -use arrow2::compute::comparison::{self, boolean::*, primitive, utf8}; -use arrow2::datatypes::{DataType, DataType::*, IntegerType, IntervalUnit, TimeUnit}; -use arrow2::scalar::new_scalar; +use re_arrow2::array::*; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::compute::comparison::{self, boolean::*, primitive, utf8}; +use re_arrow2::datatypes::{DataType, DataType::*, IntegerType, IntervalUnit, TimeUnit}; +use re_arrow2::scalar::new_scalar; #[test] fn consistency() { - use arrow2::compute::comparison::*; + use re_arrow2::compute::comparison::*; let datatypes = vec![ Null, Boolean, @@ -387,12 +387,12 @@ fn primitive_gt_eq() { #[test] #[cfg(all(feature = "compute_cast", feature = "compute_boolean_kleene"))] fn utf8_and_validity() { - use arrow2::compute::cast::CastOptions; + use re_arrow2::compute::cast::CastOptions; let a1 = Utf8Array::::from([Some("0"), Some("1"), None, Some("2")]); let a2 = Int32Array::from([Some(0), Some(1), None, Some(2)]); // due to the cast the values underneath the validity bits differ - let a2 = arrow2::compute::cast::cast(&a2, &DataType::Utf8, CastOptions::default()).unwrap(); + let a2 = re_arrow2::compute::cast::cast(&a2, &DataType::Utf8, CastOptions::default()).unwrap(); let a2 = a2.as_any().downcast_ref::>().unwrap(); let expected = BooleanArray::from_slice([true, true, true, true]); diff --git a/tests/it/compute/concatenate.rs b/tests/it/compute/concatenate.rs index b5c5e52905f..f8f437edb32 100644 --- a/tests/it/compute/concatenate.rs +++ b/tests/it/compute/concatenate.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::compute::concatenate::concatenate; -use arrow2::error::Result; +use re_arrow2::array::*; +use re_arrow2::compute::concatenate::concatenate; +use re_arrow2::error::Result; #[test] fn empty_vec() { diff --git a/tests/it/compute/contains.rs b/tests/it/compute/contains.rs index cfbdd9946e0..475ad7565b1 100644 --- a/tests/it/compute/contains.rs +++ b/tests/it/compute/contains.rs @@ -1,5 +1,5 @@ -use arrow2::array::*; -use arrow2::compute::contains::contains; +use re_arrow2::array::*; +use re_arrow2::compute::contains::contains; // disable wrapping inside literal vectors used for test data and assertions #[rustfmt::skip::macros(vec)] diff --git a/tests/it/compute/filter.rs b/tests/it/compute/filter.rs index d1037643ef5..2ff734b3ba5 100644 --- a/tests/it/compute/filter.rs +++ b/tests/it/compute/filter.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::bitmap::Bitmap; -use arrow2::compute::filter::*; +use re_arrow2::array::*; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::compute::filter::*; #[test] fn array_slice() { diff --git a/tests/it/compute/hash.rs b/tests/it/compute/hash.rs index 92e263f235d..890c8e31e12 100644 --- a/tests/it/compute/hash.rs +++ b/tests/it/compute/hash.rs @@ -1,7 +1,7 @@ -use arrow2::array::new_null_array; -use arrow2::compute::hash::*; -use arrow2::datatypes::DataType::*; -use arrow2::datatypes::TimeUnit; +use re_arrow2::array::new_null_array; +use re_arrow2::compute::hash::*; +use re_arrow2::datatypes::DataType::*; +use re_arrow2::datatypes::TimeUnit; #[test] fn consistency() { diff --git a/tests/it/compute/if_then_else.rs b/tests/it/compute/if_then_else.rs index 842ac7374b6..fe42bf81d28 100644 --- a/tests/it/compute/if_then_else.rs +++ b/tests/it/compute/if_then_else.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::compute::if_then_else::if_then_else; -use arrow2::error::Result; +use re_arrow2::array::*; +use re_arrow2::compute::if_then_else::if_then_else; +use re_arrow2::error::Result; #[test] fn basics() -> Result<()> { diff --git a/tests/it/compute/length.rs b/tests/it/compute/length.rs index ed4ab83c9f2..cfdf83ed5a9 100644 --- a/tests/it/compute/length.rs +++ b/tests/it/compute/length.rs @@ -1,7 +1,7 @@ -use arrow2::array::*; -use arrow2::compute::length::*; -use arrow2::datatypes::*; -use arrow2::offset::Offset; +use re_arrow2::array::*; +use re_arrow2::compute::length::*; +use re_arrow2::datatypes::*; +use re_arrow2::offset::Offset; fn length_test_string() { vec![ @@ -43,7 +43,7 @@ fn utf8() { #[test] fn consistency() { - use arrow2::datatypes::DataType::*; + use re_arrow2::datatypes::DataType::*; let datatypes = vec![ Null, diff --git a/tests/it/compute/like.rs b/tests/it/compute/like.rs index 8b99beb0818..88a267dc3a9 100644 --- a/tests/it/compute/like.rs +++ b/tests/it/compute/like.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::compute::like::*; -use arrow2::error::Result; +use re_arrow2::array::*; +use re_arrow2::compute::like::*; +use re_arrow2::error::Result; #[test] fn test_like_binary() -> Result<()> { diff --git a/tests/it/compute/limit.rs b/tests/it/compute/limit.rs index 545d546fe3e..81652562a64 100644 --- a/tests/it/compute/limit.rs +++ b/tests/it/compute/limit.rs @@ -1,5 +1,5 @@ -use arrow2::array::*; -use arrow2::compute::limit::limit; +use re_arrow2::array::*; +use re_arrow2::compute::limit::limit; #[test] fn limit_array() { diff --git a/tests/it/compute/merge_sort.rs b/tests/it/compute/merge_sort.rs index 54b90233e53..ed167415a34 100644 --- a/tests/it/compute/merge_sort.rs +++ b/tests/it/compute/merge_sort.rs @@ -1,9 +1,9 @@ use std::iter::once; -use arrow2::array::*; -use arrow2::compute::merge_sort::*; -use arrow2::compute::sort::sort; -use arrow2::error::Result; +use re_arrow2::array::*; +use re_arrow2::compute::merge_sort::*; +use re_arrow2::compute::sort::sort; +use re_arrow2::error::Result; #[test] fn merge_u32() -> Result<()> { diff --git a/tests/it/compute/partition.rs b/tests/it/compute/partition.rs index 1e064633197..f51eb73f585 100644 --- a/tests/it/compute/partition.rs +++ b/tests/it/compute/partition.rs @@ -1,8 +1,8 @@ -use arrow2::array::*; -use arrow2::compute::partition::*; -use arrow2::compute::sort::{SortColumn, SortOptions}; -use arrow2::datatypes::DataType; -use arrow2::error::Result; +use re_arrow2::array::*; +use re_arrow2::compute::partition::*; +use re_arrow2::compute::sort::{SortColumn, SortOptions}; +use re_arrow2::datatypes::DataType; +use re_arrow2::error::Result; #[test] fn lexicographical_partition_ranges_empty() { diff --git a/tests/it/compute/regex_match.rs b/tests/it/compute/regex_match.rs index 66f28d03b9b..2f968416689 100644 --- a/tests/it/compute/regex_match.rs +++ b/tests/it/compute/regex_match.rs @@ -1,7 +1,7 @@ -use arrow2::array::{BooleanArray, Utf8Array}; -use arrow2::compute::regex_match::*; -use arrow2::error::Result; -use arrow2::offset::Offset; +use re_arrow2::array::{BooleanArray, Utf8Array}; +use re_arrow2::compute::regex_match::*; +use re_arrow2::error::Result; +use re_arrow2::offset::Offset; fn test_generic, &Utf8Array) -> Result>( lhs: Vec<&str>, diff --git a/tests/it/compute/sort/lex_sort.rs b/tests/it/compute/sort/lex_sort.rs index 8cefae1dd87..9ee7aa63d60 100644 --- a/tests/it/compute/sort/lex_sort.rs +++ b/tests/it/compute/sort/lex_sort.rs @@ -1,5 +1,5 @@ -use arrow2::array::*; -use arrow2::compute::sort::{lexsort, SortColumn, SortOptions}; +use re_arrow2::array::*; +use re_arrow2::compute::sort::{lexsort, SortColumn, SortOptions}; fn test_lex_sort_arrays(input: Vec, expected: Vec>) { let sorted = lexsort::(&input, None).unwrap(); diff --git a/tests/it/compute/sort/mod.rs b/tests/it/compute/sort/mod.rs index 736cfbadba2..4798a780e28 100644 --- a/tests/it/compute/sort/mod.rs +++ b/tests/it/compute/sort/mod.rs @@ -1,10 +1,10 @@ mod lex_sort; mod row; -use arrow2::array::*; -use arrow2::compute::sort::*; -use arrow2::datatypes::*; -use arrow2::types::NativeType; +use re_arrow2::array::*; +use re_arrow2::compute::sort::*; +use re_arrow2::datatypes::*; +use re_arrow2::types::NativeType; fn to_indices_boolean_arrays(data: &[Option], options: SortOptions, expected_data: &[i32]) { let output = BooleanArray::from(data); @@ -550,9 +550,9 @@ fn test_lex_sort_unaligned_rows() { #[test] fn consistency() { - use arrow2::array::new_null_array; - use arrow2::datatypes::DataType::*; - use arrow2::datatypes::TimeUnit; + use re_arrow2::array::new_null_array; + use re_arrow2::datatypes::DataType::*; + use re_arrow2::datatypes::TimeUnit; let datatypes = vec![ Null, diff --git a/tests/it/compute/sort/row/mod.rs b/tests/it/compute/sort/row/mod.rs index 4ec7617b265..7d5824e7e88 100644 --- a/tests/it/compute/sort/row/mod.rs +++ b/tests/it/compute/sort/row/mod.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use arrow2::{ +use re_arrow2::{ array::{ Array, BinaryArray, BooleanArray, DictionaryArray, Float32Array, Int128Array, Int16Array, Int256Array, Int32Array, MutableDictionaryArray, MutablePrimitiveArray, MutableUtf8Array, diff --git a/tests/it/compute/substring.rs b/tests/it/compute/substring.rs index 13ae035d23b..932f1920455 100644 --- a/tests/it/compute/substring.rs +++ b/tests/it/compute/substring.rs @@ -1,4 +1,4 @@ -use arrow2::{array::*, compute::substring::*, error::Result, offset::Offset}; +use re_arrow2::{array::*, compute::substring::*, error::Result, offset::Offset}; fn with_nulls_utf8() -> Result<()> { let cases = vec![ @@ -298,8 +298,8 @@ fn without_nulls_large_binary() -> Result<()> { #[test] fn consistency() { - use arrow2::datatypes::DataType::*; - use arrow2::datatypes::TimeUnit; + use re_arrow2::datatypes::DataType::*; + use re_arrow2::datatypes::TimeUnit; let datatypes = vec![ Null, Boolean, diff --git a/tests/it/compute/take.rs b/tests/it/compute/take.rs index 54899f92f84..79e4cea4b37 100644 --- a/tests/it/compute/take.rs +++ b/tests/it/compute/take.rs @@ -1,8 +1,8 @@ -use arrow2::compute::take::{can_take, take}; -use arrow2::datatypes::{DataType, Field, IntervalUnit}; -use arrow2::error::Result; -use arrow2::{array::*, bitmap::MutableBitmap, types::NativeType}; -use arrow2::{bitmap::Bitmap, buffer::Buffer}; +use re_arrow2::compute::take::{can_take, take}; +use re_arrow2::datatypes::{DataType, Field, IntervalUnit}; +use re_arrow2::error::Result; +use re_arrow2::{array::*, bitmap::MutableBitmap, types::NativeType}; +use re_arrow2::{bitmap::Bitmap, buffer::Buffer}; fn test_take_primitive( data: &[Option], @@ -102,9 +102,9 @@ fn test_struct_with_nulls() { #[test] fn consistency() { - use arrow2::array::new_null_array; - use arrow2::datatypes::DataType::*; - use arrow2::datatypes::TimeUnit; + use re_arrow2::array::new_null_array; + use re_arrow2::datatypes::DataType::*; + use re_arrow2::datatypes::TimeUnit; let datatypes = vec![ Null, diff --git a/tests/it/compute/temporal.rs b/tests/it/compute/temporal.rs index 25792b8dd74..16f6bbff572 100644 --- a/tests/it/compute/temporal.rs +++ b/tests/it/compute/temporal.rs @@ -1,8 +1,8 @@ use std::sync::Arc; -use arrow2::array::*; -use arrow2::compute::temporal::*; -use arrow2::datatypes::*; +use re_arrow2::array::*; +use re_arrow2::compute::temporal::*; +use re_arrow2::datatypes::*; macro_rules! temporal_test { ($func:ident, $extract:ident, $data_types:path) => { @@ -331,11 +331,11 @@ fn consistency_iso_week() { consistency_check(can_iso_week, iso_week); } -fn consistency_check( +fn consistency_check( can_extract: fn(&DataType) -> bool, - extract: fn(&dyn Array) -> arrow2::error::Result>, + extract: fn(&dyn Array) -> re_arrow2::error::Result>, ) { - use arrow2::datatypes::DataType::*; + use re_arrow2::datatypes::DataType::*; let datatypes = vec![ Null, diff --git a/tests/it/compute/utf8.rs b/tests/it/compute/utf8.rs index 21b89aac3ba..ee192ab5e57 100644 --- a/tests/it/compute/utf8.rs +++ b/tests/it/compute/utf8.rs @@ -1,4 +1,4 @@ -use arrow2::{array::*, compute::utf8::*, error::Result, offset::Offset}; +use re_arrow2::{array::*, compute::utf8::*, error::Result, offset::Offset}; fn with_nulls_utf8_lower() -> Result<()> { let cases = vec![ @@ -140,8 +140,8 @@ fn without_nulls_large_string_lower() -> Result<()> { #[test] fn consistency_lower() { - use arrow2::datatypes::DataType::*; - use arrow2::datatypes::TimeUnit; + use re_arrow2::datatypes::DataType::*; + use re_arrow2::datatypes::TimeUnit; let datatypes = vec![ Null, Boolean, @@ -325,8 +325,8 @@ fn without_nulls_large_string() -> Result<()> { #[test] fn consistency_upper() { - use arrow2::datatypes::DataType::*; - use arrow2::datatypes::TimeUnit; + use re_arrow2::datatypes::DataType::*; + use re_arrow2::datatypes::TimeUnit; let datatypes = vec![ Null, Boolean, diff --git a/tests/it/compute/window.rs b/tests/it/compute/window.rs index c89706a05f9..6b3a4b082bd 100644 --- a/tests/it/compute/window.rs +++ b/tests/it/compute/window.rs @@ -1,6 +1,6 @@ -use arrow2::array::{new_null_array, Int32Array}; -use arrow2::compute::window::*; -use arrow2::datatypes::DataType; +use re_arrow2::array::{new_null_array, Int32Array}; +use re_arrow2::compute::window::*; +use re_arrow2::datatypes::DataType; #[test] fn shift_pos() { diff --git a/tests/it/ffi/data.rs b/tests/it/ffi/data.rs index b0a02561f12..31bacb83878 100644 --- a/tests/it/ffi/data.rs +++ b/tests/it/ffi/data.rs @@ -1,7 +1,7 @@ -use arrow2::array::*; -use arrow2::bitmap::Bitmap; -use arrow2::datatypes::{DataType, Field, TimeUnit}; -use arrow2::{error::Result, ffi}; +use re_arrow2::array::*; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::datatypes::{DataType, Field, TimeUnit}; +use re_arrow2::{error::Result, ffi}; use std::collections::BTreeMap; use std::sync::Arc; diff --git a/tests/it/ffi/mod.rs b/tests/it/ffi/mod.rs index 5a06722bb83..7e9cbb62da9 100644 --- a/tests/it/ffi/mod.rs +++ b/tests/it/ffi/mod.rs @@ -4,7 +4,7 @@ mod stream; #[test] fn mmap_slice() { let slice = &[1, 2, 3]; - let array = unsafe { arrow2::ffi::mmap::slice(slice) }; + let array = unsafe { re_arrow2::ffi::mmap::slice(slice) }; assert_eq!(array.values().as_ref(), &[1, 2, 3]); // note: when `slice` is dropped, array must be dropped as-well since by construction of `slice` they share their lifetimes. } @@ -12,7 +12,7 @@ fn mmap_slice() { #[test] fn mmap_bitmap() { let slice = &[123u8, 255]; - let array = unsafe { arrow2::ffi::mmap::bitmap(slice, 2, 14) }.unwrap(); + let array = unsafe { re_arrow2::ffi::mmap::bitmap(slice, 2, 14) }.unwrap(); assert_eq!( array.values_iter().collect::>(), &[false, true, true, true, true, false, true, true, true, true, true, true, true, true] diff --git a/tests/it/ffi/stream.rs b/tests/it/ffi/stream.rs index 53887d4362f..51ab7b5f670 100644 --- a/tests/it/ffi/stream.rs +++ b/tests/it/ffi/stream.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::datatypes::Field; -use arrow2::{error::Error, error::Result, ffi}; +use re_arrow2::array::*; +use re_arrow2::datatypes::Field; +use re_arrow2::{error::Error, error::Result, ffi}; fn _test_round_trip(arrays: Vec>) -> Result<()> { let field = Field::new("a", arrays[0].data_type().clone(), true); diff --git a/tests/it/io/avro/read.rs b/tests/it/io/avro/read.rs index b81c2a72e88..f59bb041ff4 100644 --- a/tests/it/io/avro/read.rs +++ b/tests/it/io/avro/read.rs @@ -1,15 +1,15 @@ use std::sync::Arc; -use arrow2::chunk::Chunk; use avro_rs::types::{Record, Value}; use avro_rs::{Codec, Writer}; use avro_rs::{Days, Decimal, Duration, Millis, Months, Schema as AvroSchema}; +use re_arrow2::chunk::Chunk; -use arrow2::array::*; -use arrow2::datatypes::*; -use arrow2::error::Result; -use arrow2::io::avro::avro_schema::read::read_metadata; -use arrow2::io::avro::read; +use re_arrow2::array::*; +use re_arrow2::datatypes::*; +use re_arrow2::error::Result; +use re_arrow2::io::avro::avro_schema::read::read_metadata; +use re_arrow2::io::avro::read; pub(super) fn schema() -> (AvroSchema, Schema) { let raw_schema = r#" diff --git a/tests/it/io/avro/read_async.rs b/tests/it/io/avro/read_async.rs index 6a6b09ac9f6..4d12ef6f48a 100644 --- a/tests/it/io/avro/read_async.rs +++ b/tests/it/io/avro/read_async.rs @@ -3,9 +3,9 @@ use avro_rs::Codec; use futures::pin_mut; use futures::StreamExt; -use arrow2::error::Result; -use arrow2::io::avro::avro_schema::read_async::{block_stream, read_metadata}; -use arrow2::io::avro::read; +use re_arrow2::error::Result; +use re_arrow2::io::avro::avro_schema::read_async::{block_stream, read_metadata}; +use re_arrow2::io::avro::read; use super::read::{schema, write_avro}; diff --git a/tests/it/io/avro/write.rs b/tests/it/io/avro/write.rs index 7fe4bcd57b0..9c1552bfe71 100644 --- a/tests/it/io/avro/write.rs +++ b/tests/it/io/avro/write.rs @@ -1,14 +1,14 @@ use std::sync::Arc; -use arrow2::array::*; -use arrow2::chunk::Chunk; -use arrow2::datatypes::*; -use arrow2::error::Result; -use arrow2::io::avro::avro_schema::file::{Block, CompressedBlock, Compression}; -use arrow2::io::avro::avro_schema::write::{compress, write_block, write_metadata}; -use arrow2::io::avro::write; -use arrow2::types::months_days_ns; use avro_schema::schema::{Field as AvroField, Record, Schema as AvroSchema}; +use re_arrow2::array::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::*; +use re_arrow2::error::Result; +use re_arrow2::io::avro::avro_schema::file::{Block, CompressedBlock, Compression}; +use re_arrow2::io::avro::avro_schema::write::{compress, write_block, write_metadata}; +use re_arrow2::io::avro::write; +use re_arrow2::types::months_days_ns; use super::read::read_avro; diff --git a/tests/it/io/avro/write_async.rs b/tests/it/io/avro/write_async.rs index b98071accbc..054e21ea7d1 100644 --- a/tests/it/io/avro/write_async.rs +++ b/tests/it/io/avro/write_async.rs @@ -1,10 +1,10 @@ -use arrow2::array::*; -use arrow2::chunk::Chunk; -use arrow2::datatypes::*; -use arrow2::error::Result; -use arrow2::io::avro::avro_schema::file::Compression; -use arrow2::io::avro::avro_schema::write_async::{write_block, write_metadata}; -use arrow2::io::avro::write; +use re_arrow2::array::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::*; +use re_arrow2::error::Result; +use re_arrow2::io::avro::avro_schema::file::Compression; +use re_arrow2::io::avro::avro_schema::write_async::{write_block, write_metadata}; +use re_arrow2::io::avro::write; use super::read::read_avro; use super::write::{data, schema, serialize_to_block}; diff --git a/tests/it/io/csv/read.rs b/tests/it/io/csv/read.rs index 083b1805910..9d31d6e6ada 100644 --- a/tests/it/io/csv/read.rs +++ b/tests/it/io/csv/read.rs @@ -2,10 +2,10 @@ use proptest::prelude::*; use std::io::Cursor; -use arrow2::array::*; -use arrow2::datatypes::*; -use arrow2::error::Result; -use arrow2::io::csv::read::*; +use re_arrow2::array::*; +use re_arrow2::datatypes::*; +use re_arrow2::error::Result; +use re_arrow2::io::csv::read::*; #[test] fn read() -> Result<()> { diff --git a/tests/it/io/csv/read_async.rs b/tests/it/io/csv/read_async.rs index a31319cc117..f761668b997 100644 --- a/tests/it/io/csv/read_async.rs +++ b/tests/it/io/csv/read_async.rs @@ -1,8 +1,8 @@ use futures::io::Cursor; -use arrow2::array::*; -use arrow2::error::Result; -use arrow2::io::csv::read_async::*; +use re_arrow2::array::*; +use re_arrow2::error::Result; +use re_arrow2::io::csv::read_async::*; #[tokio::test] async fn read() -> Result<()> { diff --git a/tests/it/io/csv/write.rs b/tests/it/io/csv/write.rs index 8527a5da895..aa4858c3414 100644 --- a/tests/it/io/csv/write.rs +++ b/tests/it/io/csv/write.rs @@ -1,10 +1,10 @@ use std::io::Cursor; -use arrow2::array::*; -use arrow2::chunk::Chunk; -use arrow2::datatypes::*; -use arrow2::error::Result; -use arrow2::io::csv::write::*; +use re_arrow2::array::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::*; +use re_arrow2::error::Result; +use re_arrow2::io::csv::write::*; fn data() -> Chunk> { let c1 = Utf8Array::::from_slice(["a b", "c", "d"]); diff --git a/tests/it/io/flight/mod.rs b/tests/it/io/flight/mod.rs index 9718b749027..306c0f8c1af 100644 --- a/tests/it/io/flight/mod.rs +++ b/tests/it/io/flight/mod.rs @@ -1,10 +1,10 @@ -use arrow2::array::Array; -use arrow2::chunk::Chunk; -use arrow2::datatypes::Schema; -use arrow2::error::Error; +use re_arrow2::array::Array; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::Schema; +use re_arrow2::error::Error; -use arrow2::io::flight::*; -use arrow2::io::ipc::write::{default_ipc_fields, WriteOptions}; +use re_arrow2::io::flight::*; +use re_arrow2::io::ipc::write::{default_ipc_fields, WriteOptions}; use super::ipc::read_gzip_json; diff --git a/tests/it/io/ipc/common.rs b/tests/it/io/ipc/common.rs index a0889670f3e..9d2e6e9828e 100644 --- a/tests/it/io/ipc/common.rs +++ b/tests/it/io/ipc/common.rs @@ -1,7 +1,7 @@ use ahash::AHashMap; use std::{fs::File, io::Read}; -use arrow2::{ +use re_arrow2::{ array::Array, chunk::Chunk, datatypes::Schema, error::Result, io::ipc::read::read_stream_metadata, io::ipc::read::StreamReader, io::ipc::IpcField, io::json_integration::read, io::json_integration::ArrowJson, diff --git a/tests/it/io/ipc/mmap.rs b/tests/it/io/ipc/mmap.rs index 7e9533c1c7d..573bd2a0365 100644 --- a/tests/it/io/ipc/mmap.rs +++ b/tests/it/io/ipc/mmap.rs @@ -1,8 +1,8 @@ -use arrow2::array::*; -use arrow2::chunk::Chunk; -use arrow2::datatypes::{DataType, Field, Schema}; -use arrow2::error::Result; -use arrow2::io::ipc::read::read_file_metadata; +use re_arrow2::array::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::{DataType, Field, Schema}; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read::read_file_metadata; use std::sync::Arc; use super::write::file::write; @@ -16,9 +16,9 @@ fn round_trip(array: Box) -> Result<()> { let metadata = read_file_metadata(&mut std::io::Cursor::new(data.as_ref()))?; let dictionaries = - unsafe { arrow2::mmap::mmap_dictionaries_unchecked(&metadata, data.clone())? }; + unsafe { re_arrow2::mmap::mmap_dictionaries_unchecked(&metadata, data.clone())? }; - let new_array = unsafe { arrow2::mmap::mmap_unchecked(&metadata, &dictionaries, data, 0)? }; + let new_array = unsafe { re_arrow2::mmap::mmap_unchecked(&metadata, &dictionaries, data, 0)? }; assert_eq!(new_array.into_arrays()[0], array); Ok(()) } diff --git a/tests/it/io/ipc/read/file.rs b/tests/it/io/ipc/read/file.rs index 663bae0dcc1..5b786c838b2 100644 --- a/tests/it/io/ipc/read/file.rs +++ b/tests/it/io/ipc/read/file.rs @@ -1,8 +1,8 @@ use std::fs::File; -use arrow2::chunk::Chunk; -use arrow2::error::Result; -use arrow2::io::ipc::read::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read::*; use super::super::common::read_gzip_json; diff --git a/tests/it/io/ipc/read/stream.rs b/tests/it/io/ipc/read/stream.rs index 404954c3e48..66debd43018 100644 --- a/tests/it/io/ipc/read/stream.rs +++ b/tests/it/io/ipc/read/stream.rs @@ -1,8 +1,8 @@ -use arrow2::chunk::Chunk; +use re_arrow2::chunk::Chunk; use std::fs::File; -use arrow2::error::Result; -use arrow2::io::ipc::read::*; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read::*; use crate::io::ipc::common::read_gzip_json; diff --git a/tests/it/io/ipc/read_file_async.rs b/tests/it/io/ipc/read_file_async.rs index 8b74e6592c4..602cc47ad83 100644 --- a/tests/it/io/ipc/read_file_async.rs +++ b/tests/it/io/ipc/read_file_async.rs @@ -2,8 +2,8 @@ use futures::StreamExt; use tokio::fs::File; use tokio_util::compat::*; -use arrow2::error::Result; -use arrow2::io::ipc::read::file_async::*; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read::file_async::*; use crate::io::ipc::common::read_gzip_json; diff --git a/tests/it/io/ipc/read_stream_async.rs b/tests/it/io/ipc/read_stream_async.rs index bb248932e9a..fa5a4cbc45b 100644 --- a/tests/it/io/ipc/read_stream_async.rs +++ b/tests/it/io/ipc/read_stream_async.rs @@ -2,8 +2,8 @@ use futures::StreamExt; use tokio::fs::File; use tokio_util::compat::*; -use arrow2::error::Result; -use arrow2::io::ipc::read::stream_async::*; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read::stream_async::*; use crate::io::ipc::common::read_gzip_json; diff --git a/tests/it/io/ipc/write/file.rs b/tests/it/io/ipc/write/file.rs index 5562f803c50..b1dee02b122 100644 --- a/tests/it/io/ipc/write/file.rs +++ b/tests/it/io/ipc/write/file.rs @@ -1,12 +1,12 @@ use std::io::Cursor; -use arrow2::array::*; -use arrow2::chunk::Chunk; -use arrow2::datatypes::{Field, Schema}; -use arrow2::error::Result; -use arrow2::io::ipc::read::{read_file_metadata, FileReader}; -use arrow2::io::ipc::{write::*, IpcField}; -use arrow2::types::{i256, months_days_ns}; +use re_arrow2::array::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::{Field, Schema}; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read::{read_file_metadata, FileReader}; +use re_arrow2::io::ipc::{write::*, IpcField}; +use re_arrow2::types::{i256, months_days_ns}; use crate::io::ipc::common::read_gzip_json; diff --git a/tests/it/io/ipc/write/file_append.rs b/tests/it/io/ipc/write/file_append.rs index 52edde06d24..3bf71c8a5e9 100644 --- a/tests/it/io/ipc/write/file_append.rs +++ b/tests/it/io/ipc/write/file_append.rs @@ -1,9 +1,9 @@ -use arrow2::array::*; -use arrow2::chunk::Chunk; -use arrow2::datatypes::*; -use arrow2::error::Result; -use arrow2::io::ipc::read; -use arrow2::io::ipc::write::{FileWriter, WriteOptions}; +use re_arrow2::array::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::*; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read; +use re_arrow2::io::ipc::write::{FileWriter, WriteOptions}; use super::file::write; diff --git a/tests/it/io/ipc/write/stream.rs b/tests/it/io/ipc/write/stream.rs index 092e4402b7d..539495fc1da 100644 --- a/tests/it/io/ipc/write/stream.rs +++ b/tests/it/io/ipc/write/stream.rs @@ -1,13 +1,13 @@ use std::io::Cursor; -use arrow2::array::Array; -use arrow2::chunk::Chunk; -use arrow2::datatypes::Schema; -use arrow2::error::Result; -use arrow2::io::ipc::read::read_stream_metadata; -use arrow2::io::ipc::read::StreamReader; -use arrow2::io::ipc::write::{StreamWriter, WriteOptions}; -use arrow2::io::ipc::IpcField; +use re_arrow2::array::Array; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::Schema; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read::read_stream_metadata; +use re_arrow2::io::ipc::read::StreamReader; +use re_arrow2::io::ipc::write::{StreamWriter, WriteOptions}; +use re_arrow2::io::ipc::IpcField; use crate::io::ipc::common::read_arrow_stream; use crate::io::ipc::common::read_gzip_json; diff --git a/tests/it/io/ipc/write_file_async.rs b/tests/it/io/ipc/write_file_async.rs index d510f20ba25..7f27dde6cb9 100644 --- a/tests/it/io/ipc/write_file_async.rs +++ b/tests/it/io/ipc/write_file_async.rs @@ -1,15 +1,15 @@ use std::io::Cursor; -use arrow2::array::Array; -use arrow2::chunk::Chunk; -use arrow2::datatypes::Schema; -use arrow2::error::Result; -use arrow2::io::ipc::read; -use arrow2::io::ipc::write::file_async::FileSink; -use arrow2::io::ipc::write::WriteOptions; -use arrow2::io::ipc::IpcField; use futures::io::Cursor as AsyncCursor; use futures::SinkExt; +use re_arrow2::array::Array; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::Schema; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read; +use re_arrow2::io::ipc::write::file_async::FileSink; +use re_arrow2::io::ipc::write::WriteOptions; +use re_arrow2::io::ipc::IpcField; use crate::io::ipc::common::read_arrow_stream; use crate::io::ipc::common::read_gzip_json; diff --git a/tests/it/io/ipc/write_stream_async.rs b/tests/it/io/ipc/write_stream_async.rs index 12669bdd59e..051c46772a7 100644 --- a/tests/it/io/ipc/write_stream_async.rs +++ b/tests/it/io/ipc/write_stream_async.rs @@ -1,15 +1,15 @@ use std::io::Cursor; -use arrow2::array::Array; -use arrow2::chunk::Chunk; -use arrow2::datatypes::Schema; -use arrow2::error::Result; -use arrow2::io::ipc::read; -use arrow2::io::ipc::write::stream_async; -use arrow2::io::ipc::write::stream_async::StreamSink; -use arrow2::io::ipc::IpcField; use futures::io::Cursor as AsyncCursor; use futures::SinkExt; +use re_arrow2::array::Array; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::Schema; +use re_arrow2::error::Result; +use re_arrow2::io::ipc::read; +use re_arrow2::io::ipc::write::stream_async; +use re_arrow2::io::ipc::write::stream_async::StreamSink; +use re_arrow2::io::ipc::IpcField; use crate::io::ipc::common::read_arrow_stream; use crate::io::ipc::common::read_gzip_json; diff --git a/tests/it/io/json/mod.rs b/tests/it/io/json/mod.rs index 59a68f8dd86..a79620337f2 100644 --- a/tests/it/io/json/mod.rs +++ b/tests/it/io/json/mod.rs @@ -1,11 +1,11 @@ mod read; mod write; -use arrow2::array::*; -use arrow2::chunk::Chunk; -use arrow2::datatypes::Schema; -use arrow2::error::Result; -use arrow2::io::json::write as json_write; +use re_arrow2::array::*; +use re_arrow2::chunk::Chunk; +use re_arrow2::datatypes::Schema; +use re_arrow2::error::Result; +use re_arrow2::io::json::write as json_write; fn write_batch(array: Box) -> Result> { let mut serializer = json_write::Serializer::new(vec![Ok(array)].into_iter(), vec![]); diff --git a/tests/it/io/json/read.rs b/tests/it/io/json/read.rs index da43cebdfac..5929eb6b719 100644 --- a/tests/it/io/json/read.rs +++ b/tests/it/io/json/read.rs @@ -1,9 +1,9 @@ use std::sync::Arc; -use arrow2::array::*; -use arrow2::datatypes::*; -use arrow2::error::Result; -use arrow2::io::json::read; +use re_arrow2::array::*; +use re_arrow2::datatypes::*; +use re_arrow2::error::Result; +use re_arrow2::io::json::read; #[test] fn read_json() -> Result<()> { diff --git a/tests/it/io/json/write.rs b/tests/it/io/json/write.rs index fd44020e9fe..9b252100f1f 100644 --- a/tests/it/io/json/write.rs +++ b/tests/it/io/json/write.rs @@ -1,7 +1,7 @@ use std::sync::Arc; -use arrow2::datatypes::IntegerType; -use arrow2::{ +use re_arrow2::datatypes::IntegerType; +use re_arrow2::{ array::*, bitmap::Bitmap, buffer::Buffer, diff --git a/tests/it/io/ndjson/mod.rs b/tests/it/io/ndjson/mod.rs index 124fa1a6552..353b4a2f5ec 100644 --- a/tests/it/io/ndjson/mod.rs +++ b/tests/it/io/ndjson/mod.rs @@ -2,11 +2,11 @@ mod read; use std::sync::Arc; -use arrow2::array::*; -use arrow2::bitmap::Bitmap; -use arrow2::datatypes::*; -use arrow2::error::Result; -use arrow2::io::ndjson::write as ndjson_write; +use re_arrow2::array::*; +use re_arrow2::bitmap::Bitmap; +use re_arrow2::datatypes::*; +use re_arrow2::error::Result; +use re_arrow2::io::ndjson::write as ndjson_write; use read::{infer, read_and_deserialize}; diff --git a/tests/it/io/ndjson/read.rs b/tests/it/io/ndjson/read.rs index 9d85f1f51e4..92cec5c1331 100644 --- a/tests/it/io/ndjson/read.rs +++ b/tests/it/io/ndjson/read.rs @@ -1,11 +1,11 @@ use std::io::Cursor; use std::sync::Arc; -use arrow2::array::*; -use arrow2::datatypes::{DataType, Field}; -use arrow2::error::{Error, Result}; -use arrow2::io::ndjson::read as ndjson_read; -use arrow2::io::ndjson::read::FallibleStreamingIterator; +use re_arrow2::array::*; +use re_arrow2::datatypes::{DataType, Field}; +use re_arrow2::error::{Error, Result}; +use re_arrow2::io::ndjson::read as ndjson_read; +use re_arrow2::io::ndjson::read::FallibleStreamingIterator; use super::*; diff --git a/tests/it/io/orc/read.rs b/tests/it/io/orc/read.rs index a35c54d34e6..21cfc9771fd 100644 --- a/tests/it/io/orc/read.rs +++ b/tests/it/io/orc/read.rs @@ -1,6 +1,6 @@ -use arrow2::array::*; -use arrow2::error::Error; -use arrow2::io::orc::{format, read}; +use re_arrow2::array::*; +use re_arrow2::error::Error; +use re_arrow2::io::orc::{format, read}; #[test] fn infer() -> Result<(), Error> { diff --git a/tests/it/io/parquet/deserialize.rs b/tests/it/io/parquet/deserialize.rs index 3ea1c2846e2..0f846cfa971 100644 --- a/tests/it/io/parquet/deserialize.rs +++ b/tests/it/io/parquet/deserialize.rs @@ -1,6 +1,6 @@ use std::fs::File; -use arrow2::{ +use re_arrow2::{ array::StructArray, datatypes::DataType, error::Result, diff --git a/tests/it/io/parquet/integration.rs b/tests/it/io/parquet/integration.rs index 7f84c433b0d..de37a7a8b92 100644 --- a/tests/it/io/parquet/integration.rs +++ b/tests/it/io/parquet/integration.rs @@ -1,4 +1,4 @@ -use arrow2::error::Result; +use re_arrow2::error::Result; use super::{integration_read, integration_write}; use crate::io::ipc::read_gzip_json; diff --git a/tests/it/io/parquet/mod.rs b/tests/it/io/parquet/mod.rs index c4eb2a007f6..73e45a3860b 100644 --- a/tests/it/io/parquet/mod.rs +++ b/tests/it/io/parquet/mod.rs @@ -2,8 +2,8 @@ use ethnum::AsI256; use std::io::{Cursor, Read, Seek}; use std::sync::Arc; -use arrow2::types::i256; -use arrow2::{ +use re_arrow2::types::i256; +use re_arrow2::{ array::*, bitmap::Bitmap, chunk::Chunk, diff --git a/tests/it/io/parquet/read.rs b/tests/it/io/parquet/read.rs index 12512116f41..51f89a75f13 100644 --- a/tests/it/io/parquet/read.rs +++ b/tests/it/io/parquet/read.rs @@ -1,8 +1,8 @@ use std::fs::File; -use arrow2::array::*; -use arrow2::error::*; -use arrow2::io::parquet::read::*; +use re_arrow2::array::*; +use re_arrow2::error::*; +use re_arrow2::io::parquet::read::*; use super::*; @@ -894,10 +894,10 @@ fn read_int96_timestamps() -> Result<()> { let parse = |time_unit: TimeUnit| { let mut reader = Cursor::new(timestamp_data); let metadata = read_metadata(&mut reader)?; - let schema = arrow2::datatypes::Schema { - fields: vec![arrow2::datatypes::Field::new( + let schema = re_arrow2::datatypes::Schema { + fields: vec![re_arrow2::datatypes::Field::new( "timestamps", - arrow2::datatypes::DataType::Timestamp(time_unit, None), + re_arrow2::datatypes::DataType::Timestamp(time_unit, None), false, )], metadata: BTreeMap::new(), @@ -910,13 +910,13 @@ fn read_int96_timestamps() -> Result<()> { // Timestamp(TimeUnit::Nanoseconds) and will cause a panic in dev builds/overflow in release builds // However, the code should work for the Microsecond/Millisecond time units for time_unit in [ - arrow2::datatypes::TimeUnit::Microsecond, - arrow2::datatypes::TimeUnit::Millisecond, - arrow2::datatypes::TimeUnit::Second, + re_arrow2::datatypes::TimeUnit::Microsecond, + re_arrow2::datatypes::TimeUnit::Millisecond, + re_arrow2::datatypes::TimeUnit::Second, ] { parse(time_unit).expect("Should not error"); } - std::panic::catch_unwind(|| parse(arrow2::datatypes::TimeUnit::Nanosecond)) + std::panic::catch_unwind(|| parse(re_arrow2::datatypes::TimeUnit::Nanosecond)) .expect_err("Should be a panic error"); Ok(()) diff --git a/tests/it/io/parquet/read_indexes.rs b/tests/it/io/parquet/read_indexes.rs index 4e41bb2baf6..c60342c8388 100644 --- a/tests/it/io/parquet/read_indexes.rs +++ b/tests/it/io/parquet/read_indexes.rs @@ -1,9 +1,11 @@ use std::io::Cursor; -use arrow2::chunk::Chunk; -use arrow2::error::Error; -use arrow2::io::parquet::read::indexes; -use arrow2::{array::*, datatypes::*, error::Result, io::parquet::read::*, io::parquet::write::*}; +use re_arrow2::chunk::Chunk; +use re_arrow2::error::Error; +use re_arrow2::io::parquet::read::indexes; +use re_arrow2::{ + array::*, datatypes::*, error::Result, io::parquet::read::*, io::parquet::write::*, +}; /// Returns 2 sets of pages with different the same number of rows distributed un-evenly fn pages(arrays: &[&dyn Array], encoding: Encoding) -> Result<(Vec, Vec, Schema)> { diff --git a/tests/it/io/parquet/sample_tests.rs b/tests/it/io/parquet/sample_tests.rs index 959f1201283..60b037fb885 100644 --- a/tests/it/io/parquet/sample_tests.rs +++ b/tests/it/io/parquet/sample_tests.rs @@ -1,5 +1,5 @@ -use arrow2::io::parquet::write::*; -use arrow2::{ +use re_arrow2::io::parquet::write::*; +use re_arrow2::{ chunk::Chunk, datatypes::{Field, Metadata, Schema}, error::Result, diff --git a/tests/it/io/parquet/write.rs b/tests/it/io/parquet/write.rs index dee5b8e2536..8023284f436 100644 --- a/tests/it/io/parquet/write.rs +++ b/tests/it/io/parquet/write.rs @@ -1,7 +1,7 @@ use std::io::Cursor; -use arrow2::error::Result; -use arrow2::io::parquet::write::*; +use re_arrow2::error::Result; +use re_arrow2::io::parquet::write::*; use super::*; diff --git a/tests/it/io/parquet/write_async.rs b/tests/it/io/parquet/write_async.rs index 1197e31c0da..7f2f3479535 100644 --- a/tests/it/io/parquet/write_async.rs +++ b/tests/it/io/parquet/write_async.rs @@ -1,5 +1,6 @@ use ahash::AHashMap; -use arrow2::{ +use futures::{future::BoxFuture, io::Cursor, SinkExt}; +use re_arrow2::{ array::{Float32Array, Int32Array}, chunk::Chunk, datatypes::{DataType, Field, Schema}, @@ -9,7 +10,6 @@ use arrow2::{ write::{CompressionOptions, Encoding, Version, WriteOptions}, }, }; -use futures::{future::BoxFuture, io::Cursor, SinkExt}; use super::FileSink; diff --git a/tests/it/io/print.rs b/tests/it/io/print.rs index 9ff261f9daf..f733a09a744 100644 --- a/tests/it/io/print.rs +++ b/tests/it/io/print.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::*, bitmap::Bitmap, buffer::Buffer, diff --git a/tests/it/scalar/binary.rs b/tests/it/scalar/binary.rs index ee71b20ba5b..e488db41412 100644 --- a/tests/it/scalar/binary.rs +++ b/tests/it/scalar/binary.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ datatypes::DataType, scalar::{BinaryScalar, Scalar}, }; diff --git a/tests/it/scalar/boolean.rs b/tests/it/scalar/boolean.rs index 9882e5a77ee..4e70748760b 100644 --- a/tests/it/scalar/boolean.rs +++ b/tests/it/scalar/boolean.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ datatypes::DataType, scalar::{BooleanScalar, Scalar}, }; diff --git a/tests/it/scalar/fixed_size_binary.rs b/tests/it/scalar/fixed_size_binary.rs index 3962c390180..b9d2cf04be6 100644 --- a/tests/it/scalar/fixed_size_binary.rs +++ b/tests/it/scalar/fixed_size_binary.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ datatypes::DataType, scalar::{FixedSizeBinaryScalar, Scalar}, }; diff --git a/tests/it/scalar/fixed_size_list.rs b/tests/it/scalar/fixed_size_list.rs index 65f646466ef..d06c22529b4 100644 --- a/tests/it/scalar/fixed_size_list.rs +++ b/tests/it/scalar/fixed_size_list.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::BooleanArray, datatypes::{DataType, Field}, scalar::{FixedSizeListScalar, Scalar}, diff --git a/tests/it/scalar/list.rs b/tests/it/scalar/list.rs index ad2eed126d2..47aef678c24 100644 --- a/tests/it/scalar/list.rs +++ b/tests/it/scalar/list.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ array::BooleanArray, datatypes::{DataType, Field}, scalar::{ListScalar, Scalar}, diff --git a/tests/it/scalar/map.rs b/tests/it/scalar/map.rs index b8fc5cd9601..c4a4b8453f8 100644 --- a/tests/it/scalar/map.rs +++ b/tests/it/scalar/map.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use arrow2::{ +use re_arrow2::{ array::{BooleanArray, StructArray, Utf8Array}, datatypes::{DataType, Field}, scalar::{MapScalar, Scalar}, diff --git a/tests/it/scalar/mod.rs b/tests/it/scalar/mod.rs index 5dd1568f6d1..66608c453ed 100644 --- a/tests/it/scalar/mod.rs +++ b/tests/it/scalar/mod.rs @@ -12,5 +12,5 @@ mod utf8; // check that `PartialEq` can be derived #[derive(PartialEq)] struct A { - array: Box, + array: Box, } diff --git a/tests/it/scalar/null.rs b/tests/it/scalar/null.rs index 685b237b803..4a593327322 100644 --- a/tests/it/scalar/null.rs +++ b/tests/it/scalar/null.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ datatypes::DataType, scalar::{NullScalar, Scalar}, }; diff --git a/tests/it/scalar/primitive.rs b/tests/it/scalar/primitive.rs index 8769af7cd75..bba069efd56 100644 --- a/tests/it/scalar/primitive.rs +++ b/tests/it/scalar/primitive.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ datatypes::DataType, scalar::{PrimitiveScalar, Scalar}, }; diff --git a/tests/it/scalar/struct_.rs b/tests/it/scalar/struct_.rs index 46839d3bc45..f90d97211e9 100644 --- a/tests/it/scalar/struct_.rs +++ b/tests/it/scalar/struct_.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use arrow2::{ +use re_arrow2::{ datatypes::{DataType, Field}, scalar::{BooleanScalar, Scalar, StructScalar}, }; diff --git a/tests/it/scalar/utf8.rs b/tests/it/scalar/utf8.rs index 6c844e01f0d..d74c9a0e5fe 100644 --- a/tests/it/scalar/utf8.rs +++ b/tests/it/scalar/utf8.rs @@ -1,4 +1,4 @@ -use arrow2::{ +use re_arrow2::{ datatypes::DataType, scalar::{Scalar, Utf8Scalar}, }; diff --git a/tests/it/temporal_conversions.rs b/tests/it/temporal_conversions.rs index a5a2f094cf7..0afa9e2e01e 100644 --- a/tests/it/temporal_conversions.rs +++ b/tests/it/temporal_conversions.rs @@ -1,7 +1,7 @@ -use arrow2::array::*; -use arrow2::datatypes::TimeUnit; -use arrow2::temporal_conversions; -use arrow2::types::months_days_ns; +use re_arrow2::array::*; +use re_arrow2::datatypes::TimeUnit; +use re_arrow2::temporal_conversions; +use re_arrow2::types::months_days_ns; use std::sync::Arc; use chrono::NaiveDateTime; diff --git a/tests/it/types.rs b/tests/it/types.rs index ee337e901fb..a7e60b32b2f 100644 --- a/tests/it/types.rs +++ b/tests/it/types.rs @@ -1,4 +1,4 @@ -use arrow2::types::{days_ms, months_days_ns, BitChunkIter, BitChunkOnes, NativeType}; +use re_arrow2::types::{days_ms, months_days_ns, BitChunkIter, BitChunkOnes, NativeType}; #[test] fn test_basic1() {