Skip to content

Commit 088ed68

Browse files
delamarch3delamarch3
committed
revert datepart changes for duration types
1 parent 5240062 commit 088ed68

File tree

1 file changed

+57
-205
lines changed

1 file changed

+57
-205
lines changed

‎arrow-arith/src/temporal.rs

+57-205
Original file line numberDiff line numberDiff line change
@@ -534,13 +534,19 @@ impl ExtractDatePartExt for PrimitiveArray<DurationSecondType> {
534534
fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError> {
535535
match part {
536536
DatePart::Week => Ok(self.unary_opt(|d| (d / (60 * 60 * 24 * 7)).try_into().ok())),
537-
DatePart::Day => Ok(self.unary_opt(|d| (d / (60 * 60 * 24) % 7).try_into().ok())),
538-
DatePart::Hour => Ok(self.unary_opt(|d| (d / (60 * 60) % 24).try_into().ok())),
539-
DatePart::Minute => Ok(self.unary_opt(|d| (d / 60 % 60).try_into().ok())),
540-
DatePart::Second => Ok(self.unary_opt(|d| (d % 60).try_into().ok())),
541-
DatePart::Millisecond | DatePart::Microsecond | DatePart::Nanosecond => {
542-
Ok(self.unary_opt(|_| Some(0)))
537+
DatePart::Day => Ok(self.unary_opt(|d| (d / (60 * 60 * 24)).try_into().ok())),
538+
DatePart::Hour => Ok(self.unary_opt(|d| (d / (60 * 60)).try_into().ok())),
539+
DatePart::Minute => Ok(self.unary_opt(|d| (d / 60).try_into().ok())),
540+
DatePart::Second => Ok(self.unary_opt(|d| d.try_into().ok())),
541+
DatePart::Millisecond => {
542+
Ok(self.unary_opt(|d| d.checked_mul(1_000).and_then(|d| d.try_into().ok())))
543543
}
544+
DatePart::Microsecond => {
545+
Ok(self.unary_opt(|d| d.checked_mul(1_000_000).and_then(|d| d.try_into().ok())))
546+
}
547+
DatePart::Nanosecond => Ok(
548+
self.unary_opt(|d| d.checked_mul(1_000_000_000).and_then(|d| d.try_into().ok()))
549+
),
544550

545551
DatePart::Year
546552
| DatePart::YearISO
@@ -562,14 +568,17 @@ impl ExtractDatePartExt for PrimitiveArray<DurationMillisecondType> {
562568
DatePart::Week => {
563569
Ok(self.unary_opt(|d| (d / (1_000 * 60 * 60 * 24 * 7)).try_into().ok()))
564570
}
565-
DatePart::Day => {
566-
Ok(self.unary_opt(|d| (d / (1_000 * 60 * 60 * 24) % 7).try_into().ok()))
571+
DatePart::Day => Ok(self.unary_opt(|d| (d / (1_000 * 60 * 60 * 24)).try_into().ok())),
572+
DatePart::Hour => Ok(self.unary_opt(|d| (d / (1_000 * 60 * 60)).try_into().ok())),
573+
DatePart::Minute => Ok(self.unary_opt(|d| (d / (1_000 * 60)).try_into().ok())),
574+
DatePart::Second => Ok(self.unary_opt(|d| (d / 1_000).try_into().ok())),
575+
DatePart::Millisecond => Ok(self.unary_opt(|d| d.try_into().ok())),
576+
DatePart::Microsecond => {
577+
Ok(self.unary_opt(|d| d.checked_mul(1_000).and_then(|d| d.try_into().ok())))
578+
}
579+
DatePart::Nanosecond => {
580+
Ok(self.unary_opt(|d| d.checked_mul(1_000_000).and_then(|d| d.try_into().ok())))
567581
}
568-
DatePart::Hour => Ok(self.unary_opt(|d| (d / (1_000 * 60 * 60) % 24).try_into().ok())),
569-
DatePart::Minute => Ok(self.unary_opt(|d| (d / (1_000 * 60) % 60).try_into().ok())),
570-
DatePart::Second => Ok(self.unary_opt(|d| (d / 1_000 % 60).try_into().ok())),
571-
DatePart::Millisecond => Ok(self.unary_opt(|d| (d % 1_000).try_into().ok())),
572-
DatePart::Microsecond | DatePart::Nanosecond => Ok(self.unary_opt(|_| Some(0))),
573582

574583
DatePart::Year
575584
| DatePart::YearISO
@@ -592,16 +601,16 @@ impl ExtractDatePartExt for PrimitiveArray<DurationMicrosecondType> {
592601
Ok(self.unary_opt(|d| (d / (1_000_000 * 60 * 60 * 24 * 7)).try_into().ok()))
593602
}
594603
DatePart::Day => {
595-
Ok(self.unary_opt(|d| (d / (1_000_000 * 60 * 60 * 24) % 7).try_into().ok()))
604+
Ok(self.unary_opt(|d| (d / (1_000_000 * 60 * 60 * 24)).try_into().ok()))
596605
}
597-
DatePart::Hour => {
598-
Ok(self.unary_opt(|d| (d / (1_000_000 * 60 * 60) % 24).try_into().ok()))
606+
DatePart::Hour => Ok(self.unary_opt(|d| (d / (1_000_000 * 60 * 60)).try_into().ok())),
607+
DatePart::Minute => Ok(self.unary_opt(|d| (d / (1_000_000 * 60)).try_into().ok())),
608+
DatePart::Second => Ok(self.unary_opt(|d| (d / 1_000_000).try_into().ok())),
609+
DatePart::Millisecond => Ok(self.unary_opt(|d| (d / 1_000).try_into().ok())),
610+
DatePart::Microsecond => Ok(self.unary_opt(|d| d.try_into().ok())),
611+
DatePart::Nanosecond => {
612+
Ok(self.unary_opt(|d| d.checked_mul(1_000).and_then(|d| d.try_into().ok())))
599613
}
600-
DatePart::Minute => Ok(self.unary_opt(|d| (d / (1_000_000 * 60) % 60).try_into().ok())),
601-
DatePart::Second => Ok(self.unary_opt(|d| (d / 1_000_000 % 60).try_into().ok())),
602-
DatePart::Millisecond => Ok(self.unary_opt(|d| (d / 1_000 % 1_000).try_into().ok())),
603-
DatePart::Microsecond => Ok(self.unary_opt(|d| (d % 1_000).try_into().ok())),
604-
DatePart::Nanosecond => Ok(self.unary_opt(|_| Some(0))),
605614

606615
DatePart::Year
607616
| DatePart::YearISO
@@ -624,20 +633,16 @@ impl ExtractDatePartExt for PrimitiveArray<DurationNanosecondType> {
624633
Ok(self.unary_opt(|d| (d / (1_000_000_000 * 60 * 60 * 24 * 7)).try_into().ok()))
625634
}
626635
DatePart::Day => {
627-
Ok(self.unary_opt(|d| (d / (1_000_000_000 * 60 * 60 * 24) % 7).try_into().ok()))
636+
Ok(self.unary_opt(|d| (d / (1_000_000_000 * 60 * 60 * 24)).try_into().ok()))
628637
}
629638
DatePart::Hour => {
630-
Ok(self.unary_opt(|d| (d / (1_000_000_000 * 60 * 60) % 24).try_into().ok()))
631-
}
632-
DatePart::Minute => {
633-
Ok(self.unary_opt(|d| (d / (1_000_000_000 * 60) % 60).try_into().ok()))
634-
}
635-
DatePart::Second => Ok(self.unary_opt(|d| (d / 1_000_000_000 % 60).try_into().ok())),
636-
DatePart::Millisecond => {
637-
Ok(self.unary_opt(|d| (d / 1_000_000 % 1_000).try_into().ok()))
639+
Ok(self.unary_opt(|d| (d / (1_000_000_000 * 60 * 60)).try_into().ok()))
638640
}
639-
DatePart::Microsecond => Ok(self.unary_opt(|d| (d / 1_000 % 1_000).try_into().ok())),
640-
DatePart::Nanosecond => Ok(self.unary_opt(|d| (d % 1_000).try_into().ok())),
641+
DatePart::Minute => Ok(self.unary_opt(|d| (d / (1_000_000_000 * 60)).try_into().ok())),
642+
DatePart::Second => Ok(self.unary_opt(|d| (d / 1_000_000_000).try_into().ok())),
643+
DatePart::Millisecond => Ok(self.unary_opt(|d| (d / 1_000_000).try_into().ok())),
644+
DatePart::Microsecond => Ok(self.unary_opt(|d| (d / 1_000).try_into().ok())),
645+
DatePart::Nanosecond => Ok(self.unary_opt(|d| d.try_into().ok())),
641646

642647
DatePart::Year
643648
| DatePart::YearISO
@@ -1991,271 +1996,118 @@ mod tests {
19911996

19921997
#[test]
19931998
fn test_duration_second() {
1994-
let input: DurationSecondArray = vec![
1995-
0, // 0s
1996-
42, // 42s
1997-
SECONDS_IN_DAY + 1, // 1d, 1s
1998-
SECONDS_IN_DAY * 14 + SECONDS_IN_DAY + SECONDS_IN_DAY / 2 + 1, // 2w, 1d, 12h, 1s
1999-
]
2000-
.into();
2001-
2002-
let actual = date_part(&input, DatePart::Week).unwrap();
2003-
let actual = actual.as_primitive::<Int32Type>();
2004-
assert_eq!(0, actual.value(0));
2005-
assert_eq!(0, actual.value(1));
2006-
assert_eq!(0, actual.value(2));
2007-
assert_eq!(2, actual.value(3));
2008-
2009-
let actual = date_part(&input, DatePart::Day).unwrap();
2010-
let actual = actual.as_primitive::<Int32Type>();
2011-
assert_eq!(0, actual.value(0));
2012-
assert_eq!(0, actual.value(1));
2013-
assert_eq!(1, actual.value(2));
2014-
assert_eq!(1, actual.value(3));
2015-
2016-
let actual = date_part(&input, DatePart::Hour).unwrap();
2017-
let actual = actual.as_primitive::<Int32Type>();
2018-
assert_eq!(0, actual.value(0));
2019-
assert_eq!(0, actual.value(1));
2020-
assert_eq!(0, actual.value(2));
2021-
assert_eq!(12, actual.value(3));
2022-
2023-
let actual = date_part(&input, DatePart::Minute).unwrap();
2024-
let actual = actual.as_primitive::<Int32Type>();
2025-
assert_eq!(0, actual.value(0));
2026-
assert_eq!(0, actual.value(1));
2027-
assert_eq!(0, actual.value(2));
2028-
assert_eq!(0, actual.value(3));
1999+
let input: DurationSecondArray = vec![0, 42, 60 * 60 * 24 + 1].into();
20292000

20302001
let actual = date_part(&input, DatePart::Second).unwrap();
20312002
let actual = actual.as_primitive::<Int32Type>();
20322003
assert_eq!(0, actual.value(0));
20332004
assert_eq!(42, actual.value(1));
2034-
assert_eq!(1, actual.value(2));
2035-
assert_eq!(1, actual.value(3));
2005+
assert_eq!(60 * 60 * 24 + 1, actual.value(2));
20362006

20372007
let actual = date_part(&input, DatePart::Millisecond).unwrap();
20382008
let actual = actual.as_primitive::<Int32Type>();
20392009
assert_eq!(0, actual.value(0));
2040-
assert_eq!(0, actual.value(1));
2041-
assert_eq!(0, actual.value(2));
2042-
assert_eq!(0, actual.value(3));
2010+
assert_eq!(42_000, actual.value(1));
2011+
assert_eq!((60 * 60 * 24 + 1) * 1_000, actual.value(2));
20432012

20442013
let actual = date_part(&input, DatePart::Microsecond).unwrap();
20452014
let actual = actual.as_primitive::<Int32Type>();
20462015
assert_eq!(0, actual.value(0));
2047-
assert_eq!(0, actual.value(1));
2016+
assert_eq!(42_000_000, actual.value(1));
20482017
assert_eq!(0, actual.value(2));
2049-
assert_eq!(0, actual.value(3));
20502018

20512019
let actual = date_part(&input, DatePart::Nanosecond).unwrap();
20522020
let actual = actual.as_primitive::<Int32Type>();
20532021
assert_eq!(0, actual.value(0));
20542022
assert_eq!(0, actual.value(1));
20552023
assert_eq!(0, actual.value(2));
2056-
assert_eq!(0, actual.value(3));
20572024
}
20582025

20592026
#[test]
20602027
fn test_duration_millisecond() {
2061-
let input: DurationMillisecondArray = vec![
2062-
0, // 0ms
2063-
42, // 42ms
2064-
60 * 60 * 24 + 1, // 1m, 26s, 401ms
2065-
MILLISECONDS_IN_DAY * 14 + MILLISECONDS_IN_DAY + MILLISECONDS_IN_DAY / 2 + 1, // 2w, 1d, 12h, 1ms
2066-
]
2067-
.into();
2068-
2069-
let actual = date_part(&input, DatePart::Week).unwrap();
2070-
let actual = actual.as_primitive::<Int32Type>();
2071-
assert_eq!(0, actual.value(0));
2072-
assert_eq!(0, actual.value(1));
2073-
assert_eq!(0, actual.value(2));
2074-
assert_eq!(2, actual.value(3));
2075-
2076-
let actual = date_part(&input, DatePart::Day).unwrap();
2077-
let actual = actual.as_primitive::<Int32Type>();
2078-
assert_eq!(0, actual.value(0));
2079-
assert_eq!(0, actual.value(1));
2080-
assert_eq!(0, actual.value(2));
2081-
assert_eq!(1, actual.value(3));
2082-
2083-
let actual = date_part(&input, DatePart::Hour).unwrap();
2084-
let actual = actual.as_primitive::<Int32Type>();
2085-
assert_eq!(0, actual.value(0));
2086-
assert_eq!(0, actual.value(1));
2087-
assert_eq!(0, actual.value(2));
2088-
assert_eq!(12, actual.value(3));
2089-
2090-
let actual = date_part(&input, DatePart::Minute).unwrap();
2091-
let actual = actual.as_primitive::<Int32Type>();
2092-
assert_eq!(0, actual.value(0));
2093-
assert_eq!(0, actual.value(1));
2094-
assert_eq!(1, actual.value(2));
2095-
assert_eq!(0, actual.value(3));
2028+
let input: DurationMillisecondArray = vec![0, 42, 60 * 60 * 24 + 1].into();
20962029

20972030
let actual = date_part(&input, DatePart::Second).unwrap();
20982031
let actual = actual.as_primitive::<Int32Type>();
20992032
assert_eq!(0, actual.value(0));
21002033
assert_eq!(0, actual.value(1));
2101-
assert_eq!(26, actual.value(2));
2102-
assert_eq!(0, actual.value(3));
2034+
assert_eq!((60 * 60 * 24 + 1) / 1_000, actual.value(2));
21032035

21042036
let actual = date_part(&input, DatePart::Millisecond).unwrap();
21052037
let actual = actual.as_primitive::<Int32Type>();
21062038
assert_eq!(0, actual.value(0));
21072039
assert_eq!(42, actual.value(1));
2108-
assert_eq!(401, actual.value(2));
2109-
assert_eq!(1, actual.value(3));
2040+
assert_eq!(60 * 60 * 24 + 1, actual.value(2));
21102041

21112042
let actual = date_part(&input, DatePart::Microsecond).unwrap();
21122043
let actual = actual.as_primitive::<Int32Type>();
21132044
assert_eq!(0, actual.value(0));
2114-
assert_eq!(0, actual.value(1));
2115-
assert_eq!(0, actual.value(2));
2116-
assert_eq!(0, actual.value(3));
2045+
assert_eq!(42_000, actual.value(1));
2046+
assert_eq!((60 * 60 * 24 + 1) * 1_000, actual.value(2));
21172047

21182048
let actual = date_part(&input, DatePart::Nanosecond).unwrap();
21192049
let actual = actual.as_primitive::<Int32Type>();
21202050
assert_eq!(0, actual.value(0));
2121-
assert_eq!(0, actual.value(1));
2051+
assert_eq!(42_000_000, actual.value(1));
21222052
assert_eq!(0, actual.value(2));
2123-
assert_eq!(0, actual.value(3));
21242053
}
21252054

21262055
#[test]
21272056
fn test_duration_microsecond() {
2128-
let input: DurationMicrosecondArray = vec![
2129-
0, // 0us
2130-
42, // 42us
2131-
MICROSECONDS + 60 * 60 * 24 + 1, // 1s, 86ms, 401us
2132-
MICROSECONDS_IN_DAY * 14 + MICROSECONDS_IN_DAY + MICROSECONDS_IN_DAY / 2 + 1, // 2w, 1d, 12h, 1us
2133-
]
2134-
.into();
2135-
2136-
let actual = date_part(&input, DatePart::Week).unwrap();
2137-
let actual = actual.as_primitive::<Int32Type>();
2138-
assert_eq!(0, actual.value(0));
2139-
assert_eq!(0, actual.value(1));
2140-
assert_eq!(0, actual.value(2));
2141-
assert_eq!(2, actual.value(3));
2142-
2143-
let actual = date_part(&input, DatePart::Day).unwrap();
2144-
let actual = actual.as_primitive::<Int32Type>();
2145-
assert_eq!(0, actual.value(0));
2146-
assert_eq!(0, actual.value(1));
2147-
assert_eq!(0, actual.value(2));
2148-
assert_eq!(1, actual.value(3));
2149-
2150-
let actual = date_part(&input, DatePart::Hour).unwrap();
2151-
let actual = actual.as_primitive::<Int32Type>();
2152-
assert_eq!(0, actual.value(0));
2153-
assert_eq!(0, actual.value(1));
2154-
assert_eq!(0, actual.value(2));
2155-
assert_eq!(12, actual.value(3));
2156-
2157-
let actual = date_part(&input, DatePart::Minute).unwrap();
2158-
let actual = actual.as_primitive::<Int32Type>();
2159-
assert_eq!(0, actual.value(0));
2160-
assert_eq!(0, actual.value(1));
2161-
assert_eq!(0, actual.value(2));
2162-
assert_eq!(0, actual.value(3));
2057+
let input: DurationMicrosecondArray = vec![0, 42, 60 * 60 * 24 + 1].into();
21632058

21642059
let actual = date_part(&input, DatePart::Second).unwrap();
21652060
let actual = actual.as_primitive::<Int32Type>();
21662061
assert_eq!(0, actual.value(0));
21672062
assert_eq!(0, actual.value(1));
2168-
assert_eq!(1, actual.value(2));
2169-
assert_eq!(0, actual.value(3));
2063+
assert_eq!(0, actual.value(2));
21702064

21712065
let actual = date_part(&input, DatePart::Millisecond).unwrap();
21722066
let actual = actual.as_primitive::<Int32Type>();
21732067
assert_eq!(0, actual.value(0));
21742068
assert_eq!(0, actual.value(1));
2175-
assert_eq!(86, actual.value(2));
2176-
assert_eq!(0, actual.value(3));
2069+
assert_eq!((60 * 60 * 24 + 1) / 1_000, actual.value(2));
21772070

21782071
let actual = date_part(&input, DatePart::Microsecond).unwrap();
21792072
let actual = actual.as_primitive::<Int32Type>();
21802073
assert_eq!(0, actual.value(0));
21812074
assert_eq!(42, actual.value(1));
2182-
assert_eq!(401, actual.value(2));
2183-
assert_eq!(1, actual.value(3));
2075+
assert_eq!(60 * 60 * 24 + 1, actual.value(2));
21842076

21852077
let actual = date_part(&input, DatePart::Nanosecond).unwrap();
21862078
let actual = actual.as_primitive::<Int32Type>();
21872079
assert_eq!(0, actual.value(0));
2188-
assert_eq!(0, actual.value(1));
2189-
assert_eq!(0, actual.value(2));
2190-
assert_eq!(0, actual.value(3));
2191-
assert_eq!(0, actual.value(3));
2080+
assert_eq!(42_000, actual.value(1));
2081+
assert_eq!((60 * 60 * 24 + 1) * 1_000, actual.value(2));
21922082
}
21932083

21942084
#[test]
21952085
fn test_duration_nanosecond() {
2196-
let input: DurationNanosecondArray = vec![
2197-
0, // 0ns
2198-
42, // 42ns
2199-
60 * 60 * 24 + 1, // 86us, 401ns
2200-
NANOSECONDS_IN_DAY * 14 + NANOSECONDS_IN_DAY + NANOSECONDS_IN_DAY / 2 + 1, // 2w, 1d, 12h, 1ns
2201-
]
2202-
.into();
2203-
2204-
let actual = date_part(&input, DatePart::Week).unwrap();
2205-
let actual = actual.as_primitive::<Int32Type>();
2206-
assert_eq!(0, actual.value(0));
2207-
assert_eq!(0, actual.value(1));
2208-
assert_eq!(0, actual.value(2));
2209-
assert_eq!(2, actual.value(3));
2210-
2211-
let actual = date_part(&input, DatePart::Day).unwrap();
2212-
let actual = actual.as_primitive::<Int32Type>();
2213-
assert_eq!(0, actual.value(0));
2214-
assert_eq!(0, actual.value(1));
2215-
assert_eq!(0, actual.value(2));
2216-
assert_eq!(1, actual.value(3));
2217-
2218-
let actual = date_part(&input, DatePart::Hour).unwrap();
2219-
let actual = actual.as_primitive::<Int32Type>();
2220-
assert_eq!(0, actual.value(0));
2221-
assert_eq!(0, actual.value(1));
2222-
assert_eq!(0, actual.value(2));
2223-
assert_eq!(12, actual.value(3));
2224-
2225-
let actual = date_part(&input, DatePart::Minute).unwrap();
2226-
let actual = actual.as_primitive::<Int32Type>();
2227-
assert_eq!(0, actual.value(0));
2228-
assert_eq!(0, actual.value(1));
2229-
assert_eq!(0, actual.value(2));
2230-
assert_eq!(0, actual.value(3));
2086+
let input: DurationNanosecondArray = vec![0, 42, 60 * 60 * 24 + 1].into();
22312087

22322088
let actual = date_part(&input, DatePart::Second).unwrap();
22332089
let actual = actual.as_primitive::<Int32Type>();
22342090
assert_eq!(0, actual.value(0));
22352091
assert_eq!(0, actual.value(1));
22362092
assert_eq!(0, actual.value(2));
2237-
assert_eq!(0, actual.value(3));
22382093

22392094
let actual = date_part(&input, DatePart::Millisecond).unwrap();
22402095
let actual = actual.as_primitive::<Int32Type>();
22412096
assert_eq!(0, actual.value(0));
22422097
assert_eq!(0, actual.value(1));
22432098
assert_eq!(0, actual.value(2));
2244-
assert_eq!(0, actual.value(3));
22452099

22462100
let actual = date_part(&input, DatePart::Microsecond).unwrap();
22472101
let actual = actual.as_primitive::<Int32Type>();
22482102
assert_eq!(0, actual.value(0));
22492103
assert_eq!(0, actual.value(1));
2250-
assert_eq!(86, actual.value(2));
2251-
assert_eq!(0, actual.value(3));
2104+
assert_eq!((60 * 60 * 24 + 1) / 1_000, actual.value(2));
22522105

22532106
let actual = date_part(&input, DatePart::Nanosecond).unwrap();
22542107
let actual = actual.as_primitive::<Int32Type>();
22552108
assert_eq!(0, actual.value(0));
22562109
assert_eq!(42, actual.value(1));
2257-
assert_eq!(401, actual.value(2));
2258-
assert_eq!(1, actual.value(3));
2110+
assert_eq!(60 * 60 * 24 + 1, actual.value(2));
22592111
}
22602112

22612113
#[test]

0 commit comments

Comments
 (0)