odbc: DSN parsing (odbc:Name -> DSN=Name); chrono/uuid decoding robustness (trim, accept Other/Unknown); add ODBC unit tests for padded values; combine CI ODBC job (Postgres + SQLite); run fmt

cursoragent · cursoragent · commit 597db7df8b0f · 2025-09-21T08:19:03.000Z
diff --git a/.github/workflows/sqlx.yml b/.github/workflows/sqlx.yml
@@ -339,37 +339,8 @@ jobs:
         env:
           DATABASE_URL: mssql://sa:Password123!@localhost/sqlx
 
-  odbc-sqlite:
-    name: ODBC (SQLite)
-    runs-on: ubuntu-22.04
-    needs: check
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: Swatinem/rust-cache@v2
-        with:
-          prefix-key: v1-sqlx
-          shared-key: odbc-sqlite
-          save-if: ${{ false }}
-      - name: Install ODBC drivers (SQLite)
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y unixodbc odbcinst libsqliteodbc
-          odbcinst -q -d || true
-      - name: Build with ODBC feature
-        run: |
-          cargo build --manifest-path sqlx-core/Cargo.toml \
-            --no-default-features \
-            --features odbc,runtime-tokio-rustls
-      - name: Run ODBC SQLite tests
-        run: |
-          cargo test \
-            --no-default-features \
-            --features odbc,runtime-tokio-rustls \
-            --test odbc-sqlite
-
   odbc:
-    name: ODBC (PostgreSQL via unixODBC)
+    name: ODBC (PostgreSQL and SQLite)
     runs-on: ubuntu-22.04
     needs: check
     steps:
@@ -384,10 +355,10 @@ jobs:
         run: |
           docker compose -f tests/docker-compose.yml run -d -p 5432:5432 --name postgres_16_no_ssl postgres_16_no_ssl
           docker exec postgres_16_no_ssl bash -c "until pg_isready; do sleep 1; done"
-      - name: Install unixODBC and PostgreSQL ODBC driver
+      - name: Install unixODBC and ODBC drivers (PostgreSQL, SQLite)
         run: |
           sudo apt-get update
-          sudo apt-get install -y unixodbc odbcinst odbcinst1debian2 odbc-postgresql
+          sudo apt-get install -y unixodbc odbcinst odbcinst1debian2 odbc-postgresql libsqliteodbc
           odbcinst -j
       - name: Configure system/user DSN for PostgreSQL
         run: |
@@ -405,3 +376,8 @@ jobs:
           cargo test --no-default-features --features any,odbc,macros,all-types,runtime-tokio-rustls -- --test odbc
         env:
           DATABASE_URL: DSN=SQLX_PG_5432;UID=postgres;PWD=password
+      - name: Run ODBC tests (SQLite driver)
+        run: |
+          cargo test --no-default-features --features any,odbc,macros,all-types,runtime-tokio-rustls -- --test odbc
+        env:
+          DATABASE_URL: Driver={SQLite3 ODBC Driver};Database=./tests/odbc/sqlite.db
diff --git a/sqlx-core/src/odbc/options/mod.rs b/sqlx-core/src/odbc/options/mod.rs
@@ -48,7 +48,10 @@ impl FromStr for OdbcConnectOptions {
             format!("DSN={}", t)
         };
 
-        Ok(Self { conn_str, log_settings: LogSettings::default() })
+        Ok(Self {
+            conn_str,
+            log_settings: LogSettings::default(),
+        })
     }
 }
 
diff --git a/sqlx-core/src/odbc/types/chrono.rs b/sqlx-core/src/odbc/types/chrono.rs
@@ -11,7 +11,9 @@ impl Type<Odbc> for NaiveDate {
         OdbcTypeInfo::DATE
     }
     fn compatible(ty: &OdbcTypeInfo) -> bool {
-        matches!(ty.data_type(), DataType::Date) || ty.data_type().accepts_character_data()
+        matches!(ty.data_type(), DataType::Date)
+            || ty.data_type().accepts_character_data()
+            || matches!(ty.data_type(), DataType::Other { .. } | DataType::Unknown)
     }
 }
 
@@ -20,7 +22,9 @@ impl Type<Odbc> for NaiveTime {
         OdbcTypeInfo::TIME
     }
     fn compatible(ty: &OdbcTypeInfo) -> bool {
-        matches!(ty.data_type(), DataType::Time { .. }) || ty.data_type().accepts_character_data()
+        matches!(ty.data_type(), DataType::Time { .. })
+            || ty.data_type().accepts_character_data()
+            || matches!(ty.data_type(), DataType::Other { .. } | DataType::Unknown)
     }
 }
 
