kosiew commented on code in PR #18761:
URL: https://github.com/apache/datafusion/pull/18761#discussion_r2534134285
##########
datafusion/common/src/scalar/mod.rs:
##########
@@ -91,6 +91,99 @@ use chrono::{Duration, NaiveDate};
use half::f16;
pub use struct_builder::ScalarStructBuilder;
+const SECONDS_PER_DAY: i64 = 86_400;
+const MILLIS_PER_DAY: i64 = SECONDS_PER_DAY * 1_000;
+const MICROS_PER_DAY: i64 = MILLIS_PER_DAY * 1_000;
+const NANOS_PER_DAY: i64 = MICROS_PER_DAY * 1_000;
+const MICROS_PER_MILLISECOND: i64 = 1_000;
+const NANOS_PER_MILLISECOND: i64 = 1_000_000;
+
+/// Returns the multiplier that converts the input date representation into the
+/// desired timestamp unit, if the conversion requires a multiplication that
can
+/// overflow an `i64`.
+pub fn date_to_timestamp_multiplier(
+ source_type: &DataType,
+ target_type: &DataType,
+) -> Option<i64> {
+ let DataType::Timestamp(target_unit, _) = target_type else {
+ return None;
+ };
+
+ // Only `Timestamp` target types have a time unit; otherwise no
+ // multiplier applies (handled above). The function returns `Some(m)`
+ // when converting the `source_type` to `target_type` requires a
+ // multiplication that could overflow `i64`. It returns `None` when
+ // the conversion is a division or otherwise doesn't require a
+ // multiplication (e.g. Date64 -> Second).
+ match source_type {
+ // Date32 stores days since epoch. Converting to any timestamp
+ // unit requires multiplying by the per-day factor (seconds,
+ // milliseconds, microseconds, nanoseconds).
+ DataType::Date32 => Some(match target_unit {
+ TimeUnit::Second => SECONDS_PER_DAY,
+ TimeUnit::Millisecond => MILLIS_PER_DAY,
+ TimeUnit::Microsecond => MICROS_PER_DAY,
+ TimeUnit::Nanosecond => NANOS_PER_DAY,
+ }),
+
+ // Date64 stores milliseconds since epoch. Converting to
+ // seconds is a division (no multiplication), so return `None`.
+ // Converting to milliseconds is 1:1 (multiplier 1). Converting
+ // to micro/nano requires multiplying by 1_000 / 1_000_000.
+ DataType::Date64 => match target_unit {
+ TimeUnit::Second => None,
+ TimeUnit::Millisecond => Some(1),
+ TimeUnit::Microsecond => Some(MICROS_PER_MILLISECOND),
+ TimeUnit::Nanosecond => Some(NANOS_PER_MILLISECOND),
+ },
+
+ _ => None,
+ }
+}
+
+/// Ensures the provided value can be represented as a timestamp with the given
+/// multiplier. Returns an [`DataFusionError::Execution`] when the converted
+/// value would overflow the timestamp range.
+pub fn ensure_timestamp_in_bounds(
+ value: i64,
+ multiplier: i64,
+ source_type: &DataType,
+ target_type: &DataType,
+) -> Result<()> {
+ if multiplier <= 1 {
+ return Ok(());
+ }
+
+ if value.checked_mul(multiplier).is_none() {
+ let target = format_timestamp_type_for_error(target_type);
+ _exec_err!(
+ "Cannot cast {} value {} to {}: timestamp values are limited to
+/-2262 years",
Review Comment:
Good catch.
Will amend accordingly.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
