cargo format

server/src/proto_wrapper.rs

@@ -1,20 +1,20 @@
 use async_trait::async_trait;
+use minisql::operation::ColumnSelection;
+use minisql::restricted_row::RestrictedRow;
+use minisql::schema::{Column, TableSchema};
+use proto::message::backend::{
+    BackendMessage, ColumnDescription, CommandCompleteData, DataRowData, ErrorResponseData,
+    ReadyForQueryData, RowDescriptionData,
+};
+use proto::message::primitive::pglist::PgList;
+use proto::writer::backend::BackendProtoWriter;
 use rand::Rng;
 use rand_pcg::Pcg64;
 use rand_seeder::Seeder;
 use std::fmt;
-use minisql::operation::ColumnSelection;
-use minisql::restricted_row::RestrictedRow;
-use minisql::schema::{Column, TableSchema};
-use proto::message::backend::{BackendMessage, ColumnDescription, CommandCompleteData, DataRowData, ErrorResponseData, ReadyForQueryData, RowDescriptionData};
-use proto::message::primitive::pglist::PgList;
-use proto::writer::backend::BackendProtoWriter;
 
 pub enum CompleteStatus {
-    Insert {
-        oid: i32,
-        rows: i32,
-    },
+    Insert { oid: i32, rows: i32 },
     Delete(usize),
     Select(usize),
     CreateTable,
@@ -38,24 +38,36 @@ pub trait ServerProto {
     async fn write_error_message(&mut self, error_message: &str) -> anyhow::Result<()>;
     async fn write_ready_for_query(&mut self) -> anyhow::Result<()>;
     async fn write_empty_query(&mut self) -> anyhow::Result<()>;
-    async fn write_table_header(&mut self, table_schema: &TableSchema, columns: &ColumnSelection) -> anyhow::Result<()>;
+    async fn write_table_header(
+        &mut self,
+        table_schema: &TableSchema,
+        columns: &ColumnSelection,
+    ) -> anyhow::Result<()>;
     async fn write_table_row(&mut self, row: &RestrictedRow) -> anyhow::Result<()>;
     async fn write_command_complete(&mut self, status: CompleteStatus) -> anyhow::Result<()>;
 }
 
 #[async_trait]
-impl<W> ServerProto for W where W: BackendProtoWriter + Send {
+impl<W> ServerProto for W
+where
+    W: BackendProtoWriter + Send,
+{
     async fn write_error_message(&mut self, error_message: &str) -> anyhow::Result<()> {
-        self.write_proto(ErrorResponseData {
-            code: b'M',
-            message: format!("{error_message}\0").into(),
-        }.into()).await?;
+        self.write_proto(
+            ErrorResponseData {
+                code: b'M',
+                message: format!("{error_message}\0").into(),
+            }
+            .into(),
+        )
+        .await?;
 
         Ok(())
     }
 
     async fn write_ready_for_query(&mut self) -> anyhow::Result<()> {
-        self.write_proto(ReadyForQueryData { status: b'I' }.into()).await?;
+        self.write_proto(ReadyForQueryData { status: b'I' }.into())
+            .await?;
         Ok(())
     }
 
@@ -64,35 +76,52 @@ impl<W> ServerProto for W where W: BackendProtoWriter + Send {
         Ok(())
     }
 
-    async fn write_table_header(&mut self, table_schema: &TableSchema, columns: &ColumnSelection) -> anyhow::Result<()> {
-        let columns = columns.iter()
+    async fn write_table_header(
+        &mut self,
+        table_schema: &TableSchema,
+        columns: &ColumnSelection,
+    ) -> anyhow::Result<()> {
+        let columns = columns
+            .iter()
             .map(|column| column_to_description(table_schema, *column))
             .collect::<anyhow::Result<Vec<ColumnDescription>>>()?;
 
-        self.write_proto(RowDescriptionData { columns: columns.into() }.into()).await?;
+        self.write_proto(
+            RowDescriptionData {
+                columns: columns.into(),
+            }
+            .into(),
+        )
+        .await?;
         Ok(())
     }
 
     async fn write_table_row(&mut self, row: &RestrictedRow) -> anyhow::Result<()> {
-        let values = row.iter()
+        let values = row
+            .iter()
             .map(|(_, value)| value.as_text_bytes().into())
             .collect::<Vec<PgList<u8, i32>>>();
 
         self.write_proto(BackendMessage::DataRow(DataRowData {
             columns: values.into(),
-        })).await?;
+        }))
+        .await?;
         Ok(())
     }
 
     async fn write_command_complete(&mut self, status: CompleteStatus) -> anyhow::Result<()> {
         self.write_proto(BackendMessage::CommandComplete(CommandCompleteData {
             tag: status.to_string().into(),
-        })).await?;
+        }))
+        .await?;
         Ok(())
     }
 }
 
-fn column_to_description(schema: &TableSchema, column: Column) -> anyhow::Result<ColumnDescription> {
+fn column_to_description(
+    schema: &TableSchema,
+    column: Column,
+) -> anyhow::Result<ColumnDescription> {
     let table_name = schema.table_name();
     let table_oid = table_name_to_oid(table_name);