Skip to content

Commit abb954a

Browse files
jimexistjimexist
committed
move more type references
1 parent de4421a commit abb954a

File tree

29 files changed

+1082
-230
lines changed

29 files changed

+1082
-230
lines changed

‎datafusion-physical-expr/src/coercion_rule/binary_rule.rs‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -493,8 +493,9 @@ fn eq_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<DataType> {
493493
#[cfg(test)]
494494
mod tests {
495495
use super::*;
496-
use crate::error::{DataFusionError, Result};
497496
use arrow::datatypes::DataType;
497+
use datafusion_common::DataFusionError;
498+
use datafusion_common::Result;
498499
use datafusion_expr::Operator;
499500

500501
#[test]

‎datafusion-physical-expr/src/coercion_rule/mod.rs‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,5 +20,4 @@
2020
//! Aggregate function rule
2121
//! Binary operation rule
2222
23-
pub mod aggregate_rule;
2423
pub mod binary_rule;

‎datafusion-physical-expr/src/expressions/array_agg.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -158,18 +158,18 @@ impl Accumulator for ArrayAggAccumulator {
158158
#[cfg(test)]
159159
mod tests {
160160
use super::*;
161+
use crate::expressions::col;
161162
use crate::expressions::tests::aggregate;
162-
use crate::from_slice::FromSlice;
163-
use crate::{error::Result, generic_test_op};
163+
use crate::generic_test_op;
164164
use arrow::array::ArrayRef;
165165
use arrow::array::Int32Array;
166166
use arrow::datatypes::*;
167167
use arrow::record_batch::RecordBatch;
168-
use datafusion_expr::col;
168+
use datafusion_common::Result;
169169

170170
#[test]
171171
fn array_agg_i32() -> Result<()> {
172-
let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5]));
172+
let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5]));
173173

174174
let list = ScalarValue::List(
175175
Some(Box::new(vec![

‎datafusion-physical-expr/src/expressions/average.rs‎

Lines changed: 10 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -216,11 +216,11 @@ impl Accumulator for AvgAccumulator {
216216
#[cfg(test)]
217217
mod tests {
218218
use super::*;
219-
use crate::from_slice::FromSlice;
220-
use crate::{error::Result, generic_test_op};
219+
use crate::expressions::col;
220+
use crate::generic_test_op;
221221
use arrow::record_batch::RecordBatch;
222222
use arrow::{array::*, datatypes::*};
223-
use datafusion_expr::col;
223+
use datafusion_common::Result;
224224

225225
#[test]
226226
fn test_avg_return_data_type() -> Result<()> {
@@ -291,7 +291,7 @@ mod tests {
291291

292292
#[test]
293293
fn avg_i32() -> Result<()> {
294-
let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5]));
294+
let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5]));
295295
generic_test_op!(
296296
a,
297297
DataType::Int32,
@@ -333,9 +333,8 @@ mod tests {
333333

334334
#[test]
335335
fn avg_u32() -> Result<()> {
336-
let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[
337-
1_u32, 2_u32, 3_u32, 4_u32, 5_u32,
338-
]));
336+
let a: ArrayRef =
337+
Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32]));
339338
generic_test_op!(
340339
a,
341340
DataType::UInt32,
@@ -347,9 +346,8 @@ mod tests {
347346

348347
#[test]
349348
fn avg_f32() -> Result<()> {
350-
let a: ArrayRef = Arc::new(Float32Array::from_slice(&[
351-
1_f32, 2_f32, 3_f32, 4_f32, 5_f32,
352-
]));
349+
let a: ArrayRef =
350+
Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32]));
353351
generic_test_op!(
354352
a,
355353
DataType::Float32,
@@ -361,9 +359,8 @@ mod tests {
361359

362360
#[test]
363361
fn avg_f64() -> Result<()> {
364-
let a: ArrayRef = Arc::new(Float64Array::from_slice(&[
365-
1_f64, 2_f64, 3_f64, 4_f64, 5_f64,
366-
]));
362+
let a: ArrayRef =
363+
Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64]));
367364
generic_test_op!(
368365
a,
369366
DataType::Float64,

‎datafusion-physical-expr/src/expressions/binary.rs‎

Lines changed: 21 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1377,8 +1377,7 @@ pub fn binary(
13771377
mod tests {
13781378
use super::*;
13791379
use crate::expressions::{col, lit};
1380-
use crate::from_slice::FromSlice;
1381-
use arrow::datatypes::{ArrowNumericType, Field, Int32Type, SchemaRef};
1380+
use arrow::datatypes::{ArrowNumericType, Field, Int32Type, SchemaRef};
13821381
use arrow::util::display::array_value_to_string;
13831382
use datafusion_common::Result;
13841383

@@ -1399,8 +1398,8 @@ mod tests {
13991398
Field::new("a", DataType::Int32, false),
14001399
Field::new("b", DataType::Int32, false),
14011400
]);
1402-
let a = Int32Array::from_slice(&[1, 2, 3, 4, 5]);
1403-
let b = Int32Array::from_slice(&[1, 2, 4, 8, 16]);
1401+
let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
1402+
let b = Int32Array::from(vec![1, 2, 4, 8, 16]);
14041403

14051404
// expression: "a < b"
14061405
let lt = binary_simple(
@@ -1433,8 +1432,8 @@ mod tests {
14331432
Field::new("a", DataType::Int32, false),
14341433
Field::new("b", DataType::Int32, false),
14351434
]);
1436-
let a = Int32Array::from_slice(&[2, 4, 6, 8, 10]);
1437-
let b = Int32Array::from_slice(&[2, 5, 4, 8, 8]);
1435+
let a = Int32Array::from(vec![2, 4, 6, 8, 10]);
1436+
let b = Int32Array::from(vec![2, 5, 4, 8, 8]);
14381437

14391438
// expression: "a < b OR a == b"
14401439
let expr = binary_simple(
@@ -1832,14 +1831,14 @@ mod tests {
18321831
Field::new("a", DataType::Int32, false),
18331832
Field::new("b", DataType::Int32, false),
18341833
]);
1835-
let a = Int32Array::from_slice(&[1, 2, 3, 4, 5]);
1836-
let b = Int32Array::from_slice(&[1, 2, 4, 8, 16]);
1834+
let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
1835+
let b = Int32Array::from(vec![1, 2, 4, 8, 16]);
18371836

18381837
apply_arithmetic::<Int32Type>(
18391838
Arc::new(schema),
18401839
vec![Arc::new(a), Arc::new(b)],
18411840
Operator::Plus,
1842-
Int32Array::from_slice(&[2, 4, 7, 12, 21]),
1841+
Int32Array::from(vec![2, 4, 7, 12, 21]),
18431842
)?;
18441843

18451844
Ok(())
@@ -1851,22 +1850,22 @@ mod tests {
18511850
Field::new("a", DataType::Int32, false),
18521851
Field::new("b", DataType::Int32, false),
18531852
]));
1854-
let a = Arc::new(Int32Array::from_slice(&[1, 2, 4, 8, 16]));
1855-
let b = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5]));
1853+
let a = Arc::new(Int32Array::from(vec![1, 2, 4, 8, 16]));
1854+
let b = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5]));
18561855

