Skip to content

Commit f07fbc8

Browse files
andylokandyandylokandy
committed
rename
1 parent c9f6cc5 commit f07fbc8

File tree

9 files changed

+247
-250
lines changed

9 files changed

+247
-250
lines changed

‎src/raw/client.rs

Lines changed: 46 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -15,13 +15,13 @@ use crate::pd::PdClient;
1515
use crate::pd::PdRpcClient;
1616
use crate::proto::metapb;
1717
use crate::raw::lowering::*;
18-
use crate::request::APIVersion;
1918
use crate::request::Collect;
2019
use crate::request::CollectSingle;
21-
use crate::request::EncodeVersion;
20+
use crate::request::EncodeKeyspace;
2221
use crate::request::KeyMode;
22+
use crate::request::Keyspace;
2323
use crate::request::Plan;
24-
use crate::request::TruncateVersion;
24+
use crate::request::TruncateKeyspace;
2525
use crate::Backoff;
2626
use crate::BoundRange;
2727
use crate::ColumnFamily;
@@ -45,7 +45,7 @@ pub struct Client<PdC: PdClient = PdRpcClient> {
4545
backoff: Backoff,
4646
/// Whether to use the [`atomic mode`](Client::with_atomic_for_cas).
4747
atomic: bool,
48-
api_version: APIVersion,
48+
keyspace: Keyspace,
4949
}
5050

5151
impl Clone for Client {
@@ -55,7 +55,7 @@ impl Clone for Client {
5555
cf: self.cf.clone(),
5656
backoff: self.backoff.clone(),
5757
atomic: self.atomic,
58-
api_version: self.api_version,
58+
keyspace: self.keyspace,
5959
}
6060
}
6161
}
@@ -109,19 +109,19 @@ impl Client<PdRpcClient> {
109109
let pd_endpoints: Vec<String> = pd_endpoints.into_iter().map(Into::into).collect();
110110
let rpc =
111111
Arc::new(PdRpcClient::connect(&pd_endpoints, config.clone(), enable_codec).await?);
112-
let api_version = match config.keyspace {
112+
let keyspace = match config.keyspace {
113113
Some(keyspace) => {
114114
let keyspace_id = rpc.get_keyspace_id(&keyspace).await?;
115-
APIVersion::V2 { keyspace_id }
115+
Keyspace::Enable { keyspace_id }
116116
}
117-
None => APIVersion::V1,
117+
None => Keyspace::Disable,
118118
};
119119
Ok(Client {
120120
rpc,
121121
cf: None,
122122
backoff: DEFAULT_REGION_BACKOFF,
123123
atomic: false,
124-
api_version,
124+
keyspace,
125125
})
126126
}
127127

@@ -156,7 +156,7 @@ impl Client<PdRpcClient> {
156156
cf: Some(cf),
157157
backoff: self.backoff.clone(),
158158
atomic: self.atomic,
159-
api_version: self.api_version,
159+
keyspace: self.keyspace,
160160
}
161161
}
162162

@@ -185,7 +185,7 @@ impl Client<PdRpcClient> {
185185
cf: self.cf.clone(),
186186
backoff,
187187
atomic: self.atomic,
188-
api_version: self.api_version,
188+
keyspace: self.keyspace,
189189
}
190190
}
191191

