fix: (#3387) use collation to determine if string type is compatible

sqlx-mysql/src/protocol/text/column.rs

@@ -3,6 +3,7 @@ use std::str::from_utf8;
 use bitflags::bitflags;
 use bytes::{Buf, Bytes};
 
+use crate::collation::Collation;
 use crate::error::Error;
 use crate::io::Decode;
 use crate::io::MySqlBufExt;
@@ -62,6 +63,10 @@ bitflags! {
 }
 
 // https://dev.mysql.com/doc/internals/en/com-query-response.html#column-type
+// dead link ^
+// https://dev.mysql.com/doc/dev/mysql-server/9.0.0/page_protocol_com_query_response_text_resultset_column_definition.html
+// the "type of the column as defined in enum_field_types"
+// https://dev.mysql.com/doc/dev/mysql-server/9.0.0/field__types_8h.html
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 #[cfg_attr(feature = "offline", derive(serde::Serialize, serde::Deserialize))]
@@ -112,8 +117,7 @@ pub(crate) struct ColumnDefinition {
     table: Bytes,
     alias: Bytes,
     name: Bytes,
-    #[allow(unused)]
-    pub(crate) collation: u16,
+    pub(crate) collation: Collation,
     pub(crate) max_size: u32,
     pub(crate) r#type: ColumnType,
     pub(crate) flags: ColumnFlags,
@@ -156,7 +160,7 @@ impl Decode<'_, Capabilities> for ColumnDefinition {
             table,
             alias,
             name,
-            collation,
+            collation: Collation::try_from(collation)?,
             max_size,
             r#type: ColumnType::try_from_u16(type_id)?,
             flags: ColumnFlags::from_bits_truncate(flags),
@@ -166,8 +170,13 @@ impl Decode<'_, Capabilities> for ColumnDefinition {
 }
 
 impl ColumnType {
-    pub(crate) fn name(self, flags: ColumnFlags, max_size: Option<u32>) -> &'static str {
-        let is_binary = flags.contains(ColumnFlags::BINARY);
+    pub(crate) fn name(
+        self,
+        collation: Collation,
+        flags: ColumnFlags,
+        max_size: Option<u32>,
+    ) -> &'static str {
+        let is_binary = collation == Collation::binary;
         let is_unsigned = flags.contains(ColumnFlags::UNSIGNED);
         let is_enum = flags.contains(ColumnFlags::ENUM);
 

sqlx-mysql/src/type_info.rs

@@ -2,14 +2,18 @@ use std::fmt::{self, Display, Formatter};
 
 pub(crate) use sqlx_core::type_info::*;
 
-use crate::protocol::text::{ColumnDefinition, ColumnFlags, ColumnType};
+use crate::{
+    collation::Collation,
+    protocol::text::{ColumnDefinition, ColumnFlags, ColumnType},
+};
 
 /// Type information for a MySql type.
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "offline", derive(serde::Serialize, serde::Deserialize))]
 pub struct MySqlTypeInfo {
     pub(crate) r#type: ColumnType,
     pub(crate) flags: ColumnFlags,
+    pub(crate) collation: Collation,
 
     // [max_size] for integer types, this is (M) in BIT(M) or TINYINT(M)
     #[cfg_attr(feature = "offline", serde(default))]
@@ -20,6 +24,7 @@ impl MySqlTypeInfo {
     pub(crate) const fn binary(ty: ColumnType) -> Self {
         Self {
             r#type: ty,
+            collation: Collation::binary,
             flags: ColumnFlags::BINARY,
             max_size: None,
         }
@@ -38,6 +43,7 @@ impl MySqlTypeInfo {
         Self {
             r#type: ColumnType::String,
             flags: ColumnFlags::ENUM,
+            collation: Collation::binary,
             max_size: None,
         }
     }
@@ -60,6 +66,7 @@ impl MySqlTypeInfo {
         Self {
             r#type: column.r#type,
             flags: column.flags,
+            collation: column.collation,
             max_size: Some(column.max_size),
         }
     }
@@ -77,7 +84,7 @@ impl TypeInfo for MySqlTypeInfo {
     }
 
     fn name(&self) -> &str {
-        self.r#type.name(self.flags, self.max_size)
+        self.r#type.name(self.collation, self.flags, self.max_size)
     }
 }
 

sqlx-mysql/src/types/bool.rs

@@ -1,3 +1,4 @@
+use crate::collation::Collation;
 use crate::decode::Decode;
 use crate::encode::{Encode, IsNull};
 use crate::error::BoxDynError;
@@ -12,6 +13,7 @@ impl Type<MySql> for bool {
         // MySQL has no actual `BOOLEAN` type, the type is an alias of `TINYINT(1)`
         MySqlTypeInfo {
             flags: ColumnFlags::BINARY | ColumnFlags::UNSIGNED,
+            collation: Collation::binary,
             max_size: Some(1),
             r#type: ColumnType::Tiny,
         }

sqlx-mysql/src/types/str.rs

@@ -1,3 +1,4 @@
+use crate::collation::Collation;
 use crate::decode::Decode;
 use crate::encode::{Encode, IsNull};
 use crate::error::BoxDynError;
@@ -12,6 +13,7 @@ impl Type<MySql> for str {
         MySqlTypeInfo {
             r#type: ColumnType::VarString, // VARCHAR
             flags: ColumnFlags::empty(),
+            collation: Collation::utf8mb3_bin,
             max_size: None,
         }
     }
@@ -28,7 +30,7 @@ impl Type<MySql> for str {
                 | ColumnType::String
                 | ColumnType::VarString
                 | ColumnType::Enum
-        ) && !ty.flags.contains(ColumnFlags::BINARY)
+        ) && ty.collation != Collation::binary
     }
 }
 

