chore: impl Display for meta-service txn struct with crate display-more (#18289)

Author: drmingdrmer

Cargo.lock

@@ -298,7 +298,7 @@ defer = "0.2"
 deltalake = "0.26"
 derive-visitor = { version = "0.4.0", features = ["std-types-drive"] }
 derive_more = { version = "1.0.0", features = ["full"] }
-display-more = { version = "0.1.0" }
+display-more = { version = "0.2.0" }
 divan = "0.1.21"
 dtparse = { git = "https://github.com/datafuse-extras/dtparse.git", rev = "30e28ca" }
 dyn-clone = "1.0.9"
@@ -652,7 +652,7 @@ async-recursion = { git = "https://github.com/datafuse-extras/async-recursion.gi
 backtrace = { git = "https://github.com/rust-lang/backtrace-rs.git", rev = "72265be" }
 color-eyre = { git = "https://github.com/eyre-rs/eyre.git", rev = "e5d92c3" }
 deltalake = { git = "https://github.com/delta-io/delta-rs", rev = "9954bff" }
-display-more = { git = "https://github.com/databendlabs/display-more", tag = "v0.1.3" }
+display-more = { git = "https://github.com/databendlabs/display-more", tag = "v0.2.0" }
 map-api = { git = "https://github.com/databendlabs/map-api", tag = "v0.2.3" }
 openai_api_rust = { git = "https://github.com/datafuse-extras/openai-api", rev = "819a0ed" }
 openraft = { git = "https://github.com/databendlabs/openraft", tag = "v0.10.0-alpha.9" }

Cargo.toml

@@ -248,7 +248,7 @@ pub async fn send_txn(
     debug!("send txn: {}", txn_req);
     let tx_reply = kv_api.transaction(txn_req).await?;
     let (succ, responses) = unpack_txn_reply(tx_reply);
-    debug!("txn success: {}: {}", succ, responses.display_n::<20>());
+    debug!("txn success: {}: {}", succ, responses.display_n(20));
     Ok((succ, responses))
 }
 

src/meta/api/src/util.rs

@@ -73,8 +73,8 @@ impl Display for ProcedureMeta {
             f,
             "Lanuage: {:?}, args {} return_type: {}, CreatedOn: {:?}, Script: {}, Comment: {:?}",
             self.procedure_language,
-            self.arg_names.display_n::<1000>(),
-            self.return_types.display_n::<1000>(),
+            self.arg_names.display_n(1000),
+            self.return_types.display_n(1000),
             self.created_on,
             self.script,
             self.comment

src/meta/app/src/principal/procedure.rs

@@ -13,6 +13,7 @@ anyhow = { workspace = true }
 async-trait = { workspace = true }
 databend-common-meta-app-types = { workspace = true }
 databend-common-meta-types = { workspace = true }
+display-more = { workspace = true }
 futures-util = { workspace = true }
 log = { workspace = true }
 serde = { workspace = true }

src/meta/kvapi/Cargo.toml

@@ -17,7 +17,7 @@ use std::fmt::Formatter;
 
 use databend_common_meta_types::seq_value::SeqV;
 use databend_common_meta_types::Change;
-use databend_common_meta_types::VecDisplay;
+use display_more::display_slice::DisplaySliceExt;
 
 #[derive(serde::Serialize, serde::Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct GetKVReq {
@@ -47,7 +47,7 @@ impl MGetKVReq {
 
 impl fmt::Display for MGetKVReq {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{}", VecDisplay::new_at_most(&self.keys, 5))
+        write!(f, "{}", self.keys.display())
     }
 }
 

src/meta/kvapi/src/kvapi/message.rs

@@ -89,7 +89,6 @@ pub use match_seq::MatchSeqExt;
 pub use node::Node;
 pub use operation::MetaId;
 pub use operation::Operation;
-pub use proto_display::VecDisplay;
 pub use protobuf::txn_condition;
 pub use protobuf::txn_condition::ConditionResult;
 pub use protobuf::txn_op;

src/meta/types/src/lib.rs

@@ -48,64 +48,6 @@ use crate::TxnPutResponse;
 use crate::TxnReply;
 use crate::TxnRequest;
 
-struct OptionDisplay<'a, T: Display> {
-    t: &'a Option<T>,
-}
-
-impl<T: Display> Display for OptionDisplay<'_, T> {
-    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        match &self.t {
-            None => {
-                write!(f, "None")
-            }
-            Some(x) => x.fmt(f),
-        }
-    }
-}
-
-pub struct VecDisplay<'a, T: Display> {
-    at_most: Option<usize>,
-    vec: &'a Vec<T>,
-}
-
-impl<'a, T> VecDisplay<'a, T>
-where T: Display
-{
-    pub fn new(vec: &'a Vec<T>) -> Self {
-        VecDisplay { at_most: None, vec }
-    }
-
-    pub fn new_at_most(vec: &'a Vec<T>, at_most: usize) -> Self {
-        VecDisplay {
-            at_most: Some(at_most),
-            vec,
-        }
-    }
-}
-
-impl<T: Display> Display for VecDisplay<'_, T> {
-    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        write!(f, "[")?;
-
-        for (i, t) in self.vec.iter().enumerate() {
-            if i > 0 {
-                write!(f, ",")?;
-            }
-
-            if let Some(at_most) = self.at_most {
-                if i >= at_most {
-                    write!(f, "...")?;
-                    break;
-                }
-            }
-
-            write!(f, "{}", t)?;
-        }
-
-        write!(f, "]")
-    }
-}
-
 impl Display for TxnRequest {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         write!(f, "TxnRequest{{",)?;
@@ -114,9 +56,9 @@ impl Display for TxnRequest {
             write!(f, "{{ {} }}, ", op)?;
         }
 
-        write!(f, "if:{} ", VecDisplay::new_at_most(&self.condition, 10),)?;
-        write!(f, "then:{} ", VecDisplay::new_at_most(&self.if_then, 10),)?;
-        write!(f, "else:{}", VecDisplay::new_at_most(&self.else_then, 10),)?;
+        write!(f, "if:{} ", self.condition.display_n(10),)?;
+        write!(f, "then:{} ", self.if_then.display_n(10),)?;
+        write!(f, "else:{}", self.else_then.display_n(10),)?;
 
         write!(f, "}}",)
     }