@@ -203,7 +203,7 @@ impl Client<PdRpcClient> {
203203
cf: self.cf.clone(),
204204
backoff: self.backoff.clone(),
205205
atomic: true,
206-
api_version: self.api_version,
206+
keyspace: self.keyspace,
207207
}
208208
}
209209
}
@@ -229,9 +229,9 @@ impl<PdC: PdClient> Client<PdC> {
229229
/// ```
230230
pub async fn get(&self, key: impl Into<Key>) -> Result<Option<Value>> {
231231
debug!("invoking raw get request");
232-
let key = key.into().encode_version(self.api_version, KeyMode::Raw);
232+
let key = key.into().encode_keyspace(self.keyspace, KeyMode::Raw);
233233
let request = new_raw_get_request(key, self.cf.clone());
234-
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.api_version, request)
234+
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.keyspace, request)
235235
.retry_multi_region(self.backoff.clone())
236236
.merge(CollectSingle)
237237
.post_process_default()
@@ -264,15 +264,15 @@ impl<PdC: PdClient> Client<PdC> {
264264
debug!("invoking raw batch_get request");
265265
let keys = keys
266266
.into_iter()
267-
.map(|k| k.into().encode_version(self.api_version, KeyMode::Raw));
267+
.map(|k| k.into().encode_keyspace(self.keyspace, KeyMode::Raw));
268268
let request = new_raw_batch_get_request(keys, self.cf.clone());
269-
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.api_version, request)
269+
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.keyspace, request)
270270
.retry_multi_region(self.backoff.clone())
271271
.merge(Collect)
272272
.plan();
273273
plan.execute().await.map(|r| {
274274
r.into_iter()
275-
.map(|pair| pair.truncate_version(self.api_version))
275+
.map(|pair| pair.truncate_keyspace(self.keyspace))
276276
.collect()
277277
})
278278
}
@@ -295,9 +295,9 @@ impl<PdC: PdClient> Client<PdC> {
295295
/// ```
296296
pub async fn put(&self, key: impl Into<Key>, value: impl Into<Value>) -> Result<()> {
297297
debug!("invoking raw put request");
298-
let key = key.into().encode_version(self.api_version, KeyMode::Raw);
298+
let key = key.into().encode_keyspace(self.keyspace, KeyMode::Raw);
299299
let request = new_raw_put_request(key, value.into(), self.cf.clone(), self.atomic);
300-
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.api_version, request)
300+
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.keyspace, request)
301301
.retry_multi_region(self.backoff.clone())
302302
.merge(CollectSingle)
303303
.extract_error()
@@ -330,9 +330,9 @@ impl<PdC: PdClient> Client<PdC> {
330330
debug!("invoking raw batch_put request");
331331
let pairs = pairs
332332
.into_iter()
333-
.map(|pair| pair.into().encode_version(self.api_version, KeyMode::Raw));
333+
.map(|pair| pair.into().encode_keyspace(self.keyspace, KeyMode::Raw));
334334
let request = new_raw_batch_put_request(pairs, self.cf.clone(), self.atomic);
335-
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.api_version, request)
335+
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.keyspace, request)
336336
.retry_multi_region(self.backoff.clone())
337337
.extract_error()
338338
.plan();
@@ -359,9 +359,9 @@ impl<PdC: PdClient> Client<PdC> {
359359
/// ```
360360
pub async fn delete(&self, key: impl Into<Key>) -> Result<()> {
361361
debug!("invoking raw delete request");
362-
let key = key.into().encode_version(self.api_version, KeyMode::Raw);
362+
let key = key.into().encode_keyspace(self.keyspace, KeyMode::Raw);
363363
let request = new_raw_delete_request(key, self.cf.clone(), self.atomic);
364-
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.api_version, request)
364+
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.keyspace, request)
365365
.retry_multi_region(self.backoff.clone())
366366
.merge(CollectSingle)
367367
.extract_error()
@@ -392,9 +392,9 @@ impl<PdC: PdClient> Client<PdC> {
392392
self.assert_non_atomic()?;
393393
let keys = keys
394394
.into_iter()
395-
.map(|k| k.into().encode_version(self.api_version, KeyMode::Raw));
395+
.map(|k| k.into().encode_keyspace(self.keyspace, KeyMode::Raw));
396396
let request = new_raw_batch_delete_request(keys, self.cf.clone());
397-
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.api_version, request)
397+
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.keyspace, request)
398398
.retry_multi_region(self.backoff.clone())
399399
.extract_error()
400400
.plan();
@@ -420,9 +420,9 @@ impl<PdC: PdClient> Client<PdC> {
420420
pub async fn delete_range(&self, range: impl Into<BoundRange>) -> Result<()> {
421421
debug!("invoking raw delete_range request");
422422
self.assert_non_atomic()?;
423-
let range = range.into().encode_version(self.api_version, KeyMode::Raw);
423+
let range = range.into().encode_keyspace(self.keyspace, KeyMode::Raw);
424424
let request = new_raw_delete_range_request(range, self.cf.clone());
425-
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.api_version, request)
425+
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.keyspace, request)
426426
.retry_multi_region(self.backoff.clone())
427427
.extract_error()
428428
.plan();
@@ -572,14 +572,14 @@ impl<PdC: PdClient> Client<PdC> {
572572
) -> Result<(Option<Value>, bool)> {
573573
debug!("invoking raw compare_and_swap request");
574574
self.assert_atomic()?;
575-
let key = key.into().encode_version(self.api_version, KeyMode::Raw);
575+
let key = key.into().encode_keyspace(self.keyspace, KeyMode::Raw);
576576
let req = new_cas_request(
577577
key,
578578
new_value.into(),
579579
previous_value.into(),
580580
self.cf.clone(),
581581
);
582-
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.api_version, req)
582+
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.keyspace, req)
583583
.retry_multi_region(self.backoff.clone())
584584
.merge(CollectSingle)
585585
.post_process_default()
@@ -598,14 +598,14 @@ impl<PdC: PdClient> Client<PdC> {
598598
semver::VersionReq::from_str(&copr_version_req)?;
599599
let ranges = ranges
600600
.into_iter()
601-
.map(|range| range.into().encode_version(self.api_version, KeyMode::Raw));
602-
let api_version = self.api_version;
601+
.map(|range| range.into().encode_keyspace(self.keyspace, KeyMode::Raw));
602+
let keyspace = self.keyspace;
603603
let request_builder = move |region, ranges: Vec<Range<Key>>| {
604604
request_builder(
605605
region,
606606
ranges
607607
.into_iter()
608-
.map(|range| range.truncate_version(api_version))
608+
.map(|range| range.truncate_keyspace(keyspace))
609609
.collect(),
610610
)
611611
};
@@ -615,7 +615,7 @@ impl<PdC: PdClient> Client<PdC> {
615615
ranges,
616616
request_builder,
617617
);
618-
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.api_version, req)
618+
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.keyspace, req)
619619
.preserve_shard()
620620
.retry_multi_region(self.backoff.clone())
621621
.post_process_default()
@@ -624,7 +624,7 @@ impl<PdC: PdClient> Client<PdC> {
624624
.execute()
625625
.await?
626626
.into_iter()
627-
.map(|(ranges, data)| (ranges.truncate_version(api_version), data))
627+
.map(|(ranges, data)| (ranges.truncate_keyspace(keyspace), data))
628628
.collect())
629629
}
630630

