Improve the display of interval types

[alamb]

Is your feature request related to a problem or challenge? Please describe what you are trying to do.

Today if an interval like -3 MONTH is parsed into an IntervalArray and then displayed using https://docs.rs/arrow/latest/arrow/util/display/fn.array_value_to_string.html the output is correct but overly verbose:

0 YEARS -3 MONS 0 DAYS 0 HOURS 0 MINS 0.000000000 SECS

Describe the solution you'd like

It would be nice if the displayed version was closer to the original input and did not print out fields with 0 values explicitly. For the example above, it would be great to look more like

-3 MONS

Describe alternatives you've considered

@goldmedal implemented some version of this code as part of a DataFusion PR here
apache/datafusion@9ae676c that might be a reasonable implementation to start from:

Any real representation should avoid allocating vec![] and strings (via format!)

            ScalarValue::IntervalMonthDayNano(Some(i)) => {
                let mut s = vec![];
                if i.months != 0 {
                    s.push(format!("{} MONTH", i.months));
                }
                if i.days != 0 {
                    s.push(format!("{} DAY", i.days));
                }
                if i.nanoseconds != 0 {
                    s.push(Self::process_interval_nanosecond(i.nanoseconds));
                }

                let interval = Interval {
                    value: Box::new(ast::Expr::Value(SingleQuotedString(s.join(" ")))),
                    leading_field: None,
                    leading_precision: None,
                    last_field: None,
                    fractional_seconds_precision: None,
                };
                Ok(ast::Expr::Interval(interval))

And

        let mut s = vec![];
        let hour = nano / 3_600_000_000_000;
        let minute = nano / 60_000_000_000 % 60;
        let second = nano / 1_000_000_000 % 60;
        let millisecond = nano / 1_000_000 % 1_000;
        let microsecond = nano / 1_000 % 1_000;
        let nanosecond = nano % 1_000;
        if hour != 0 {
            s.push(format!("{} HOUR", hour));
        }
        if minute != 0 {
            s.push(format!("{} MINUTE", minute));
        }
        if second != 0 {
            s.push(format!("{} SECOND", second));
        }
        if millisecond != 0 {
            s.push(format!("{} MILLISECOND", millisecond));
        }
        if microsecond != 0 {
            s.push(format!("{} MICROSECOND", microsecond));
        }
        if nanosecond != 0 {
            s.push(format!("{} NANOSECOND", nanosecond));
        }
        s.join(" ")

Additional context

[Rachelint]

Have finished the basic codes.
Adding some tests and fixing compile...

[Jefffrey]

Looks like there's an edge case where if all values are 0 for MonthDayNano then an empty string is used as the display:

arrow-rs/arrow-cast/src/display.rs

Lines 733 to 758 in 2ec77b5

	impl DisplayIndex for &PrimitiveArray<IntervalMonthDayNanoType> {
	fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
	let value = self.value(idx);
	let mut prefix = "";
	if value.months != 0 {
	write!(f, "{prefix}{} mons", value.months)?;
	prefix = " ";
	}
	if value.days != 0 {
	write!(f, "{prefix}{} days", value.days)?;
	prefix = " ";
	}
	if value.nanoseconds != 0 {
	let nano_fmt = NanosecondsFormatter {
	nanoseconds: value.nanoseconds,
	prefix,
	};
	f.write_fmt(format_args!("{nano_fmt}"))?;
	}
	Ok(())
	}
	}

• Related DataFusion issue: [datafusion-spark] [SQL] [TEST] IntervalMonthDayNano(0,0,0) give line blank datafusion#17455

Could consider using 0 seconds as the default, similar to what Spark does

I think this issue might happen for DayTime too based on looking at the code:

arrow-rs/arrow-cast/src/display.rs

Lines 710 to 731 in 2ec77b5

	impl DisplayIndex for &PrimitiveArray<IntervalDayTimeType> {
	fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
	let value = self.value(idx);
	let mut prefix = "";
	if value.days != 0 {
	write!(f, "{prefix}{} days", value.days)?;
	prefix = " ";
	}
	if value.milliseconds != 0 {
	let millis_fmt = MillisecondsFormatter {
	milliseconds: value.milliseconds,
	prefix,
	};
	f.write_fmt(format_args!("{millis_fmt}"))?;
	}
	Ok(())
	}
	}