From dda415e5059d8205c7513ca2f7fef69209fd659c Mon Sep 17 00:00:00 2001 From: Rahul Rane Date: Thu, 15 Feb 2024 23:19:03 -0800 Subject: [PATCH] Addressed comments Signed-off-by: Rahul Rane --- src/raw/client.rs | 8 ++++---- src/raw/requests.rs | 9 +++++++-- tests/integration_tests.rs | 22 +++++++++++++--------- 3 files changed, 24 insertions(+), 15 deletions(-) diff --git a/src/raw/client.rs b/src/raw/client.rs index 4d025a10..c119169f 100644 --- a/src/raw/client.rs +++ b/src/raw/client.rs @@ -503,7 +503,7 @@ impl Client { self.scan_inner(range.into(), limit, false, false).await } - // Create a new 'scan' request but scans in "reverse" direction. + /// Create a new 'scan' request but scans in "reverse" direction. /// /// Once resolved this request will result in a `Vec` of key-value pairs that lies in the specified range. /// @@ -511,8 +511,8 @@ impl Client { /// only the first `limit` pairs are returned, ordered by the key. /// /// - /// Reverse Scan queries continuous kv pairs in range (endKey, startKey], - /// from startKey(upperBound) to endKey(lowerBound), up to limit pairs. + /// Reverse Scan queries continuous kv pairs in range [startKey, endKey), + /// from startKey(lowerBound) to endKey(upperBound) in reverse order, up to limit pairs. /// The returned keys are in reversed lexicographical order. /// If you want to include the endKey or exclude the startKey, push a '\0' to the key. /// It doesn't support Scanning from "", because locating the last Region is not yet implemented. @@ -522,7 +522,7 @@ impl Client { /// # use futures::prelude::*; /// # futures::executor::block_on(async { /// # let client = RawClient::new(vec!["192.168.0.100"]).await.unwrap(); - /// let inclusive_range = "TiDB"..="TiKV"; + /// let inclusive_range = "TiKV"..="TiDB"; /// let req = client.scan_reverse(inclusive_range.into_owned(), 2); /// let result: Vec = req.await.unwrap(); /// # }); diff --git a/src/raw/requests.rs b/src/raw/requests.rs index af59b770..e31fc2fe 100644 --- a/src/raw/requests.rs +++ b/src/raw/requests.rs @@ -282,8 +282,13 @@ pub fn new_raw_scan_request( cf: Option, ) -> kvrpcpb::RawScanRequest { let mut req = kvrpcpb::RawScanRequest::default(); - req.start_key = start_key; - req.end_key = end_key; + if !reverse { + req.start_key = start_key; + req.end_key = end_key; + } else { + req.start_key = end_key; + req.end_key = start_key; + } req.limit = limit; req.key_only = key_only; req.reverse = reverse; diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs index cc3d09b9..a7ec0fc2 100644 --- a/tests/integration_tests.rs +++ b/tests/integration_tests.rs @@ -562,10 +562,10 @@ async fn raw_req() -> Result<()> { assert_eq!(res[6].1, "v5".as_bytes()); // reverse scan - // By default end key is exclusive, so k5 is not included and start key in included + // By default end key is exclusive, so k5 is not included and start key in included let res = client - .scan_reverse("k5".to_owned().."k2".to_owned(), 5) + .scan_reverse("k2".to_owned().."k5".to_owned(), 5) .await?; assert_eq!(res.len(), 3); assert_eq!(res[0].1, "v4".as_bytes()); @@ -574,7 +574,7 @@ async fn raw_req() -> Result<()> { // by default end key in exclusive and start key is inclusive but now exclude start key let res = client - .scan_reverse("k5".to_owned()..="k2".to_owned(), 5) + .scan_reverse("k2\0".to_owned().."k5".to_owned(), 5) .await?; assert_eq!(res.len(), 2); assert_eq!(res[0].1, "v4".as_bytes()); @@ -583,7 +583,7 @@ async fn raw_req() -> Result<()> { // reverse scan // by default end key is exclusive and start key is inclusive but now include end key let res = client - .scan_reverse("k5\0".to_owned().."k2".to_owned(), 5) + .scan_reverse("k2".to_owned()..="k5".to_owned(), 5) .await?; assert_eq!(res.len(), 4); assert_eq!(res[0].1, "v5".as_bytes()); @@ -593,7 +593,7 @@ async fn raw_req() -> Result<()> { // by default end key is exclusive and start key is inclusive but now include end key and exclude start key let res = client - .scan_reverse("k5\0".to_owned()..="k2".to_owned(), 5) + .scan_reverse("k2\0".to_owned()..="k5".to_owned(), 5) .await?; assert_eq!(res.len(), 3); assert_eq!(res[0].1, "v5".as_bytes()); @@ -602,16 +602,20 @@ async fn raw_req() -> Result<()> { // limit results to first 2 let res = client - .scan_reverse("k5".to_owned().."k2".to_owned(), 2) + .scan_reverse("k2".to_owned().."k5".to_owned(), 2) .await?; assert_eq!(res.len(), 2); assert_eq!(res[0].1, "v4".as_bytes()); assert_eq!(res[1].1, "v3".as_bytes()); - //let range = "k5"..; // Upperbound (k5, +inf). This is NOT SUPPORTED by TiKV. - let range = BoundRange::range_from(Key::from("k5".to_owned())); + // if endKey is not provided then it scan everything including end key + let range = BoundRange::range_from(Key::from("k2".to_owned())); let res = client.scan_reverse(range, 20).await?; - assert_eq!(res.len(), 0); + assert_eq!(res.len(), 4); + assert_eq!(res[0].1, "v5".as_bytes()); + assert_eq!(res[1].1, "v4".as_bytes()); + assert_eq!(res[2].1, "v3".as_bytes()); + assert_eq!(res[3].1, "v2".as_bytes()); Ok(()) }