feat: Unify Debug implementations across PgRow, MySqlRow and SqliteRow (#3890)

* Introduce `debug_row` function

* Use `debug_row` to implement `Debug` for `SqliteRow`

* Use `debug_row` in `PgRow`'s `Debug` implementation

* Match `MySqlRow`'s `Debug` implementation

Author: davidcornu

sqlx-core/src/row.rs

@@ -1,8 +1,9 @@
-use crate::column::ColumnIndex;
+use crate::column::{Column, ColumnIndex};
 use crate::database::Database;
 use crate::decode::Decode;
 use crate::error::{mismatched_types, Error};
 
+use crate::type_checking::TypeChecking;
 use crate::type_info::TypeInfo;
 use crate::types::Type;
 use crate::value::ValueRef;
@@ -176,3 +177,32 @@ pub trait Row: Unpin + Send + Sync + 'static {
     where
         I: ColumnIndex<Self>;
 }
+
+pub fn debug_row<R>(row: &R, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+where
+    R: Row,
+    usize: ColumnIndex<R>,
+    <R as Row>::Database: TypeChecking,
+{
+    write!(f, "{} ", std::any::type_name::<R>())?;
+
+    let mut debug_map = f.debug_map();
+
+    for column in row.columns().iter() {
+        match row.try_get_raw(column.ordinal()) {
+            Ok(value) => {
+                debug_map.entry(
+                    &column.name(),
+                    &<R as Row>::Database::fmt_value_debug(
+                        &<<R as Row>::Database as Database>::ValueRef::to_owned(&value),
+                    ),
+                );
+            }
+            Err(error) => {
+                debug_map.entry(&column.name(), &format!("decode error: {error:?}"));
+            }
+        }
+    }
+
+    debug_map.finish()
+}

sqlx-mysql/src/row.rs

@@ -9,7 +9,6 @@ use crate::HashMap;
 use crate::{protocol, MySql, MySqlColumn, MySqlValueFormat, MySqlValueRef};
 
 /// Implementation of [`Row`] for MySQL.
-#[derive(Debug)]
 pub struct MySqlRow {
     pub(crate) row: protocol::Row,
     pub(crate) format: MySqlValueFormat,
@@ -49,3 +48,9 @@ impl ColumnIndex<MySqlRow> for &'_ str {
             .copied()
     }
 }
+
+impl std::fmt::Debug for MySqlRow {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        debug_row(self, f)
+    }
+}

sqlx-postgres/src/row.rs

@@ -4,10 +4,8 @@ use crate::message::DataRow;
 use crate::statement::PgStatementMetadata;
 use crate::value::PgValueFormat;
 use crate::{PgColumn, PgValueRef, Postgres};
+use sqlx_core::row::debug_row;
 pub(crate) use sqlx_core::row::Row;
-use sqlx_core::type_checking::TypeChecking;
-use sqlx_core::value::ValueRef;
-use std::fmt::Debug;
 use std::sync::Arc;
 
 /// Implementation of [`Row`] for PostgreSQL.
@@ -51,25 +49,8 @@ impl ColumnIndex<PgRow> for &'_ str {
     }
 }
 
-impl Debug for PgRow {
+impl std::fmt::Debug for PgRow {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "PgRow ")?;
-
-        let mut debug_map = f.debug_map();
-        for (index, column) in self.columns().iter().enumerate() {
-            match self.try_get_raw(index) {
-                Ok(value) => {
-                    debug_map.entry(
-                        &column.name,
-                        &Postgres::fmt_value_debug(&<PgValueRef as ValueRef>::to_owned(&value)),
-                    );
-                }
-                Err(error) => {
-                    debug_map.entry(&column.name, &format!("decode error: {error:?}"));
-                }
-            }
-        }
-
-        debug_map.finish()
+        debug_row(self, f)
     }
 }

sqlx-sqlite/src/row.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use sqlx_core::column::ColumnIndex;
 use sqlx_core::error::Error;
 use sqlx_core::ext::ustr::UStr;
-use sqlx_core::row::Row;
+use sqlx_core::row::{debug_row, Row};
 use sqlx_core::HashMap;
 
 use crate::statement::StatementHandle;
@@ -77,6 +77,12 @@ impl ColumnIndex<SqliteRow> for &'_ str {
     }
 }
 
+impl std::fmt::Debug for SqliteRow {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        debug_row(self, f)
+    }
+}
+
 // #[cfg(feature = "any")]
 // impl From<SqliteRow> for crate::any::AnyRow {
 //     #[inline]