feat: Enhanced BLOB support across all database backends

- Add comprehensive BLOB support for all supported databases:
  * PostgreSQL: BYTEA columns with data URL conversion
  * MySQL/MariaDB: BLOB columns with data URL conversion
  * MSSQL: VARBINARY, BIGVARBINARY, BINARY, IMAGE columns
  * SQLite: BLOB columns with data URL conversion

- Create shared data URL conversion functions to eliminate code duplication
- Add comprehensive tests for all database types
- Update CHANGELOG.md with detailed feature description

- All blob data is now consistently converted to data URLs with base64 encoding
- Cross-database compatibility ensures identical blob behavior across all backends
- Comprehensive testing validates functionality across PostgreSQL, MySQL, MariaDB, MSSQL, and SQLite

Author: lovasoa

CHANGELOG.md

@@ -11,6 +11,14 @@
    - Since modals have their own url inside the page, you can now link to a modal from another page, and if you refresh a page while the modal is open, the modal will stay open.
    - modals now have an `open` parameter to open the modal automatically when the page is loaded.
  - New [download](https://sql-page.com/component.sql?component=download) component to let the user download files. The files may be stored as BLOBs in the database, local files on the server, or may be fetched from a different server.
+ - **Enhanced BLOB Support**: Comprehensive improvements to binary data handling across all supported databases:
+   - **PostgreSQL**: Full support for `BYTEA` columns with automatic conversion to data URLs
+   - **MySQL/MariaDB**: Full support for `BLOB` columns with automatic conversion to data URLs
+   - **MSSQL**: Extended support for `VARBINARY`, `BIGVARBINARY`, `BINARY`, and `IMAGE` columns with automatic conversion to data URLs
+   - **SQLite**: Full support for `BLOB` columns with automatic conversion to data URLs
+   - **Unified API**: All blob data is now consistently converted to data URLs with base64 encoding, eliminating code duplication
+   - **Cross-Database Compatibility**: Blob functionality now works identically across all supported database backends
+   - **Comprehensive Testing**: Added blob tests for all database types ensuring reliable functionality
 
 ## v0.36.1
  - Fix regression introduced in v0.36.0: PostgreSQL money values showed as 0.0

docker-compose.yml

@@ -4,6 +4,11 @@
 # DATABASE_URL='postgres://root:Password123!@localhost/sqlpage'
 # DATABASE_URL='mssql://root:Password123!@localhost/sqlpage'
 # DATABASE_URL='mysql://root:Password123!@localhost/sqlpage'
+
+# Run for instance:
+# docker compose up postgres
+# and in another terminal:
+# DATABASE_URL='db_url' cargo test
 services:
   web:
     build: { context: "." }

src/webserver/database/sql_to_json.rs

@@ -96,6 +96,7 @@ pub fn sql_nonnull_to_json<'r>(mut get_ref: impl FnMut() -> sqlx::any::AnyValueR
             decode_raw::<f64>(raw_value).into()
         }
         "JSON" | "JSON[]" | "JSONB" | "JSONB[]" => decode_raw::<Value>(raw_value),
+        "BLOB" | "BYTEA" | "FILESTREAM" | "VARBINARY" | "BIGVARBINARY" | "BINARY" | "IMAGE" => vec_to_data_uri_value(decode_raw::<Vec<u8>>(raw_value)),
         // Deserialize as a string by default
         _ => decode_raw::<String>(raw_value).into(),
     }
@@ -111,6 +112,30 @@ pub fn row_to_string(row: &AnyRow) -> Option<String> {
     }
 }
 