18571856
apply_arithmetic::<Int32Type>(
18581857
schema.clone(),
18591858
vec![a.clone(), b.clone()],
18601859
Operator::Minus,
1861-
Int32Array::from_slice(&[0, 0, 1, 4, 11]),
1860+
Int32Array::from(vec![0, 0, 1, 4, 11]),
18621861
)?;
18631862

18641863
// should handle have negative values in result (for signed)
18651864
apply_arithmetic::<Int32Type>(
18661865
schema,
18671866
vec![b, a],
18681867
Operator::Minus,
1869-
Int32Array::from_slice(&[0, 0, -1, -4, -11]),
1868+
Int32Array::from(vec![0, 0, -1, -4, -11]),
18701869
)?;
18711870

18721871
Ok(())
@@ -1878,14 +1877,14 @@ mod tests {
18781877
Field::new("a", DataType::Int32, false),
18791878
Field::new("b", DataType::Int32, false),
18801879
]));
1881-
let a = Arc::new(Int32Array::from_slice(&[4, 8, 16, 32, 64]));
1882-
let b = Arc::new(Int32Array::from_slice(&[2, 4, 8, 16, 32]));
1880+
let a = Arc::new(Int32Array::from(vec![4, 8, 16, 32, 64]));
1881+
let b = Arc::new(Int32Array::from(vec![2, 4, 8, 16, 32]));
18831882

18841883
apply_arithmetic::<Int32Type>(
18851884
schema,
18861885
vec![a, b],
18871886
Operator::Multiply,
1888-
Int32Array::from_slice(&[8, 32, 128, 512, 2048]),
1887+
Int32Array::from(vec![8, 32, 128, 512, 2048]),
18891888
)?;
18901889

