Add pipeline examples and bump version

Author: ohsayan

Cargo.toml

@@ -9,7 +9,7 @@ license = "Apache-2.0"
 name = "skytable"
 readme = "README.md"
 repository = "https://github.com/skytable/client-rust"
-version = "0.6.2-alpha.1"
+version = "0.6.2-alpha.2"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -26,13 +26,13 @@ sync = []
 
 [dependencies]
 bytes = { version = "1.1.0", optional = true }
-openssl = { version = "0.10.36", optional = true }
-tokio = { version = "1.12.0", features = [
+openssl = { version = "0.10.38", optional = true }
+tokio = { version = "1.13.0", features = [
     "net",
     "io-util",
     "io-std",
 ], optional = true }
-tokio-openssl = { version = "0.6.2", optional = true }
+tokio-openssl = { version = "0.6.3", optional = true }
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

README.md

@@ -26,7 +26,7 @@ cargo new skyapp
 First add this to your `Cargo.toml` file:
 
 ```toml
-skytable = "0.6.2-alpha.1"
+skytable = "0.6.2-alpha.2"
 ```
 
 Now open up your `src/main.rs` file and establish a connection to the server while also adding some
@@ -118,7 +118,7 @@ You can also find the [latest examples here](https://github.com/skytable/client-
 If you need to use an `async` API, just change your import to:
 
 ```toml
-skytable = { version = "0.6.2-alpha.1", features=["async"], default-features = false }
+skytable = { version = "0.6.2-alpha.2", features=["async"], default-features = false }
 ```
 
 You can now establish a connection by using `skytable::AsyncConnection::new()`, adding `.await`s wherever
@@ -130,7 +130,7 @@ With this client driver, it is possible to use both sync and `async` APIs **at t
 this, simply change your import to:
 
 ```toml
-skytable = { version="0.6.2-alpha.1", features=["sync", "async"] }
+skytable = { version="0.6.2-alpha.2", features=["sync", "async"] }
 ```
 
 ## TLS
@@ -140,15 +140,15 @@ If you need to use TLS features, this crate will let you do so with OpenSSL.
 ### Using TLS with sync interfaces
 
 ```toml
-skytable = { version="0.6.2-alpha.1", features=["sync","ssl"] }
+skytable = { version="0.6.2-alpha.2", features=["sync","ssl"] }
 ```
 
 You can now use the async `sync::TlsConnection` object.
 
 ### Using TLS with async interfaces
 
 ```toml
-skytable = { version="0.6.2-alpha.1", features=["async","aio-ssl"], default-features=false }
+skytable = { version="0.6.2-alpha.2", features=["async","aio-ssl"], default-features=false }
 ```
 
 You can now use the async `aio::TlsConnection` object.

src/actions.rs

@@ -197,8 +197,6 @@ implement_actions! {
     }
     /// Get multiple keys
     ///
-    /// This returns a [`SimpleArray`] of values for the provided keys
-    ///
     /// This is equivalent to:
     /// ```text
     /// MGET <k1> <k2> ...

src/aio.rs

@@ -58,6 +58,8 @@ macro_rules! impl_async_methods {
                     RawResponse::PipelinedQuery(_) => Err(SkyhashError::InvalidResponse.into()),
                 }
             }
+            /// Runs a pipelined query. See the [`Pipeline`](Pipeline) documentation for a guide on
+            /// usage
             pub async fn run_pipeline(&mut self, pipeline: Pipeline) -> SkyRawResult<Vec<Element>> {
                 match self._run_query(&pipeline).await? {
                     RawResponse::PipelinedQuery(pq) => Ok(pq),

src/lib.rs

@@ -38,7 +38,7 @@
 //!
 //! First add this to your `Cargo.toml` file:
 //! ```toml
-//! skytable = "0.6.2-alpha.1"
+//! skytable = "0.6.2-alpha.2"
 //! ```
 //! Now open up your `src/main.rs` file and establish a connection to the server while also adding some
 //! imports:
@@ -125,7 +125,7 @@
 //!
 //! If you need to use an `async` API, just change your import to:
 //! ```toml
-//! skytable = { version = "0.6.2-alpha.1", features=["async"], default-features=false }
+//! skytable = { version = "0.6.2-alpha.2", features=["async"], default-features=false }
 //! ```
 //! You can now establish a connection by using `skytable::AsyncConnection::new()`, adding `.await`s wherever
 //! necessary. Do note that you'll the [Tokio runtime](https://tokio.rs).
@@ -135,7 +135,7 @@
 //! With this client driver, it is possible to use both sync and `async` APIs **at the same time**. To do
 //! this, simply change your import to:
 //! ```toml
-//! skytable = { version="0.6.2-alpha.1", features=["sync", "async"] }
+//! skytable = { version="0.6.2-alpha.2", features=["sync", "async"] }
 //! ```
 //!
 //! ## TLS
@@ -144,13 +144,13 @@
 //!
 //! ### Using TLS with sync interfaces
 //! ```toml
-//! skytable = { version="0.6.2-alpha.1", features=["sync","ssl"] }
+//! skytable = { version="0.6.2-alpha.2", features=["sync","ssl"] }
 //! ```
 //! You can now use the async [TlsConnection](`sync::TlsConnection`) object.
 //!
 //! ### Using TLS with async interfaces
 //! ```toml
-//! skytable = { version="0.6.2-alpha.1", features=["async","aio-ssl"], default-features=false }
+//! skytable = { version="0.6.2-alpha.2", features=["async","aio-ssl"], default-features=false }
 //! ```
 //! You can now use the async [TlsConnection](`aio::TlsConnection`) object.
 //!
@@ -608,7 +608,52 @@ cfg_dbg!(
 /// # Pipeline
 ///
 /// A pipeline is a way of queing up multiple queries, sending them to the server at once instead of sending them individually, avoiding
-/// round-trip-times while also simplifying usage in several places. Responses are returned in the order they are sent
+/// round-trip-times while also simplifying usage in several places. Responses are returned in the order they are sent.
+///
+/// ## Example with the sync API
+///
+/// ```no_run
+/// use skytable::{query, Pipeline, Element, RespCode};
+/// use skytable::sync::Connection;
+///
+/// let mut con = Connection::new("127.0.0.1", 2003).unwrap();
+/// let pipe = Pipeline::new()
+///     .add(query!("set", "x", "100"))
+///     .add(query!("heya", "echo me!"));
+///
+/// let ret = con.run_pipeline(pipe).unwrap();
+/// assert_eq!(
+///     ret,
+///     vec![
+///         Element::RespCode(RespCode::Okay),
+///         Element::String("echo me!".to_owned())
+///     ]
+/// );
+/// ```
+///
+/// ## Example with the async API
+///
+/// ```no_run
+/// use skytable::{query, Pipeline, Element, RespCode};
+/// use skytable::aio::Connection;
+///
+/// async fn run() {
+///     let mut con = Connection::new("127.0.0.1", 2003).await.unwrap();
+///     let pipe = Pipeline::new()
+///         .add(query!("set", "x", "100"))
+///         .add(query!("heya", "echo me!"));
+///
+///     let ret = con.run_pipeline(pipe).await.unwrap();
+///     assert_eq!(
+///         ret,
+///         vec![
+///             Element::RespCode(RespCode::Okay),
+///             Element::String("echo me!".to_owned())
+///         ]
+///     );
+/// }
+/// ```
+///
 pub struct Pipeline {
     len: usize,
     chain: Vec<u8>,
@@ -633,6 +678,7 @@ impl Pipeline {
         self.len += 1;
         query.write_query_to_writable(&mut self.chain);
     }
+    /// Returns the number of queries in the pipeline
     pub fn len(&self) -> usize {
         self.len
     }

src/sync.rs

@@ -55,8 +55,8 @@ macro_rules! impl_sync_methods {
                     RawResponse::PipelinedQuery(_) => Err(SkyhashError::InvalidResponse.into()),
                 }
             }
-            /// This function will write a pipelined query to the stream and read the response from the server,
-            /// returning errors if they do occur.
+            /// Runs a pipelined query. See the [`Pipeline`](Pipeline) documentation for a guide on
+            /// usage
             pub fn run_pipeline(&mut self, pipeline: Pipeline) -> SkyRawResult<Vec<Element>> {
                 assert!(pipeline.len() != 0, "A `Pipeline` cannot be empty!");
                 match self._run_query(&pipeline)? {