mysql create table add table and colunm comment

src/backend/mysql/table.rs

@@ -1,6 +1,15 @@
 use super::*;
 
 impl TableBuilder for MysqlQueryBuilder {
+    fn prepare_table_opt(&self, create: &TableCreateStatement, sql: &mut dyn SqlWriter) {
+        // comment
+        if let Some(comment) = &create.comment {
+            // self.quote()
+            write!(sql, " COMMENT '{comment}'").unwrap();
+        }
+        self.prepare_table_opt_def(create, sql)
+    }
+
     fn prepare_column_def(&self, column_def: &ColumnDef, sql: &mut dyn SqlWriter) {
         column_def.name.prepare(sql.as_writer(), self.quote());
 
@@ -191,4 +200,10 @@ impl TableBuilder for MysqlQueryBuilder {
             self.prepare_table_ref_table_stmt(to_name, sql);
         }
     }
+
+    /// column comment
+    fn column_comment(&self, comment: &str, sql: &mut dyn SqlWriter) {
+        let comment = comment.replace('\'', "\\'");
+        write!(sql, "COMMENT '{comment}'").unwrap()
+    }
 }

src/backend/postgres/table.rs

@@ -10,6 +10,9 @@ impl TableBuilder for PostgresQueryBuilder {
             if let ColumnSpec::AutoIncrement = column_spec {
                 continue;
             }
+            if let ColumnSpec::Comment(_) = column_spec {
+                continue;
+            }
             write!(sql, " ").unwrap();
             self.prepare_column_spec(column_spec, sql);
         }
@@ -167,6 +170,7 @@ impl TableBuilder for PostgresQueryBuilder {
                             ColumnSpec::Check(check) => self.prepare_check_constraint(check, sql),
                             ColumnSpec::Generated { .. } => {}
                             ColumnSpec::Extra(string) => write!(sql, "{string}").unwrap(),
+                            ColumnSpec::Comment(_) => {}
                         }
                         false
                     });

src/backend/sqlite/table.rs

@@ -21,6 +21,9 @@ impl TableBuilder for SqliteQueryBuilder {
                 is_auto_increment = true;
                 continue;
             }
+            if let ColumnSpec::Comment(_) = column_spec {
+                continue;
+            }
             write!(sql, " ").unwrap();
             self.prepare_column_spec(column_spec, sql);
         }

src/backend/table_builder.rs

@@ -106,14 +106,23 @@ pub trait TableBuilder:
                 self.prepare_generated_column(expr, *stored, sql)
             }
             ColumnSpec::Extra(string) => write!(sql, "{string}").unwrap(),
+            ColumnSpec::Comment(comment) => self.column_comment(comment, sql),
         }
     }
 
+    /// column comment
+    fn column_comment(&self, _comment: &str, _sql: &mut dyn SqlWriter) {}
+
     /// The keyword for setting a column to be auto increment.
     fn column_spec_auto_increment_keyword(&self) -> &str;
 
     /// Translate [`TableOpt`] into SQL statement.
     fn prepare_table_opt(&self, create: &TableCreateStatement, sql: &mut dyn SqlWriter) {
+        self.prepare_table_opt_def(create, sql)
+    }
+
+    /// Default function
+    fn prepare_table_opt_def(&self, create: &TableCreateStatement, sql: &mut dyn SqlWriter) {
         for table_opt in create.options.iter() {
             write!(sql, " ").unwrap();
             write!(

src/table/column.rs

@@ -111,6 +111,7 @@ pub enum ColumnSpec {
     Check(SimpleExpr),
     Generated { expr: SimpleExpr, stored: bool },
     Extra(String),
+    Comment(String),
 }
 
 // All interval fields
@@ -638,6 +639,15 @@ impl ColumnDef {
         self
     }
 
+    /// MySQL only.
+    pub fn comment<T>(&mut self, string: T) -> &mut Self
+    where
+        T: Into<String>,
+    {
+        self.spec.push(ColumnSpec::Comment(string.into()));
+        self
+    }
+
     pub fn get_column_name(&self) -> String {
         self.name.to_string()
     }

src/table/create.rs

@@ -15,8 +15,9 @@ use crate::{
 /// let table = Table::create()
 ///     .table(Char::Table)
 ///     .if_not_exists()
+///     .comment("table comment")
 ///     .col(ColumnDef::new(Char::Id).integer().not_null().auto_increment().primary_key())
-///     .col(ColumnDef::new(Char::FontSize).integer().not_null())
+///     .col(ColumnDef::new(Char::FontSize).integer().not_null().comment("font size"))
 ///     .col(ColumnDef::new(Char::Character).string().not_null())
 ///     .col(ColumnDef::new(Char::SizeW).integer().not_null())
 ///     .col(ColumnDef::new(Char::SizeH).integer().not_null())
@@ -36,15 +37,15 @@ use crate::{
 ///     [
 ///         r#"CREATE TABLE IF NOT EXISTS `character` ("#,
 ///             r#"`id` int NOT NULL AUTO_INCREMENT PRIMARY KEY,"#,
-///             r#"`font_size` int NOT NULL,"#,
+///             r#"`font_size` int NOT NULL COMMENT 'font size',"#,
 ///             r#"`character` varchar(255) NOT NULL,"#,
 ///             r#"`size_w` int NOT NULL,"#,
 ///             r#"`size_h` int NOT NULL,"#,
 ///             r#"`font_id` int DEFAULT NULL,"#,
 ///             r#"CONSTRAINT `FK_2e303c3a712662f1fc2a4d0aad6`"#,
 ///                 r#"FOREIGN KEY (`font_id`) REFERENCES `font` (`id`)"#,
 ///                 r#"ON DELETE CASCADE ON UPDATE CASCADE"#,
-///         r#")"#,
+///         r#") COMMENT 'table comment'"#,
 ///     ].join(" ")
 /// );
 /// assert_eq!(
@@ -88,6 +89,7 @@ pub struct TableCreateStatement {
     pub(crate) foreign_keys: Vec<ForeignKeyCreateStatement>,
     pub(crate) if_not_exists: bool,
     pub(crate) check: Vec<SimpleExpr>,
+    pub(crate) comment: Option<String>,
     pub(crate) extra: Option<String>,
 }
 
@@ -124,6 +126,15 @@ impl TableCreateStatement {
         self
     }
 
+    /// Set table comment
+    pub fn comment<T>(&mut self, comment: T) -> &mut Self
+    where
+        T: Into<String>,
+    {
+        self.comment = Some(comment.into());
+        self
+    }
+
     /// Add a new table column
     pub fn col(&mut self, column: &mut ColumnDef) -> &mut Self {
         let mut column = column.take();
@@ -270,6 +281,10 @@ impl TableCreateStatement {
         self.columns.as_ref()
     }
 
+    pub fn get_comment(&self) -> Option<&String> {
+        self.comment.as_ref()
+    }
+
     pub fn get_foreign_key_create_stmts(&self) -> &Vec<ForeignKeyCreateStatement> {
         self.foreign_keys.as_ref()
     }
@@ -334,6 +349,7 @@ impl TableCreateStatement {
             foreign_keys: std::mem::take(&mut self.foreign_keys),
             if_not_exists: self.if_not_exists,
             check: std::mem::take(&mut self.check),
+            comment: std::mem::take(&mut self.comment),
             extra: std::mem::take(&mut self.extra),
         }
     }