18911890
Ok(())
@@ -1897,14 +1896,14 @@ mod tests {
18971896
Field::new("a", DataType::Int32, false),
18981897
Field::new("b", DataType::Int32, false),
18991898
]));
1900-
let a = Arc::new(Int32Array::from_slice(&[8, 32, 128, 512, 2048]));
1901-
let b = Arc::new(Int32Array::from_slice(&[2, 4, 8, 16, 32]));
1899+
let a = Arc::new(Int32Array::from(vec![8, 32, 128, 512, 2048]));
1900+
let b = Arc::new(Int32Array::from(vec![2, 4, 8, 16, 32]));
19021901

19031902
apply_arithmetic::<Int32Type>(
19041903
schema,
19051904
vec![a, b],
19061905
Operator::Divide,
1907-
Int32Array::from_slice(&[4, 8, 16, 32, 64]),
1906+
Int32Array::from(vec![4, 8, 16, 32, 64]),
19081907
)?;
19091908

19101909
Ok(())
@@ -1916,14 +1915,14 @@ mod tests {
19161915
Field::new("a", DataType::Int32, false),
19171916
Field::new("b", DataType::Int32, false),
19181917
]));
1919-
let a = Arc::new(Int32Array::from_slice(&[8, 32, 128, 512, 2048]));
1920-
let b = Arc::new(Int32Array::from_slice(&[2, 4, 7, 14, 32]));
1918+
let a = Arc::new(Int32Array::from(vec![8, 32, 128, 512, 2048]));
1919+
let b = Arc::new(Int32Array::from(vec![2, 4, 7, 14, 32]));
19211920

19221921
apply_arithmetic::<Int32Type>(
19231922
schema,
19241923
vec![a, b],
19251924
Operator::Modulo,
1926-
Int32Array::from_slice(&[0, 0, 2, 8, 0]),
1925+
Int32Array::from(vec![0, 0, 2, 8, 0]),
19271926
)?;
19281927

19291928
Ok(())

‎datafusion-physical-expr/src/expressions/case.rs‎

Lines changed: 4 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -455,14 +455,12 @@ pub fn case(
455455
#[cfg(test)]
456456
mod tests {
457457
use super::*;
458-
use crate::{
459-
error::Result,
460-
physical_plan::expressions::{binary, col, lit},
461-
scalar::ScalarValue,
462-
};
458+
use crate::expressions::binary;
459+
use crate::expressions::col;
460+
use crate::expressions::lit;
463461
use arrow::array::StringArray;
464462
use arrow::datatypes::*;
465-
use datafusion_expr::col;
463+
use datafusion_common::ScalarValue;
466464
use datafusion_expr::Operator;
467465

468466
#[test]

‎datafusion-physical-expr/src/expressions/cast.rs‎

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,6 @@ use std::any::Any;
1919
use std::fmt;
2020
use std::sync::Arc;
2121

22-
use super::ColumnarValue;
2322
use crate::PhysicalExpr;
2423
use arrow::compute;
2524
use arrow::compute::kernels;
@@ -29,6 +28,7 @@ use arrow::record_batch::RecordBatch;
2928
use compute::can_cast_types;
3029
use datafusion_common::ScalarValue;
3130
use datafusion_common::{DataFusionError, Result};
31+
use datafusion_expr::ColumnarValue;
3232

3333
/// provide Datafusion default cast options
3434
pub const DEFAULT_DATAFUSION_CAST_OPTIONS: CastOptions = CastOptions { safe: false };
@@ -158,7 +158,7 @@ pub fn cast(
158158
#[cfg(test)]
159159
mod tests {
160160
use super::*;
161-
use crate::from_slice::FromSlice;
161+
use crate::expressions::col;
162162
use arrow::{
163163
array::{
164164
Array, DecimalArray, DecimalBuilder, Float32Array, Float64Array, Int16Array,
@@ -168,7 +168,6 @@ mod tests {
168168
datatypes::*,
169169
};
170170
use datafusion_common::Result;
171-
use datafusion_expr::col;
172171

173172
// runs an end-to-end test of physical type cast
174173
// 1. construct a record batch with a column "a" of type A
@@ -621,7 +620,7 @@ mod tests {
621620
fn invalid_cast_with_options_error() -> Result<()> {
622621
// Ensure a useful error happens at plan time if invalid casts are used
623622
let schema = Schema::new(vec![Field::new("a", DataType::Utf8, false)]);
624-
let a = StringArray::from_slice(&["9.1"]);
623+
let a = StringArray::from(vec!["9.1"]);
625624
let batch = RecordBatch::try_new(Arc::new(schema.clone()), vec![Arc::new(a)])?;
626625
let expression = cast_with_options(
627626
col("a", &schema)?,

‎datafusion-physical-expr/src/expressions/correlation.rs‎

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -228,16 +228,16 @@ impl Accumulator for CorrelationAccumulator {
228228
#[cfg(test)]
229229
mod tests {
230230
use super::*;
231-
use crate::from_slice::FromSlice;
232-
use crate::{error::Result, generic_test_op2};
231+
use crate::expressions::col;
232+
use crate::generic_test_op2;
233233
use arrow::record_batch::RecordBatch;
234234
use arrow::{array::*, datatypes::*};
235-
use datafusion_expr::col;
235+
use datafusion_common::Result;
236236

237237
#[test]
238238
fn correlation_f64_1() -> Result<()> {
239-
let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64]));
240-
let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 7_f64]));
239+
let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64]));
240+
let b: ArrayRef = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 7_f64]));
241241

