Tidy up lib.rs

Signed-off-by: Nick Cameron <nrc@ncameron.org>

Author: nrc

src/lib.rs

@@ -1,78 +1,37 @@
 // Copyright 2018 TiKV Project Authors. Licensed under Apache-2.0.
 
-// Long and nested future chains can quickly result in large generic types.
-#![type_length_limit = "16777216"]
-#![allow(clippy::redundant_closure)]
-#![allow(clippy::type_complexity)]
-#![allow(incomplete_features)]
-
-//! This crate provides a clean, ready to use client for [TiKV](https://github.com/tikv/tikv), a
-//! distributed transactional Key-Value database written in Rust.
+//! This crate provides an easy-to-use client for [TiKV](https://github.com/tikv/tikv), a
+//! distributed, transactional key-value database written in Rust.
 //!
-//! With this crate you can easily connect to any TiKV deployment, interact with it, and mutate the
-//! data it contains.
+//! This crate lets you connect to a TiKV cluster and use either a transactional or raw (simple
+//! get/put style without transactional consistency guarantees) API to access and update your data.
 //!
 //! ## Choosing an API
 //!
 //! This crate offers both [**raw**](raw/index.html) and
 //! [**transactional**](transaction/index.html) APIs. You should choose just one for your system.
 //!
-//! The *consequence* of supporting transactions is increased overhead of coordination with the
-//! placement driver for timestamp acquisition. This is approximately 1 RTT.
+//! The consequence of supporting transactions is increased overhead of coordination with the
+//! placement driver and TiKV, and additional code complexity.
 //!
 //! *While it is possible to use both APIs at the same time, doing so is unsafe and unsupported.*
 //!
-//! Choose the one that suites your needs as described below, then add the import statement to your
-//! file where you need to use the library.
-//!
 //! ### Transactional
 //!
-//! The [transactional](transaction/index.html) API supports **transactions** via Multi-Version
-//! Concurrency Control (MVCC).
+//! The [transactional](transaction/index.html) API supports **transactions** via multi-version
+//! concurrency control (MVCC).
 //!
-//! **Best when you mostly do** complex sets of actions, actions which may require a rollback,
-//! operations affecting multiple keys or values, or operations that depend on strong ordering.
+//! Best when you mostly do complex sets of actions, actions which may require a rollback,
+//! operations affecting multiple keys or values, or operations that depend on strong consistency.
 //!
-//! ```rust
-//! use tikv_client::*;
-//! ```
 //!
 //! ### Raw
 //!
-//! The [raw](raw/index.html) API has **reduced coordination overhead**, but lacks any
+//! The [raw](raw/index.html) API has reduced coordination overhead, but lacks any
 //! transactional abilities.
 //!
-//! **Best when you mostly do** single row changes, and have very limited cross-row (eg. foreign
-//! key) requirements. You will not be able to use transactions with this API.
-//!
-//! ```rust
-//! use tikv_client::*;
-//! ```
-//!
-//! ## Connect
-//!
-//! Regardless of which API you choose, you'll need to connect your client
-//! ([raw](raw::Client), [transactional](transaction::Client)).
-//!
-//! ```rust,no_run
-//! # use tikv_client::*;
-//! # use futures::prelude::*;
-//!
-//! # futures::executor::block_on(async {
-//! // Configure endpoints and optional TLS.
-//! let config = Config::default().with_security("root.ca", "internal.cert", "internal.key");
-//!
-//! // Get a transactional client.
-//! let client = TransactionClient::new_with_config(
-//!     vec![
-//!         // A list of PD endpoints.
-//!         "192.168.0.100:2379",
-//!         "192.168.0.101:2379",
-//!     ], config).await.unwrap();
-//! # });
-//! ```
-//!
-//! At this point, you should seek the documentation in the related API modules.
+//! Best when you mostly do single value changes, and have very limited cross-value
+//! requirements. You will not be able to use transactions with this API.
 
 #[macro_use]
 mod request;