@@ -31,6 +35,7 @@ impl Type<Odbc> for NaiveDateTime {
     fn compatible(ty: &OdbcTypeInfo) -> bool {
         matches!(ty.data_type(), DataType::Timestamp { .. })
             || ty.data_type().accepts_character_data()
+            || matches!(ty.data_type(), DataType::Other { .. } | DataType::Unknown)
     }
 }
 
@@ -41,6 +46,7 @@ impl Type<Odbc> for DateTime<Utc> {
     fn compatible(ty: &OdbcTypeInfo) -> bool {
         matches!(ty.data_type(), DataType::Timestamp { .. })
             || ty.data_type().accepts_character_data()
+            || matches!(ty.data_type(), DataType::Other { .. } | DataType::Unknown)
     }
 }
 
@@ -51,6 +57,7 @@ impl Type<Odbc> for DateTime<FixedOffset> {
     fn compatible(ty: &OdbcTypeInfo) -> bool {
         matches!(ty.data_type(), DataType::Timestamp { .. })
             || ty.data_type().accepts_character_data()
+            || matches!(ty.data_type(), DataType::Other { .. } | DataType::Unknown)
     }
 }
 
@@ -61,6 +68,7 @@ impl Type<Odbc> for DateTime<Local> {
     fn compatible(ty: &OdbcTypeInfo) -> bool {
         matches!(ty.data_type(), DataType::Timestamp { .. })
             || ty.data_type().accepts_character_data()
+            || matches!(ty.data_type(), DataType::Other { .. } | DataType::Unknown)
     }
 }
 
@@ -168,8 +176,18 @@ impl<'r> Decode<'r, Odbc> for NaiveTime {
 
 impl<'r> Decode<'r, Odbc> for NaiveDateTime {
     fn decode(value: OdbcValueRef<'r>) -> Result<Self, BoxDynError> {
-        let s = <String as Decode<'r, Odbc>>::decode(value)?;
-        Ok(s.parse()?)
+        let mut s = <String as Decode<'r, Odbc>>::decode(value)?;
+        // Some ODBC drivers (e.g. PostgreSQL) may include trailing spaces or NULs
+        // in textual representations of timestamps. Trim them before parsing.
+        if s.ends_with('\u{0}') {
+            s = s.trim_end_matches('\u{0}').to_string();
+        }
+        let s_trimmed = s.trim();
+        // Try strict format first, then fall back to Chrono's FromStr
+        if let Ok(dt) = NaiveDateTime::parse_from_str(s_trimmed, "%Y-%m-%d %H:%M:%S") {
+            return Ok(dt);
+        }
+        Ok(s_trimmed.parse()?)
     }
 }
 
diff --git a/sqlx-core/src/odbc/types/uuid.rs b/sqlx-core/src/odbc/types/uuid.rs
@@ -12,7 +12,12 @@ impl Type<Odbc> for Uuid {
         // UUID string length
     }
     fn compatible(ty: &OdbcTypeInfo) -> bool {
-        ty.data_type().accepts_character_data() || ty.data_type().accepts_binary_data()
+        ty.data_type().accepts_character_data()
+            || ty.data_type().accepts_binary_data()
+            || matches!(
+                ty.data_type(),
+                odbc_api::DataType::Other { .. } | odbc_api::DataType::Unknown
+            )
     }
 }
 
@@ -32,14 +37,13 @@ impl<'r> Decode<'r, Odbc> for Uuid {
     fn decode(value: OdbcValueRef<'r>) -> Result<Self, BoxDynError> {
         if let Some(bytes) = value.blob {
             if bytes.len() == 16 {
-                // Binary UUID format
                 return Ok(Uuid::from_bytes(bytes.try_into()?));
             }
-            // Try as string
-            let s = std::str::from_utf8(bytes)?;
+            // Some drivers may return UUIDs as ASCII/UTF-8 bytes
+            let s = std::str::from_utf8(bytes)?.trim();
             return Ok(Uuid::from_str(s)?);
         }
         let s = <String as Decode<'r, Odbc>>::decode(value)?;
-        Ok(Uuid::from_str(&s)?)
+        Ok(Uuid::from_str(s.trim())?)
     }
 }
diff --git a/tests/odbc/types.rs b/tests/odbc/types.rs
@@ -103,6 +103,12 @@ test_type!(uuid<sqlx_oldapi::types::Uuid>(Odbc,
     "'00000000-0000-0000-0000-000000000000'" == sqlx_oldapi::types::Uuid::nil()
 ));
 
