Update the readme to use async await

Author: NeoLegends

README.md

@@ -54,8 +54,6 @@ For an example with using Serde deserialization, please refer to [serde_integrat
 
 ```rust
 use influxdb::{Client, Query, Timestamp};
-use serde::Deserialize;
-use tokio::runtime::current_thread::Runtime;
 
 // Create a Client with URL `http://localhost:8086`
 // and database name `test`
@@ -67,21 +65,15 @@ let client = Client::new("http://localhost:8086", "test");
 let write_query = Query::write_query(Timestamp::Now, "weather")
     .add_field("temperature", 82);
 
-// Since this library is async by default, we're going to need a Runtime,
-// which can asynchonously run our query.
-// The [tokio](https://crates.io/crates/tokio) crate lets us easily create a new Runtime.
-let mut rt = Runtime::new().expect("Unable to create a runtime");
-
-// To actually submit the data to InfluxDB, the `block_on` method can be used to
-// halt execution of our program until it has been completed.
-let write_result = rt.block_on(client.query(&write_query));
+// Submit the query to InfluxDB.
+let write_result = client.query(&write_query).await;
 assert!(write_result.is_ok(), "Write result was not okay");
 
 // Reading data is as simple as writing. First we need to create a query
 let read_query = Query::raw_read_query("SELECT * FROM weather");
 
-// Again, we're blocking until the request is done
-let read_result = rt.block_on(client.query(&read_query));
+// submit the request and wait until it's done
+let read_result = client.query(&read_query).await;
 
 assert!(read_result.is_ok(), "Read result was not ok");
 

src/integrations/serde_integration.rs

@@ -22,30 +22,27 @@
 //!     weather: WeatherWithoutCityName,
 //! }
 //!
-//! let mut rt = tokio::runtime::current_thread::Runtime::new().unwrap();
+//! # #[tokio::main]
+//! # async fn main() -> Box<dyn std::error::Error> {
 //! let client = Client::new("http://localhost:8086", "test");
 //! let query = Query::raw_read_query(
 //!     "SELECT temperature FROM /weather_[a-z]*$/ WHERE time > now() - 1m ORDER BY DESC",
 //! );
-//! let _result = rt
-//!     .block_on(client.json_query(query))
-//!     .map(|mut db_result| db_result.deserialize_next::<WeatherWithoutCityName>())
-//!     .map(|it| {
-//!         it.map(|series_vec| {
-//!             series_vec
-//!                 .series
-//!                 .into_iter()
-//!                 .map(|mut city_series| {
-//!                     let city_name =
-//!                         city_series.name.split("_").collect::<Vec<&str>>().remove(2);
-//!                     Weather {
-//!                         weather: city_series.values.remove(0),
-//!                         city_name: city_name.to_string(),
-//!                     }
-//!                 })
-//!                 .collect::<Vec<Weather>>()
-//!         })
-//!     });
+//! let db_result = client.json_query(query).await?;
+//! let _result = db_result
+//!     .deserialize_next::<WeatherWithoutCityName>()?
+//!     .series
+//!     .into_iter()
+//!     .map(|mut city_series| {
+//!         let city_name =
+//!             city_series.name.split("_").collect::<Vec<&str>>().remove(2);
+//!         Weather {
+//!             weather: city_series.values.remove(0),
+//!             city_name: city_name.to_string(),
+//!         }
+//!     })
+//!     .collect::<Vec<Weather>>();
+//! # }
 //! ```
 
 use reqwest::{Client as ReqwestClient, StatusCode, Url};

src/lib.rs

@@ -28,9 +28,9 @@
 //!
 //! ```rust,no_run
 //! use influxdb::{Client, Query, Timestamp};
-//! use serde::Deserialize;
-//! use tokio::runtime::current_thread::Runtime;
 //!
+//! # #[tokio::main]
+//! # async fn main() {
 //! // Create a Client with URL `http://localhost:8086`
 //! // and database name `test`
 //! let client = Client::new("http://localhost:8086", "test");
@@ -41,27 +41,22 @@
 //! let write_query = Query::write_query(Timestamp::Now, "weather")
 //!     .add_field("temperature", 82);
 //!
-//! // Since this library is async by default, we're going to need a Runtime,
-//! // which can asynchonously run our query.
-//! // The [tokio](https://crates.io/crates/tokio) crate lets us easily create a new Runtime.
-//! let mut rt = Runtime::new().expect("Unable to create a runtime");
-//!
-//! // To actually submit the data to InfluxDB, the `block_on` method can be used to
-//! // halt execution of our program until it has been completed.
-//! let write_result = rt.block_on(client.query(&write_query));
+//! // Submit the query to InfluxDB.
+//! let write_result = client.query(&write_query).await;
 //! assert!(write_result.is_ok(), "Write result was not okay");
 //!
 //! // Reading data is as simple as writing. First we need to create a query
 //! let read_query = Query::raw_read_query("SELECT * FROM weather");
 //!
-//! // Again, we're blocking until the request is done
-//! let read_result = rt.block_on(client.query(&read_query));
+//! // submit the request and wait until it's done
+//! let read_result = client.query(&read_query).await;
 //!
 //! assert!(read_result.is_ok(), "Read result was not ok");
 //!
 //! // We can be sure the result was successful, so we can unwrap the result to get
 //! // the response String from InfluxDB
 //! println!("{}", read_result.unwrap());
+//! # }
 //! ```
 //!
 //! For further examples, check out the Integration Tests in `tests/integration_tests.rs`