chore: update deps to horaedb-

Cargo.toml

@@ -94,7 +94,6 @@ bytes = "1"
 bytes_ext = { path = "components/bytes_ext" }
 catalog = { path = "catalog" }
 catalog_impls = { path = "catalog_impls" }
-ceresdbproto = "1.0.23"
 codec = { path = "components/codec" }
 chrono = "0.4"
 clap = "3.0"
@@ -113,6 +112,7 @@ futures = "0.3"
 generic_error = { path = "components/generic_error" }
 hash_ext = { path = "components/hash_ext" }
 hex = "0.4.3"
+horaedbproto = "1.0.23"
 hyperloglog = { git = "https://github.com/jedisct1/rust-hyperloglog.git", rev = "425487ce910f26636fbde8c4d640b538431aad50" }
 id_allocator = { path = "components/id_allocator" }
 influxql-logical-planner = { git = "https://github.com/CeresDB/influxql.git", rev = "acbd3ad7651f2deb74857155bea892f88926da57", package = "iox_query_influxql" }

analytic_engine/Cargo.toml

@@ -43,14 +43,14 @@ async-trait = { workspace = true }
 atomic_enum = { workspace = true }
 base64 = { workspace = true }
 bytes_ext = { workspace = true }
-ceresdbproto = { workspace = true }
 codec = { workspace = true }
 common_types = { workspace = true }
 datafusion = { workspace = true }
 future_ext = { workspace = true }
 futures = { workspace = true }
 generic_error = { workspace = true }
 hex = { workspace = true }
+horaedbproto = { workspace = true }
 hyperloglog = { workspace = true }
 id_allocator = { workspace = true }
 itertools = { workspace = true }

analytic_engine/src/instance/write.rs

@@ -17,7 +17,6 @@
 use std::iter;
 
 use bytes_ext::ByteVec;
