From 802501ad74fbbb127a81bbab53c05ab9ba94bcb4 Mon Sep 17 00:00:00 2001 From: Nicolas Trinquier Date: Sat, 16 Feb 2019 01:11:26 +0100 Subject: [PATCH 1/4] :xImplement Debug for PrimitiveArrays --- rust/arrow/src/array.rs | 59 +++++++++++++++++++++++++++++++++++++ rust/arrow/src/datatypes.rs | 5 +++- 2 files changed, 63 insertions(+), 1 deletion(-) diff --git a/rust/arrow/src/array.rs b/rust/arrow/src/array.rs index c887ab7a68e..f4b3bf1c83b 100644 --- a/rust/arrow/src/array.rs +++ b/rust/arrow/src/array.rs @@ -56,6 +56,7 @@ use std::any::Any; use std::convert::From; +use std::fmt; use std::io::Write; use std::mem; use std::sync::Arc; @@ -248,6 +249,25 @@ impl PrimitiveArray { } } +impl fmt::Debug for PrimitiveArray { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "PrimitiveArray<{:?}> {{ len: {:?}, values: [", + T::get_data_type(), + self.len() + ) + .unwrap(); + for i in 0..self.len() { + write!(f, "{:?}", self.value(i)).unwrap(); + if i != self.len() - 1 { + write!(f, ", ").unwrap(); + } + } + write!(f, "] }}") + } +} + /// Specific implementation for Boolean arrays due to bit-packing impl PrimitiveArray { pub fn new(length: usize, values: Buffer, null_count: usize, offset: usize) -> Self { @@ -280,6 +300,25 @@ impl PrimitiveArray { } } +impl fmt::Debug for PrimitiveArray { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "PrimitiveArray<{:?}> {{ len: {:?}, values: [", + BooleanType::get_data_type(), + self.len() + ) + .unwrap(); + for i in 0..self.len() { + write!(f, "{:?}", self.value(i)).unwrap(); + if i != self.len() - 1 { + write!(f, ", ").unwrap(); + } + } + write!(f, "] }}") + } +} + // TODO: the macro is needed here because we'd get "conflicting implementations" error // otherwise with both `From>` and `From>>`. // We should revisit this in future. @@ -761,6 +800,26 @@ mod tests { let _slice = arr.value_slice(0, 4); } + #[test] + fn test_int32_fmt_debug() { + let buf = Buffer::from(&[0, 1, 2, 3, 4].to_byte_slice()); + let arr = Int32Array::new(5, buf, 0, 0); + assert_eq!( + "PrimitiveArray { len: 5, values: [0, 1, 2, 3, 4] }", + format!("{:?}", arr) + ); + } + + #[test] + fn test_boolean_fmt_debug() { + let buf = Buffer::from(&[true, false, false].to_byte_slice()); + let arr = BooleanArray::new(3, buf, 0, 0); + assert_eq!( + "PrimitiveArray { len: 3, values: [true, false, false] }", + format!("{:?}", arr) + ); + } + #[test] fn test_primitive_array_builder() { // Test building an primitive array with ArrayData builder and offset diff --git a/rust/arrow/src/datatypes.rs b/rust/arrow/src/datatypes.rs index 36f73414f46..4dc55d66ecb 100644 --- a/rust/arrow/src/datatypes.rs +++ b/rust/arrow/src/datatypes.rs @@ -96,7 +96,10 @@ pub struct Field { nullable: bool, } -pub trait ArrowNativeType: Send + Sync + Copy + PartialOrd + FromStr + 'static {} +pub trait ArrowNativeType: + fmt::Debug + Send + Sync + Copy + PartialOrd + FromStr + 'static +{ +} /// Trait indicating a primitive fixed-width type (bool, ints and floats). pub trait ArrowPrimitiveType: 'static { From c0e7d551a88386232d7877c3c1c387996760918a Mon Sep 17 00:00:00 2001 From: Nicolas Trinquier Date: Sat, 16 Feb 2019 15:29:19 +0100 Subject: [PATCH 2/4] Handle null case --- rust/arrow/src/array.rs | 38 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 36 insertions(+), 2 deletions(-) diff --git a/rust/arrow/src/array.rs b/rust/arrow/src/array.rs index f4b3bf1c83b..49016abb2e8 100644 --- a/rust/arrow/src/array.rs +++ b/rust/arrow/src/array.rs @@ -259,7 +259,11 @@ impl fmt::Debug for PrimitiveArray { ) .unwrap(); for i in 0..self.len() { - write!(f, "{:?}", self.value(i)).unwrap(); + if self.is_null(i) { + write!(f, "null").unwrap(); + } else { + write!(f, "{:?}", self.value(i)).unwrap(); + } if i != self.len() - 1 { write!(f, ", ").unwrap(); } @@ -310,7 +314,11 @@ impl fmt::Debug for PrimitiveArray { ) .unwrap(); for i in 0..self.len() { - write!(f, "{:?}", self.value(i)).unwrap(); + if self.is_null(i) { + write!(f, "null").unwrap(); + } else { + write!(f, "{:?}", self.value(i)).unwrap(); + } if i != self.len() - 1 { write!(f, ", ").unwrap(); } @@ -810,6 +818,19 @@ mod tests { ); } + #[test] + fn test_int32_with_null_fmt_debug() { + let mut builder = Int32Array::builder(3); + builder.append_slice(&[0, 1]).unwrap(); + builder.append_null().unwrap(); + builder.append_slice(&[3, 4]).unwrap(); + let arr = builder.finish(); + assert_eq!( + "PrimitiveArray { len: 5, values: [0, 1, null, 3, 4] }", + format!("{:?}", arr) + ); + } + #[test] fn test_boolean_fmt_debug() { let buf = Buffer::from(&[true, false, false].to_byte_slice()); @@ -820,6 +841,19 @@ mod tests { ); } + #[test] + fn test_boolean_with_null_fmt_debug() { + let mut builder = BooleanArray::builder(3); + builder.append_value(true).unwrap(); + builder.append_null().unwrap(); + builder.append_value(false).unwrap(); + let arr = builder.finish(); + assert_eq!( + "PrimitiveArray { len: 3, values: [true, null, false] }", + format!("{:?}", arr) + ); + } + #[test] fn test_primitive_array_builder() { // Test building an primitive array with ArrayData builder and offset From bceddd01ef4c329fd04f58d9f624c57c417f39a9 Mon Sep 17 00:00:00 2001 From: Nicolas Trinquier Date: Sat, 16 Feb 2019 22:23:00 +0100 Subject: [PATCH 3/4] Display arrays vertically --- rust/arrow/src/array.rs | 42 ++++++++++++----------------------------- 1 file changed, 12 insertions(+), 30 deletions(-) diff --git a/rust/arrow/src/array.rs b/rust/arrow/src/array.rs index 49016abb2e8..205739a611c 100644 --- a/rust/arrow/src/array.rs +++ b/rust/arrow/src/array.rs @@ -251,24 +251,15 @@ impl PrimitiveArray { impl fmt::Debug for PrimitiveArray { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "PrimitiveArray<{:?}> {{ len: {:?}, values: [", - T::get_data_type(), - self.len() - ) - .unwrap(); + write!(f, "PrimitiveArray<{:?}>\n[\n", T::get_data_type()).unwrap(); for i in 0..self.len() { if self.is_null(i) { - write!(f, "null").unwrap(); + write!(f, " null,\n").unwrap(); } else { - write!(f, "{:?}", self.value(i)).unwrap(); - } - if i != self.len() - 1 { - write!(f, ", ").unwrap(); + write!(f, " {:?},\n", self.value(i)).unwrap(); } } - write!(f, "] }}") + write!(f, "]") } } @@ -306,24 +297,15 @@ impl PrimitiveArray { impl fmt::Debug for PrimitiveArray { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "PrimitiveArray<{:?}> {{ len: {:?}, values: [", - BooleanType::get_data_type(), - self.len() - ) - .unwrap(); + write!(f, "PrimitiveArray<{:?}>\n[\n", BooleanType::get_data_type()).unwrap(); for i in 0..self.len() { if self.is_null(i) { - write!(f, "null").unwrap(); + write!(f, " null,\n").unwrap(); } else { - write!(f, "{:?}", self.value(i)).unwrap(); - } - if i != self.len() - 1 { - write!(f, ", ").unwrap(); + write!(f, " {:?},\n", self.value(i)).unwrap(); } } - write!(f, "] }}") + write!(f, "]") } } @@ -813,7 +795,7 @@ mod tests { let buf = Buffer::from(&[0, 1, 2, 3, 4].to_byte_slice()); let arr = Int32Array::new(5, buf, 0, 0); assert_eq!( - "PrimitiveArray { len: 5, values: [0, 1, 2, 3, 4] }", + "PrimitiveArray\n[\n 0,\n 1,\n 2,\n 3,\n 4,\n]", format!("{:?}", arr) ); } @@ -826,7 +808,7 @@ mod tests { builder.append_slice(&[3, 4]).unwrap(); let arr = builder.finish(); assert_eq!( - "PrimitiveArray { len: 5, values: [0, 1, null, 3, 4] }", + "PrimitiveArray\n[\n 0,\n 1,\n null,\n 3,\n 4,\n]", format!("{:?}", arr) ); } @@ -836,7 +818,7 @@ mod tests { let buf = Buffer::from(&[true, false, false].to_byte_slice()); let arr = BooleanArray::new(3, buf, 0, 0); assert_eq!( - "PrimitiveArray { len: 3, values: [true, false, false] }", + "PrimitiveArray\n[\n true,\n false,\n false,\n]", format!("{:?}", arr) ); } @@ -849,7 +831,7 @@ mod tests { builder.append_value(false).unwrap(); let arr = builder.finish(); assert_eq!( - "PrimitiveArray { len: 3, values: [true, null, false] }", + "PrimitiveArray\n[\n true,\n null,\n false,\n]", format!("{:?}", arr) ); } From 0dbf90cd7cfd066a0e14029e6886c2bdc783408d Mon Sep 17 00:00:00 2001 From: Nicolas Trinquier Date: Sat, 16 Feb 2019 22:48:32 +0100 Subject: [PATCH 4/4] Propagate Err --- rust/arrow/src/array.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/rust/arrow/src/array.rs b/rust/arrow/src/array.rs index 205739a611c..dc0a5090ee8 100644 --- a/rust/arrow/src/array.rs +++ b/rust/arrow/src/array.rs @@ -251,12 +251,12 @@ impl PrimitiveArray { impl fmt::Debug for PrimitiveArray { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "PrimitiveArray<{:?}>\n[\n", T::get_data_type()).unwrap(); + write!(f, "PrimitiveArray<{:?}>\n[\n", T::get_data_type())?; for i in 0..self.len() { if self.is_null(i) { - write!(f, " null,\n").unwrap(); + write!(f, " null,\n")?; } else { - write!(f, " {:?},\n", self.value(i)).unwrap(); + write!(f, " {:?},\n", self.value(i))?; } } write!(f, "]") @@ -297,12 +297,12 @@ impl PrimitiveArray { impl fmt::Debug for PrimitiveArray { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "PrimitiveArray<{:?}>\n[\n", BooleanType::get_data_type()).unwrap(); + write!(f, "PrimitiveArray<{:?}>\n[\n", BooleanType::get_data_type())?; for i in 0..self.len() { if self.is_null(i) { - write!(f, " null,\n").unwrap(); + write!(f, " null,\n")? } else { - write!(f, " {:?},\n", self.value(i)).unwrap(); + write!(f, " {:?},\n", self.value(i))? } } write!(f, "]")