resp: Add enhanced multi-row support (#28)

* derive: add `FromRow` derive

* resp: Enhance multi-row decode support

Author: ohsayan

Cargo.toml

@@ -14,7 +14,7 @@ version = "0.8.8"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 # internal deps
-sky-derive = "0.2.2"
+sky-derive = "0.2.3"
 # external deps
 tokio = { version = "1.38.0", features = ["full"] }
 native-tls = "0.2.12"

examples/multi_row.rs

@@ -0,0 +1,21 @@
+use skytable::{query, response::Rows, Config, Query, Response};
+
+#[derive(Query, Response)]
+pub struct User {
+    username: String,
+    password: String,
+    followers: u64,
+    email: Option<String>,
+}
+
+fn main() {
+    let mut db = Config::new_default("user", "password").connect().unwrap();
+    let users: Rows<User> = db
+        .query_parse(&query!(
+            "select all username, password, followers, email from myspace.mymodel limit ?",
+            1000u64
+        ))
+        .unwrap();
+    // assume the first row has username set to 'sayan'
+    assert_eq!(users[0].username, "sayan");
+}

sky-derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sky-derive"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 license = "Apache-2.0"
 description = "Macros for the Skytable client driver"

sky-derive/src/lib.rs

@@ -54,6 +54,12 @@ pub fn derive_response(input: TokenStream) -> TokenStream {
                             Ok(#struct_instantiation)
                         }
                     }
+                    impl #impl_generics skytable::response::FromRow for #name #ty_generics #where_clause {
+                        fn from_row(row: skytable::response::Row) -> skytable::ClientResult<Self> {
+                            let #tuple_pattern = skytable::response::FromRow::from_row(row)?;
+                            Ok(#struct_instantiation)
+                        }
+                    }
                 }
             }
             _ => unimplemented!(),

src/response.rs

@@ -32,7 +32,10 @@
 //! ```
 //!
 
-use crate::error::{ClientResult, Error, ParseError};
+use {
+    crate::error::{ClientResult, Error, ParseError},
+    std::ops::Deref,
+};
 
 /// The value directly returned by the server without any additional type parsing and/or casting
 #[derive(Debug, PartialEq, Clone)]
@@ -92,6 +95,13 @@ pub struct Row {
     values: Vec<Value>,
 }
 
+impl Deref for Row {
+    type Target = [Value];
+    fn deref(&self) -> &Self::Target {
+        &self.values
+    }
+}
+
 impl Row {
     pub(crate) fn new(values: Vec<Value>) -> Self {
         Self { values }
@@ -267,6 +277,15 @@ macro_rules! from_response_row {
                     Ok(($($elem::from_value(values.next().unwrap())?),*,))
                 }
             }
+            impl<$($elem: FromValue),*> FromRow for ($($elem),*,) {
+                fn from_row(row: Row) -> ClientResult<Self> {
+                    if row.values().len() != $size {
+                        return Err(Error::ParseError(ParseError::TypeMismatch));
+                    }
+                    let mut values = row.into_values().into_iter();
+                    Ok(($($elem::from_value(values.next().unwrap())?),*,))
+                }
+            }
         )*
     }
 }
@@ -323,3 +342,48 @@ impl FromResponse for Vec<Row> {
         }
     }
 }
+
+/// Trait for parsing a row into a custom type
+pub trait FromRow: Sized {
+    /// Parse a row into a custom type
+    fn from_row(row: Row) -> ClientResult<Self>;
+}
+
+impl FromRow for Row {
+    fn from_row(row: Row) -> ClientResult<Self> {
+        Ok(row)
+    }
+}
+
+#[derive(Debug, PartialEq)]
+/// A collection of rows
+pub struct Rows<T: FromRow = Row>(Vec<T>);
+
+impl<T: FromRow> Rows<T> {
+    /// Consume the [`Rows`] object and get all the rows as a vector
+    pub fn into_rows(self) -> Vec<T> {
+        self.0
+    }
+}
+
+impl<T: FromRow> FromResponse for Rows<T> {
+    fn from_response(resp: Response) -> ClientResult<Self> {
+        match resp {
+            Response::Rows(rows) => {
+                let mut ret = vec![];
+                for row in rows {
+                    ret.push(T::from_row(row)?);
+                }
+                Ok(Self(ret))
+            }
+            _ => Err(Error::ParseError(ParseError::ResponseMismatch)),
+        }
+    }
+}
+
+impl<T: FromRow> Deref for Rows<T> {
+    type Target = [T];
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}