Add sync API for raw client

Signed-off-by: xuhui-lu <[email protected]>

Author: xuhui-lu

src/lib.rs

@@ -122,7 +122,7 @@ pub use crate::backoff::Backoff;
 #[doc(inline)]
 pub use crate::kv::{BoundRange, IntoOwnedRange, Key, KvPair, Value};
 #[doc(inline)]
-pub use crate::raw::{lowering as raw_lowering, Client as RawClient, ColumnFamily};
+pub use crate::raw::{lowering as raw_lowering, Client as RawClient, SyncClient, ColumnFamily};
 #[doc(inline)]
 pub use crate::request::RetryOptions;
 #[doc(inline)]

src/raw/client.rs

@@ -10,6 +10,7 @@ use crate::{
     request::{Collect, Plan},
     BoundRange, ColumnFamily, Key, KvPair, Result, Value,
 };
+use futures::executor::block_on;
 use log::debug;
 use std::{sync::Arc, u32};
 
@@ -159,6 +160,10 @@ impl Client {
         plan.execute().await
     }
 
+    pub fn get_sync(&self, key: impl Into<Key>) -> Result<Option<Value>> {
+        block_on(self.get(key))
+    }
+
     /// Create a new 'batch get' request.
     ///
     /// Once resolved this request will result in the fetching of the values associated with the
@@ -193,6 +198,13 @@ impl Client {
             .map(|r| r.into_iter().map(Into::into).collect())
     }
 
+    pub fn batch_get_sync(
+        &self,
+        keys: impl IntoIterator<Item = impl Into<Key>>,
+    ) -> Result<Vec<KvPair>> {
+        block_on(self.batch_get(keys))
+    }
+
     /// Create a new 'put' request.
     ///
     /// Once resolved this request will result in the setting of the value associated with the given key.
@@ -222,6 +234,10 @@ impl Client {
         Ok(())
     }
 
+    pub fn put_sync(&self, key: impl Into<Key>, value: impl Into<Value>) -> Result<()> {
+        block_on(self.put(key, value))
+    }
+
     /// Create a new 'batch put' request.
     ///
     /// Once resolved this request will result in the setting of the values associated with the given keys.
@@ -258,6 +274,10 @@ impl Client {
         Ok(())
     }
 
+    pub fn batch_put_sync(&self, pairs: impl IntoIterator<Item = impl Into<KvPair>>) -> Result<()> {
+        block_on(self.batch_put(pairs))
+    }
+
     /// Create a new 'delete' request.
     ///
     /// Once resolved this request will result in the deletion of the given key.
@@ -288,6 +308,10 @@ impl Client {
         Ok(())
     }
 
+    pub fn delete_sync(&self, key: impl Into<Key>) -> Result<()> {
+        block_on(self.delete(key))
+    }
+
     /// Create a new 'batch delete' request.
     ///
     /// Once resolved this request will result in the deletion of the given keys.
@@ -319,6 +343,10 @@ impl Client {
         Ok(())
     }
 
+    pub fn batch_delete_sync(&self, keys: impl IntoIterator<Item = impl Into<Key>>) -> Result<()> {
+        block_on(self.batch_delete(keys))
+    }
+
     /// Create a new 'delete range' request.
     ///
     /// Once resolved this request will result in the deletion of all keys lying in the given range.
@@ -347,6 +375,10 @@ impl Client {
         Ok(())
     }
 
+    pub fn delete_range_sync(&self, range: impl Into<BoundRange>) -> Result<()> {
+        block_on(self.delete_range(range))
+    }
+
     /// Create a new 'scan' request.
     ///
     /// Once resolved this request will result in a `Vec` of key-value pairs that lies in the specified range.
@@ -371,6 +403,10 @@ impl Client {
         self.scan_inner(range.into(), limit, false).await
     }
 
+    pub fn scan_sync(&self, range: impl Into<BoundRange>, limit: u32) -> Result<Vec<KvPair>> {
+        block_on(self.scan(range, limit))
+    }
+
     /// Create a new 'scan' request that only returns the keys.
     ///
     /// Once resolved this request will result in a `Vec` of keys that lies in the specified range.
@@ -400,6 +436,10 @@ impl Client {
             .collect())
     }
 
+    pub fn scan_keys_sync(&self, range: impl Into<BoundRange>, limit: u32) -> Result<Vec<Key>> {
+        block_on(self.scan_keys(range, limit))
+    }
+
     /// Create a new 'batch scan' request.
     ///
     /// Once resolved this request will result in a set of scanners over the given keys.
@@ -432,6 +472,14 @@ impl Client {
         self.batch_scan_inner(ranges, each_limit, false).await
     }
 
+    pub fn batch_scan_sync(
+        &self,
+        ranges: impl IntoIterator<Item = impl Into<BoundRange>>,
+        each_limit: u32,
+    ) -> Result<Vec<KvPair>> {
+        block_on(self.batch_scan(ranges, each_limit))
+    }
+
     /// Create a new 'batch scan' request that only returns the keys.
     ///
     /// Once resolved this request will result in a set of scanners over the given keys.
@@ -468,6 +516,14 @@ impl Client {
             .collect())
     }
 