+// Extra UUID decoding edge cases (ODBC may return padded strings)
+#[cfg(feature = "uuid")]
+test_type!(uuid_padded<sqlx_oldapi::types::Uuid>(Odbc,
+    "'550e8400-e29b-41d4-a716-446655440000  '" == sqlx_oldapi::types::Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000").unwrap()
+));
+
 #[cfg(feature = "json")]
 mod json_tests {
     use super::*;
@@ -156,6 +162,11 @@ mod chrono_tests {
         "'2019-01-02 05:10:20'" == NaiveDate::from_ymd_opt(2019, 1, 2).unwrap().and_hms_opt(5, 10, 20).unwrap()
     ));
 
+    // Extra chrono decoding edge case (padded timestamp string)
+    test_type!(chrono_datetime_padded<NaiveDateTime>(Odbc,
+        "'2023-12-25 14:30:00   '" == NaiveDate::from_ymd_opt(2023, 12, 25).unwrap().and_hms_opt(14, 30, 0).unwrap()
+    ));
+
     test_type!(chrono_datetime_utc<DateTime<Utc>>(Odbc,
         "'2023-12-25 14:30:00'" == DateTime::<Utc>::from_naive_utc_and_offset(
             NaiveDate::from_ymd_opt(2023, 12, 25).unwrap().and_hms_opt(14, 30, 0).unwrap(),

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,10 @@ impl FromStr for OdbcConnectOptions {`
`48`	`48`	`format!("DSN={}", t)`
`49`	`49`	`};`
`50`	`50`
`51`		`- Ok(Self { conn_str, log_settings: LogSettings::default() })`
	`51`	`+ Ok(Self {`
	`52`	`+ conn_str,`
	`53`	`+ log_settings: LogSettings::default(),`
	`54`	`+ })`
`52`	`55`	`}`
`53`	`56`	`}`
`54`	`57`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,9 @@ impl Type<Odbc> for NaiveDate {`
`11`	`11`	`OdbcTypeInfo::DATE`
`12`	`12`	`}`
`13`	`13`	`fn compatible(ty: &OdbcTypeInfo) -> bool {`
`14`		`- matches!(ty.data_type(), DataType::Date) \|\| ty.data_type().accepts_character_data()`
	`14`	`+ matches!(ty.data_type(), DataType::Date)`
	`15`	`+ \|\| ty.data_type().accepts_character_data()`
	`16`	`+ \|\| matches!(ty.data_type(), DataType::Other { .. } \| DataType::Unknown)`
`15`	`17`	`}`
`16`	`18`	`}`
`17`	`19`
`@@ -20,7 +22,9 @@ impl Type<Odbc> for NaiveTime {`
`20`	`22`	`OdbcTypeInfo::TIME`
`21`	`23`	`}`
`22`	`24`	`fn compatible(ty: &OdbcTypeInfo) -> bool {`
`23`		`- matches!(ty.data_type(), DataType::Time { .. }) \|\| ty.data_type().accepts_character_data()`
	`25`	`+ matches!(ty.data_type(), DataType::Time { .. })`
	`26`	`+ \|\| ty.data_type().accepts_character_data()`
	`27`	`+ \|\| matches!(ty.data_type(), DataType::Other { .. } \| DataType::Unknown)`
`24`	`28`	`}`
`25`	`29`	`}`
`26`	`30`
`@@ -31,6 +35,7 @@ impl Type<Odbc> for NaiveDateTime {`
`31`	`35`	`fn compatible(ty: &OdbcTypeInfo) -> bool {`
`32`	`36`	`matches!(ty.data_type(), DataType::Timestamp { .. })`
`33`	`37`	`\|\| ty.data_type().accepts_character_data()`
	`38`	`+ \|\| matches!(ty.data_type(), DataType::Other { .. } \| DataType::Unknown)`
`34`	`39`	`}`
`35`	`40`	`}`
`36`	`41`
`@@ -41,6 +46,7 @@ impl Type<Odbc> for DateTime<Utc> {`
`41`	`46`	`fn compatible(ty: &OdbcTypeInfo) -> bool {`
`42`	`47`	`matches!(ty.data_type(), DataType::Timestamp { .. })`
`43`	`48`	`\|\| ty.data_type().accepts_character_data()`
	`49`	`+ \|\| matches!(ty.data_type(), DataType::Other { .. } \| DataType::Unknown)`
`44`	`50`	`}`
`45`	`51`	`}`
`46`	`52`
`@@ -51,6 +57,7 @@ impl Type<Odbc> for DateTime<FixedOffset> {`
`51`	`57`	`fn compatible(ty: &OdbcTypeInfo) -> bool {`
`52`	`58`	`matches!(ty.data_type(), DataType::Timestamp { .. })`
`53`	`59`	`\|\| ty.data_type().accepts_character_data()`
	`60`	`+ \|\| matches!(ty.data_type(), DataType::Other { .. } \| DataType::Unknown)`
`54`	`61`	`}`
`55`	`62`	`}`
`56`	`63`
`@@ -61,6 +68,7 @@ impl Type<Odbc> for DateTime<Local> {`
`61`	`68`	`fn compatible(ty: &OdbcTypeInfo) -> bool {`
`62`	`69`	`matches!(ty.data_type(), DataType::Timestamp { .. })`
`63`	`70`	`\|\| ty.data_type().accepts_character_data()`
	`71`	`+ \|\| matches!(ty.data_type(), DataType::Other { .. } \| DataType::Unknown)`
`64`	`72`	`}`
`65`	`73`	`}`
`66`	`74`
`@@ -168,8 +176,18 @@ impl<'r> Decode<'r, Odbc> for NaiveTime {`
`168`	`176`
`169`	`177`	`impl<'r> Decode<'r, Odbc> for NaiveDateTime {`
`170`	`178`	`fn decode(value: OdbcValueRef<'r>) -> Result<Self, BoxDynError> {`
`171`		`- let s = <String as Decode<'r, Odbc>>::decode(value)?;`
`172`		`- Ok(s.parse()?)`
	`179`	`+ let mut s = <String as Decode<'r, Odbc>>::decode(value)?;`
	`180`	`+ // Some ODBC drivers (e.g. PostgreSQL) may include trailing spaces or NULs`
	`181`	`+ // in textual representations of timestamps. Trim them before parsing.`
	`182`	`+ if s.ends_with('\u{0}') {`
	`183`	`+ s = s.trim_end_matches('\u{0}').to_string();`
	`184`	`+ }`
	`185`	`+ let s_trimmed = s.trim();`
	`186`	`+ // Try strict format first, then fall back to Chrono's FromStr`
	`187`	`+ if let Ok(dt) = NaiveDateTime::parse_from_str(s_trimmed, "%Y-%m-%d %H:%M:%S") {`
	`188`	`+ return Ok(dt);`
	`189`	`+ }`
	`190`	`+ Ok(s_trimmed.parse()?)`
`173`	`191`	`}`
`174`	`192`	`}`
`175`	`193`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,12 @@ impl Type<Odbc> for Uuid {`
`12`	`12`	`// UUID string length`
`13`	`13`	`}`
`14`	`14`	`fn compatible(ty: &OdbcTypeInfo) -> bool {`
`15`		`- ty.data_type().accepts_character_data() \|\| ty.data_type().accepts_binary_data()`
	`15`	`+ ty.data_type().accepts_character_data()`
	`16`	`+ \|\| ty.data_type().accepts_binary_data()`
	`17`	`+ \|\| matches!(`
	`18`	`+ ty.data_type(),`
	`19`	`+ odbc_api::DataType::Other { .. } \| odbc_api::DataType::Unknown`
	`20`	`+ )`
`16`	`21`	`}`
`17`	`22`	`}`
`18`	`23`
`@@ -32,14 +37,13 @@ impl<'r> Decode<'r, Odbc> for Uuid {`
`32`	`37`	`fn decode(value: OdbcValueRef<'r>) -> Result<Self, BoxDynError> {`
`33`	`38`	`if let Some(bytes) = value.blob {`
`34`	`39`	`if bytes.len() == 16 {`
`35`		`- // Binary UUID format`
`36`	`40`	`return Ok(Uuid::from_bytes(bytes.try_into()?));`
`37`	`41`	`}`
`38`		`- // Try as string`
`39`		`- let s = std::str::from_utf8(bytes)?;`
	`42`	`+ // Some drivers may return UUIDs as ASCII/UTF-8 bytes`
	`43`	`+ let s = std::str::from_utf8(bytes)?.trim();`
`40`	`44`	`return Ok(Uuid::from_str(s)?);`
`41`	`45`	`}`
`42`	`46`	`let s = <String as Decode<'r, Odbc>>::decode(value)?;`
`43`		`- Ok(Uuid::from_str(&s)?)`
	`47`	`+ Ok(Uuid::from_str(s.trim())?)`
`44`	`48`	`}`
`45`	`49`	`}`