From 0c5eb3f70f0a715af3b518fa32dcf3b61aff1731 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Wed, 26 Oct 2022 16:24:49 +0200 Subject: [PATCH] style: format imports Re-order and re-format the imports so that they follow a consistent pattern. This helps eliminate conflicts due to imports. --- router/benches/e2e.rs | 3 ++- router/benches/schema_validator.rs | 3 ++- router/src/dml_handlers/chain.rs | 3 ++- router/src/dml_handlers/fan_out.rs | 6 +++-- router/src/dml_handlers/instrumentation.rs | 11 ++++++---- router/src/dml_handlers/mock.rs | 6 +++-- router/src/dml_handlers/nop.rs | 6 +++-- router/src/dml_handlers/ns_autocreation.rs | 16 +++++++++----- router/src/dml_handlers/partitioner.rs | 6 +++-- router/src/dml_handlers/schema_validation.rs | 14 +++++++----- .../src/dml_handlers/sharded_write_buffer.rs | 22 +++++++++++-------- router/src/dml_handlers/trait.rs | 6 +++-- router/src/dml_handlers/write_summary.rs | 6 +++-- router/src/namespace_cache.rs | 3 ++- router/src/namespace_cache/memory.rs | 9 +++++--- router/src/namespace_cache/metrics.rs | 14 +++++++----- router/src/namespace_cache/sharded_cache.rs | 14 +++++++----- router/src/server.rs | 10 +++++---- router/src/server/grpc.rs | 8 ++++--- router/src/server/grpc/sharder.rs | 6 +++-- router/src/server/http.rs | 13 +++++------ router/src/shard.rs | 3 ++- router/tests/http.rs | 3 ++- 23 files changed, 120 insertions(+), 71 deletions(-) diff --git a/router/benches/e2e.rs b/router/benches/e2e.rs index cb35283286..321b6fbd6b 100644 --- a/router/benches/e2e.rs +++ b/router/benches/e2e.rs @@ -1,3 +1,5 @@ +use std::{collections::BTreeSet, iter, sync::Arc}; + use criterion::{criterion_group, criterion_main, Criterion, Throughput}; use data_types::{PartitionTemplate, TemplatePart}; use hyper::{Body, Request}; @@ -12,7 +14,6 @@ use router::{ shard::Shard, }; use sharder::JumpHash; -use std::{collections::BTreeSet, iter, sync::Arc}; use tokio::runtime::Runtime; use write_buffer::{ core::WriteBufferWriting, diff --git a/router/benches/schema_validator.rs b/router/benches/schema_validator.rs index e19c6986dc..ee20f8abba 100644 --- a/router/benches/schema_validator.rs +++ b/router/benches/schema_validator.rs @@ -1,3 +1,5 @@ +use std::{iter, sync::Arc}; + use criterion::{ criterion_group, criterion_main, measurement::WallTime, BatchSize, BenchmarkGroup, Criterion, Throughput, @@ -12,7 +14,6 @@ use router::{ namespace_cache::{MemoryNamespaceCache, ShardedCache}, }; use schema::selection::Selection; -use std::{iter, sync::Arc}; use tokio::runtime::Runtime; static NAMESPACE: Lazy> = Lazy::new(|| "bananas".try_into().unwrap()); diff --git a/router/src/dml_handlers/chain.rs b/router/src/dml_handlers/chain.rs index 48740e4651..bf8b2f3619 100644 --- a/router/src/dml_handlers/chain.rs +++ b/router/src/dml_handlers/chain.rs @@ -1,8 +1,9 @@ -use super::{DmlError, DmlHandler}; use async_trait::async_trait; use data_types::{DatabaseName, DeletePredicate}; use trace::ctx::SpanContext; +use super::{DmlError, DmlHandler}; + /// An extension trait to chain together the execution of a pair of /// [`DmlHandler`] implementations. pub trait DmlHandlerChainExt: DmlHandler + Sized { diff --git a/router/src/dml_handlers/fan_out.rs b/router/src/dml_handlers/fan_out.rs index 165351a4ee..ec171e9fc7 100644 --- a/router/src/dml_handlers/fan_out.rs +++ b/router/src/dml_handlers/fan_out.rs @@ -1,10 +1,12 @@ -use super::DmlHandler; +use std::{fmt::Debug, marker::PhantomData}; + use async_trait::async_trait; use data_types::{DatabaseName, DeletePredicate}; use futures::{stream::FuturesUnordered, TryStreamExt}; -use std::{fmt::Debug, marker::PhantomData}; use trace::ctx::SpanContext; +use super::DmlHandler; + /// A [`FanOutAdaptor`] takes an iterator of DML write operation inputs and /// executes them concurrently against the inner handler, returning once all /// operations are complete. diff --git a/router/src/dml_handlers/instrumentation.rs b/router/src/dml_handlers/instrumentation.rs index aa3338c074..3289cfd4d0 100644 --- a/router/src/dml_handlers/instrumentation.rs +++ b/router/src/dml_handlers/instrumentation.rs @@ -1,4 +1,3 @@ -use super::DmlHandler; use async_trait::async_trait; use data_types::{DatabaseName, DeletePredicate}; use iox_time::{SystemProvider, TimeProvider}; @@ -8,6 +7,8 @@ use trace::{ span::{SpanExt, SpanRecorder}, }; +use super::DmlHandler; + /// An instrumentation decorator recording call latencies for [`DmlHandler`] implementations. /// /// Metrics are broken down by operation (write/delete) and result (success/error). @@ -135,15 +136,17 @@ where #[cfg(test)] mod tests { - use super::*; - use crate::dml_handlers::{mock::MockDmlHandler, DmlError}; + use std::sync::Arc; + use assert_matches::assert_matches; use data_types::TimestampRange; use metric::Attributes; - use std::sync::Arc; use trace::{span::SpanStatus, RingBufferTraceCollector, TraceCollector}; use write_summary::WriteSummary; + use super::*; + use crate::dml_handlers::{mock::MockDmlHandler, DmlError}; + const HANDLER_NAME: &str = "bananas"; fn assert_metric_hit( diff --git a/router/src/dml_handlers/mock.rs b/router/src/dml_handlers/mock.rs index 25eeaef947..50da8c5aa3 100644 --- a/router/src/dml_handlers/mock.rs +++ b/router/src/dml_handlers/mock.rs @@ -1,11 +1,13 @@ -use super::{DmlError, DmlHandler}; +use std::{collections::VecDeque, fmt::Debug}; + use async_trait::async_trait; use data_types::{DatabaseName, DeletePredicate}; use parking_lot::Mutex; -use std::{collections::VecDeque, fmt::Debug}; use trace::ctx::SpanContext; use write_summary::WriteSummary; +use super::{DmlError, DmlHandler}; + /// A captured call to a [`MockDmlHandler`], generic over `W`, the captured /// [`DmlHandler::WriteInput`] type. #[derive(Debug, Clone)] diff --git a/router/src/dml_handlers/nop.rs b/router/src/dml_handlers/nop.rs index 459aabd065..cdad61186a 100644 --- a/router/src/dml_handlers/nop.rs +++ b/router/src/dml_handlers/nop.rs @@ -1,12 +1,14 @@ //! A NOP implementation of [`DmlHandler`]. -use super::{DmlError, DmlHandler}; +use std::{fmt::Debug, marker::PhantomData}; + use async_trait::async_trait; use data_types::{DatabaseName, DeletePredicate}; use observability_deps::tracing::*; -use std::{fmt::Debug, marker::PhantomData}; use trace::ctx::SpanContext; +use super::{DmlError, DmlHandler}; + /// A [`DmlHandler`] implementation that does nothing. #[derive(Debug)] pub struct NopDmlHandler(PhantomData); diff --git a/router/src/dml_handlers/ns_autocreation.rs b/router/src/dml_handlers/ns_autocreation.rs index 4e5c2d6343..93e239d114 100644 --- a/router/src/dml_handlers/ns_autocreation.rs +++ b/router/src/dml_handlers/ns_autocreation.rs @@ -1,13 +1,15 @@ -use super::DmlHandler; -use crate::namespace_cache::NamespaceCache; +use std::{fmt::Debug, marker::PhantomData, sync::Arc}; + use async_trait::async_trait; use data_types::{DatabaseName, DeletePredicate, QueryPoolId, TopicId}; use iox_catalog::interface::Catalog; use observability_deps::tracing::*; -use std::{fmt::Debug, marker::PhantomData, sync::Arc}; use thiserror::Error; use trace::ctx::SpanContext; +use super::DmlHandler; +use crate::namespace_cache::NamespaceCache; + /// An error auto-creating the request namespace. #[derive(Debug, Error)] pub enum NamespaceCreationError { @@ -130,11 +132,13 @@ where #[cfg(test)] mod tests { - use super::*; - use crate::namespace_cache::MemoryNamespaceCache; + use std::sync::Arc; + use data_types::{Namespace, NamespaceId, NamespaceSchema}; use iox_catalog::mem::MemCatalog; - use std::sync::Arc; + + use super::*; + use crate::namespace_cache::MemoryNamespaceCache; #[tokio::test] async fn test_cache_hit() { diff --git a/router/src/dml_handlers/partitioner.rs b/router/src/dml_handlers/partitioner.rs index 7060f4816e..099ffbff11 100644 --- a/router/src/dml_handlers/partitioner.rs +++ b/router/src/dml_handlers/partitioner.rs @@ -1,4 +1,3 @@ -use super::DmlHandler; use async_trait::async_trait; use data_types::{DatabaseName, DeletePredicate, PartitionKey, PartitionTemplate}; use hashbrown::HashMap; @@ -7,6 +6,8 @@ use observability_deps::tracing::*; use thiserror::Error; use trace::ctx::SpanContext; +use super::DmlHandler; + /// An error raised by the [`Partitioner`] handler. #[derive(Debug, Error)] pub enum PartitionError { @@ -112,10 +113,11 @@ impl DmlHandler for Partitioner { #[cfg(test)] mod tests { - use super::*; use assert_matches::assert_matches; use data_types::TemplatePart; + use super::*; + /// The default timestamp applied to test LP if the write does not specify /// one. const DEFAULT_TIMESTAMP_NANOS: i64 = 42000000000000000; diff --git a/router/src/dml_handlers/schema_validation.rs b/router/src/dml_handlers/schema_validation.rs index c84c5bf75d..f649f6abe5 100644 --- a/router/src/dml_handlers/schema_validation.rs +++ b/router/src/dml_handlers/schema_validation.rs @@ -1,5 +1,5 @@ -use super::DmlHandler; -use crate::namespace_cache::{metrics::InstrumentedCache, MemoryNamespaceCache, NamespaceCache}; +use std::{ops::DerefMut, sync::Arc}; + use async_trait::async_trait; use data_types::{DatabaseName, DeletePredicate, NamespaceSchema}; use hashbrown::HashMap; @@ -10,10 +10,12 @@ use iox_catalog::{ use metric::U64Counter; use mutable_batch::MutableBatch; use observability_deps::tracing::*; -use std::{ops::DerefMut, sync::Arc}; use thiserror::Error; use trace::ctx::SpanContext; +use super::DmlHandler; +use crate::namespace_cache::{metrics::InstrumentedCache, MemoryNamespaceCache, NamespaceCache}; + /// Errors emitted during schema validation. #[derive(Debug, Error)] pub enum SchemaError { @@ -328,12 +330,14 @@ fn validate_column_limits( #[cfg(test)] mod tests { - use super::*; + use std::sync::Arc; + use assert_matches::assert_matches; use data_types::{ColumnType, TimestampRange}; use iox_tests::util::{TestCatalog, TestNamespace}; use once_cell::sync::Lazy; - use std::sync::Arc; + + use super::*; static NAMESPACE: Lazy> = Lazy::new(|| "bananas".try_into().unwrap()); diff --git a/router/src/dml_handlers/sharded_write_buffer.rs b/router/src/dml_handlers/sharded_write_buffer.rs index 419cad85a8..be5c34d9e1 100644 --- a/router/src/dml_handlers/sharded_write_buffer.rs +++ b/router/src/dml_handlers/sharded_write_buffer.rs @@ -1,7 +1,10 @@ //! Logic to shard writes/deletes and push them into a write buffer shard. -use super::Partitioned; -use crate::{dml_handlers::DmlHandler, shard::Shard}; +use std::{ + fmt::{Debug, Display}, + sync::Arc, +}; + use async_trait::async_trait; use data_types::{DatabaseName, DeletePredicate, NonEmptyString}; use dml::{DmlDelete, DmlMeta, DmlOperation, DmlWrite}; @@ -10,14 +13,13 @@ use hashbrown::HashMap; use mutable_batch::MutableBatch; use observability_deps::tracing::*; use sharder::Sharder; -use std::{ - fmt::{Debug, Display}, - sync::Arc, -}; use thiserror::Error; use trace::ctx::SpanContext; use write_buffer::core::WriteBufferError; +use super::Partitioned; +use crate::{dml_handlers::DmlHandler, shard::Shard}; + /// Errors occurring while writing to one or more write buffer shards. #[derive(Debug, Error)] pub enum ShardError { @@ -211,14 +213,16 @@ where #[cfg(test)] mod tests { - use super::*; - use crate::dml_handlers::DmlHandler; + use std::sync::Arc; + use assert_matches::assert_matches; use data_types::{ShardIndex, TimestampRange}; use sharder::mock::{MockSharder, MockSharderCall, MockSharderPayload}; - use std::sync::Arc; use write_buffer::mock::{MockBufferForWriting, MockBufferSharedState}; + use super::*; + use crate::dml_handlers::DmlHandler; + // Parse `lp` into a table-keyed MutableBatch map. fn lp_to_writes(lp: &str) -> Partitioned> { let (writes, _) = mutable_batch_lp::lines_to_batches_stats(lp, 42) diff --git a/router/src/dml_handlers/trait.rs b/router/src/dml_handlers/trait.rs index f6289d5607..784ea82584 100644 --- a/router/src/dml_handlers/trait.rs +++ b/router/src/dml_handlers/trait.rs @@ -1,10 +1,12 @@ -use super::{partitioner::PartitionError, NamespaceCreationError, SchemaError, ShardError}; +use std::{error::Error, fmt::Debug, sync::Arc}; + use async_trait::async_trait; use data_types::{DatabaseName, DeletePredicate}; -use std::{error::Error, fmt::Debug, sync::Arc}; use thiserror::Error; use trace::ctx::SpanContext; +use super::{partitioner::PartitionError, NamespaceCreationError, SchemaError, ShardError}; + /// Errors emitted by a [`DmlHandler`] implementation during DML request /// processing. #[derive(Debug, Error)] diff --git a/router/src/dml_handlers/write_summary.rs b/router/src/dml_handlers/write_summary.rs index c0f72418b6..eefa1d6594 100644 --- a/router/src/dml_handlers/write_summary.rs +++ b/router/src/dml_handlers/write_summary.rs @@ -1,11 +1,13 @@ -use super::DmlHandler; +use std::fmt::Debug; + use async_trait::async_trait; use data_types::{DatabaseName, DeletePredicate}; use dml::DmlMeta; -use std::fmt::Debug; use trace::ctx::SpanContext; use write_summary::WriteSummary; +use super::DmlHandler; + /// A [`WriteSummaryAdapter`] wraps DML Handler that produces /// `Vec>` for each write, and produces a WriteSummary, /// suitable for diff --git a/router/src/namespace_cache.rs b/router/src/namespace_cache.rs index 7b51016928..2567ef826b 100644 --- a/router/src/namespace_cache.rs +++ b/router/src/namespace_cache.rs @@ -8,9 +8,10 @@ pub use sharded_cache::*; pub mod metrics; -use data_types::{DatabaseName, NamespaceSchema}; use std::{fmt::Debug, sync::Arc}; +use data_types::{DatabaseName, NamespaceSchema}; + /// An abstract cache of [`NamespaceSchema`]. pub trait NamespaceCache: Debug + Send + Sync { /// Return the [`NamespaceSchema`] for `namespace`. diff --git a/router/src/namespace_cache/memory.rs b/router/src/namespace_cache/memory.rs index ab435f3170..2e67113476 100644 --- a/router/src/namespace_cache/memory.rs +++ b/router/src/namespace_cache/memory.rs @@ -1,8 +1,10 @@ -use super::NamespaceCache; +use std::sync::Arc; + use data_types::{DatabaseName, NamespaceSchema}; use hashbrown::HashMap; use parking_lot::RwLock; -use std::sync::Arc; + +use super::NamespaceCache; /// An in-memory cache of [`NamespaceSchema`] backed by a hashmap protected with /// a read-write mutex. @@ -27,9 +29,10 @@ impl NamespaceCache for Arc { #[cfg(test)] mod tests { - use super::*; use data_types::{NamespaceId, QueryPoolId, TopicId}; + use super::*; + #[test] fn test_put_get() { let ns = DatabaseName::new("test").expect("database name is valid"); diff --git a/router/src/namespace_cache/metrics.rs b/router/src/namespace_cache/metrics.rs index 34f1b5842e..a81a349e23 100644 --- a/router/src/namespace_cache/metrics.rs +++ b/router/src/namespace_cache/metrics.rs @@ -1,10 +1,12 @@ //! Metric instrumentation for a [`NamespaceCache`] implementation. -use super::NamespaceCache; +use std::sync::Arc; + use data_types::{DatabaseName, NamespaceSchema}; use iox_time::{SystemProvider, TimeProvider}; use metric::{DurationHistogram, Metric, U64Gauge}; -use std::sync::Arc; + +use super::NamespaceCache; /// An [`InstrumentedCache`] decorates a [`NamespaceCache`] with cache read /// hit/miss and cache put insert/update metrics. @@ -151,13 +153,15 @@ impl NamespaceStats { #[cfg(test)] mod tests { - use super::*; - use crate::namespace_cache::MemoryNamespaceCache; + use std::collections::BTreeMap; + use data_types::{ ColumnId, ColumnSchema, ColumnType, NamespaceId, QueryPoolId, TableId, TableSchema, TopicId, }; use metric::{Attributes, MetricObserver, Observation}; - use std::collections::BTreeMap; + + use super::*; + use crate::namespace_cache::MemoryNamespaceCache; /// Deterministically generate a schema containing tables with the specified /// column cardinality. diff --git a/router/src/namespace_cache/sharded_cache.rs b/router/src/namespace_cache/sharded_cache.rs index 64b637d59c..4ff058a762 100644 --- a/router/src/namespace_cache/sharded_cache.rs +++ b/router/src/namespace_cache/sharded_cache.rs @@ -1,7 +1,9 @@ -use super::NamespaceCache; +use std::sync::Arc; + use data_types::{DatabaseName, NamespaceSchema}; use sharder::JumpHash; -use std::sync::Arc; + +use super::NamespaceCache; /// A decorator sharding the [`NamespaceCache`] keyspace into a set of `T`. #[derive(Debug)] @@ -38,11 +40,13 @@ where #[cfg(test)] mod tests { - use super::*; - use crate::namespace_cache::MemoryNamespaceCache; + use std::{collections::HashMap, iter}; + use data_types::{NamespaceId, QueryPoolId, TopicId}; use rand::{distributions::Alphanumeric, thread_rng, Rng}; - use std::{collections::HashMap, iter}; + + use super::*; + use crate::namespace_cache::MemoryNamespaceCache; fn rand_namespace() -> DatabaseName<'static> { thread_rng() diff --git a/router/src/server.rs b/router/src/server.rs index a82b414894..10e3213c32 100644 --- a/router/src/server.rs +++ b/router/src/server.rs @@ -1,11 +1,13 @@ //! Router server entrypoint. +use std::sync::Arc; + +use hashbrown::HashMap; +use mutable_batch::MutableBatch; +use trace::TraceCollector; + use self::{grpc::GrpcDelegate, http::HttpDelegate}; use crate::dml_handlers::DmlHandler; -use hashbrown::HashMap; -use mutable_batch::MutableBatch; -use std::sync::Arc; -use trace::TraceCollector; pub mod grpc; pub mod http; diff --git a/router/src/server/grpc.rs b/router/src/server/grpc.rs index 7d34227366..1fcfdc3d74 100644 --- a/router/src/server/grpc.rs +++ b/router/src/server/grpc.rs @@ -2,8 +2,8 @@ pub mod sharder; -use self::sharder::ShardService; -use crate::shard::Shard; +use std::sync::Arc; + use ::sharder::Sharder; use generated_types::influxdata::iox::{ catalog::v1::*, object_store::v1::*, schema::v1::*, sharder::v1::*, @@ -13,7 +13,9 @@ use object_store::DynObjectStore; use service_grpc_catalog::CatalogService; use service_grpc_object_store::ObjectStoreService; use service_grpc_schema::SchemaService; -use std::sync::Arc; + +use self::sharder::ShardService; +use crate::shard::Shard; /// This type is responsible for managing all gRPC services exposed by `router`. #[derive(Debug)] diff --git a/router/src/server/grpc/sharder.rs b/router/src/server/grpc/sharder.rs index e4636819d6..1b7f0fbfd2 100644 --- a/router/src/server/grpc/sharder.rs +++ b/router/src/server/grpc/sharder.rs @@ -1,6 +1,7 @@ //! A gRPC service to provide shard mappings to external clients. -use crate::shard::Shard; +use std::sync::Arc; + use data_types::{DatabaseName, ShardId, ShardIndex, TopicMetadata}; use generated_types::influxdata::iox::sharder::v1::{ shard_service_server, MapToShardRequest, MapToShardResponse, @@ -8,9 +9,10 @@ use generated_types::influxdata::iox::sharder::v1::{ use hashbrown::HashMap; use iox_catalog::interface::Catalog; use sharder::Sharder; -use std::sync::Arc; use tonic::{Request, Response}; +use crate::shard::Shard; + /// A [`ShardService`] exposes a [gRPC endpoint] for external systems to discover the shard mapping /// for specific tables. /// diff --git a/router/src/server/http.rs b/router/src/server/http.rs index f4c1fb18e6..dbae3e6be8 100644 --- a/router/src/server/http.rs +++ b/router/src/server/http.rs @@ -2,8 +2,8 @@ mod delete_predicate; -use self::delete_predicate::parse_http_delete_request; -use crate::dml_handlers::{DmlError, DmlHandler, PartitionError, SchemaError}; +use std::{str::Utf8Error, sync::Arc, time::Instant}; + use bytes::{Bytes, BytesMut}; use data_types::{org_and_bucket_to_database, OrgBucketMappingError}; use futures::StreamExt; @@ -16,13 +16,14 @@ use mutable_batch_lp::LinesConverter; use observability_deps::tracing::*; use predicate::delete_predicate::parse_delete_predicate; use serde::Deserialize; -use std::time::Instant; -use std::{str::Utf8Error, sync::Arc}; use thiserror::Error; use tokio::sync::{Semaphore, TryAcquireError}; use trace::ctx::SpanContext; use write_summary::WriteSummary; +use self::delete_predicate::parse_http_delete_request; +use crate::dml_handlers::{DmlError, DmlHandler, PartitionError, SchemaError}; + const WRITE_TOKEN_HTTP_HEADER: &str = "X-IOx-Write-Token"; /// Errors returned by the `router` HTTP request handler. @@ -521,7 +522,6 @@ mod tests { use std::{io::Write, iter, sync::Arc, time::Duration}; use assert_matches::assert_matches; - use flate2::{write::GzEncoder, Compression}; use hyper::header::HeaderValue; use metric::{Attributes, Metric}; @@ -530,9 +530,8 @@ mod tests { use test_helpers::timeout::FutureTimeout; use tokio_stream::wrappers::ReceiverStream; - use crate::dml_handlers::mock::{MockDmlHandler, MockDmlHandlerCall}; - use super::*; + use crate::dml_handlers::mock::{MockDmlHandler, MockDmlHandlerCall}; const MAX_BYTES: usize = 1024; diff --git a/router/src/shard.rs b/router/src/shard.rs index 5e199a7160..bb2a1c68d4 100644 --- a/router/src/shard.rs +++ b/router/src/shard.rs @@ -1,10 +1,11 @@ //! A representation of a single operation shard. +use std::{borrow::Cow, hash::Hash, sync::Arc}; + use data_types::ShardIndex; use dml::{DmlMeta, DmlOperation}; use iox_time::{SystemProvider, TimeProvider}; use metric::{DurationHistogram, Metric}; -use std::{borrow::Cow, hash::Hash, sync::Arc}; use write_buffer::core::{WriteBufferError, WriteBufferWriting}; /// A shard tags a write buffer with a shard index (Kafka partition). diff --git a/router/tests/http.rs b/router/tests/http.rs index bc815783ff..f990bac483 100644 --- a/router/tests/http.rs +++ b/router/tests/http.rs @@ -1,3 +1,5 @@ +use std::{collections::BTreeSet, iter, string::String, sync::Arc}; + use assert_matches::assert_matches; use data_types::{ColumnType, PartitionTemplate, QueryPoolId, ShardIndex, TemplatePart, TopicId}; use dml::DmlOperation; @@ -17,7 +19,6 @@ use router::{ shard::Shard, }; use sharder::JumpHash; -use std::{collections::BTreeSet, iter, string::String, sync::Arc}; use write_buffer::{ core::WriteBufferWriting, mock::{MockBufferForWriting, MockBufferSharedState},