@@ -126,9 +68,7 @@ impl Display for TxnCondition {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         let expect: ConditionResult = FromPrimitive::from_i32(self.expected).unwrap();
 
-        write!(f, "{} {} {}", self.key, expect, OptionDisplay {
-            t: &self.target
-        })
+        write!(f, "{} {} {}", self.key, expect, self.target.display())
     }
 }
 
@@ -148,7 +88,7 @@ impl Display for ConditionResult {
 
 impl Display for TxnOp {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        write!(f, "{}", OptionDisplay { t: &self.request })
+        write!(f, "{}", self.request.display())
     }
 }
 
@@ -231,14 +171,14 @@ impl Display for TxnReply {
             f,
             "TxnReply{{ success: {}, responses: {}}}",
             self.success,
-            VecDisplay::new_at_most(&self.responses, 5),
+            self.responses.display()
         )
     }
 }
 
 impl Display for TxnOpResponse {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        write!(f, "TxnOpResponse: {}", OptionDisplay { t: &self.response })
+        write!(f, "TxnOpResponse: {}", self.response.display())
     }
 }
 
@@ -342,7 +282,7 @@ impl Display for ConditionalOperation {
             f,
             "if:({}) then:{}",
             self.predicate.display(),
-            self.operations.display_n::<10>()
+            self.operations.display_n(10)
         )
     }
 }
@@ -380,29 +320,6 @@ mod tests {
     use crate::protobuf::TxnCondition;
     use crate::TxnOp;
 
-    #[test]
-    fn test_vec_display() {
-        assert_eq!(
-            format!("{}", super::VecDisplay::new(&vec![1, 2, 3])),
-            "[1,2,3]"
-        );
-
-        assert_eq!(
-            format!("{}", super::VecDisplay::new_at_most(&vec![1, 2, 3], 3)),
-            "[1,2,3]"
-        );
-
-        assert_eq!(
-            format!("{}", super::VecDisplay::new_at_most(&vec![1, 2, 3, 4], 3)),
-            "[1,2,3,...]"
-        );
-
-        assert_eq!(
-            format!("{}", super::VecDisplay::new_at_most(&vec![1, 2, 3, 4], 0)),
-            "[...]"
-        );
-    }
-
     #[test]
     fn test_tx_display_with_bool_expression() {
         let expr = BooleanExpression::from_conditions_and([