+/// Converts binary data to a data URL string.
+/// This function is used by both SQL type conversion and file reading functions.
+pub fn vec_to_data_uri(bytes: Vec<u8>) -> String {
+    vec_to_data_uri_with_mime(bytes, "application/octet-stream")
+}
+
+/// Converts binary data to a data URL string with a specific MIME type.
+/// This function is used by both SQL type conversion and file reading functions.
+pub fn vec_to_data_uri_with_mime(bytes: Vec<u8>, mime_type: &str) -> String {
+    let mut data_url = format!("data:{};base64,", mime_type);
+    base64::Engine::encode_string(
+        &base64::engine::general_purpose::STANDARD,
+        &bytes,
+        &mut data_url,
+    );
+    data_url
+}
+
+/// Converts binary data to a data URL JSON value.
+/// This is a convenience function for SQL type conversion.
+pub fn vec_to_data_uri_value(bytes: Vec<u8>) -> Value {
+    Value::String(vec_to_data_uri(bytes))
+}
+
 #[cfg(test)]
 mod tests {
     use crate::app_config::tests::test_database_url;
@@ -171,7 +196,7 @@ mod tests {
         };
         let mut c = sqlx::AnyConnection::connect(&db_url).await?;
         let row = sqlx::query(
-            "SELECT 
+            "SELECT
                 42::INT2 as small_int,
                 42::INT4 as integer,
                 42::INT8 as big_int,
@@ -189,7 +214,8 @@ mod tests {
                 '{\"key\": \"value\"}'::JSONB as jsonb,
                 age('2024-03-14'::timestamp, '2024-01-01'::timestamp) as age_interval,
                 justify_interval(interval '1 year 2 months 3 days') as justified_interval,
-                1234.56::MONEY as money_val",
+                1234.56::MONEY as money_val,
+                '\\x68656c6c6f20776f726c64'::BYTEA as blob_data",
         )
         .fetch_one(&mut c)
         .await?;
@@ -214,7 +240,8 @@ mod tests {
                 "jsonb": {"key": "value"},
                 "age_interval": "2 mons 13 days",
                 "justified_interval": "1 year 2 mons 3 days",
-                "money_val": "$1,234.56"
+                "money_val": "$1,234.56",
+                "blob_data": "data:application/octet-stream;base64,aGVsbG8gd29ybGQ="
             }),
         );
         Ok(())
@@ -235,7 +262,8 @@ mod tests {
                 '2024-03-14 13:14:15+02:00'::TIMESTAMPTZ as timestamptz,
                 INTERVAL '-01:02:03' as time_interval,
                 '{\"key\": \"value\"}'::JSON as json,
-                1234.56::MONEY as money_val
+                1234.56::MONEY as money_val,
+                '\\x74657374'::BYTEA as blob_data
             where $1",
         )
         .bind(true)
@@ -250,7 +278,8 @@ mod tests {
                 "timestamptz": "2024-03-14T11:14:15+00:00",
                 "time_interval": "-01:02:03",
                 "json": {"key": "value"},
-                "money_val": "" // TODO: fix this bug: https://github.com/sqlpage/SQLPage/issues/983
+                "money_val": "", // TODO: fix this bug: https://github.com/sqlpage/SQLPage/issues/983
+                "blob_data": "data:application/octet-stream;base64,dGVzdA=="
             }),
         );
         Ok(())
@@ -287,9 +316,10 @@ mod tests {
                 year_val YEAR,
                 char_val CHAR(10),
                 varchar_val VARCHAR(50),
-                text_val TEXT
-            ) AS 
-            SELECT 
+                text_val TEXT,
+                blob_val BLOB
+            ) AS
+            SELECT
                 127 as tiny_int,
                 32767 as small_int,
                 8388607 as medium_int,
@@ -311,7 +341,8 @@ mod tests {
                 2024 as year_val,
                 'CHAR' as char_val,
                 'VARCHAR' as varchar_val,
-                'TEXT' as text_val",
+                'TEXT' as text_val,
+                x'626c6f62' as blob_val",
         )
         .execute(&mut c)
         .await?;
@@ -344,7 +375,8 @@ mod tests {
                 "year_val": 2024,
                 "char_val": "CHAR",
                 "varchar_val": "VARCHAR",
-                "text_val": "TEXT"
+                "text_val": "TEXT",
+                "blob_val": "data:application/octet-stream;base64,YmxvYg=="
             }),
         );
 
@@ -375,7 +407,7 @@ mod tests {
                 "integer": 42,
                 "real": 42.25,
                 "string": "xxx",
-                "blob": "hello world",
+                "blob": "data:application/octet-stream;base64,aGVsbG8gd29ybGQ=",
             }),
         );
         Ok(())