-use ceresdbproto::{schema as schema_pb, table_requests};
 use codec::{
     columnar::{ColumnarEncoder, EncodeHint},
     row,
@@ -27,6 +26,7 @@ use common_types::{
     schema::{IndexInWriterSchema, Schema},
     MIN_SEQUENCE_NUMBER,
 };
+use horaedbproto::{schema as schema_pb, table_requests};
 use itertools::Itertools;
 use logger::{debug, error, info, trace, warn};
 use macros::define_result;

analytic_engine/src/manifest/details.rs

@@ -25,8 +25,8 @@ use std::{
 };
 
 use async_trait::async_trait;
-use ceresdbproto::manifest as manifest_pb;
 use generic_error::{BoxError, GenericError, GenericResult};
+use horaedbproto::manifest as manifest_pb;
 use lazy_static::lazy_static;
 use logger::{debug, info, warn};
 use macros::define_result;

analytic_engine/src/manifest/meta_edit.rs

@@ -17,11 +17,11 @@
 use std::convert::TryFrom;
 
 use bytes_ext::{Buf, BufMut};
-use ceresdbproto::{manifest as manifest_pb, schema as schema_pb};
 use common_types::{
     schema::{Schema, Version},
     SequenceNumber,
 };
+use horaedbproto::{manifest as manifest_pb, schema as schema_pb};
 use macros::define_result;
 use prost::Message;
 use snafu::{Backtrace, OptionExt, ResultExt, Snafu};

analytic_engine/src/payload.rs

@@ -15,7 +15,6 @@
 //! Payloads to write to wal
 
 use bytes_ext::{Buf, BufMut, SafeBuf, SafeBufMut};
-use ceresdbproto::{manifest as manifest_pb, table_requests};
 use codec::{
     columnar::{ColumnarDecoder, DecodeContext, DecodeResult},
     row::WalRowDecoder,
@@ -26,6 +25,7 @@ use common_types::{
     schema::Schema,
     table::TableId,
 };
+use horaedbproto::{manifest as manifest_pb, table_requests};
 use macros::define_result;
 use prost::Message;
 use snafu::{Backtrace, OptionExt, ResultExt, Snafu};

analytic_engine/src/sst/meta_data/mod.rs

@@ -17,8 +17,8 @@ mod metadata_reader;
 
 use std::{str::Utf8Error, sync::Arc};
 
-use ceresdbproto::sst as sst_pb;
 use common_types::{schema::Schema, time::TimeRange, SequenceNumber};
+use horaedbproto::sst as sst_pb;
 use macros::define_result;
 use snafu::{Backtrace, OptionExt, ResultExt, Snafu};
 use table_engine::table::TableId;

analytic_engine/src/sst/parquet/encoding.rs

@@ -18,9 +18,9 @@ use arrow::{compute, record_batch::RecordBatch as ArrowRecordBatch};
 use async_trait::async_trait;
 use bytes::Bytes;
 use bytes_ext::{BytesMut, SafeBufMut};
-use ceresdbproto::sst as sst_pb;
 use common_types::schema::{ArrowSchemaRef, Schema};
 use generic_error::{BoxError, GenericError};
+use horaedbproto::sst as sst_pb;
 use macros::define_result;
 use parquet::{
     arrow::AsyncArrowWriter,

analytic_engine/src/sst/parquet/meta_data.rs

@@ -17,13 +17,13 @@
 use std::{collections::HashSet, fmt, ops::Index, sync::Arc};
 
 use bytes_ext::Bytes;
-use ceresdbproto::{schema as schema_pb, sst as sst_pb};
 use common_types::{
     datum::DatumKind,
     schema::{RecordSchemaWithKey, Schema},
     time::TimeRange,
     SequenceNumber,
 };
+use horaedbproto::{schema as schema_pb, sst as sst_pb};
 use macros::define_result;
 use snafu::{Backtrace, OptionExt, ResultExt, Snafu};
 use xorfilter::xor8::{Xor8, Xor8Builder};

analytic_engine/src/table/version_edit.rs

@@ -16,8 +16,8 @@
 
 use std::convert::TryFrom;
 
-use ceresdbproto::manifest as manifest_pb;
 use common_types::{time::TimeRange, SequenceNumber};
+use horaedbproto::manifest as manifest_pb;
 use macros::define_result;
 use snafu::{Backtrace, OptionExt, ResultExt, Snafu};
 

analytic_engine/src/table_options.rs

@@ -16,13 +16,13 @@
 
 use std::{collections::HashMap, string::ToString, time::Duration};
 
-use ceresdbproto::manifest as manifest_pb;
 use common_types::{
     time::Timestamp, ARENA_BLOCK_SIZE, COMPACTION_STRATEGY, COMPRESSION, ENABLE_TTL, MEMTABLE_TYPE,
     NUM_ROWS_PER_ROW_GROUP, OPTION_KEY_ENABLE_TTL, SEGMENT_DURATION, STORAGE_FORMAT, TTL,
     UPDATE_MODE, WRITE_BUFFER_SIZE,
 };
 use datafusion::parquet::basic::Compression as ParquetCompression;
+use horaedbproto::manifest as manifest_pb;
 use macros::define_result;
 use serde::{Deserialize, Serialize};
 use size_ext::ReadableSize;

cluster/Cargo.toml

@@ -31,11 +31,11 @@ workspace = true
 async-trait = { workspace = true }
 bytes_ext = { workspace = true }
 catalog = { workspace = true }
-ceresdbproto = { workspace = true }
 common_types = { workspace = true }
 etcd-client = { workspace = true }
 future_ext = { workspace = true }
 generic_error = { workspace = true }
+horaedbproto = { workspace = true }
 logger = { workspace = true }
 macros = { workspace = true }
 meta_client = { workspace = true }

cluster/src/shard_lock_manager.rs

@@ -20,11 +20,11 @@ use std::{
 };
 
 use bytes_ext::Bytes;
-use ceresdbproto::meta_event::ShardLockValue;
 use common_types::table::ShardId;
 use etcd_client::{
     Client, Compare, CompareOp, LeaseKeepAliveStream, LeaseKeeper, PutOptions, Txn, TxnOp,
 };
+use horaedbproto::meta_event::ShardLockValue;
 use logger::{debug, error, info, warn};
 use macros::define_result;
 use prost::Message;

common_types/Cargo.toml

@@ -35,10 +35,10 @@ test = []
 arrow = { workspace = true }
 arrow_ext = { workspace = true }
 bytes_ext = { workspace = true }
-ceresdbproto = { workspace = true }
 chrono = { workspace = true }
 datafusion = { workspace = true }
 hash_ext = { workspace = true }
+horaedbproto = { workspace = true }
 macros = { workspace = true }
 paste = { workspace = true }
 prost = { workspace = true }

common_types/src/column_schema.rs

@@ -17,7 +17,7 @@
 use std::{collections::HashMap, convert::TryFrom, str::FromStr, sync::Arc};
 
 use arrow::datatypes::{DataType, Field};
-use ceresdbproto::{remote_engine::ColumnDesc, schema as schema_pb};
+use horaedbproto::{remote_engine::ColumnDesc, schema as schema_pb};
 use snafu::{ensure, Backtrace, OptionExt, ResultExt, Snafu};
 use sqlparser::ast::Expr;
 

common_types/src/datum.rs

@@ -21,10 +21,10 @@ use arrow::{
     temporal_conversions::{EPOCH_DAYS_FROM_CE, NANOSECONDS},
 };
 use bytes_ext::Bytes;
-use ceresdbproto::schema::DataType as DataTypePb;
 use chrono::{Datelike, Local, NaiveDate, NaiveTime, TimeZone, Timelike};
 use datafusion::scalar::ScalarValue;
 use hash_ext::hash64;
+use horaedbproto::schema::DataType as DataTypePb;
 use serde::ser::{Serialize, Serializer};
 use snafu::{Backtrace, OptionExt, ResultExt, Snafu};
 use sqlparser::ast::{DataType as SqlDataType, Value};

common_types/src/projected_schema.rs

@@ -183,15 +183,15 @@ impl ProjectedSchema {
     }
 }
 
-impl From<ProjectedSchema> for ceresdbproto::schema::ProjectedSchema {
+impl From<ProjectedSchema> for horaedbproto::schema::ProjectedSchema {
     fn from(request: ProjectedSchema) -> Self {
         let table_schema_pb = (&request.0.original_schema).into();
         let projection_pb = request.0.projection.as_ref().map(|project| {
             let project = project
                 .iter()
                 .map(|one_project| *one_project as u64)
                 .collect::<Vec<u64>>();
-            ceresdbproto::schema::Projection { idx: project }
+            horaedbproto::schema::Projection { idx: project }
         });
 
         Self {
@@ -201,11 +201,11 @@ impl From<ProjectedSchema> for ceresdbproto::schema::ProjectedSchema {
     }
 }
 
-impl TryFrom<ceresdbproto::schema::ProjectedSchema> for ProjectedSchema {
+impl TryFrom<horaedbproto::schema::ProjectedSchema> for ProjectedSchema {
     type Error = Error;
 
     fn try_from(
-        pb: ceresdbproto::schema::ProjectedSchema,
+        pb: horaedbproto::schema::ProjectedSchema,
     ) -> std::result::Result<Self, Self::Error> {
         let schema: Schema = pb
             .table_schema

common_types/src/schema.rs

@@ -29,7 +29,7 @@ use std::{
 // use a new type pattern to wrap Schema/SchemaRef and not allow to use
 // the data type we not supported
 pub use arrow::datatypes::{DataType, Field, Schema as ArrowSchema, SchemaRef as ArrowSchemaRef};
-use ceresdbproto::schema as schema_pb;
+use horaedbproto::schema as schema_pb;
 use prost::Message;
 use snafu::{ensure, Backtrace, OptionExt, ResultExt, Snafu};
 

common_types/src/time.rs

@@ -21,11 +21,11 @@ use std::{
     time::{self, Duration, SystemTime},
 };
 
-use ceresdbproto::time_range;
 use datafusion::{
     prelude::{col, lit, Expr},
     scalar::ScalarValue,
 };
+use horaedbproto::time_range;
 use snafu::{Backtrace, OptionExt, Snafu};
 
 /// Error of time module.

components/object_store/Cargo.toml

@@ -30,13 +30,13 @@ workspace = true
 [dependencies]
 async-trait = { workspace = true }
 bytes = { workspace = true }
-ceresdbproto = { workspace = true }
 chrono = { workspace = true }
 clru = { workspace = true }
 crc = "3.0.0"
 futures = { workspace = true }
 generic_error = { workspace = true }
 hash_ext = { workspace = true }
+horaedbproto = { workspace = true }
 lazy_static = { workspace = true }
 logger = { workspace = true }
 lru = { workspace = true }

components/time_ext/Cargo.toml

@@ -28,10 +28,10 @@ workspace = true
 workspace = true
 
 [dependencies]
-# In alphabetical order
-ceresdbproto = { workspace = true }
 chrono = { workspace = true }
 common_types = { workspace = true }
+# In alphabetical order
+horaedbproto = { workspace = true }
 macros = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

components/time_ext/src/lib.rs

@@ -24,9 +24,9 @@ use std::{
     time::{Duration, Instant, UNIX_EPOCH},
 };
 
-use ceresdbproto::manifest as manifest_pb;
 use chrono::{DateTime, Utc};
 use common_types::time::Timestamp;
+use horaedbproto::manifest as manifest_pb;
 use macros::define_result;
 use serde::{
     de::{self, Visitor},

df_engine_extensions/Cargo.toml

@@ -32,12 +32,12 @@ arrow = { workspace = true }
 async-recursion = "1.0.4"
 async-trait = { workspace = true }
 catalog = { workspace = true, features = ["test"] }
-ceresdbproto = { workspace = true }
 common_types = { workspace = true, features = ["test"] }
 datafusion = { workspace = true }
 datafusion-proto = { workspace = true }
 futures =   { workspace = true }
 generic_error = { workspace = true }
+horaedbproto = { workspace = true }
 lazy_static = { workspace = true }
 prometheus = { workspace = true }
 prost = { workspace = true }

df_engine_extensions/src/codec.rs

@@ -14,13 +14,13 @@
 
 use std::{fmt, sync::Arc};
 
-use ceresdbproto::remote_engine::{extension_node::TypedExtension, ExtensionNode};
 use datafusion::{
     error::{DataFusionError, Result as DfResult},
     execution::FunctionRegistry,
     physical_plan::ExecutionPlan,
 };
 use datafusion_proto::physical_plan::PhysicalExtensionCodec;
+use horaedbproto::remote_engine::{extension_node::TypedExtension, ExtensionNode};
 use prost::Message;
 
 use crate::dist_sql_query::codec::DistSqlQueryCodec;

df_engine_extensions/src/dist_sql_query/codec.rs

@@ -14,12 +14,12 @@
 
 use std::sync::Arc;
 
-use ceresdbproto::remote_engine::{extension_node::TypedExtension, DistSqlQueryExtensionNode};
 use datafusion::{
     error::{DataFusionError, Result as DfResult},
     execution::FunctionRegistry,
     physical_plan::ExecutionPlan,
 };
+use horaedbproto::remote_engine::{extension_node::TypedExtension, DistSqlQueryExtensionNode};
 
 use crate::{
     codec::TypedPhysicalExtensionCodec, dist_sql_query::physical_plan::UnresolvedSubTableScan,

df_engine_extensions/src/dist_sql_query/mod.rs

@@ -90,7 +90,7 @@ impl TableScanContext {
     }
 }
 
-impl TryFrom<TableScanContext> for ceresdbproto::remote_engine::TableScanContext {
+impl TryFrom<TableScanContext> for horaedbproto::remote_engine::TableScanContext {
     type Error = datafusion::error::DataFusionError;
 
     fn try_from(value: TableScanContext) -> DfResult<Self> {
@@ -116,10 +116,10 @@ impl TryFrom<TableScanContext> for ceresdbproto::remote_engine::TableScanContext
     }
 }
 
-impl TryFrom<ceresdbproto::remote_engine::TableScanContext> for TableScanContext {
+impl TryFrom<horaedbproto::remote_engine::TableScanContext> for TableScanContext {
     type Error = datafusion::error::DataFusionError;
 
-    fn try_from(value: ceresdbproto::remote_engine::TableScanContext) -> DfResult<Self> {
+    fn try_from(value: horaedbproto::remote_engine::TableScanContext) -> DfResult<Self> {
         let projected_schema = value
             .projected_schema
             .ok_or(DataFusionError::Internal(

df_engine_extensions/src/dist_sql_query/physical_plan.rs

@@ -558,11 +558,11 @@ impl DisplayAs for UnresolvedSubTableScan {
     }
 }
 
-impl TryFrom<ceresdbproto::remote_engine::UnresolvedSubScan> for UnresolvedSubTableScan {
+impl TryFrom<horaedbproto::remote_engine::UnresolvedSubScan> for UnresolvedSubTableScan {
     type Error = DataFusionError;
 
     fn try_from(
-        value: ceresdbproto::remote_engine::UnresolvedSubScan,
+        value: horaedbproto::remote_engine::UnresolvedSubScan,
     ) -> Result<Self, Self::Error> {
         let table = value
             .table
@@ -587,7 +587,7 @@ impl TryFrom<ceresdbproto::remote_engine::UnresolvedSubScan> for UnresolvedSubTa
     }
 }
 
-impl TryFrom<UnresolvedSubTableScan> for ceresdbproto::remote_engine::UnresolvedSubScan {
+impl TryFrom<UnresolvedSubTableScan> for horaedbproto::remote_engine::UnresolvedSubScan {
     type Error = DataFusionError;
 
     fn try_from(value: UnresolvedSubTableScan) -> Result<Self, Self::Error> {

integration_tests/Cargo.toml

@@ -27,7 +27,7 @@ workspace = true
 [dependencies]
 anyhow = "1.0.58"
 async-trait = "0.1"
-ceresdb-client = "1.0.2"
+horaedb-client = "1.0.2"
 local-ip-address = "0.5"
 reqwest = { workspace = true }
 serde = { workspace = true }