224 lines
8.1 KiB
Rust
224 lines
8.1 KiB
Rust
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum SqlServerTemporalKind {
|
|
Date,
|
|
Time { scale: u8 },
|
|
SmallDateTime,
|
|
DateTime,
|
|
DateTime2 { scale: u8 },
|
|
DateTimeOffset { scale: u8 },
|
|
}
|
|
|
|
pub fn format_sqlserver_datetime_display(value: &chrono::NaiveDateTime) -> String {
|
|
let rounded = value.checked_add_signed(chrono::Duration::microseconds(500)).unwrap_or(*value);
|
|
let base = rounded.format("%Y-%m-%d %H:%M:%S").to_string();
|
|
let millis = rounded.and_utc().timestamp_subsec_millis();
|
|
if millis == 0 {
|
|
base
|
|
} else {
|
|
format!("{base}.{millis:03}")
|
|
}
|
|
}
|
|
|
|
pub fn normalize_sqlserver_temporal_literal(value: &str, column_type: Option<&str>) -> Option<String> {
|
|
let kind = sqlserver_temporal_kind(column_type?)?;
|
|
let parts = parse_sqlserver_temporal(value)?;
|
|
match kind {
|
|
SqlServerTemporalKind::Date => Some(parts.date),
|
|
SqlServerTemporalKind::Time { scale } => Some(format_sqlserver_time_text(&parts.time, scale)),
|
|
SqlServerTemporalKind::SmallDateTime => {
|
|
Some(format!("{} {}", parts.date, format_sqlserver_time_text(&parts.time, 0)))
|
|
}
|
|
SqlServerTemporalKind::DateTime => Some(format_sqlserver_datetime_parts(&parts.date, &parts.time)),
|
|
SqlServerTemporalKind::DateTime2 { scale } => {
|
|
Some(format!("{} {}", parts.date, format_sqlserver_time_text(&parts.time, scale)))
|
|
}
|
|
SqlServerTemporalKind::DateTimeOffset { scale } => {
|
|
let offset = parts.offset?;
|
|
Some(format!("{} {}{}", parts.date, format_sqlserver_time_text(&parts.time, scale), offset))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn sqlserver_temporal_kind(column_type: &str) -> Option<SqlServerTemporalKind> {
|
|
let lower = column_type.trim().to_ascii_lowercase();
|
|
let base = lower.split(['(', ' ', '\t', '\n']).next().unwrap_or("");
|
|
match base {
|
|
"date" | "daten" => Some(SqlServerTemporalKind::Date),
|
|
"smalldatetime" => Some(SqlServerTemporalKind::SmallDateTime),
|
|
"datetime" | "datetimen" => Some(SqlServerTemporalKind::DateTime),
|
|
"datetime4" => Some(SqlServerTemporalKind::SmallDateTime),
|
|
"datetime2" => Some(SqlServerTemporalKind::DateTime2 { scale: temporal_scale(&lower).unwrap_or(7) }),
|
|
"time" | "timen" => Some(SqlServerTemporalKind::Time { scale: temporal_scale(&lower).unwrap_or(7) }),
|
|
"datetimeoffset" | "datetimeoffsetn" => {
|
|
Some(SqlServerTemporalKind::DateTimeOffset { scale: temporal_scale(&lower).unwrap_or(7) })
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn temporal_scale(column_type: &str) -> Option<u8> {
|
|
let start = column_type.find('(')?;
|
|
let end = column_type[start + 1..].find(')')? + start + 1;
|
|
let scale = column_type[start + 1..end].trim().parse::<u8>().ok()?;
|
|
Some(scale.min(7))
|
|
}
|
|
|
|
struct SqlServerTemporalParts {
|
|
date: String,
|
|
time: String,
|
|
offset: Option<String>,
|
|
}
|
|
|
|
fn parse_sqlserver_temporal(value: &str) -> Option<SqlServerTemporalParts> {
|
|
let trimmed = value.trim();
|
|
let bytes = trimmed.as_bytes();
|
|
if bytes.len() >= 10 && is_date_prefix(bytes) {
|
|
let date = trimmed[..10].to_string();
|
|
let mut rest = trimmed[10..].trim_start();
|
|
if rest.starts_with('T') || rest.starts_with('t') {
|
|
rest = rest[1..].trim_start();
|
|
}
|
|
if rest.is_empty() {
|
|
return Some(SqlServerTemporalParts { date, time: "00:00:00".to_string(), offset: None });
|
|
}
|
|
let (time, offset) = split_time_and_offset(rest)?;
|
|
return Some(SqlServerTemporalParts { date, time, offset });
|
|
}
|
|
|
|
let (time, offset) = split_time_and_offset(trimmed)?;
|
|
Some(SqlServerTemporalParts { date: "1900-01-01".to_string(), time, offset })
|
|
}
|
|
|
|
fn is_date_prefix(bytes: &[u8]) -> bool {
|
|
bytes.len() >= 10
|
|
&& bytes[4] == b'-'
|
|
&& bytes[7] == b'-'
|
|
&& bytes[0..4].iter().all(u8::is_ascii_digit)
|
|
&& bytes[5..7].iter().all(u8::is_ascii_digit)
|
|
&& bytes[8..10].iter().all(u8::is_ascii_digit)
|
|
}
|
|
|
|
fn split_time_and_offset(value: &str) -> Option<(String, Option<String>)> {
|
|
if value.len() < 8 {
|
|
return None;
|
|
}
|
|
let bytes = value.as_bytes();
|
|
if bytes.get(2) != Some(&b':') || bytes.get(5) != Some(&b':') {
|
|
return None;
|
|
}
|
|
if !bytes[0..2].iter().all(u8::is_ascii_digit)
|
|
|| !bytes[3..5].iter().all(u8::is_ascii_digit)
|
|
|| !bytes[6..8].iter().all(u8::is_ascii_digit)
|
|
{
|
|
return None;
|
|
}
|
|
|
|
let mut end = 8;
|
|
if bytes.get(end) == Some(&b'.') {
|
|
end += 1;
|
|
let fraction_start = end;
|
|
while end < bytes.len() && bytes[end].is_ascii_digit() {
|
|
end += 1;
|
|
}
|
|
if end == fraction_start {
|
|
return None;
|
|
}
|
|
}
|
|
|
|
let time = value[..end].to_string();
|
|
let suffix = value[end..].trim();
|
|
if suffix.is_empty() {
|
|
return Some((time, None));
|
|
}
|
|
if suffix.eq_ignore_ascii_case("z") {
|
|
return Some((time, Some("+00:00".to_string())));
|
|
}
|
|
if is_timezone_offset(suffix) {
|
|
return Some((time, Some(suffix.to_string())));
|
|
}
|
|
None
|
|
}
|
|
|
|
fn is_timezone_offset(value: &str) -> bool {
|
|
let bytes = value.as_bytes();
|
|
bytes.len() == 6
|
|
&& matches!(bytes[0], b'+' | b'-')
|
|
&& bytes[3] == b':'
|
|
&& bytes[1].is_ascii_digit()
|
|
&& bytes[2].is_ascii_digit()
|
|
&& bytes[4].is_ascii_digit()
|
|
&& bytes[5].is_ascii_digit()
|
|
}
|
|
|
|
fn format_sqlserver_time_text(value: &str, scale: u8) -> String {
|
|
let (base, fraction) = value.split_once('.').unwrap_or((value, ""));
|
|
if scale == 0 {
|
|
return base.to_string();
|
|
}
|
|
let mut digits = fraction.chars().take_while(|ch| ch.is_ascii_digit()).take(scale as usize).collect::<String>();
|
|
while digits.len() < scale as usize {
|
|
digits.push('0');
|
|
}
|
|
if digits.chars().all(|ch| ch == '0') {
|
|
base.to_string()
|
|
} else {
|
|
format!("{base}.{digits}")
|
|
}
|
|
}
|
|
|
|
fn format_sqlserver_datetime_parts(date: &str, time: &str) -> String {
|
|
let value = format!("{date} {time}");
|
|
chrono::NaiveDateTime::parse_from_str(&value, "%Y-%m-%d %H:%M:%S%.f")
|
|
.map(|value| format_sqlserver_datetime_display(&value))
|
|
.unwrap_or_else(|_| format!("{date} {}", format_sqlserver_time_text(time, 3)))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn formats_sqlserver_datetime_display_with_millisecond_precision() {
|
|
let value =
|
|
chrono::NaiveDate::from_ymd_opt(2026, 6, 29).unwrap().and_hms_nano_opt(10, 11, 12, 896_666_666).unwrap();
|
|
|
|
assert_eq!(format_sqlserver_datetime_display(&value), "2026-06-29 10:11:12.897");
|
|
|
|
let boundary =
|
|
chrono::NaiveDate::from_ymd_opt(2026, 6, 29).unwrap().and_hms_nano_opt(23, 59, 59, 999_600_000).unwrap();
|
|
assert_eq!(format_sqlserver_datetime_display(&boundary), "2026-06-30 00:00:00");
|
|
}
|
|
|
|
#[test]
|
|
fn normalizes_sqlserver_datetime_literals_by_column_type() {
|
|
assert_eq!(
|
|
normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.896666666", Some("datetime")),
|
|
Some("2026-06-29 10:11:12.897".to_string())
|
|
);
|
|
assert_eq!(
|
|
normalize_sqlserver_temporal_literal("2026-06-29T10:11:12.8966666Z", Some("datetime2(7)")),
|
|
Some("2026-06-29 10:11:12.8966666".to_string())
|
|
);
|
|
assert_eq!(
|
|
normalize_sqlserver_temporal_literal("2026-06-29T10:11:12.8966666Z", Some("datetime2(3)")),
|
|
Some("2026-06-29 10:11:12.896".to_string())
|
|
);
|
|
assert_eq!(
|
|
normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.8966666+08:00", Some("datetimeoffset(4)")),
|
|
Some("2026-06-29 10:11:12.8966+08:00".to_string())
|
|
);
|
|
assert_eq!(
|
|
normalize_sqlserver_temporal_literal("10:11:12.8966666", Some("time(2)")),
|
|
Some("10:11:12.89".to_string())
|
|
);
|
|
assert_eq!(
|
|
normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.8966666", Some("date")),
|
|
Some("2026-06-29".to_string())
|
|
);
|
|
assert_eq!(
|
|
normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.8966666", Some("smalldatetime")),
|
|
Some("2026-06-29 10:11:12".to_string())
|
|
);
|
|
}
|
|
}
|