tikv_client/raw/
lowering.rs

1// Copyright 2021 TiKV Project Authors. Licensed under Apache-2.0.
2
3//! This module provides constructor functions for requests which take arguments as high-level
4//! types (i.e., the types from the client crate) and converts these to the types used in the
5//! generated protobuf code, then calls the low-level ctor functions in the requests module.
6
7use std::iter::Iterator;
8use std::ops::Range;
9use std::sync::Arc;
10
11use crate::proto::kvrpcpb;
12use crate::proto::metapb;
13use crate::raw::requests;
14use crate::BoundRange;
15use crate::ColumnFamily;
16use crate::Key;
17use crate::KvPair;
18use crate::Value;
19
20pub fn new_raw_get_request(key: Key, cf: Option<ColumnFamily>) -> kvrpcpb::RawGetRequest {
21    requests::new_raw_get_request(key.into(), cf)
22}
23
24pub fn new_raw_batch_get_request(
25    keys: impl Iterator<Item = Key>,
26    cf: Option<ColumnFamily>,
27) -> kvrpcpb::RawBatchGetRequest {
28    requests::new_raw_batch_get_request(keys.map(Into::into).collect(), cf)
29}
30
31pub fn new_raw_get_key_ttl_request(
32    key: Key,
33    cf: Option<ColumnFamily>,
34) -> kvrpcpb::RawGetKeyTtlRequest {
35    requests::new_raw_get_key_ttl_request(key.into(), cf)
36}
37
38pub fn new_raw_put_request(
39    key: Key,
40    value: Value,
41    cf: Option<ColumnFamily>,
42    ttl: u64,
43    atomic: bool,
44) -> kvrpcpb::RawPutRequest {
45    requests::new_raw_put_request(key.into(), value, ttl, cf, atomic)
46}
47
48pub fn new_raw_batch_put_request(
49    pairs: impl Iterator<Item = KvPair>,
50    ttls: impl Iterator<Item = u64>,
51    cf: Option<ColumnFamily>,
52    atomic: bool,
53) -> kvrpcpb::RawBatchPutRequest {
54    let pairs = pairs.map(Into::into).collect::<Vec<_>>();
55    let ttls = ttls.take(pairs.len()).collect::<Vec<_>>();
56    assert_eq!(pairs.len(), ttls.len());
57    requests::new_raw_batch_put_request(pairs, ttls, cf, atomic)
58}
59
60pub fn new_raw_delete_request(
61    key: Key,
62    cf: Option<ColumnFamily>,
63    atomic: bool,
64) -> kvrpcpb::RawDeleteRequest {
65    requests::new_raw_delete_request(key.into(), cf, atomic)
66}
67
68pub fn new_raw_batch_delete_request(
69    keys: impl Iterator<Item = Key>,
70    cf: Option<ColumnFamily>,
71) -> kvrpcpb::RawBatchDeleteRequest {
72    requests::new_raw_batch_delete_request(keys.map(Into::into).collect(), cf)
73}
74
75pub fn new_raw_delete_range_request(
76    range: BoundRange,
77    cf: Option<ColumnFamily>,
78) -> kvrpcpb::RawDeleteRangeRequest {
79    let (start_key, end_key) = range.into_keys();
80    requests::new_raw_delete_range_request(start_key.into(), end_key.unwrap_or_default().into(), cf)
81}
82
83pub fn new_raw_scan_request(
84    range: BoundRange,
85    limit: u32,
86    key_only: bool,
87    reverse: bool,
88    cf: Option<ColumnFamily>,
89) -> kvrpcpb::RawScanRequest {
90    let (start_key, end_key) = range.into_keys();
91    requests::new_raw_scan_request(
92        start_key.into(),
93        end_key.unwrap_or_default().into(),
94        limit,
95        key_only,
96        reverse,
97        cf,
98    )
99}
100
101pub fn new_raw_batch_scan_request(
102    ranges: impl Iterator<Item = BoundRange>,
103    each_limit: u32,
104    key_only: bool,
105    cf: Option<ColumnFamily>,
106) -> kvrpcpb::RawBatchScanRequest {
107    requests::new_raw_batch_scan_request(ranges.map(Into::into).collect(), each_limit, key_only, cf)
108}
109
110pub fn new_cas_request(
111    key: Key,
112    value: Value,
113    previous_value: Option<Value>,
114    cf: Option<ColumnFamily>,
115) -> kvrpcpb::RawCasRequest {
116    requests::new_cas_request(key.into(), value, previous_value, cf)
117}
118
119pub fn new_raw_coprocessor_request(
120    copr_name: String,
121    copr_version_req: String,
122    ranges: impl Iterator<Item = BoundRange>,
123    request_builder: impl Fn(metapb::Region, Vec<Range<Key>>) -> Vec<u8> + Send + Sync + 'static,
124) -> requests::RawCoprocessorRequest {
125    requests::new_raw_coprocessor_request(
126        copr_name,
127        copr_version_req,
128        ranges.map(Into::into).collect(),
129        Arc::new(move |region, ranges| {
130            request_builder(
131                region,
132                ranges
133                    .into_iter()
134                    .map(|range| range.start_key.into()..range.end_key.into())
135                    .collect(),
136            )
137        }),
138    )
139}