Format microsecond in prepare_constant (#929)

Fixed the issue where milliseconds were truncated when formatting
`Value::Constant`

-
[Postgres](https://www.postgresql.org/docs/current/datatype-datetime.html#DATATYPE-DATETIME-INPUT-TIMES)
  Support microseconds
-
[Mysql](https://dev.mysql.com/doc/refman/8.4/en/fractional-seconds.html)
  Support microseconds
- [Sqlite](https://sqlite.org/lang_datefunc.html)
  Support milliseconds, ignore extra digits

<!-- mention the related issue -->
- Closes #808

- [x] Fixed the issue where microseconds were truncated when formatting
`Value::Constant`

---------

Co-authored-by: Chris Tsang <[email protected]>

Author: Huliiiiii

src/backend/query_builder.rs

@@ -1131,22 +1131,22 @@ pub trait QueryBuilder:
             #[cfg(feature = "with-chrono")]
             Value::ChronoDate(Some(v)) => write!(s, "'{}'", v.format("%Y-%m-%d")).unwrap(),
             #[cfg(feature = "with-chrono")]
-            Value::ChronoTime(Some(v)) => write!(s, "'{}'", v.format("%H:%M:%S")).unwrap(),
+            Value::ChronoTime(Some(v)) => write!(s, "'{}'", v.format("%H:%M:%S%.6f")).unwrap(),
             #[cfg(feature = "with-chrono")]
             Value::ChronoDateTime(Some(v)) => {
-                write!(s, "'{}'", v.format("%Y-%m-%d %H:%M:%S")).unwrap()
+                write!(s, "'{}'", v.format("%Y-%m-%d %H:%M:%S%.6f")).unwrap()
             }
             #[cfg(feature = "with-chrono")]
             Value::ChronoDateTimeUtc(Some(v)) => {
-                write!(s, "'{}'", v.format("%Y-%m-%d %H:%M:%S %:z")).unwrap()
+                write!(s, "'{}'", v.format("%Y-%m-%d %H:%M:%S%.6f %:z")).unwrap()
             }
             #[cfg(feature = "with-chrono")]
             Value::ChronoDateTimeLocal(Some(v)) => {
-                write!(s, "'{}'", v.format("%Y-%m-%d %H:%M:%S %:z")).unwrap()
+                write!(s, "'{}'", v.format("%Y-%m-%d %H:%M:%S%.6f %:z")).unwrap()
             }
             #[cfg(feature = "with-chrono")]
             Value::ChronoDateTimeWithTimeZone(Some(v)) => {
-                write!(s, "'{}'", v.format("%Y-%m-%d %H:%M:%S %:z")).unwrap()
+                write!(s, "'{}'", v.format("%Y-%m-%d %H:%M:%S%.6f %:z")).unwrap()
             }
             #[cfg(feature = "with-time")]
             Value::TimeDate(Some(v)) => {
@@ -1699,3 +1699,67 @@ pub(crate) fn common_well_known_left_associative(op: &BinOper) -> bool {
         BinOper::And | BinOper::Or | BinOper::Add | BinOper::Sub | BinOper::Mul | BinOper::Mod
     )
 }
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "with-chrono")]
+    use chrono::{DateTime, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime, Utc};
+
+    use crate::{MysqlQueryBuilder, PostgresQueryBuilder, QueryBuilder, SqliteQueryBuilder};
+
+    /// [Postgresql reference](https://www.postgresql.org/docs/current/datatype-datetime.html#DATATYPE-DATETIME-INPUT-TIMES)
+    ///
+    /// [Mysql reference](https://dev.mysql.com/doc/refman/8.4/en/fractional-seconds.html)
+    ///
+    /// [Sqlite reference](https://sqlite.org/lang_datefunc.html)
+    #[test]
+    #[cfg(feature = "with-chrono")]
+    fn format_time_constant() {
+        let time = NaiveTime::from_hms_micro_opt(1, 2, 3, 123456)
+            .unwrap()
+            .into();
+
+        let mut string = String::new();
+        macro_rules! compare {
+            ($a:ident, $b:literal) => {
+                PostgresQueryBuilder.prepare_constant(&$a, &mut string);
+                assert_eq!(string, $b);
+
+                string.clear();
+
+                MysqlQueryBuilder.prepare_constant(&$a, &mut string);
+                assert_eq!(string, $b);
+
+                string.clear();
+
+                SqliteQueryBuilder.prepare_constant(&$a, &mut string);
+                assert_eq!(string, $b);
+
+                string.clear();
+            };
+        }
+
+        compare!(time, "'01:02:03.123456'");
+
+        let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
+        let t = NaiveTime::from_hms_micro_opt(12, 34, 56, 123456).unwrap();
+
+        let dt = NaiveDateTime::new(d, t);
+
+        let date_time = dt.into();
+
+        compare!(date_time, "'2015-06-03 12:34:56.123456'");
+
+        let date_time_utc = DateTime::<Utc>::from_naive_utc_and_offset(dt, Utc).into();
+
+        compare!(date_time_utc, "'2015-06-03 12:34:56.123456 +00:00'");
+
+        let date_time_tz = DateTime::<FixedOffset>::from_naive_utc_and_offset(
+            dt,
+            FixedOffset::east_opt(8 * 3600).unwrap(),
+        )
+        .into();
+
+        compare!(date_time_tz, "'2015-06-03 20:34:56.123456 +08:00'");
+    }
+}

src/value.rs

@@ -1999,7 +1999,7 @@ mod tests {
 
         let query = Query::select().expr(timestamp).to_owned();
 
-        let formatted = "2020-01-01 02:02:02 +08:00";
+        let formatted = "2020-01-01 02:02:02.000000 +08:00";
 
         assert_eq!(
             query.to_string(MysqlQueryBuilder),

tests/mysql/query.rs

@@ -1125,7 +1125,7 @@ fn insert_4() {
                 .unwrap()
                 .into()])
             .to_string(MysqlQueryBuilder),
-        "INSERT INTO `glyph` (`image`) VALUES ('1970-01-01 00:00:00')"
+        "INSERT INTO `glyph` (`image`) VALUES ('1970-01-01 00:00:00.000000')"
     );
 }
 

tests/postgres/query.rs

@@ -1164,7 +1164,7 @@ fn insert_4() {
                 .unwrap()
                 .into()])
             .to_string(PostgresQueryBuilder),
-        "INSERT INTO \"glyph\" (\"image\") VALUES ('1970-01-01 00:00:00')"
+        "INSERT INTO \"glyph\" (\"image\") VALUES ('1970-01-01 00:00:00.000000')"
     );
 }
 

tests/sqlite/query.rs

@@ -1098,7 +1098,7 @@ fn insert_4() {
                 .unwrap()
                 .into()])
             .to_string(SqliteQueryBuilder),
-        r#"INSERT INTO "glyph" ("image") VALUES ('1970-01-01 00:00:00')"#
+        r#"INSERT INTO "glyph" ("image") VALUES ('1970-01-01 00:00:00.000000')"#
     );
 }