feat(odbc): enhance type compatibility and decoding for various data types

implemented after running tests with the snowflake odbc driver

- Added support for ODBC compatibility with additional types such as Numeric and Decimal across integer types.
- Improved decoding logic for Decimal, JSON, and date/time types to handle various input formats, including Unix timestamps and string representations.
- Introduced tests for new functionality and edge cases to ensure robustness and accuracy in data handling.

Author: lovasoa

sqlx-core/Cargo.toml

@@ -20,7 +20,7 @@ default = ["migrate"]
 migrate = ["sha2", "crc"]
 
 # databases
-all-databases = ["postgres", "mysql", "sqlite", "mssql", "any"]
+all-databases = ["postgres", "mysql", "sqlite", "mssql", "odbc", "any"]
 postgres = [
     "md-5",
     "sha2",

sqlx-core/src/odbc/row.rs

@@ -39,9 +39,15 @@ impl Row for OdbcRow {
 
 impl ColumnIndex<OdbcRow> for &str {
     fn index(&self, row: &OdbcRow) -> Result<usize, Error> {
+        // Try exact match first (for performance)
+        if let Some(pos) = row.columns.iter().position(|col| col.name == *self) {
+            return Ok(pos);
+        }
+
+        // Fall back to case-insensitive match (for databases like Snowflake)
         row.columns
             .iter()
-            .position(|col| col.name == *self)
+            .position(|col| col.name.eq_ignore_ascii_case(self))
             .ok_or_else(|| Error::ColumnNotFound((*self).into()))
     }
 }
@@ -52,6 +58,115 @@ mod private {
     impl Sealed for OdbcRow {}
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::odbc::{OdbcColumn, OdbcTypeInfo};
+    use crate::type_info::TypeInfo;
+    use odbc_api::DataType;
+
+    fn create_test_row() -> OdbcRow {
+        OdbcRow {
+            columns: vec![
+                OdbcColumn {
+                    name: "lowercase_col".to_string(),
+                    type_info: OdbcTypeInfo::new(DataType::Integer),
+                    ordinal: 0,
+                },
+                OdbcColumn {
+                    name: "UPPERCASE_COL".to_string(),
+                    type_info: OdbcTypeInfo::new(DataType::Varchar { length: None }),
+                    ordinal: 1,
+                },
+                OdbcColumn {
+                    name: "MixedCase_Col".to_string(),
+                    type_info: OdbcTypeInfo::new(DataType::Double),
+                    ordinal: 2,
+                },
+            ],
+            values: vec![
+                (OdbcTypeInfo::new(DataType::Integer), Some(vec![1, 2, 3, 4])),
+                (
+                    OdbcTypeInfo::new(DataType::Varchar { length: None }),
+                    Some(b"test".to_vec()),
+                ),
+                (
+                    OdbcTypeInfo::new(DataType::Double),
+                    Some(vec![1, 2, 3, 4, 5, 6, 7, 8]),
+                ),
+            ],
+        }
+    }
+
+    #[test]
+    fn test_exact_column_match() {
+        let row = create_test_row();
+
+        // Exact matches should work
+        assert_eq!("lowercase_col".index(&row).unwrap(), 0);
+        assert_eq!("UPPERCASE_COL".index(&row).unwrap(), 1);
+        assert_eq!("MixedCase_Col".index(&row).unwrap(), 2);
+    }
+
+    #[test]
+    fn test_case_insensitive_column_match() {
+        let row = create_test_row();
+
+        // Case-insensitive matches should work
+        assert_eq!("LOWERCASE_COL".index(&row).unwrap(), 0);
+        assert_eq!("lowercase_col".index(&row).unwrap(), 0);
+        assert_eq!("uppercase_col".index(&row).unwrap(), 1);
+        assert_eq!("UPPERCASE_COL".index(&row).unwrap(), 1);
+        assert_eq!("mixedcase_col".index(&row).unwrap(), 2);
+        assert_eq!("MIXEDCASE_COL".index(&row).unwrap(), 2);
+        assert_eq!("MixedCase_Col".index(&row).unwrap(), 2);
+    }
+
+    #[test]
+    fn test_column_not_found() {
+        let row = create_test_row();
+
+        let result = "nonexistent_column".index(&row);
+        assert!(result.is_err());
+        if let Err(Error::ColumnNotFound(name)) = result {
+            assert_eq!(name, "nonexistent_column");
+        } else {
+            panic!("Expected ColumnNotFound error");
+        }
+    }
+
+    #[test]
+    fn test_try_get_raw() {
+        let row = create_test_row();
+
+        // Test accessing by exact name
+        let value = row.try_get_raw("lowercase_col").unwrap();
+        assert!(!value.is_null);
+        assert_eq!(value.type_info.name(), "INTEGER");
+
+        // Test accessing by case-insensitive name
+        let value = row.try_get_raw("LOWERCASE_COL").unwrap();
+        assert!(!value.is_null);
+        assert_eq!(value.type_info.name(), "INTEGER");
+
+        // Test accessing uppercase column with lowercase name
+        let value = row.try_get_raw("uppercase_col").unwrap();
+        assert!(!value.is_null);
+        assert_eq!(value.type_info.name(), "VARCHAR");
+    }
+
+    #[test]
+    fn test_columns_method() {
+        let row = create_test_row();
+        let columns = row.columns();
+
+        assert_eq!(columns.len(), 3);
+        assert_eq!(columns[0].name, "lowercase_col");
+        assert_eq!(columns[1].name, "UPPERCASE_COL");
+        assert_eq!(columns[2].name, "MixedCase_Col");
+    }
+}
+
 #[cfg(feature = "any")]
 impl From<OdbcRow> for crate::any::AnyRow {
     fn from(row: OdbcRow) -> Self {