Refactor SQL column handling to ensure consistent JSON output

- Updated column name handling in `row_to_json` to use lowercase for ODBC databases.
- Added `canonical_col_name` function to standardize column names.
- Modified SQL queries in tests to use lowercase column names for consistency.
- Enhanced tests for edge cases and variations in column naming.

Author: lovasoa

src/webserver/database/sql_to_json.rs

@@ -3,7 +3,7 @@ use crate::webserver::database::blob_to_data_url;
 use bigdecimal::{BigDecimal, ToPrimitive};
 use chrono::{DateTime, FixedOffset, NaiveDateTime};
 use serde_json::{self, Map, Value};
-use sqlx::any::{AnyRow, AnyTypeInfo, AnyTypeInfoKind};
+use sqlx::any::{AnyColumn, AnyRow, AnyTypeInfo, AnyTypeInfoKind};
 use sqlx::Decode;
 use sqlx::{Column, Row, TypeInfo, ValueRef};
 
@@ -13,13 +13,27 @@ pub fn row_to_json(row: &AnyRow) -> Value {
     let columns = row.columns();
     let mut map = Map::new();
     for col in columns {
-        let key = col.name().to_string();
+        let key = canonical_col_name(col);
         let value: Value = sql_to_json(row, col);
         map = add_value_to_map(map, (key, value));
     }
     Object(map)
 }
 
+fn canonical_col_name(col: &AnyColumn) -> String {
+    // Some databases fold all unquoted identifiers to uppercase but SQLPage uses lowercase property names
+    if matches!(col.type_info().0, AnyTypeInfoKind::Odbc(_))
+        && col
+            .name()
+            .chars()
+            .all(|c| c.is_ascii_uppercase() || c == '_')
+    {
+        col.name().to_ascii_lowercase()
+    } else {
+        col.name().to_owned()
+    }
+}
+
 pub fn sql_to_json(row: &AnyRow, col: &sqlx::any::AnyColumn) -> Value {
     let raw_value_result = row.try_get_raw(col.ordinal());
     match raw_value_result {
@@ -160,23 +174,23 @@ mod tests {
         let db_url = test_database_url();
         let mut c = sqlx::AnyConnection::connect(&db_url).await?;
         let row = sqlx::query(
-            r#"SELECT
-                123.456 as "ONE_VALUE",
-                1 as "TWO_VALUES",
-                2 as "TWO_VALUES",
-                'x' as "THREE_VALUES",
-                'y' as "THREE_VALUES",
-                'z' as "THREE_VALUES"
-        "#,
+            "SELECT
+                123.456 as one_value,
+                1 as two_values,
+                2 as two_values,
+                'x' as three_values,
+                'y' as three_values,
+                'z' as three_values
+        ",
         )
         .fetch_one(&mut c)
         .await?;
         expect_json_object_equal(
             &row_to_json(&row),
             &serde_json::json!({
-                "ONE_VALUE": 123.456,
-                "TWO_VALUES": [1,2],
-                "THREE_VALUES": ["x","y","z"],
+                "one_value": 123.456,
+                "two_values": [1,2],
+                "three_values": ["x","y","z"],
             }),
         );
         Ok(())
@@ -506,6 +520,100 @@ mod tests {
         );
     }
 
+    #[actix_web::test]
+    async fn test_canonical_col_name_variations() -> anyhow::Result<()> {
+        let db_url = test_database_url();
+        let mut c = sqlx::AnyConnection::connect(&db_url).await?;
+
+        // Test various column name formats to ensure canonical_col_name works correctly
+        let row = sqlx::query(
+            r#"SELECT
+                42 as "UPPERCASE_COL",
+                42 as "lowercase_col",
+                42 as "Mixed_Case_Col",
+                42 as "COL_WITH_123_NUMBERS",
+                42 as "col-with-dashes",
+                42 as "col with spaces",
+                42 as "_UNDERSCORE_PREFIX",
+                42 as "123_NUMBER_PREFIX"
+        "#,
+        )
+        .fetch_one(&mut c)
+        .await?;
+
+        let json_result = row_to_json(&row);
+
+        // For ODBC databases, uppercase columns should be converted to lowercase
+        // For other databases, names should remain as-is
+        let expected_json = if c.kind() == sqlx::any::AnyKind::Odbc {
+            // ODBC database - uppercase should be converted to lowercase
+            serde_json::json!({
+                "uppercase_col": 42,
+                "lowercase_col": 42,
+                "Mixed_Case_Col": 42,
+                "COL_WITH_123_NUMBERS": 42,
+                "col-with-dashes": 42,
+                "col with spaces": 42,
+                "_underscore_prefix": 42,
+                "123_NUMBER_PREFIX": 42
+            })
+        } else {
+            // Non-ODBC database - names remain as-is
+            serde_json::json!({
+                "UPPERCASE_COL": 42,
+                "lowercase_col": 42,
+                "Mixed_Case_Col": 42,
+                "COL_WITH_123_NUMBERS": 42,
+                "col-with-dashes": 42,
+                "col with spaces": 42,
+                "_UNDERSCORE_PREFIX": 42,
+                "123_NUMBER_PREFIX": 42
+            })
+        };
+
+        expect_json_object_equal(&json_result, &expected_json);
+
+        Ok(())
+    }
+
+    #[actix_web::test]
+    async fn test_row_to_json_edge_cases() -> anyhow::Result<()> {
+        let db_url = test_database_url();
+        let mut c = sqlx::AnyConnection::connect(&db_url).await?;
+
+        // Test edge cases for row_to_json
+        let row = sqlx::query(
+            "SELECT
+                NULL as null_col,
+                '' as empty_string,
+                0 as zero_value,
+                -42 as negative_int,
+                1.23456 as my_float,
+                'special_chars_!@#$%^&*()' as special_chars,
+                'line1
+line2' as multiline_string
+        ",
+        )
+        .fetch_one(&mut c)
+        .await?;
+
+        let json_result = row_to_json(&row);
+
+        let expected_json = serde_json::json!({
+            "null_col": null,
+            "empty_string": "",
+            "zero_value": 0,
+            "negative_int": -42,
+            "my_float": 1.23456,
+            "special_chars": "special_chars_!@#$%^&*()",
+            "multiline_string": "line1\nline2"
+        });
+
+        expect_json_object_equal(&json_result, &expected_json);
+
+        Ok(())
+    }
+
     /// Compare JSON values, treating integers and floats that are numerically equal as equal
     fn json_values_equal(a: &Value, b: &Value) -> bool {
         use Value::*;

tests/data_formats/csv_data.sql

@@ -3,9 +3,9 @@ select
     ';' as separator;
 
 select
-    0 as "ID",
-    'Hello World !' as "MSG"
+    0 as id,
+    'Hello World !' as msg
 union all
 select
-    1 as "ID",
-    'Tu gères '';'' et ''"'' ?' as "MSG";
+    1 as id,
+    'Tu gères '';'' et ''"'' ?' as msg;

tests/data_formats/mod.rs

@@ -43,7 +43,7 @@ async fn test_csv_body() -> actix_web::Result<()> {
     let body_str = String::from_utf8(body.to_vec()).unwrap();
     assert_eq!(
         body_str,
-        "ID;MSG\n0;Hello World !\n1;\"Tu gères ';' et '\"\"' ?\"\n"
+        "id;msg\n0;Hello World !\n1;\"Tu gères ';' et '\"\"' ?\"\n"
     );
     Ok(())
 }