mysql: sized blob data type moved to MySqlType & upstream StringLen

src/backend/mysql/table.rs

@@ -34,8 +34,9 @@ impl TableBuilder for MysqlQueryBuilder {
                     None => "char".into(),
                 },
                 ColumnType::String(length) => match length {
-                    Some(length) => format!("varchar({length})"),
-                    None => "varchar(255)".into(),
+                    StringLen::N(length) => format!("varchar({length})"),
+                    StringLen::None => format!("varchar(255)"),
+                    StringLen::Max => "varchar(65535)".into(),
                 },
                 ColumnType::Text => "text".into(),
                 ColumnType::TinyInteger | ColumnType::TinyUnsigned => "tinyint".into(),
@@ -63,18 +64,12 @@ impl TableBuilder for MysqlQueryBuilder {
                     }
                 }
                 ColumnType::Interval(_, _) => "unsupported".into(),
-                ColumnType::Binary(blob_size) => match blob_size {
-                    BlobSize::Tiny => "tinyblob".into(),
-                    BlobSize::Blob(length) => {
-                        match length {
-                            Some(length) => format!("binary({length})"),
-                            None => "blob".into(),
-                        }
-                    }
-                    BlobSize::Medium => "mediumblob".into(),
-                    BlobSize::Long => "longblob".into(),
+                ColumnType::Binary(length) => format!("binary({length})"),
+                ColumnType::VarBinary(length) => match length {
+                    StringLen::N(length) => format!("varbinary({length})"),
+                    StringLen::None => format!("varbinary(255)"),
+                    StringLen::Max => "varbinary(65535)".into(),
                 },
-                ColumnType::VarBinary(length) => format!("varbinary({length})"),
                 ColumnType::Bit(length) => {
                     match length {
                         Some(length) => format!("bit({length})"),

src/backend/postgres/table.rs

@@ -18,8 +18,8 @@ impl TableBuilder for PostgresQueryBuilder {
                     None => "char".into(),
                 },
                 ColumnType::String(length) => match length {
-                    Some(length) => format!("varchar({length})"),
-                    None => "varchar".into(),
+                    StringLen::N(length) => format!("varchar({length})"),
+                    _ => "varchar".into(),
                 },
                 ColumnType::Text => "text".into(),
                 ColumnType::TinyInteger | ColumnType::TinyUnsigned => "smallint".into(),
@@ -48,7 +48,10 @@ impl TableBuilder for PostgresQueryBuilder {
                     typ
                 }
                 ColumnType::Binary(_) => "bytea".into(),
-                ColumnType::VarBinary(length) => format!("bit varying({length})"),
+                ColumnType::VarBinary(length) => match length {
+                    StringLen::N(length) => format!("bit varying({length})"),
+                    _ => "bit varying".into(),
+                },
                 ColumnType::Bit(length) => {
                     match length {
                         Some(length) => format!("varbit({length})"),

src/backend/sqlite/table.rs

@@ -135,8 +135,8 @@ impl SqliteQueryBuilder {
                     None => "char".into(),
                 },
                 ColumnType::String(length) => match length {
-                    Some(length) => format!("varchar({length})"),
-                    None => "varchar".into(),
+                    StringLen::N(length) => format!("varchar({length})"),
+                    _ => "varchar".into(),
                 },
                 ColumnType::Text => "text".into(),
                 ColumnType::TinyInteger | ColumnType::TinyUnsigned => integer("tinyint").into(),
@@ -167,14 +167,11 @@ impl SqliteQueryBuilder {
                 ColumnType::Date => "date_text".into(),
                 ColumnType::Interval(_, _) =>
                     unimplemented!("Interval is not available in Sqlite."),
-                ColumnType::Binary(blob_size) => match blob_size {
-                    BlobSize::Tiny => "tinyblob".into(),
-                    BlobSize::Blob(Some(length)) => format!("blob({length})"),
-                    BlobSize::Blob(None) => "blob".into(),
-                    BlobSize::Medium => "mediumblob".into(),
-                    BlobSize::Long => "longblob".into(),
+                ColumnType::Binary(length) => format!("blob({length})"),
+                ColumnType::VarBinary(length) => match length {
+                    StringLen::N(length) => format!("varbinary_blob({length})"),
+                    _ => "varbinary_blob".into(),
                 },
-                ColumnType::VarBinary(length) => format!("varbinary_blob({length})"),
                 ColumnType::Boolean => "boolean".into(),
                 ColumnType::Money(precision) => match precision {
                     Some((precision, scale)) => format!("money({precision}, {scale})"),

src/extension/mysql/column.rs

@@ -0,0 +1,21 @@
+use crate::Iden;
+
+#[derive(Debug, Copy, Clone)]
+pub enum MySqlType {
+    Blob,
+    TinyBlob,
+    MediumBlob,
+    LongBlob,
+}
+
+impl Iden for MySqlType {
+    fn unquoted(&self, s: &mut dyn std::fmt::Write) {
+        let ty = match self {
+            Self::Blob => "blob",
+            Self::TinyBlob => "tinyblob",
+            Self::MediumBlob => "mediumblob",
+            Self::LongBlob => "longblob",
+        };
+        write!(s, "{ty}").unwrap();
+    }
+}

src/extension/mysql/mod.rs

@@ -1,5 +1,7 @@
+mod column;
 mod index;
 mod select;
 
+pub use column::*;
 pub use index::*;
 pub use select::*;

src/table/column.rs

@@ -14,7 +14,7 @@ pub struct ColumnDef {
 #[derive(Debug, Clone)]
 pub enum ColumnType {
     Char(Option<u32>),
-    String(Option<u32>),
+    String(StringLen),
     Text,
     TinyInteger,
     SmallInteger,
@@ -34,8 +34,8 @@ pub enum ColumnType {
     Date,
     Year(Option<MySqlYear>),
     Interval(Option<PgInterval>, Option<u32>),
-    Binary(BlobSize),
-    VarBinary(u32),
+    Binary(u32),
+    VarBinary(StringLen),
     Bit(Option<u32>),
     VarBit(u32),
     Boolean,
@@ -55,6 +55,21 @@ pub enum ColumnType {
     LTree,
 }
 
+/// Length for var-char/binary; default to 255
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum StringLen {
+    /// String size
+    N(u32),
+    Max,
+    None,
+}
+
+impl Default for StringLen {
+    fn default() -> Self {
+        Self::None
+    }
+}
+
 impl PartialEq for ColumnType {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
@@ -140,15 +155,6 @@ pub enum MySqlYear {
     Four,
 }
 
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum BlobSize {
-    Tiny,
-    /// MySQL & SQLite support `binary(length)` column type
-    Blob(Option<u32>),
-    Medium,
-    Long,
-}
-
 impl ColumnDef {
     /// Construct a table column
     pub fn new<T>(name: T) -> Self
@@ -266,13 +272,19 @@ impl ColumnDef {
 
     /// Set column type as string with custom length
     pub fn string_len(&mut self, length: u32) -> &mut Self {
-        self.types = Some(ColumnType::String(Some(length)));
+        self.types = Some(ColumnType::String(StringLen::N(length)));
+        self
+    }
+
+    /// Set column type as string with maximum length
+    pub fn string_max(&mut self) -> &mut Self {
+        self.types = Some(ColumnType::String(StringLen::Max));
         self
     }
 
     /// Set column type as string
     pub fn string(&mut self) -> &mut Self {
-        self.types = Some(ColumnType::String(None));
+        self.types = Some(ColumnType::String(Default::default()));
         self
     }
 
@@ -437,26 +449,20 @@ impl ColumnDef {
     }
 
     /// Set column type as binary with custom length
-    pub fn binary_len(&mut self, length: u32) -> &mut Self {
-        self.types = Some(ColumnType::Binary(BlobSize::Blob(Some(length))));
-        self
-    }
-
-    /// Set column type as binary
-    pub fn binary(&mut self) -> &mut Self {
-        self.types = Some(ColumnType::Binary(BlobSize::Blob(None)));
+    pub fn binary(&mut self, length: u32) -> &mut Self {
+        self.types = Some(ColumnType::Binary(length));
         self
     }
 
-    /// Set column type as blob, but when given BlobSize::Blob(size) argument, this column map to binary(size) type instead.
-    pub fn blob(&mut self, size: BlobSize) -> &mut Self {
-        self.types = Some(ColumnType::Binary(size));
+    /// Set column type as binary with variable length
+    pub fn var_binary(&mut self, length: u32) -> &mut Self {
+        self.types = Some(ColumnType::VarBinary(StringLen::N(length)));
         self
     }
 
-    /// Set column type as binary with variable length
-    pub fn var_binary(&mut self, length: u32) -> &mut Self {
-        self.types = Some(ColumnType::VarBinary(length));
+    /// Set column type as binary with maximum length
+    pub fn var_binary_max(&mut self) -> &mut Self {
+        self.types = Some(ColumnType::VarBinary(StringLen::Max));
         self
     }
 

src/value.rs

@@ -31,7 +31,7 @@ use std::net::IpAddr;
 #[cfg(feature = "with-mac_address")]
 use mac_address::MacAddress;
 
-use crate::{BlobSize, ColumnType, CommonSqlQueryBuilder, QueryBuilder};
+use crate::{ColumnType, CommonSqlQueryBuilder, QueryBuilder, StringLen};
 
 /// [`Value`] types variant for Postgres array
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
@@ -495,12 +495,12 @@ impl ValueType for Cow<'_, str> {
     }
 
     fn column_type() -> ColumnType {
-        ColumnType::String(None)
+        ColumnType::String(StringLen::Max)
     }
 }
 
-type_to_box_value!(Vec<u8>, Bytes, Binary(BlobSize::Blob(None)));
-type_to_box_value!(String, String, String(None));
+type_to_box_value!(Vec<u8>, Bytes, VarBinary(StringLen::Max));
+type_to_box_value!(String, String, String(StringLen::Max));
 
 #[cfg(feature = "with-json")]
 #[cfg_attr(docsrs, doc(cfg(feature = "with-json")))]

tests/common.rs

@@ -11,6 +11,7 @@ use sea_query::Iden;
 ///
 /// [`Iden`]: crate::types::Iden
 #[derive(Debug)]
+#[allow(dead_code)]
 pub enum BinaryType {
     Table,
     BinaryLen,

tests/mysql/mod.rs

@@ -1,4 +1,4 @@
-use sea_query::{tests_cfg::*, *};
+use sea_query::{extension::mysql::*, tests_cfg::*, *};
 
 mod foreign_key;
 mod index;

tests/mysql/table.rs

@@ -163,20 +163,17 @@ fn create_6() {
     assert_eq!(
         Table::create()
             .table(BinaryType::Table)
-            .col(ColumnDef::new(BinaryType::BinaryLen).binary_len(32))
-            .col(ColumnDef::new(BinaryType::Binary).binary())
-            .col(ColumnDef::new(BinaryType::BlobSize).blob(BlobSize::Blob(Some(32))))
-            .col(ColumnDef::new(BinaryType::TinyBlob).blob(BlobSize::Tiny))
-            .col(ColumnDef::new(BinaryType::Blob).blob(BlobSize::Blob(None)))
-            .col(ColumnDef::new(BinaryType::MediumBlob).blob(BlobSize::Medium))
-            .col(ColumnDef::new(BinaryType::LongBlob).blob(BlobSize::Long))
+            .col(ColumnDef::new(BinaryType::BinaryLen).binary(32))
+            .col(ColumnDef::new(BinaryType::Binary).custom(MySqlType::Blob))
+            .col(ColumnDef::new(BinaryType::TinyBlob).custom(MySqlType::TinyBlob))
+            .col(ColumnDef::new(BinaryType::MediumBlob).custom(MySqlType::MediumBlob))
+            .col(ColumnDef::new(BinaryType::LongBlob).custom(MySqlType::LongBlob))
             .to_string(MysqlQueryBuilder),
         [
             "CREATE TABLE `binary_type` (",
             "`binlen` binary(32),",
-            "`bin` blob, `defb` binary(32),",
+            "`bin` blob,",
             "`tb` tinyblob,",
-            "`b` blob,",
             "`mb` mediumblob,",
             "`lb` longblob",
             ")",
@@ -190,8 +187,8 @@ fn create_7() {
     assert_eq!(
         Table::create()
             .table(Char::Table)
-            .col(ColumnDef::new(Char::Character).binary())
-            .col(ColumnDef::new(Char::FontSize).binary_len(10))
+            .col(ColumnDef::new(Char::Character).custom(MySqlType::Blob))
+            .col(ColumnDef::new(Char::FontSize).binary(10))
             .col(ColumnDef::new(Char::SizeW).var_binary(10))
             .to_string(MysqlQueryBuilder),
         [

tests/postgres/table.rs

@@ -258,23 +258,11 @@ fn create_12() {
     assert_eq!(
         Table::create()
             .table(BinaryType::Table)
-            .col(ColumnDef::new(BinaryType::BinaryLen).binary_len(32))
-            .col(ColumnDef::new(BinaryType::Binary).binary())
-            .col(ColumnDef::new(BinaryType::BlobSize).blob(BlobSize::Blob(Some(32))))
-            .col(ColumnDef::new(BinaryType::TinyBlob).blob(BlobSize::Tiny))
-            .col(ColumnDef::new(BinaryType::Blob).blob(BlobSize::Blob(None)))
-            .col(ColumnDef::new(BinaryType::MediumBlob).blob(BlobSize::Medium))
-            .col(ColumnDef::new(BinaryType::LongBlob).blob(BlobSize::Long))
+            .col(ColumnDef::new(BinaryType::BinaryLen).binary(32))
             .to_string(PostgresQueryBuilder),
         [
             r#"CREATE TABLE "binary_type" ("#,
-            r#""binlen" bytea,"#,
-            r#""bin" bytea,"#,
-            r#""defb" bytea,"#,
-            r#""tb" bytea,"#,
-            r#""b" bytea,"#,
-            r#""mb" bytea,"#,
-            r#""lb" bytea"#,
+            r#""binlen" bytea"#,
             r#")"#,
         ]
         .join(" ")
@@ -286,13 +274,11 @@ fn create_13() {
     assert_eq!(
         Table::create()
             .table(Char::Table)
-            .col(ColumnDef::new(Char::Character).binary())
-            .col(ColumnDef::new(Char::FontSize).binary_len(10))
+            .col(ColumnDef::new(Char::FontSize).binary(10))
             .col(ColumnDef::new(Char::SizeW).var_binary(10))
             .to_string(PostgresQueryBuilder),
         [
             r#"CREATE TABLE "character" ("#,
-            r#""character" bytea,"#,
             r#""font_size" bytea,"#,
             r#""size_w" bit varying(10)"#,
             r#")"#,

tests/sqlite/table.rs

@@ -105,23 +105,11 @@ fn create_4() {
     assert_eq!(
         Table::create()
             .table(BinaryType::Table)
-            .col(ColumnDef::new(BinaryType::BinaryLen).binary_len(32))
-            .col(ColumnDef::new(BinaryType::Binary).binary())
-            .col(ColumnDef::new(BinaryType::BlobSize).blob(BlobSize::Blob(Some(32))))
-            .col(ColumnDef::new(BinaryType::TinyBlob).blob(BlobSize::Tiny))
-            .col(ColumnDef::new(BinaryType::Blob).blob(BlobSize::Blob(None)))
-            .col(ColumnDef::new(BinaryType::MediumBlob).blob(BlobSize::Medium))
-            .col(ColumnDef::new(BinaryType::LongBlob).blob(BlobSize::Long))
+            .col(ColumnDef::new(BinaryType::BinaryLen).binary(32))
             .to_string(SqliteQueryBuilder),
         [
             r#"CREATE TABLE "binary_type" ("#,
-            r#""binlen" blob(32),"#,
-            r#""bin" blob,"#,
-            r#""defb" blob(32),"#,
-            r#""tb" tinyblob,"#,
-            r#""b" blob,"#,
-            r#""mb" mediumblob,"#,
-            r#""lb" longblob"#,
+            r#""binlen" blob(32)"#,
             r#")"#,
         ]
         .join(" ")
@@ -133,13 +121,11 @@ fn create_5() {
     assert_eq!(
         Table::create()
             .table(Char::Table)
-            .col(ColumnDef::new(Char::Character).binary())
-            .col(ColumnDef::new(Char::FontSize).binary_len(10))
+            .col(ColumnDef::new(Char::FontSize).binary(10))
             .col(ColumnDef::new(Char::SizeW).var_binary(10))
             .to_string(SqliteQueryBuilder),
         [
             r#"CREATE TABLE "character" ("#,
-            r#""character" blob,"#,
             r#""font_size" blob(10),"#,
             r#""size_w" varbinary_blob(10)"#,
             r#")"#,