chore: fix server logic_type convert

src/bin/server.rs

@@ -270,7 +270,7 @@ fn encode_tuples<'a>(schema: &SchemaRef, tuples: Vec<Tuple>) -> PgWireResult<Que
                 }
                 LogicalType::Date => encoder.encode_field(&value.date()),
                 LogicalType::DateTime => encoder.encode_field(&value.datetime()),
-                LogicalType::Time => encoder.encode_field(&value.time()),
+                LogicalType::Time(_) => encoder.encode_field(&value.time()),
                 LogicalType::Decimal(_, _) => {
                     encoder.encode_field(&value.decimal().map(|decimal| decimal.to_string()))
                 }
@@ -297,7 +297,7 @@ fn into_pg_type(data_type: &LogicalType) -> PgWireResult<Type> {
         LogicalType::Varchar(..) => Type::VARCHAR,
         LogicalType::Date | LogicalType::DateTime => Type::DATE,
         LogicalType::Char(..) => Type::CHAR,
-        LogicalType::Time => Type::TIME,
+        LogicalType::Time(_) => Type::TIME,
         LogicalType::Decimal(_, _) => Type::NUMERIC,
         _ => {
             return Err(PgWireError::UserError(Box::new(ErrorInfo::new(

src/execution/dml/copy_from_file.rs

@@ -114,7 +114,7 @@ impl CopyFromFile {
 }
 
 fn return_result(size: usize, tx: Sender<Tuple>) -> Result<(), DatabaseError> {
-    let tuple = TupleBuilder::build_result(format!("import {} rows", size));
+    let tuple = TupleBuilder::build_result(size.to_string());
 
     tx.send(tuple).map_err(|_| DatabaseError::ChannelClose)?;
     Ok(())
@@ -229,10 +229,7 @@ mod tests {
             CoroutineState::Complete(()) => unreachable!(),
         }
         .unwrap();
-        assert_eq!(
-            tuple,
-            TupleBuilder::build_result(format!("import {} rows", 2))
-        );
+        assert_eq!(tuple, TupleBuilder::build_result(2.to_string()));
 
         Ok(())
     }

src/execution/dml/delete.rs

@@ -48,6 +48,7 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Delete {
                 .ok_or(DatabaseError::TableNotFound));
                 let mut indexes: HashMap<IndexId, Value> = HashMap::new();
 
+                let mut deleted_count = 0;
                 let mut coroutine = build_read(input, cache, transaction);
 
                 while let CoroutineState::Yielded(tuple) = Pin::new(&mut coroutine).resume(()) {
@@ -99,10 +100,11 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Delete {
                         }
 
                         throw!(unsafe { &mut (*transaction) }.remove_tuple(&table_name, tuple_id));
+                        deleted_count += 1;
                     }
                 }
                 drop(coroutine);
-                yield Ok(TupleBuilder::build_result("1".to_string()));
+                yield Ok(TupleBuilder::build_result(deleted_count.to_string()));
             },
         )
     }

src/execution/dml/insert.rs

@@ -88,6 +88,7 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Insert {
                     throw!(Err(DatabaseError::NotNull))
                 }
 
+                let mut inserted_count = 0;
                 if let Some(table_catalog) =
                     throw!(unsafe { &mut (*transaction) }.table(cache.0, table_name.clone()))
                         .cloned()
@@ -149,10 +150,11 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Insert {
                             &types,
                             is_overwrite
                         ));
+                        inserted_count += 1;
                     }
                     drop(coroutine);
                 }
-                yield Ok(TupleBuilder::build_result("1".to_string()));
+                yield Ok(TupleBuilder::build_result(inserted_count.to_string()));
             },
         )
     }

src/execution/dml/update.rs

@@ -63,6 +63,7 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Update {
 
                 let input_schema = input.output_schema().clone();
                 let types = types(&input_schema);
+                let mut updated_count = 0;
 
                 if let Some(table_catalog) =
                     throw!(unsafe { &mut (*transaction) }.table(cache.0, table_name.clone()))
@@ -135,10 +136,11 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Update {
                             &types,
                             is_overwrite
                         ));
+                        updated_count += 1;
                     }
                     drop(coroutine);
                 }
-                yield Ok(TupleBuilder::build_result("1".to_string()));
+                yield Ok(TupleBuilder::build_result(updated_count.to_string()));
             },
         )
     }

tests/slt/copy.slt

@@ -5,7 +5,7 @@ create table test_copy (a int primary key, b float, c varchar(10))
 query I
 COPY test_copy FROM 'tests/data/copy.tbl' ( DELIMITER '|' );
 ----
-import 2 rows
+2
 
 query I
 SELECT * FROM test_copy