+    pub fn batch_scan_keys_sync(
+        &self,
+        ranges: impl IntoIterator<Item = impl Into<BoundRange>>,
+        each_limit: u32,
+    ) -> Result<Vec<Key>> {
+        block_on(self.batch_scan_keys(ranges, each_limit))
+    }
+
     /// Create a new *atomic* 'compare and set' request.
     ///
     /// Once resolved this request will result in an atomic `compare and set'
@@ -502,6 +558,15 @@ impl Client {
         plan.execute().await
     }
 
+    pub async fn compare_and_swap_sync(
+        &self,
+        key: impl Into<Key>,
+        previous_value: impl Into<Option<Value>>,
+        new_value: impl Into<Value>,
+    ) -> Result<(Option<Value>, bool)> {
+        block_on(self.compare_and_swap(key, previous_value, new_value))
+    }
+
     async fn scan_inner(
         &self,
         range: impl Into<BoundRange>,
@@ -563,3 +628,117 @@ impl Client {
         self.atomic.then(|| ()).ok_or(Error::UnsupportedMode)
     }
 }
+
+#[derive(Clone)]
+pub struct SyncClient {
+    client: Client,
+}
+
+impl SyncClient {
+    /// The Sync version of Client
+    ///
+    /// # Examples
+    ///
+    /// ```rust,no_run
+    /// # use tikv_client::SyncClient;
+    /// let client = SyncClient::new(vec!["192.168.0.100"]).await.unwrap();
+    /// ```
+    pub async fn new<S: Into<String>>(pd_endpoints: Vec<S>) -> Result<Client> {
+        Self::new_with_config(pd_endpoints, Config::default()).await
+    }
+
+    pub async fn new_with_config<S: Into<String>>(
+        pd_endpoints: Vec<S>,
+        config: Config,
+    ) -> Result<Client> {
+        let client = Client::new_with_config(pd_endpoints, config)
+        Ok(SyncClient {
+            client: client
+        })
+    }
+
+    pub fn with_cf(&self, cf: ColumnFamily) -> SyncClient {
+        SyncClient {
+            client: self.clietn.with_cf(cf),
+        }
+    }
+
+    pub fn with_atomic_for_cas(&self) -> SyncClient {
+        SyncClient {
+            client: self.client.with_atomic_for_cas()
+        }
+    }
+
+    pub fn get(&self, key: impl Into<Key>) -> Result<Option<Value>> {
+        block_on(self.client.get(key))
+    }
+
+    pub fn batch_get(
+        &self,
+        keys: impl IntoIterator<Item = impl Into<Key>>,
+    ) -> Result<Vec<KvPair>> {
+        block_on(self.client.batch_get(keys))
+    }
+
+    pub fn put(&self, key: impl Into<Key>, value: impl Into<Value>) -> Result<()> {
+        block_on(self.client.put(key, value))
+    }
+
+    pub fn batch_put(&self, pairs: impl IntoIterator<Item = impl Into<KvPair>>) -> Result<()> {
+        block_on(self.client.batch_put(pairs))
+    }
+
+    pub fn delete(&self, key: impl Into<Key>) -> Result<()> {
+        block_on(self.client.delete(key))
+    }
+
+    pub fn batch_delete(&self, keys: impl IntoIterator<Item = impl Into<Key>>) -> Result<()> {
+        block_on(self.client.batch_delete(keys))
+    }
+
+    pub fn delete_range(&self, range: impl Into<BoundRange>) -> Result<()> {
+        block_on(self.client.delete_range(range))
+    }
+
+    pub fn scan(&self, range: impl Into<BoundRange>, limit: u32) -> Result<Vec<KvPair>> {
+        block_on(self.client.scan(range, limit))
+    }
+
+    pub fn scan_keys(&self, range: impl Into<BoundRange>, limit: u32) -> Result<Vec<Key>> {
+        block_on(self.client.scan_keys(range, limit))
+    }
+
+    pub fn batch_scan(
+        &self,
+        ranges: impl IntoIterator<Item = impl Into<BoundRange>>,
+        each_limit: u32,
+    ) -> Result<Vec<KvPair>> {
+        block_on(self.client.batch_scan(ranges, each_limit))
+    }
+
+    pub fn batch_scan_keys(
+        &self,
+        ranges: impl IntoIterator<Item = impl Into<BoundRange>>,
+        each_limit: u32,
+    ) -> Result<Vec<Key>> {
+        block_on(self.client.batch_scan_keys(ranges, each_limit))
+    }
+
+    pub fn compare_and_swap(
+        &self,
+        key: impl Into<Key>,
+        previous_value: impl Into<Option<Value>>,
+        new_value: impl Into<Value>,
+    ) -> Result<(Option<Value>, bool)> {
+        block_on(self.client.compare_and_swap(key, previous_value, new_value))
+    }
+
+
+    fn assert_non_atomic(&self) -> Result<()> {
+        (!self.atomic).then(|| ()).ok_or(Error::UnsupportedMode)
+    }
+
+    fn assert_atomic(&self) -> Result<()> {
+        self.atomic.then(|| ()).ok_or(Error::UnsupportedMode)
+    }
+}