Upgrade client to use binary strings

Author: ohsayan

Cargo.toml

@@ -1,34 +1,34 @@
 [package]
-name = "skytable"
-version = "0.4.0"
 authors = ["Sayan Nandan <[email protected]>"]
-edition = "2018"
-readme = "README.md"
+categories = []
 description = "Official Rust client driver for Skytable"
-license = "Apache-2.0"
 documentation = "https://docs.rs/skytable"
-repository = "https://github.com/skytable/client-rust"
-categories = []
+edition = "2018"
 keywords = ["skytable", "driver", "client", "database", "nosql"]
+license = "Apache-2.0"
+name = "skytable"
+readme = "README.md"
+repository = "https://github.com/skytable/client-rust"
+version = "0.4.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-default = ["sync"]
+aio-ssl = ["tokio-openssl", "openssl"]
+aio-sslv = ["tokio-openssl", "openssl/vendored"]
 async = ["bytes", "tokio"]
-sync = []
-dbg = []
 const-gen = []
+dbg = []
+default = ["sync"]
 ssl = ["openssl"]
 sslv = ["openssl/vendored"]
-aio-ssl = ["tokio-openssl", "openssl"]
-aio-sslv = ["tokio-openssl", "openssl/vendored"]
+sync = []
 
 [dependencies]
-bytes = { version="1.0.1", optional=true }
-tokio = { version="1.7.1", features=["net", "io-util", "io-std"], optional=true }
-openssl = { version="0.10.35", optional=true }
-tokio-openssl = { version="0.6.2", optional=true }
+bytes = {version = "1.0.1", optional = true}
+openssl = {version = "0.10.35", optional = true}
+tokio = {version = "1.9.0", features = ["net", "io-util", "io-std"], optional = true}
+tokio-openssl = {version = "0.6.2", optional = true}
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

src/actions.rs

@@ -33,7 +33,7 @@
 //! use skytable::{actions::Actions, Connection};
 //! let mut con = Connection::new("127.0.0.1", 2003).unwrap();
 //! con.set("x", "100").unwrap();
-//! assert_eq!(con.get("x").unwrap(), "100".to_owned());
+//! assert_eq!(con.get("x").unwrap(), Vec::from("100"));
 //!
 //! ```
 
@@ -173,7 +173,7 @@ implement_actions!(
         Response::Item(Element::RespCode(RespCode::Okay)) => {}
     }
     /// Get the value of a key
-    fn get(key: impl IntoSkyhashBytes + 's) -> String {
+    fn get(key: impl IntoSkyhashBytes + 's) -> Vec<u8> {
         { Query::from("get").arg(key)}
         Response::Item(Element::String(st)) => st
     }
@@ -185,7 +185,7 @@ implement_actions!(
     /// Returns a vector of keys
     ///
     /// Do note that the order might be completely meaningless
-    fn lskeys(count: usize) -> Vec<String> {
+    fn lskeys(count: usize) -> Vec<Vec<u8>> {
         { Query::from("lskeys").arg(count)}
         Response::Item(Element::FlatArray(arr)) => arr
     }

src/deserializer.rs

@@ -65,12 +65,12 @@ pub(super) struct Parser<'a> {
 pub enum Element {
     /// Arrays can be nested! Their `<tsymbol>` is `&`
     Array(Vec<Element>),
-    /// A String value; `<tsymbol>` is `+`
-    String(String),
+    /// A binary/unicode string value; `<tsymbol>` is `+`
+    String(Vec<u8>),
     /// An unsigned integer value; `<tsymbol>` is `:`
     UnsignedInt(u64),
     /// A non-recursive String array; tsymbol: `_`
-    FlatArray(Vec<String>),
+    FlatArray(Vec<Vec<u8>>),
     /// A response code
     RespCode(RespCode),
 }
@@ -280,9 +280,9 @@ impl<'a> Parser<'a> {
         }
     }
     /// The cursor should have passed the `+` tsymbol
-    fn parse_next_string(&mut self) -> ParseResult<String> {
+    fn parse_next_string(&mut self) -> ParseResult<Vec<u8>> {
         let our_string_chunk = self.__get_next_element()?;
-        let our_string = String::from_utf8_lossy(&our_string_chunk).to_string();
+        let our_string = Vec::from(our_string_chunk);
         if self.will_cursor_give_linefeed()? {
             // there is a lf after the end of the string; great!
             // let's skip that now
@@ -337,7 +337,7 @@ impl<'a> Parser<'a> {
         }
     }
     /// The cursor should have passed the tsymbol
-    fn parse_next_flat_array(&mut self) -> ParseResult<Vec<String>> {
+    fn parse_next_flat_array(&mut self) -> ParseResult<Vec<Vec<u8>>> {
         let (start, stop) = self.read_line();
         if let Some(our_size_chunk) = self.buffer.get(start..stop) {
             let array_size = Self::parse_into_usize(&our_size_chunk)?;

src/lib.rs

@@ -57,11 +57,15 @@
 //!     let mut con = Connection::new("127.0.0.1", 2003)?;
 //!     let query = Query::from("heya");
 //!     let res = con.run_simple_query(&query)?;
-//!     assert_eq!(res, Response::Item(Element::String("HEY!".to_owned())));
+//!     assert_eq!(res, Response::Item(Element::String(Vec::from("HEY"))));
 //!     Ok(())
 //! }
 //! ```
 //!
+//! **And why was our string a [`Vec`]?**
+//! That's because the server sends a binary string with arbitrary bytes. The returned value may
+//! or may not be unicode, and this depends on the data type you set for your table.
+//!
 //! Way to go — you're all set! Now go ahead and run more advanced queries!
 //!
 //! ## Going advanced