@@ -388,7 +420,7 @@ mod tests {
         };
         let mut c = sqlx::AnyConnection::connect(&db_url).await?;
         let row = sqlx::query(
-            "SELECT 
+            "SELECT
                 CAST(1 AS BIT) as true_bit,
                 CAST(0 AS BIT) as false_bit,
                 CAST(NULL AS BIT) as null_bit,
@@ -407,7 +439,8 @@ mod tests {
                 N'Unicode String' as nvarchar,
                 'ASCII String' as varchar,
                 CAST(1234.56 AS MONEY) as money_val,
-                CAST(12.34 AS SMALLMONEY) as small_money_val",
+                CAST(12.34 AS SMALLMONEY) as small_money_val,
+                CAST(0x6D7373716C AS VARBINARY(10)) as blob_data",
         )
         .fetch_one(&mut c)
         .await?;
@@ -433,12 +466,54 @@ mod tests {
                 "nvarchar": "Unicode String",
                 "varchar": "ASCII String",
                 "money_val": 1234.56,
-                "small_money_val": 12.34
+                "small_money_val": 12.34,
+                "blob_data": "data:application/octet-stream;base64,bXNzcWw="
             }),
         );
         Ok(())
     }
 
+    #[test]
+    fn test_vec_to_data_uri() {
+        // Test with empty bytes
+        let result = vec_to_data_uri(vec![]);
+        assert_eq!(result, "data:application/octet-stream;base64,");
+
+        // Test with simple text
+        let result = vec_to_data_uri(b"Hello World".to_vec());
+        assert_eq!(result, "data:application/octet-stream;base64,SGVsbG8gV29ybGQ=");
+
+        // Test with binary data
+        let binary_data = vec![0, 1, 2, 255, 254, 253];
+        let result = vec_to_data_uri(binary_data);
+        assert_eq!(result, "data:application/octet-stream;base64,AAEC//79");
+    }
+
+    #[test]
+    fn test_vec_to_data_uri_with_mime() {
+        // Test with custom MIME type
+        let result = vec_to_data_uri_with_mime(b"Hello".to_vec(), "text/plain");
+        assert_eq!(result, "data:text/plain;base64,SGVsbG8=");
+
+        // Test with image MIME type
+        let result = vec_to_data_uri_with_mime(vec![255, 216, 255], "image/jpeg");
+        assert_eq!(result, "data:image/jpeg;base64,/9j/");
+
+        // Test with empty bytes and custom MIME
+        let result = vec_to_data_uri_with_mime(vec![], "application/json");
+        assert_eq!(result, "data:application/json;base64,");
+    }
+
+    #[test]
+    fn test_vec_to_data_uri_value() {
+        // Test that it returns a JSON string value
+        let result = vec_to_data_uri_value(b"test".to_vec());
+        match result {
+            Value::String(s) => assert_eq!(s, "data:application/octet-stream;base64,dGVzdA=="),
+            _ => panic!("Expected String value"),
+        }
+    }
+
     fn expect_json_object_equal(actual: &Value, expected: &Value) {
         use std::fmt::Write;
 

src/webserver/database/sqlpage_functions/functions.rs

@@ -2,6 +2,7 @@ use super::RequestInfo;
 use crate::webserver::{
     database::{
         execute_queries::DbConn, sqlpage_functions::url_parameter_deserializer::URLParameters,
+        sql_to_json::vec_to_data_uri_with_mime,
     },
     http::SingleOrVec,
     http_client::make_http_client,
@@ -504,12 +505,7 @@ async fn read_file_as_data_url<'a>(
         || Cow::Owned(mime_guess_from_filename(&file_path)),
         Cow::Borrowed,
     );
-    let mut data_url = format!("data:{mime};base64,");
-    base64::Engine::encode_string(
-        &base64::engine::general_purpose::STANDARD,
-        bytes,
-        &mut data_url,
-    );
+    let data_url = vec_to_data_uri_with_mime(bytes, &mime.to_string());
     Ok(Some(Cow::Owned(data_url)))
 }