sqlx-mysql/src/types/uint.rs

@@ -1,3 +1,4 @@
+use crate::collation::Collation;
 use crate::decode::Decode;
 use crate::encode::{Encode, IsNull};
 use crate::error::BoxDynError;
@@ -10,6 +11,7 @@ fn uint_type_info(ty: ColumnType) -> MySqlTypeInfo {
     MySqlTypeInfo {
         r#type: ty,
         flags: ColumnFlags::BINARY | ColumnFlags::UNSIGNED,
+        collation: Collation::binary,
         max_size: None,
     }
 }

tests/mysql/types.rs

@@ -384,3 +384,75 @@ CREATE TEMPORARY TABLE user_login (
 
     Ok(())
 }
+
+mod string_collation_tests {
+    use super::*;
+
+    #[sqlx_macros::test]
+    async fn test_binary_string_collation() -> anyhow::Result<()> {
+        let mut conn = new::<MySql>().await?;
+
+        conn.execute(
+            r#"
+    CREATE TEMPORARY TABLE strings (
+        id INT PRIMARY KEY AUTO_INCREMENT,
+        char_bin CHAR(50) COLLATE utf8mb4_bin,
+        varchar_bin VARCHAR(255) COLLATE utf8mb4_bin,
+        text_bin TEXT COLLATE utf8mb4_bin
+    );
+                "#,
+        )
+        .await?;
+
+        // Insert sample data
+        conn.execute(
+            r#"
+    INSERT INTO strings (char_bin, varchar_bin, text_bin) VALUES
+        ('char_binary', 'varchar_binary', 'text_binary');
+                "#,
+        )
+        .await?;
+
+        // Query the data back
+        let row: (String, String, String) = sqlx::query_as(
+            r#"
+    SELECT char_bin, varchar_bin, text_bin FROM strings
+                "#,
+        )
+        .fetch_one(&mut conn)
+        .await?;
+
+        // Assert the values
+        assert_eq!(row.0, "char_binary");
+        assert_eq!(row.1, "varchar_binary");
+        assert_eq!(row.2, "text_binary");
+
+        Ok(())
+    }
+
+    #[sqlx_macros::test]
+    async fn test_blob_to_string_err() -> anyhow::Result<()> {
+        let mut conn = new::<MySql>().await?;
+        conn.execute(
+            r#"
+    CREATE TEMPORARY TABLE blobs (
+        id INT PRIMARY KEY AUTO_INCREMENT,
+        myblob BLOB
+    );
+                "#,
+        )
+        .await?;
+
+        // Insert sample data
+        conn.execute("INSERT INTO blobs (myblob) VALUES ('0x243524598');")
+            .await?;
+
+        let res: Result<(i32, String), sqlx::Error> =
+            sqlx::query_as("SELECT id, myblob FROM blobs")
+                .fetch_one(&mut conn)
+                .await;
+
+        assert!(res.is_err());
+        Ok(())
+    }
+}