@@ -117,6 +76,4 @@ pub use crate::transaction::{
 #[doc(inline)]
 pub use config::Config;
 #[doc(inline)]
-pub use region::{Region, RegionId, RegionVerId, StoreId};
-#[doc(inline)]
 pub use tikv_client_common::{security::SecurityManager, Error, Result};

src/pd/client.rs

@@ -1,8 +1,12 @@
 // Copyright 2018 TiKV Project Authors. Licensed under Apache-2.0.
 
 use crate::{
-    compat::stream_fn, kv::codec, pd::RetryClient, store::Store, BoundRange, Config, Key, Region,
-    RegionId, Result, SecurityManager, Timestamp,
+    compat::stream_fn,
+    kv::codec,
+    pd::RetryClient,
+    region::{Region, RegionId},
+    store::Store,
+    BoundRange, Config, Key, Result, SecurityManager, Timestamp,
 };
 use async_trait::async_trait;
 use futures::{prelude::*, stream::BoxStream};

src/pd/retry.rs

@@ -2,7 +2,11 @@
 
 //! A utility module for managing and retrying PD requests.
 
-use crate::{stats::pd_stats, Error, Region, RegionId, Result, SecurityManager, StoreId};
+use crate::{
+    region::{Region, RegionId, StoreId},
+    stats::pd_stats,
+    Error, Result, SecurityManager,
+};
 use async_trait::async_trait;
 use futures_timer::Delay;
 use grpcio::Environment;

src/store.rs

@@ -1,6 +1,6 @@
 // Copyright 2019 TiKV Project Authors. Licensed under Apache-2.0.
 
-use crate::{pd::PdClient, BoundRange, Key, Region, Result};
+use crate::{pd::PdClient, region::Region, BoundRange, Key, Result};
 use derive_new::new;
 use futures::{prelude::*, stream::BoxStream};
 use std::{
@@ -48,6 +48,7 @@ where
         .boxed()
 }
 
+#[allow(clippy::type_complexity)]
 pub fn store_stream_for_range<PdC: PdClient>(
     range: (Vec<u8>, Vec<u8>),
     pd_client: Arc<PdC>,
@@ -67,16 +68,16 @@ pub fn store_stream_for_range<PdC: PdClient>(
 }
 
 pub fn store_stream_for_range_by_start_key<PdC: PdClient>(
-    start_key: Vec<u8>,
+    start_key: Key,
     pd_client: Arc<PdC>,
 ) -> BoxStream<'static, Result<(Vec<u8>, Store)>> {
-    let bnd_range = BoundRange::range_from(start_key.clone().into());
+    let bnd_range = BoundRange::range_from(start_key.clone());
     pd_client
         .stores_for_range(bnd_range)
         .map_ok(move |store| {
             let region_range = store.region.range();
             (
-                range_intersection(region_range, (start_key.clone().into(), vec![].into()))
+                range_intersection(region_range, (start_key.clone(), vec![].into()))
                     .0
                     .into(),
                 store,

src/transaction/buffer.rs

@@ -75,10 +75,7 @@ impl Buffer {
         let (cached_results, undetermined_keys) = {
             // Partition the keys into those we have buffered and those we have to
             // get from the store.
-            let (undetermined_keys, cached_results): (
-                Vec<(Key, MutationValue)>,
-                Vec<(Key, MutationValue)>,
-            ) = keys
+            let (undetermined_keys, cached_results): (Vec<_>, Vec<_>) = keys
                 .map(|key| {
                     let value = self
                         .entry_map

src/transaction/lock.rs

@@ -3,10 +3,11 @@
 use crate::{
     backoff::{Backoff, DEFAULT_REGION_BACKOFF, OPTIMISTIC_BACKOFF},
     pd::PdClient,
+    region::RegionVerId,
     request::Plan,
     timestamp::TimestampExt,
     transaction::requests,
-    Error, RegionVerId, Result,
+    Error, Result,
 };
 use std::{
     collections::{HashMap, HashSet},

src/transaction/requests.rs

@@ -278,11 +278,11 @@ impl KvRequest for kvrpcpb::CommitRequest {
 shardable_keys!(kvrpcpb::CommitRequest);
 
 pub fn new_batch_rollback_request(
-    keys: Vec<Key>,
+    keys: Vec<Vec<u8>>,
     start_version: u64,
 ) -> kvrpcpb::BatchRollbackRequest {
     let mut req = kvrpcpb::BatchRollbackRequest::default();
-    req.set_keys(keys.into_iter().map(Into::into).collect());
+    req.set_keys(keys);
     req.set_start_version(start_version);
 
     req
@@ -429,7 +429,7 @@ impl Shardable for kvrpcpb::ScanLockRequest {
         &self,
         pd_client: &Arc<impl PdClient>,
     ) -> BoxStream<'static, Result<(Self::Shard, Store)>> {
-        store_stream_for_range_by_start_key(self.start_key.clone(), pd_client.clone())
+        store_stream_for_range_by_start_key(self.start_key.clone().into(), pd_client.clone())
     }
 
     fn apply_shard(&mut self, shard: Self::Shard, store: &Store) -> Result<()> {

src/transaction/transaction.rs

@@ -1035,7 +1035,7 @@ impl<PdC: PdClient> Committer<PdC> {
                 r.min_commit_ts
             })
             .max()
-            .map(|ts| Timestamp::from_version(ts));
+            .map(Timestamp::from_version);
 
         Ok(min_commit_ts)
     }