Update README

Cargo.toml

@@ -9,7 +9,7 @@ license = "Apache-2.0"
 name = "skytable"
 readme = "README.md"
 repository = "https://github.com/skytable/client-rust"
-version = "0.8.0"
+version = "0.8.0-beta.1"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]

README.md

@@ -35,149 +35,20 @@ cargo new skyapp
 First add this to your `Cargo.toml` file:
 
 ```toml
-skytable = "0.7.0-alpha.4"
+skytable = "0.8.0-beta.1"
 ```
 
-Now open up your `src/main.rs` file and establish a connection to the server while also adding some
-imports:
+You're ready to go!
 
 ```rust
-use skytable::{Connection, Query, Element, SkyResult};
-fn main() -> SkyResult<()> {
-    let mut con = Connection::new("127.0.0.1", 2003)?;
-    Ok(())
-}
-```
-
-Now let's run a `Query`! Change the previous code block to:
-
-```rust
-use skytable::{error, Connection, Query, Element};
-fn main() -> Result<(), error::Error> {
-    let mut con = Connection::new("127.0.0.1", 2003)?;
-    let query = Query::from("heya");
-    let res: String = con.run_query(&query)?;
-    assert_eq!(res, "HEY!");
-    Ok(())
-}
-```
-
-## Running actions
-
-As noted [below](#binary-data), the default table is a key/value table with a binary key
-type and a binary value type. Let's go ahead and run some actions (we're assuming you're
-using the sync API; for async, simply change the import to `use skytable::actions::AsyncActions`).
-
-### `SET`ting a key
-
-```rust
-use skytable::actions::Actions;
-use skytable::sync::Connection;
-
-let mut con = Connection::new("127.0.0.1", 2003).unwrap();
-con.set("hello", "world").unwrap();
-```
-
-This will set the value of the key `hello` to `world` in the `default:default` entity.
-
-### `GET`ting a key
-
-```rust
-use skytable::actions::Actions;
-use skytable::sync::Connection;
-
-let mut con = Connection::new("127.0.0.1", 2003).unwrap();
-let x: String = con.get("hello").unwrap();
-assert_eq!(x, "world");
-```
-
-Way to go &mdash; you're all set! Now go ahead and run more advanced queries!
-
-## Binary data
-
-The `default:default` keyspace has the following declaration:
-
-```text
-Keymap { data:(binstr,binstr), volatile:false }
-```
-
-This means that the default keyspace is ready to store binary data. Let's say
-you wanted to `SET` the value of a key called `bindata` to some binary data stored
-in a `Vec<u8>`. You can achieve this with the `RawString` type:
-
-```rust
-use skytable::actions::Actions;
-use skytable::sync::Connection;
-use skytable::types::RawString;
-
-let mut con = Connection::new("127.0.0.1", 2003).unwrap();
-let mybinarydata = RawString::from(vec![1, 2, 3, 4]);
-assert!(con.set("bindata", mybinarydata).unwrap());
-```
+use skytable::{Config, query};
 
-## Going advanced
-
-Now that you know how you can run basic queries, check out the [`actions`] module documentation for learning
-to use actions and the [`types`] module documentation for implementing your own Skyhash serializable
-types. Need to meddle with DDL queries like creating and dropping tables? Check out the [`ddl`] module.
-You can also find some [examples here](https://github.com/skytable/client-rust/tree/v0.7.0-alpha.4/examples)
-
-## Connection pooling
-
-This library supports using sync/async connection pools. See the [`pool`] module-level documentation for examples
-and information.
-
-## Async API
-
-If you need to use an `async` API, just change your import to:
-
-```toml
-skytable = { version = "0.7.0-alpha.4", features=["aio"], 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).
-
-## Using both `sync` and `async` APIs
-
-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.7.0-alpha.4", features=["sync", "aio"] }
-```
-
-## TLS
-
-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.7.0-alpha.4", features=["sync","ssl"] }
-```
-
-You can now use the async `sync::TlsConnection` object.
-
-### Using TLS with async interfaces
-
-```toml
-skytable = { version="0.7.0-alpha.4", features=["aio","aio-ssl"], default-features=false }
+let mut db = Config::new_default("username", "password").connect().unwrap();
+let query = query!("select username, password from myspace.mytbl WHERE username = ?", your_fn_to_get_user());
+let (username, password) = db.query_parse::<(String, String)>(&query).unwrap();
 ```
 
-You can now use the async `aio::TlsConnection` object.
-
-### _Packed TLS_ setup
-
-If you want to pack OpenSSL with your crate, then for sync add `sslv` instead of `ssl` or
-add `aio-sslv` instead of `aio-ssl` for async. Adding this will statically link OpenSSL
-to your crate. Do note that you'll need a C compiler, GNU Make and Perl to compile OpenSSL
-and statically link against it.
-
-## MSRV
-
-The MSRV for this crate is Rust 1.39. Need const generics? Add the `const-gen` feature to your
-dependency!
+> **Read [docs here to learn BlueQL](https://docs.skytable.io/)**
 
 ## Contributing