242242
generic_test_op2!(
243243
a,
@@ -252,8 +252,8 @@ mod tests {
252252

253253
#[test]
254254
fn correlation_f64_2() -> Result<()> {
255-
let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64]));
256-
let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4_f64, -5_f64, 6_f64]));
255+
let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64]));
256+
let b: ArrayRef = Arc::new(Float64Array::from(vec![4_f64, -5_f64, 6_f64]));
257257

258258
generic_test_op2!(
259259
a,
@@ -268,8 +268,8 @@ mod tests {
268268

269269
#[test]
270270
fn correlation_f64_4() -> Result<()> {
271-
let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64]));
272-
let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4.1_f64, 5_f64, 6_f64]));
271+
let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64]));
272+
let b: ArrayRef = Arc::new(Float64Array::from(vec![4.1_f64, 5_f64, 6_f64]));
273273

274274
generic_test_op2!(
275275
a,
@@ -304,8 +304,8 @@ mod tests {
304304

305305
#[test]
306306
fn correlation_i32() -> Result<()> {
307-
let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3]));
308-
let b: ArrayRef = Arc::new(Int32Array::from_slice(&[4, 5, 6]));
307+
let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3]));
308+
let b: ArrayRef = Arc::new(Int32Array::from(vec![4, 5, 6]));
309309

310310
generic_test_op2!(
311311
a,
@@ -320,8 +320,8 @@ mod tests {
320320

321321
#[test]
322322
fn correlation_u32() -> Result<()> {
323-
let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[1_u32, 2_u32, 3_u32]));
324-
let b: ArrayRef = Arc::new(UInt32Array::from_slice(&[4_u32, 5_u32, 6_u32]));
323+
let a: ArrayRef = Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32]));
324+
let b: ArrayRef = Arc::new(UInt32Array::from(vec![4_u32, 5_u32, 6_u32]));
325325
generic_test_op2!(
326326
a,
327327
b,
@@ -335,8 +335,8 @@ mod tests {
335335

336336
#[test]
337337
fn correlation_f32() -> Result<()> {
338-
let a: ArrayRef = Arc::new(Float32Array::from_slice(&[1_f32, 2_f32, 3_f32]));
339-
let b: ArrayRef = Arc::new(Float32Array::from_slice(&[4_f32, 5_f32, 6_f32]));
338+
let a: ArrayRef = Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32]));
339+
let b: ArrayRef = Arc::new(Float32Array::from(vec![4_f32, 5_f32, 6_f32]));
340340
generic_test_op2!(
341341
a,
342342
b,
@@ -425,10 +425,10 @@ mod tests {
425425

426426
#[test]
427427
fn correlation_f64_merge_1() -> Result<()> {
428-
let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64]));
429-
let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64]));
430-
let c = Arc::new(Float64Array::from_slice(&[1.1_f64, 2.2_f64, 3.3_f64]));
431-
let d = Arc::new(Float64Array::from_slice(&[4.4_f64, 5.5_f64, 9.9_f64]));
428+
let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64]));
429+
let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64]));
430+
let c = Arc::new(Float64Array::from(vec![1.1_f64, 2.2_f64, 3.3_f64]));
431+
let d = Arc::new(Float64Array::from(vec![4.4_f64, 5.5_f64, 9.9_f64]));
432432

433433
let schema = Schema::new(vec![
434434
Field::new("a", DataType::Float64, false),
@@ -460,8 +460,8 @@ mod tests {
460460

461461
#[test]
462462
fn correlation_f64_merge_2() -> Result<()> {
463-
let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64]));
464-
let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64]));
463+
let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64]));
464+
let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64]));
465465
let c = Arc::new(Float64Array::from(vec![None]));
466466
let d = Arc::new(Float64Array::from(vec![None]));
467467

0 commit comments

Comments
 (0)