@@ -641,7 +641,7 @@ impl<PdC: PdClient> Client<PdC> {
641641
});
642642
}
643643

644-
let mut cur_range = range.into().encode_version(self.api_version, KeyMode::Raw);
644+
let mut cur_range = range.into().encode_keyspace(self.keyspace, KeyMode::Raw);
645645
let mut result = Vec::new();
646646
let mut scan_regions = self.rpc.clone().stores_for_range(cur_range.clone()).boxed();
647647
let mut region_store =
@@ -656,13 +656,12 @@ impl<PdC: PdClient> Client<PdC> {
656656
while cur_limit > 0 {
657657
let request =
658658
new_raw_scan_request(cur_range.clone(), cur_limit, key_only, self.cf.clone());
659-
let resp =
660-
crate::request::PlanBuilder::new(self.rpc.clone(), self.api_version, request)
661-
.single_region_with_store(region_store.clone())
662-
.await?
663-
.plan()
664-
.execute()
665-
.await?;
659+
let resp = crate::request::PlanBuilder::new(self.rpc.clone(), self.keyspace, request)
660+
.single_region_with_store(region_store.clone())
661+
.await?
662+
.plan()
663+
.execute()
664+
.await?;
666665
let mut region_scan_res = resp
667666
.kvs
668667
.into_iter()
@@ -694,7 +693,7 @@ impl<PdC: PdClient> Client<PdC> {
694693
result.truncate(limit as usize);
695694

696695
// truncate the version of keys
697-
let result = result.truncate_version(self.api_version);
696+
let result = result.truncate_keyspace(self.keyspace);
698697

699698
Ok(result)
700699
}
@@ -714,16 +713,16 @@ impl<PdC: PdClient> Client<PdC> {
714713

715714
let ranges = ranges
716715
.into_iter()
717-
.map(|range| range.into().encode_version(self.api_version, KeyMode::Raw));
716+
.map(|range| range.into().encode_keyspace(self.keyspace, KeyMode::Raw));
718717

719718
let request = new_raw_batch_scan_request(ranges, each_limit, key_only, self.cf.clone());
720-
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.api_version, request)
719+
let plan = crate::request::PlanBuilder::new(self.rpc.clone(), self.keyspace, request)
721720
.retry_multi_region(self.backoff.clone())
722721
.merge(Collect)
723722
.plan();
724723
plan.execute().await.map(|r| {
725724
r.into_iter()
726-
.map(|pair| pair.truncate_version(self.api_version))
725+
.map(|pair| pair.truncate_keyspace(self.keyspace))
727726
.collect()
728727
})
729728
}
@@ -778,7 +777,7 @@ mod tests {
778777
cf: Some(ColumnFamily::Default),
779778
backoff: DEFAULT_REGION_BACKOFF,
780779
atomic: false,
781-
api_version: APIVersion::V2 { keyspace_id: 0 },
780+
keyspace: Keyspace::Enable { keyspace_id: 0 },
782781
};
783782
let resps = client
784783
.coprocessor(

‎src/raw/requests.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -503,15 +503,15 @@ mod test {
503503
use crate::mock::MockKvClient;
504504
use crate::mock::MockPdClient;
505505
use crate::proto::kvrpcpb;
506-
use crate::request::APIVersion;
506+
use crate::request::Keyspace;
507507
use crate::request::Plan;
508508
use crate::Key;
509509

510510
#[rstest::rstest]
511-
#[case(APIVersion::V1)]
512-
#[case(APIVersion::V2 { keyspace_id: 0 })]
511+
#[case(Keyspace::Disable)]
512+
#[case(Keyspace::Enable { keyspace_id: 0 })]
513513
#[tokio::test]
514-
async fn test_raw_scan(#[case] api_version: APIVersion) {
514+
async fn test_raw_scan(#[case] keyspace: Keyspace) {
515515
let client = Arc::new(MockPdClient::new(MockKvClient::with_dispatch_hook(
516516
|req: &dyn Any| {
517517
let req: &kvrpcpb::RawScanRequest = req.downcast_ref().unwrap();
@@ -540,8 +540,8 @@ mod test {
540540
key_only: true,
541541
..Default::default()
542542
};
543-
let plan = crate::request::PlanBuilder::new(client, api_version, scan)
544-
.resolve_lock(OPTIMISTIC_BACKOFF, api_version)
543+
let plan = crate::request::PlanBuilder::new(client, keyspace, scan)
544+
.resolve_lock(OPTIMISTIC_BACKOFF, keyspace)
545545
.retry_multi_region(DEFAULT_REGION_BACKOFF)
546546
.merge(Collect)
547547
.plan();

0 commit comments

Comments
 (0)