reduce type annotation

Signed-off-by: iosmanthus <[email protected]>

Author: iosmanthus

src/pd/client.rs

@@ -225,7 +225,7 @@ impl<C: RequestCodec, KvC: KvConnect + Send + Sync + 'static> PdClient for PdRpc
     }
 
     async fn region_for_key(&self, key: &Key) -> Result<RegionWithLeader> {
-        self.region_cache.get_region_by_key(&key).await
+        self.region_cache.get_region_by_key(key).await
     }
 
     async fn region_for_id(&self, id: RegionId) -> Result<RegionWithLeader> {

src/raw/client.rs

@@ -185,7 +185,11 @@ impl<C: RawCodec> Client<C> {
     }
 }
 
-impl<C: RawCodec> Client<C> {
+impl<C, PdC> Client<C, PdC>
+where
+    C: RawCodec,
+    PdC: PdClient<RequestCodec = C>,
+{
     /// Create a new 'get' request.
     ///
     /// Once resolved this request will result in the fetching of the value associated with the
@@ -212,7 +216,7 @@ impl<C: RawCodec> Client<C> {
     /// Same as [`get`](Client::get) but with custom [`backoff`](crate::Backoff) strategy.
     pub async fn get_opt(&self, key: impl Into<Key>, backoff: Backoff) -> Result<Option<Value>> {
         debug!(self.logger, "invoking raw get request");
-        let request = new_raw_get_request::<C>(key.into(), self.cf.clone());
+        let request = new_raw_get_request(key.into(), self.cf.clone());
         let plan = crate::request::PlanBuilder::new(self.rpc.clone(), request)
             .retry_multi_region(backoff)
             .merge(CollectSingle)
@@ -254,8 +258,7 @@ impl<C: RawCodec> Client<C> {
         backoff: Backoff,
     ) -> Result<Vec<KvPair>> {
         debug!(self.logger, "invoking raw batch_get request");
-        let request =
-            new_raw_batch_get_request::<C>(keys.into_iter().map(Into::into), self.cf.clone());
+        let request = new_raw_batch_get_request(keys.into_iter().map(Into::into), self.cf.clone());
         let plan = crate::request::PlanBuilder::new(self.rpc.clone(), request)
             .retry_multi_region(backoff)
             .merge(Collect)
@@ -294,8 +297,7 @@ impl<C: RawCodec> Client<C> {
         backoff: Backoff,
     ) -> Result<()> {
         debug!(self.logger, "invoking raw put request");
-        let request =
-            new_raw_put_request::<C>(key.into(), value.into(), self.cf.clone(), self.atomic);
+        let request = new_raw_put_request(key.into(), value.into(), self.cf.clone(), self.atomic);
         let plan = crate::request::PlanBuilder::new(self.rpc.clone(), request)
             .retry_multi_region(backoff)
             .merge(CollectSingle)
@@ -337,7 +339,7 @@ impl<C: RawCodec> Client<C> {
         backoff: Backoff,
     ) -> Result<()> {
         debug!(self.logger, "invoking raw batch_put request");
-        let request = new_raw_batch_put_request::<C>(
+        let request = new_raw_batch_put_request(
             pairs.into_iter().map(Into::into),
             self.cf.clone(),
             self.atomic,
@@ -375,7 +377,7 @@ impl<C: RawCodec> Client<C> {
     /// Same as [`delete`](Client::delete) but with custom [`backoff`](crate::Backoff) strategy.
     pub async fn delete_opt(&self, key: impl Into<Key>, backoff: Backoff) -> Result<()> {
         debug!(self.logger, "invoking raw delete request");
-        let request = new_raw_delete_request::<C>(key.into(), self.cf.clone(), self.atomic);
+        let request = new_raw_delete_request(key.into(), self.cf.clone(), self.atomic);
         let plan = crate::request::PlanBuilder::new(self.rpc.clone(), request)
             .retry_multi_region(backoff)
             .merge(CollectSingle)
@@ -416,7 +418,7 @@ impl<C: RawCodec> Client<C> {
         debug!(self.logger, "invoking raw batch_delete request");
         self.assert_non_atomic()?;
         let request =
-            new_raw_batch_delete_request::<C>(keys.into_iter().map(Into::into), self.cf.clone());
+            new_raw_batch_delete_request(keys.into_iter().map(Into::into), self.cf.clone());
         let plan = crate::request::PlanBuilder::new(self.rpc.clone(), request)
             .retry_multi_region(backoff)
             .extract_error()
@@ -453,7 +455,7 @@ impl<C: RawCodec> Client<C> {
     ) -> Result<()> {
         debug!(self.logger, "invoking raw delete_range request");
         self.assert_non_atomic()?;
-        let request = new_raw_delete_range_request::<C>(range.into(), self.cf.clone());
+        let request = new_raw_delete_range_request(range.into(), self.cf.clone());
         let plan = crate::request::PlanBuilder::new(self.rpc.clone(), request)
             .retry_multi_region(backoff)
             .extract_error()
@@ -664,7 +666,7 @@ impl<C: RawCodec> Client<C> {
     ) -> Result<(Option<Value>, bool)> {
         debug!(self.logger, "invoking raw compare_and_swap request");
         self.assert_atomic()?;
-        let req = new_cas_request::<C>(
+        let req = new_cas_request(
             key.into(),
             new_value.into(),
             previous_value.into(),
@@ -706,7 +708,7 @@ impl<C: RawCodec> Client<C> {
     ) -> Result<Vec<(Vec<u8>, Vec<Range<Key>>)>> {
         let copr_version_req = copr_version_req.into();
         semver::VersionReq::from_str(&copr_version_req)?;
-        let req = new_raw_coprocessor_request::<C>(
+        let req = new_raw_coprocessor_request(
             copr_name.into(),
             copr_version_req,
             ranges.into_iter().map(Into::into),
@@ -734,7 +736,7 @@ impl<C: RawCodec> Client<C> {
             });
         }
 
-        let request = new_raw_scan_request::<C>(range.into(), limit, key_only, self.cf.clone());
+        let request = new_raw_scan_request(range.into(), limit, key_only, self.cf.clone());
         let plan = crate::request::PlanBuilder::new(self.rpc.clone(), request)
             .retry_multi_region(backoff)
             .merge(Collect)
@@ -760,7 +762,7 @@ impl<C: RawCodec> Client<C> {
             });
         }
 
-        let request = new_raw_batch_scan_request::<C>(
+        let request = new_raw_batch_scan_request(
             ranges.into_iter().map(Into::into),
             each_limit,
             key_only,

src/raw/lowering.rs

@@ -8,77 +8,67 @@ use std::{iter::Iterator, ops::Range, sync::Arc};
 
 use tikv_client_proto::{kvrpcpb, metapb};
 
-use crate::{
-    raw::requests, request::request_codec::RequestCodec, BoundRange, ColumnFamily, Key, KvPair,
-    Value,
-};
+use crate::{raw::requests, BoundRange, ColumnFamily, Key, KvPair, Value};
 
-pub fn new_raw_get_request<C: RequestCodec>(
-    key: Key,
-    cf: Option<ColumnFamily>,
-) -> kvrpcpb::RawGetRequest {
-    requests::new_raw_get_request::<C>(key.into(), cf)
+pub fn new_raw_get_request(key: Key, cf: Option<ColumnFamily>) -> kvrpcpb::RawGetRequest {
+    requests::new_raw_get_request(key.into(), cf)
 }
 
-pub fn new_raw_batch_get_request<C: RequestCodec>(
+pub fn new_raw_batch_get_request(
     keys: impl Iterator<Item = Key>,
     cf: Option<ColumnFamily>,
 ) -> kvrpcpb::RawBatchGetRequest {
-    requests::new_raw_batch_get_request::<C>(keys.map(Into::into).collect(), cf)
+    requests::new_raw_batch_get_request(keys.map(Into::into).collect(), cf)
 }
 
-pub fn new_raw_put_request<C: RequestCodec>(
+pub fn new_raw_put_request(
     key: Key,
     value: Value,
     cf: Option<ColumnFamily>,
     atomic: bool,
 ) -> kvrpcpb::RawPutRequest {
-    requests::new_raw_put_request::<C>(key.into(), value, cf, atomic)
+    requests::new_raw_put_request(key.into(), value, cf, atomic)
 }
 
-pub fn new_raw_batch_put_request<C: RequestCodec>(
+pub fn new_raw_batch_put_request(
     pairs: impl Iterator<Item = KvPair>,
     cf: Option<ColumnFamily>,
     atomic: bool,
 ) -> kvrpcpb::RawBatchPutRequest {
-    requests::new_raw_batch_put_request::<C>(pairs.map(Into::into).collect(), cf, atomic)
+    requests::new_raw_batch_put_request(pairs.map(Into::into).collect(), cf, atomic)
 }
 
-pub fn new_raw_delete_request<C: RequestCodec>(
+pub fn new_raw_delete_request(
     key: Key,
     cf: Option<ColumnFamily>,
     atomic: bool,
 ) -> kvrpcpb::RawDeleteRequest {
-    requests::new_raw_delete_request::<C>(key.into(), cf, atomic)
+    requests::new_raw_delete_request(key.into(), cf, atomic)
 }
 
-pub fn new_raw_batch_delete_request<C: RequestCodec>(
+pub fn new_raw_batch_delete_request(
     keys: impl Iterator<Item = Key>,
     cf: Option<ColumnFamily>,
 ) -> kvrpcpb::RawBatchDeleteRequest {
-    requests::new_raw_batch_delete_request::<C>(keys.map(Into::into).collect(), cf)
+    requests::new_raw_batch_delete_request(keys.map(Into::into).collect(), cf)
 }
 
-pub fn new_raw_delete_range_request<C: RequestCodec>(
+pub fn new_raw_delete_range_request(
     range: BoundRange,
     cf: Option<ColumnFamily>,
 ) -> kvrpcpb::RawDeleteRangeRequest {
     let (start_key, end_key) = range.into_keys();
-    requests::new_raw_delete_range_request::<C>(
-        start_key.into(),
-        end_key.unwrap_or_default().into(),
-        cf,
-    )
+    requests::new_raw_delete_range_request(start_key.into(), end_key.unwrap_or_default().into(), cf)
 }
 
-pub fn new_raw_scan_request<C: RequestCodec>(
+pub fn new_raw_scan_request(
     range: BoundRange,
     limit: u32,
     key_only: bool,
     cf: Option<ColumnFamily>,
 ) -> kvrpcpb::RawScanRequest {
     let (start_key, end_key) = range.into_keys();
-    requests::new_raw_scan_request::<C>(
+    requests::new_raw_scan_request(
         start_key.into(),
         end_key.unwrap_or_default().into(),
         limit,
@@ -87,36 +77,31 @@ pub fn new_raw_scan_request<C: RequestCodec>(
     )
 }
 
-pub fn new_raw_batch_scan_request<C: RequestCodec>(
+pub fn new_raw_batch_scan_request(
     ranges: impl Iterator<Item = BoundRange>,
     each_limit: u32,
     key_only: bool,
     cf: Option<ColumnFamily>,
 ) -> kvrpcpb::RawBatchScanRequest {
-    requests::new_raw_batch_scan_request::<C>(
-        ranges.map(Into::into).collect(),
-        each_limit,
-        key_only,
-        cf,
-    )
+    requests::new_raw_batch_scan_request(ranges.map(Into::into).collect(), each_limit, key_only, cf)
 }
 
-pub fn new_cas_request<C: RequestCodec>(
+pub fn new_cas_request(
     key: Key,
     value: Value,
     previous_value: Option<Value>,
     cf: Option<ColumnFamily>,
 ) -> kvrpcpb::RawCasRequest {
-    requests::new_cas_request::<C>(key.into(), value, previous_value, cf)
+    requests::new_cas_request(key.into(), value, previous_value, cf)
 }
 
-pub fn new_raw_coprocessor_request<C: RequestCodec>(
+pub fn new_raw_coprocessor_request(
     copr_name: String,
     copr_version_req: String,
     ranges: impl Iterator<Item = BoundRange>,
     request_builder: impl Fn(metapb::Region, Vec<Range<Key>>) -> Vec<u8> + Send + Sync + 'static,
 ) -> requests::RawCoprocessorRequest {
-    requests::new_raw_coprocessor_request::<C>(
+    requests::new_raw_coprocessor_request(
         copr_name,
         copr_version_req,
         ranges.map(Into::into).collect(),