release v0.3.1

2025-12-26 16:10:02 +00:00 · 2023-06-21 16:28:41 +08:00 · 2023-06-21 16:28:07 +08:00
393 changed files with 5536 additions and 7240 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -20,3 +20,6 @@ out/

 # Rust
 target/
+
+# Git
+.git
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -22,7 +22,7 @@ name: Release
 env:
  RUST_TOOLCHAIN: nightly-2023-05-03

-  SCHEDULED_BUILD_VERSION_PREFIX: v0.4.0
+  SCHEDULED_BUILD_VERSION_PREFIX: v0.3.1

  SCHEDULED_PERIOD: nightly

--- a/.gitignore
+++ b/.gitignore
@@ -44,5 +44,3 @@ benchmarks/data

 # Vscode workspace
 *.code-workspace
-
-venv/
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1527,7 +1527,6 @@ dependencies = [
 "datafusion",
 "datanode",
 "datatypes",
- "derive-new",
 "enum_dispatch",
 "futures-util",
 "moka 0.9.7",
@@ -1680,7 +1679,6 @@ dependencies = [
 "derive_builder 0.12.0",
 "futures",
 "object-store",
- "orc-rust",
 "paste",
 "regex",
 "snafu",
@@ -3071,12 +3069,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"

-[[package]]
-name = "fallible-streaming-iterator"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
-
 [[package]]
 name = "fastrand"
 version = "1.9.0"
@@ -5210,7 +5202,7 @@ dependencies = [
 [[package]]
 name = "meter-core"
 version = "0.1.0"
-source = "git+https://github.com/GreptimeTeam/greptime-meter.git?rev=abbd357c1e193cd270ea65ee7652334a150b628f#abbd357c1e193cd270ea65ee7652334a150b628f"
+source = "git+https://github.com/GreptimeTeam/greptime-meter.git?rev=f0798c4c648d89f51abe63e870919c75dd463199#f0798c4c648d89f51abe63e870919c75dd463199"
 dependencies = [
 "anymap",
 "once_cell",
@@ -5220,7 +5212,7 @@ dependencies = [
 [[package]]
 name = "meter-macros"
 version = "0.1.0"
-source = "git+https://github.com/GreptimeTeam/greptime-meter.git?rev=abbd357c1e193cd270ea65ee7652334a150b628f#abbd357c1e193cd270ea65ee7652334a150b628f"
+source = "git+https://github.com/GreptimeTeam/greptime-meter.git?rev=f0798c4c648d89f51abe63e870919c75dd463199#f0798c4c648d89f51abe63e870919c75dd463199"
 dependencies = [
 "meter-core",
 ]
@@ -5991,27 +5983,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "978aa494585d3ca4ad74929863093e87cac9790d81fe7aba2b3dc2890643a0fc"

-[[package]]
-name = "orc-rust"
-version = "0.2.3"
-source = "git+https://github.com/WenyXu/orc-rs.git?rev=0319acd32456e403c20f135cc012441a76852605#0319acd32456e403c20f135cc012441a76852605"
-dependencies = [
- "arrow",
- "bytes",
- "chrono",
- "fallible-streaming-iterator",
- "flate2",
- "futures",
- "futures-util",
- "lazy_static",
- "paste",
- "prost",
- "snafu",
- "tokio",
- "zigzag",
- "zstd 0.12.3+zstd.1.5.2",
-]
-
 [[package]]
 name = "ordered-float"
 version = "1.1.1"
@@ -8935,7 +8906,7 @@ dependencies = [
 [[package]]
 name = "sqlness"
 version = "0.4.3"
-source = "git+https://github.com/CeresDB/sqlness.git?rev=a4663365795d2067eb53966c383e1bb0c89c7627#a4663365795d2067eb53966c383e1bb0c89c7627"
+source = "git+https://github.com/CeresDB/sqlness.git?rev=dde4b19d7e4a41319d05a0c5bfae5c4422fde14f#dde4b19d7e4a41319d05a0c5bfae5c4422fde14f"
 dependencies = [
 "async-trait",
 "derive_builder 0.11.2",
@@ -9150,10 +9121,8 @@ dependencies = [
 "common-test-util",
 "common-time",
 "criterion 0.3.6",
- "datafusion",
 "datafusion-common",
 "datafusion-expr",
- "datafusion-physical-expr",
 "datatypes",
 "futures",
 "futures-util",
@@ -11245,15 +11214,6 @@ version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9"

-[[package]]
-name = "zigzag"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70b40401a28d86ce16a330b863b86fd7dbee4d7c940587ab09ab8c019f9e3fdf"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "zstd"
 version = "0.11.2+zstd.1.5.2"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -50,7 +50,7 @@ members = [
 ]

 [workspace.package]
-version = "0.4.0"
+version = "0.3.1"
 edition = "2021"
 license = "Apache-2.0"

@@ -88,11 +88,11 @@ tokio-util = { version = "0.7", features = ["io-util", "compat"] }
 tonic = { version = "0.9", features = ["tls"] }
 uuid = { version = "1", features = ["serde", "v4", "fast-rng"] }
 metrics = "0.20"
-meter-core = { git = "https://github.com/GreptimeTeam/greptime-meter.git", rev = "abbd357c1e193cd270ea65ee7652334a150b628f" }
+meter-core = { git = "https://github.com/GreptimeTeam/greptime-meter.git", rev = "f0798c4c648d89f51abe63e870919c75dd463199" }

 [workspace.dependencies.meter-macros]
 git = "https://github.com/GreptimeTeam/greptime-meter.git"
-rev = "abbd357c1e193cd270ea65ee7652334a150b628f"
+rev = "f0798c4c648d89f51abe63e870919c75dd463199"

 [profile.release]
 debug = true
--- a/benchmarks/src/bin/nyc-taxi.rs
+++ b/benchmarks/src/bin/nyc-taxi.rs
@@ -114,7 +114,7 @@ async fn write_data(
        };

        let now = Instant::now();
-        let _ = db.insert(requests).await.unwrap();
+        db.insert(requests).await.unwrap();
        let elapsed = now.elapsed();
        total_rpc_elapsed_ms += elapsed.as_millis();
        progress_bar.inc(row_count as _);
@@ -377,16 +377,19 @@ fn create_table_expr() -> CreateTableExpr {
 }

 fn query_set() -> HashMap<String, String> {
-    HashMap::from([
-        (
-            "count_all".to_string(), 
-            format!("SELECT COUNT(*) FROM {TABLE_NAME};"),
-        ),
-        (
-            "fare_amt_by_passenger".to_string(),
-            format!("SELECT passenger_count, MIN(fare_amount), MAX(fare_amount), SUM(fare_amount) FROM {TABLE_NAME} GROUP BY passenger_count"),
-        )
-    ])
+    let mut ret = HashMap::new();
+
+    ret.insert(
+        "count_all".to_string(),
+        format!("SELECT COUNT(*) FROM {TABLE_NAME};"),
+    );
+
+    ret.insert(
+        "fare_amt_by_passenger".to_string(),
+        format!("SELECT passenger_count, MIN(fare_amount), MAX(fare_amount), SUM(fare_amount) FROM {TABLE_NAME} GROUP BY passenger_count")
+    );
+
+    ret
 }

 async fn do_write(args: &Args, db: &Database) {
@@ -411,8 +414,7 @@ async fn do_write(args: &Args, db: &Database) {
            let db = db.clone();
            let mpb = multi_progress_bar.clone();
            let pb_style = progress_bar_style.clone();
-            let _ = write_jobs
-                .spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
+            write_jobs.spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
        }
    }
    while write_jobs.join_next().await.is_some() {
@@ -421,8 +423,7 @@ async fn do_write(args: &Args, db: &Database) {
            let db = db.clone();
            let mpb = multi_progress_bar.clone();
            let pb_style = progress_bar_style.clone();
-            let _ = write_jobs
-                .spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
+            write_jobs.spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
        }
    }
 }
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -8,7 +8,6 @@ RUN apt-get update && apt-get install -y \
    libssl-dev \
    protobuf-compiler \
    curl \
-    git \
    build-essential \
    pkg-config \
    python3 \
--- a/docker/aarch64/Dockerfile
+++ b/docker/aarch64/Dockerfile
@@ -8,7 +8,6 @@ RUN apt-get update && apt-get install -y \
    libssl-dev \
    protobuf-compiler \
    curl \
-    git \
    build-essential \
    pkg-config \
    wget
--- a/src/catalog/src/error.rs
+++ b/src/catalog/src/error.rs
@@ -192,18 +192,11 @@ pub enum Error {
        source: BoxedError,
    },

-    #[snafu(display(
-        "Failed to upgrade weak catalog manager reference. location: {}",
-        location
-    ))]
-    UpgradeWeakCatalogManagerRef { location: Location },
-
    #[snafu(display("Failed to execute system catalog table scan, source: {}", source))]
    SystemCatalogTableScanExec {
        location: Location,
        source: common_query::error::Error,
    },
-
    #[snafu(display("Cannot parse catalog value, source: {}", source))]
    InvalidCatalogValue {
        location: Location,
@@ -263,9 +256,7 @@ impl ErrorExt for Error {
            | Error::EmptyValue { .. }
            | Error::ValueDeserialize { .. } => StatusCode::StorageUnavailable,

-            Error::Generic { .. }
-            | Error::SystemCatalogTypeMismatch { .. }
-            | Error::UpgradeWeakCatalogManagerRef { .. } => StatusCode::Internal,
+            Error::Generic { .. } | Error::SystemCatalogTypeMismatch { .. } => StatusCode::Internal,

            Error::ReadSystemCatalog { source, .. } | Error::CreateRecordBatch { source, .. } => {
                source.status_code()
--- a/src/catalog/src/helper.rs
+++ b/src/catalog/src/helper.rs
@@ -67,7 +67,6 @@ pub fn build_schema_prefix(catalog_name: impl AsRef<str>) -> String {
    format!("{SCHEMA_KEY_PREFIX}-{}-", catalog_name.as_ref())
 }

-/// Global table info has only one key across all datanodes so it does not have `node_id` field.
 pub fn build_table_global_prefix(
    catalog_name: impl AsRef<str>,
    schema_name: impl AsRef<str>,
@@ -79,7 +78,6 @@ pub fn build_table_global_prefix(
    )
 }

-/// Regional table info varies between datanode, so it contains a `node_id` field.
 pub fn build_table_regional_prefix(
    catalog_name: impl AsRef<str>,
    schema_name: impl AsRef<str>,
@@ -203,9 +201,6 @@ impl TableRegionalKey {
 /// region ids allocated by metasrv.
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct TableRegionalValue {
-    // We can remove the `Option` from the table id once all regional values
-    // stored in meta have table ids.
-    pub table_id: Option<TableId>,
    pub version: TableVersion,
    pub regions_ids: Vec<u32>,
    pub engine_name: Option<String>,
@@ -392,6 +387,6 @@ mod tests {
    #[test]
    fn test_table_global_value_compatibility() {
        let s = r#"{"node_id":1,"regions_id_map":{"1":[0]},"table_info":{"ident":{"table_id":1098,"version":1},"name":"container_cpu_limit","desc":"Created on insertion","catalog_name":"greptime","schema_name":"dd","meta":{"schema":{"column_schemas":[{"name":"container_id","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"container_name","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"docker_image","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"host","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"image_name","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"image_tag","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"interval","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"runtime","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"short_image","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"type","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"dd_value","data_type":{"Float64":{}},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"ts","data_type":{"Timestamp":{"Millisecond":null}},"is_nullable":false,"is_time_index":true,"default_constraint":null,"metadata":{"greptime:time_index":"true"}},{"name":"git.repository_url","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}}],"timestamp_index":11,"version":1},"primary_key_indices":[0,1,2,3,4,5,6,7,8,9,12],"value_indices":[10,11],"engine":"mito","next_column_id":12,"region_numbers":[],"engine_options":{},"options":{},"created_on":"1970-01-01T00:00:00Z"},"table_type":"Base"}}"#;
-        let _ = TableGlobalValue::parse(s).unwrap();
+        TableGlobalValue::parse(s).unwrap();
    }
 }
--- a/src/catalog/src/information_schema.rs
+++ b/src/catalog/src/information_schema.rs
@@ -16,10 +16,12 @@ mod columns;
 mod tables;

 use std::any::Any;
-use std::sync::{Arc, Weak};
+use std::sync::Arc;

 use async_trait::async_trait;
 use common_error::prelude::BoxedError;
+use common_query::physical_plan::PhysicalPlanRef;
+use common_query::prelude::Expr;
 use common_recordbatch::{RecordBatchStreamAdaptor, SendableRecordBatchStream};
 use datatypes::schema::SchemaRef;
 use futures_util::StreamExt;
@@ -31,35 +33,46 @@ use table::{Result as TableResult, Table, TableRef};
 use self::columns::InformationSchemaColumns;
 use crate::error::Result;
 use crate::information_schema::tables::InformationSchemaTables;
-use crate::CatalogManager;
+use crate::{CatalogProviderRef, SchemaProvider};

 const TABLES: &str = "tables";
 const COLUMNS: &str = "columns";

-pub struct InformationSchemaProvider {
+pub(crate) struct InformationSchemaProvider {
    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
+    catalog_provider: CatalogProviderRef,
+    tables: Vec<String>,
 }

 impl InformationSchemaProvider {
-    pub fn new(catalog_name: String, catalog_manager: Weak<dyn CatalogManager>) -> Self {
+    pub(crate) fn new(catalog_name: String, catalog_provider: CatalogProviderRef) -> Self {
        Self {
            catalog_name,
-            catalog_manager,
+            catalog_provider,
+            tables: vec![TABLES.to_string(), COLUMNS.to_string()],
        }
    }
 }

-impl InformationSchemaProvider {
-    pub fn table(&self, name: &str) -> Result<Option<TableRef>> {
+#[async_trait]
+impl SchemaProvider for InformationSchemaProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    async fn table_names(&self) -> Result<Vec<String>> {
+        Ok(self.tables.clone())
+    }
+
+    async fn table(&self, name: &str) -> Result<Option<TableRef>> {
        let stream_builder = match name.to_ascii_lowercase().as_ref() {
            TABLES => Arc::new(InformationSchemaTables::new(
                self.catalog_name.clone(),
-                self.catalog_manager.clone(),
+                self.catalog_provider.clone(),
            )) as _,
            COLUMNS => Arc::new(InformationSchemaColumns::new(
                self.catalog_name.clone(),
-                self.catalog_manager.clone(),
+                self.catalog_provider.clone(),
            )) as _,
            _ => {
                return Ok(None);
@@ -68,6 +81,11 @@ impl InformationSchemaProvider {

        Ok(Some(Arc::new(InformationTable::new(stream_builder))))
    }
+
+    async fn table_exist(&self, name: &str) -> Result<bool> {
+        let normalized_name = name.to_ascii_lowercase();
+        Ok(self.tables.contains(&normalized_name))
+    }
 }

 // TODO(ruihang): make it a more generic trait:
@@ -102,6 +120,20 @@ impl Table for InformationTable {
        unreachable!("Should not call table_info() of InformationTable directly")
    }

+    /// Scan the table and returns a SendableRecordBatchStream.
+    async fn scan(
+        &self,
+        _projection: Option<&Vec<usize>>,
+        _filters: &[Expr],
+        // limit can be used to reduce the amount scanned
+        // from the datasource as a performance optimization.
+        // If set, it contains the amount of rows needed by the `LogicalPlan`,
+        // The datasource should return *at least* this number of rows if available.
+        _limit: Option<usize>,
+    ) -> TableResult<PhysicalPlanRef> {
+        unimplemented!()
+    }
+
    async fn scan_to_stream(&self, request: ScanRequest) -> TableResult<SendableRecordBatchStream> {
        let projection = request.projection;
        let projected_schema = if let Some(projection) = &projection {
--- a/src/catalog/src/information_schema/columns.rs
+++ b/src/catalog/src/information_schema/columns.rs
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-use std::sync::{Arc, Weak};
+use std::sync::Arc;

 use arrow_schema::SchemaRef as ArrowSchemaRef;
 use common_catalog::consts::{
@@ -29,18 +29,16 @@ use datatypes::prelude::{ConcreteDataType, DataType};
 use datatypes::scalars::ScalarVectorBuilder;
 use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
 use datatypes::vectors::{StringVectorBuilder, VectorRef};
-use snafu::{OptionExt, ResultExt};
+use snafu::ResultExt;

 use super::InformationStreamBuilder;
-use crate::error::{
-    CreateRecordBatchSnafu, InternalSnafu, Result, UpgradeWeakCatalogManagerRefSnafu,
-};
-use crate::CatalogManager;
+use crate::error::{CreateRecordBatchSnafu, InternalSnafu, Result};
+use crate::CatalogProviderRef;

 pub(super) struct InformationSchemaColumns {
    schema: SchemaRef,
    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
+    catalog_provider: CatalogProviderRef,
 }

 const TABLE_CATALOG: &str = "table_catalog";
@@ -51,7 +49,7 @@ const DATA_TYPE: &str = "data_type";
 const SEMANTIC_TYPE: &str = "semantic_type";

 impl InformationSchemaColumns {
-    pub(super) fn new(catalog_name: String, catalog_manager: Weak<dyn CatalogManager>) -> Self {
+    pub(super) fn new(catalog_name: String, catalog_provider: CatalogProviderRef) -> Self {
        let schema = Arc::new(Schema::new(vec![
            ColumnSchema::new(TABLE_CATALOG, ConcreteDataType::string_datatype(), false),
            ColumnSchema::new(TABLE_SCHEMA, ConcreteDataType::string_datatype(), false),
@@ -63,7 +61,7 @@ impl InformationSchemaColumns {
        Self {
            schema,
            catalog_name,
-            catalog_manager,
+            catalog_provider,
        }
    }

@@ -71,7 +69,7 @@ impl InformationSchemaColumns {
        InformationSchemaColumnsBuilder::new(
            self.schema.clone(),
            self.catalog_name.clone(),
-            self.catalog_manager.clone(),
+            self.catalog_provider.clone(),
        )
    }
 }
@@ -105,7 +103,7 @@ impl InformationStreamBuilder for InformationSchemaColumns {
 struct InformationSchemaColumnsBuilder {
    schema: SchemaRef,
    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
+    catalog_provider: CatalogProviderRef,

    catalog_names: StringVectorBuilder,
    schema_names: StringVectorBuilder,
@@ -116,15 +114,11 @@ struct InformationSchemaColumnsBuilder {
 }

 impl InformationSchemaColumnsBuilder {
-    fn new(
-        schema: SchemaRef,
-        catalog_name: String,
-        catalog_manager: Weak<dyn CatalogManager>,
-    ) -> Self {
+    fn new(schema: SchemaRef, catalog_name: String, catalog_provider: CatalogProviderRef) -> Self {
        Self {
            schema,
            catalog_name,
-            catalog_manager,
+            catalog_provider,
            catalog_names: StringVectorBuilder::with_capacity(42),
            schema_names: StringVectorBuilder::with_capacity(42),
            table_names: StringVectorBuilder::with_capacity(42),
@@ -137,23 +131,11 @@ impl InformationSchemaColumnsBuilder {
    /// Construct the `information_schema.tables` virtual table
    async fn make_tables(&mut self) -> Result<RecordBatch> {
        let catalog_name = self.catalog_name.clone();
-        let catalog_manager = self
-            .catalog_manager
-            .upgrade()
-            .context(UpgradeWeakCatalogManagerRefSnafu)?;

-        for schema_name in catalog_manager.schema_names(&catalog_name).await? {
-            if !catalog_manager
-                .schema_exist(&catalog_name, &schema_name)
-                .await?
-            {
-                continue;
-            }
-            for table_name in catalog_manager
-                .table_names(&catalog_name, &schema_name)
-                .await?
-            {
-                let Some(table) = catalog_manager.table(&catalog_name, &schema_name, &table_name).await? else { continue };
+        for schema_name in self.catalog_provider.schema_names().await? {
+            let Some(schema) = self.catalog_provider.schema(&schema_name).await? else { continue };
+            for table_name in schema.table_names().await? {
+                let Some(table) = schema.table(&table_name).await? else { continue };
                let keys = &table.table_info().meta.primary_key_indices;
                let schema = table.schema();
                for (idx, column) in schema.column_schemas().iter().enumerate() {
--- a/src/catalog/src/information_schema/tables.rs
+++ b/src/catalog/src/information_schema/tables.rs
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-use std::sync::{Arc, Weak};
+use std::sync::Arc;

 use arrow_schema::SchemaRef as ArrowSchemaRef;
 use common_catalog::consts::INFORMATION_SCHEMA_NAME;
@@ -26,23 +26,21 @@ use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatc
 use datatypes::prelude::{ConcreteDataType, ScalarVectorBuilder, VectorRef};
 use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
 use datatypes::vectors::{StringVectorBuilder, UInt32VectorBuilder};
-use snafu::{OptionExt, ResultExt};
+use snafu::ResultExt;
 use table::metadata::TableType;

-use crate::error::{
-    CreateRecordBatchSnafu, InternalSnafu, Result, UpgradeWeakCatalogManagerRefSnafu,
-};
+use crate::error::{CreateRecordBatchSnafu, InternalSnafu, Result};
 use crate::information_schema::InformationStreamBuilder;
-use crate::CatalogManager;
+use crate::CatalogProviderRef;

 pub(super) struct InformationSchemaTables {
    schema: SchemaRef,
    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
+    catalog_provider: CatalogProviderRef,
 }

 impl InformationSchemaTables {
-    pub(super) fn new(catalog_name: String, catalog_manager: Weak<dyn CatalogManager>) -> Self {
+    pub(super) fn new(catalog_name: String, catalog_provider: CatalogProviderRef) -> Self {
        let schema = Arc::new(Schema::new(vec![
            ColumnSchema::new("table_catalog", ConcreteDataType::string_datatype(), false),
            ColumnSchema::new("table_schema", ConcreteDataType::string_datatype(), false),
@@ -54,7 +52,7 @@ impl InformationSchemaTables {
        Self {
            schema,
            catalog_name,
-            catalog_manager,
+            catalog_provider,
        }
    }

@@ -62,7 +60,7 @@ impl InformationSchemaTables {
        InformationSchemaTablesBuilder::new(
            self.schema.clone(),
            self.catalog_name.clone(),
-            self.catalog_manager.clone(),
+            self.catalog_provider.clone(),
        )
    }
 }
@@ -99,7 +97,7 @@ impl InformationStreamBuilder for InformationSchemaTables {
 struct InformationSchemaTablesBuilder {
    schema: SchemaRef,
    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
+    catalog_provider: CatalogProviderRef,

    catalog_names: StringVectorBuilder,
    schema_names: StringVectorBuilder,
@@ -110,15 +108,11 @@ struct InformationSchemaTablesBuilder {
 }

 impl InformationSchemaTablesBuilder {
-    fn new(
-        schema: SchemaRef,
-        catalog_name: String,
-        catalog_manager: Weak<dyn CatalogManager>,
-    ) -> Self {
+    fn new(schema: SchemaRef, catalog_name: String, catalog_provider: CatalogProviderRef) -> Self {
        Self {
            schema,
            catalog_name,
-            catalog_manager,
+            catalog_provider,
            catalog_names: StringVectorBuilder::with_capacity(42),
            schema_names: StringVectorBuilder::with_capacity(42),
            table_names: StringVectorBuilder::with_capacity(42),
@@ -131,27 +125,15 @@ impl InformationSchemaTablesBuilder {
    /// Construct the `information_schema.tables` virtual table
    async fn make_tables(&mut self) -> Result<RecordBatch> {
        let catalog_name = self.catalog_name.clone();
-        let catalog_manager = self
-            .catalog_manager
-            .upgrade()
-            .context(UpgradeWeakCatalogManagerRefSnafu)?;

-        for schema_name in catalog_manager.schema_names(&catalog_name).await? {
+        for schema_name in self.catalog_provider.schema_names().await? {
            if schema_name == INFORMATION_SCHEMA_NAME {
                continue;
            }
-            if !catalog_manager
-                .schema_exist(&catalog_name, &schema_name)
-                .await?
-            {
-                continue;
-            }

-            for table_name in catalog_manager
-                .table_names(&catalog_name, &schema_name)
-                .await?
-            {
-                let Some(table) = catalog_manager.table(&catalog_name, &schema_name, &table_name).await? else { continue };
+            let Some(schema) = self.catalog_provider.schema(&schema_name).await? else { continue };
+            for table_name in schema.table_names().await? {
+                let Some(table) = schema.table(&table_name).await? else { continue };
                let table_info = table.table_info();
                self.add_table(
                    &catalog_name,
--- a/src/catalog/src/lib.rs
+++ b/src/catalog/src/lib.rs
@@ -14,7 +14,6 @@

 #![feature(trait_upcasting)]
 #![feature(assert_matches)]
-#![feature(try_blocks)]

 use std::any::Any;
 use std::collections::HashMap;
@@ -30,45 +29,64 @@ use table::requests::CreateTableRequest;
 use table::TableRef;

 use crate::error::{CreateTableSnafu, Result};
+pub use crate::schema::{SchemaProvider, SchemaProviderRef};

 pub mod error;
 pub mod helper;
-pub mod information_schema;
+pub(crate) mod information_schema;
 pub mod local;
 mod metrics;
 pub mod remote;
+pub mod schema;
 pub mod system;
 pub mod table_source;
 pub mod tables;

+/// Represents a catalog, comprising a number of named schemas.
 #[async_trait::async_trait]
-pub trait CatalogManager: Send + Sync {
+pub trait CatalogProvider: Sync + Send {
+    /// Returns the catalog provider as [`Any`](std::any::Any)
+    /// so that it can be downcast to a specific implementation.
    fn as_any(&self) -> &dyn Any;

+    /// Retrieves the list of available schema names in this catalog.
+    async fn schema_names(&self) -> Result<Vec<String>>;
+
+    /// Registers schema to this catalog.
+    async fn register_schema(
+        &self,
+        name: String,
+        schema: SchemaProviderRef,
+    ) -> Result<Option<SchemaProviderRef>>;
+
+    /// Retrieves a specific schema from the catalog by name, provided it exists.
+    async fn schema(&self, name: &str) -> Result<Option<SchemaProviderRef>>;
+}
+
+pub type CatalogProviderRef = Arc<dyn CatalogProvider>;
+
+#[async_trait::async_trait]
+pub trait CatalogManager: Send + Sync {
    /// Starts a catalog manager.
    async fn start(&self) -> Result<()>;

-    /// Registers a catalog to catalog manager, returns whether the catalog exist before.
-    async fn register_catalog(&self, name: String) -> Result<bool>;
-
-    /// Register a schema with catalog name and schema name. Retuens whether the
-    /// schema registered.
-    ///
-    /// # Errors
-    ///
-    /// This method will/should fail if catalog not exist
-    async fn register_schema(&self, request: RegisterSchemaRequest) -> Result<bool>;
+    async fn register_catalog(
+        &self,
+        name: String,
+        catalog: CatalogProviderRef,
+    ) -> Result<Option<CatalogProviderRef>>;

    /// Registers a table within given catalog/schema to catalog manager,
    /// returns whether the table registered.
-    ///
-    /// # Errors
-    ///
-    /// This method will/should fail if catalog or schema not exist
    async fn register_table(&self, request: RegisterTableRequest) -> Result<bool>;

-    /// Deregisters a table within given catalog/schema to catalog manager
-    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<()>;
+    /// Deregisters a table within given catalog/schema to catalog manager,
+    /// returns whether the table deregistered.
+    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<bool>;
+
+    /// Register a schema with catalog name and schema name. Retuens whether the
+    /// schema registered.
+    async fn register_schema(&self, request: RegisterSchemaRequest) -> Result<bool>;

    /// Rename a table to [RenameTableRequest::new_table_name], returns whether the table is renamed.
    async fn rename_table(&self, request: RenameTableRequest) -> Result<bool>;
@@ -79,15 +97,9 @@ pub trait CatalogManager: Send + Sync {

    async fn catalog_names(&self) -> Result<Vec<String>>;

-    async fn schema_names(&self, catalog: &str) -> Result<Vec<String>>;
+    async fn catalog(&self, catalog: &str) -> Result<Option<CatalogProviderRef>>;

-    async fn table_names(&self, catalog: &str, schema: &str) -> Result<Vec<String>>;
-
-    async fn catalog_exist(&self, catalog: &str) -> Result<bool>;
-
-    async fn schema_exist(&self, catalog: &str, schema: &str) -> Result<bool>;
-
-    async fn table_exist(&self, catalog: &str, schema: &str, table: &str) -> Result<bool>;
+    async fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>>;

    /// Returns the table by catalog, schema and table name.
    async fn table(
@@ -96,6 +108,8 @@ pub trait CatalogManager: Send + Sync {
        schema: &str,
        table_name: &str,
    ) -> Result<Option<TableRef>>;
+
+    fn as_any(&self) -> &dyn Any;
 }

 pub type CatalogManagerRef = Arc<dyn CatalogManager>;
@@ -155,6 +169,14 @@ pub struct RegisterSchemaRequest {
    pub schema: String,
 }

+pub trait CatalogProviderFactory {
+    fn create(&self, catalog_name: String) -> CatalogProviderRef;
+}
+
+pub trait SchemaProviderFactory {
+    fn create(&self, catalog_name: String, schema_name: String) -> SchemaProviderRef;
+}
+
 pub(crate) async fn handle_system_table_request<'a, M: CatalogManager>(
    manager: &'a M,
    engine: TableEngineRef,
@@ -180,7 +202,7 @@ pub(crate) async fn handle_system_table_request<'a, M: CatalogManager>(
                        table_name,
                    ),
                })?;
-            let _ = manager
+            manager
                .register_table(RegisterTableRequest {
                    catalog: catalog_name.clone(),
                    schema: schema_name.clone(),
@@ -211,11 +233,15 @@ pub async fn datanode_stat(catalog_manager: &CatalogManagerRef) -> (u64, Vec<Reg

    let Ok(catalog_names) = catalog_manager.catalog_names().await else { return (region_number, region_stats) };
    for catalog_name in catalog_names {
-        let Ok(schema_names) = catalog_manager.schema_names(&catalog_name).await else { continue };
+        let Ok(Some(catalog)) = catalog_manager.catalog(&catalog_name).await else { continue };
+
+        let Ok(schema_names) = catalog.schema_names().await else { continue };
        for schema_name in schema_names {
-            let Ok(table_names) = catalog_manager.table_names(&catalog_name,&schema_name).await else { continue };
+            let Ok(Some(schema)) = catalog.schema(&schema_name).await else { continue };
+
+            let Ok(table_names) = schema.table_names().await else { continue };
            for table_name in table_names {
-                let Ok(Some(table)) = catalog_manager.table(&catalog_name, &schema_name, &table_name).await else { continue };
+                let Ok(Some(table)) = schema.table(&table_name).await else { continue };

                let region_numbers = &table.table_info().meta.region_numbers;
                region_number += region_numbers.len() as u64;
--- a/src/catalog/src/local.rs
+++ b/src/catalog/src/local.rs
@@ -16,4 +16,6 @@ pub mod manager;
 pub mod memory;

 pub use manager::LocalCatalogManager;
-pub use memory::{new_memory_catalog_manager, MemoryCatalogManager};
+pub use memory::{
+    new_memory_catalog_list, MemoryCatalogManager, MemoryCatalogProvider, MemorySchemaProvider,
+};
--- a/src/catalog/src/local/manager.rs
+++ b/src/catalog/src/local/manager.rs
@@ -18,8 +18,7 @@ use std::sync::Arc;

 use common_catalog::consts::{
    DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, INFORMATION_SCHEMA_NAME, MIN_USER_TABLE_ID,
-    MITO_ENGINE, NUMBERS_TABLE_ID, SYSTEM_CATALOG_NAME, SYSTEM_CATALOG_TABLE_ID,
-    SYSTEM_CATALOG_TABLE_NAME,
+    MITO_ENGINE, SYSTEM_CATALOG_NAME, SYSTEM_CATALOG_TABLE_NAME,
 };
 use common_catalog::format_full_table_name;
 use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
@@ -33,7 +32,7 @@ use table::engine::manager::TableEngineManagerRef;
 use table::engine::EngineContext;
 use table::metadata::TableId;
 use table::requests::OpenTableRequest;
-use table::table::numbers::{NumbersTable, NUMBERS_TABLE_NAME};
+use table::table::numbers::NumbersTable;
 use table::table::TableIdProvider;
 use table::TableRef;

@@ -43,16 +42,16 @@ use crate::error::{
    SystemCatalogTypeMismatchSnafu, TableEngineNotFoundSnafu, TableExistsSnafu, TableNotExistSnafu,
    TableNotFoundSnafu,
 };
-use crate::information_schema::InformationSchemaProvider;
-use crate::local::memory::MemoryCatalogManager;
+use crate::local::memory::{MemoryCatalogManager, MemoryCatalogProvider, MemorySchemaProvider};
 use crate::system::{
    decode_system_catalog, Entry, SystemCatalogTable, TableEntry, ENTRY_TYPE_INDEX, KEY_INDEX,
    VALUE_INDEX,
 };
 use crate::tables::SystemCatalog;
 use crate::{
-    handle_system_table_request, CatalogManager, CatalogManagerRef, DeregisterTableRequest,
+    handle_system_table_request, CatalogManager, CatalogProviderRef, DeregisterTableRequest,
    RegisterSchemaRequest, RegisterSystemTableRequest, RegisterTableRequest, RenameTableRequest,
+    SchemaProviderRef,
 };

 /// A `CatalogManager` consists of a system catalog and a bunch of user catalogs.
@@ -75,11 +74,11 @@ impl LocalCatalogManager {
                engine_name: MITO_ENGINE,
            })?;
        let table = SystemCatalogTable::new(engine.clone()).await?;
-        let memory_catalog_manager = crate::local::memory::new_memory_catalog_manager()?;
+        let memory_catalog_list = crate::local::memory::new_memory_catalog_list()?;
        let system_catalog = Arc::new(SystemCatalog::new(table));
        Ok(Self {
            system: system_catalog,
-            catalogs: memory_catalog_manager,
+            catalogs: memory_catalog_list,
            engine_manager,
            next_table_id: AtomicU32::new(MIN_USER_TABLE_ID),
            init_lock: Mutex::new(false),
@@ -117,47 +116,26 @@ impl LocalCatalogManager {
    }

    async fn init_system_catalog(&self) -> Result<()> {
-        // register SystemCatalogTable
-        let _ = self
-            .catalogs
-            .register_catalog_sync(SYSTEM_CATALOG_NAME.to_string())?;
-        let _ = self.catalogs.register_schema_sync(RegisterSchemaRequest {
-            catalog: SYSTEM_CATALOG_NAME.to_string(),
-            schema: INFORMATION_SCHEMA_NAME.to_string(),
-        })?;
-        let register_table_req = RegisterTableRequest {
-            catalog: SYSTEM_CATALOG_NAME.to_string(),
-            schema: INFORMATION_SCHEMA_NAME.to_string(),
-            table_name: SYSTEM_CATALOG_TABLE_NAME.to_string(),
-            table_id: SYSTEM_CATALOG_TABLE_ID,
-            table: self.system.information_schema.system.clone(),
-        };
-        let _ = self.catalogs.register_table(register_table_req).await?;
+        let system_schema = Arc::new(MemorySchemaProvider::new());
+        system_schema.register_table_sync(
+            SYSTEM_CATALOG_TABLE_NAME.to_string(),
+            self.system.information_schema.system.clone(),
+        )?;
+        let system_catalog = Arc::new(MemoryCatalogProvider::new());
+        system_catalog.register_schema_sync(INFORMATION_SCHEMA_NAME.to_string(), system_schema)?;
+        self.catalogs
+            .register_catalog_sync(SYSTEM_CATALOG_NAME.to_string(), system_catalog)?;

-        // register default catalog and default schema
-        let _ = self
-            .catalogs
-            .register_catalog_sync(DEFAULT_CATALOG_NAME.to_string())?;
-        let _ = self.catalogs.register_schema_sync(RegisterSchemaRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-        })?;
+        let default_catalog = Arc::new(MemoryCatalogProvider::new());
+        let default_schema = Arc::new(MemorySchemaProvider::new());

        // Add numbers table for test
-        let numbers_table = Arc::new(NumbersTable::default());
-        let register_number_table_req = RegisterTableRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: NUMBERS_TABLE_NAME.to_string(),
-            table_id: NUMBERS_TABLE_ID,
-            table: numbers_table,
-        };
-
-        let _ = self
-            .catalogs
-            .register_table(register_number_table_req)
-            .await?;
+        let table = Arc::new(NumbersTable::default());
+        default_schema.register_table_sync("numbers".to_string(), table)?;

+        default_catalog.register_schema_sync(DEFAULT_SCHEMA_NAME.to_string(), default_schema)?;
+        self.catalogs
+            .register_catalog_sync(DEFAULT_CATALOG_NAME.to_string(), default_catalog)?;
        Ok(())
    }

@@ -229,17 +207,24 @@ impl LocalCatalogManager {
        for entry in entries {
            match entry {
                Entry::Catalog(c) => {
-                    let _ = self
-                        .catalogs
-                        .register_catalog_if_absent(c.catalog_name.clone());
+                    self.catalogs.register_catalog_if_absent(
+                        c.catalog_name.clone(),
+                        Arc::new(MemoryCatalogProvider::new()),
+                    );
                    info!("Register catalog: {}", c.catalog_name);
                }
                Entry::Schema(s) => {
-                    let req = RegisterSchemaRequest {
-                        catalog: s.catalog_name.clone(),
-                        schema: s.schema_name.clone(),
-                    };
-                    let _ = self.catalogs.register_schema_sync(req)?;
+                    self.catalogs
+                        .catalog(&s.catalog_name)
+                        .await?
+                        .context(CatalogNotFoundSnafu {
+                            catalog_name: &s.catalog_name,
+                        })?
+                        .register_schema(
+                            s.schema_name.clone(),
+                            Arc::new(MemorySchemaProvider::new()),
+                        )
+                        .await?;
                    info!("Registered schema: {:?}", s);
                }
                Entry::Table(t) => {
@@ -260,11 +245,23 @@ impl LocalCatalogManager {
    }

    async fn open_and_register_table(&self, t: &TableEntry) -> Result<()> {
-        self.check_catalog_schema_exist(&t.catalog_name, &t.schema_name)
-            .await?;
+        let catalog =
+            self.catalogs
+                .catalog(&t.catalog_name)
+                .await?
+                .context(CatalogNotFoundSnafu {
+                    catalog_name: &t.catalog_name,
+                })?;
+        let schema = catalog
+            .schema(&t.schema_name)
+            .await?
+            .context(SchemaNotFoundSnafu {
+                catalog: &t.catalog_name,
+                schema: &t.schema_name,
+            })?;

        let context = EngineContext {};
-        let open_request = OpenTableRequest {
+        let request = OpenTableRequest {
            catalog_name: t.catalog_name.clone(),
            schema_name: t.schema_name.clone(),
            table_name: t.table_name.clone(),
@@ -278,8 +275,8 @@ impl LocalCatalogManager {
                engine_name: &t.engine,
            })?;

-        let table_ref = engine
-            .open_table(&context, open_request)
+        let option = engine
+            .open_table(&context, request)
            .await
            .with_context(|_| OpenTableSnafu {
                table_info: format!(
@@ -294,48 +291,7 @@ impl LocalCatalogManager {
                ),
            })?;

-        let register_request = RegisterTableRequest {
-            catalog: t.catalog_name.clone(),
-            schema: t.schema_name.clone(),
-            table_name: t.table_name.clone(),
-            table_id: t.table_id,
-            table: table_ref,
-        };
-        let _ = self.catalogs.register_table(register_request).await?;
-
-        Ok(())
-    }
-
-    async fn check_state(&self) -> Result<()> {
-        let started = self.init_lock.lock().await;
-        ensure!(
-            *started,
-            IllegalManagerStateSnafu {
-                msg: "Catalog manager not started",
-            }
-        );
-        Ok(())
-    }
-
-    async fn check_catalog_schema_exist(
-        &self,
-        catalog_name: &str,
-        schema_name: &str,
-    ) -> Result<()> {
-        if !self.catalogs.catalog_exist(catalog_name).await? {
-            return CatalogNotFoundSnafu { catalog_name }.fail()?;
-        }
-        if !self
-            .catalogs
-            .schema_exist(catalog_name, schema_name)
-            .await?
-        {
-            return SchemaNotFoundSnafu {
-                catalog: catalog_name,
-                schema: schema_name,
-            }
-            .fail()?;
-        }
+        schema.register_table(t.table_name.clone(), option).await?;
        Ok(())
    }
 }
@@ -356,21 +312,34 @@ impl CatalogManager for LocalCatalogManager {
    }

    async fn register_table(&self, request: RegisterTableRequest) -> Result<bool> {
-        self.check_state().await?;
+        let started = self.init_lock.lock().await;

-        let catalog_name = request.catalog.clone();
-        let schema_name = request.schema.clone();
+        ensure!(
+            *started,
+            IllegalManagerStateSnafu {
+                msg: "Catalog manager not started",
+            }
+        );

-        self.check_catalog_schema_exist(&catalog_name, &schema_name)
-            .await?;
+        let catalog_name = &request.catalog;
+        let schema_name = &request.schema;
+
+        let catalog = self
+            .catalogs
+            .catalog(catalog_name)
+            .await?
+            .context(CatalogNotFoundSnafu { catalog_name })?;
+        let schema = catalog
+            .schema(schema_name)
+            .await?
+            .with_context(|| SchemaNotFoundSnafu {
+                catalog: catalog_name,
+                schema: schema_name,
+            })?;

        {
            let _lock = self.register_lock.lock().await;
-            if let Some(existing) = self
-                .catalogs
-                .table(&request.catalog, &request.schema, &request.table_name)
-                .await?
-            {
+            if let Some(existing) = schema.table(&request.table_name).await? {
                if existing.table_info().ident.table_id != request.table_id {
                    error!(
                        "Unexpected table register request: {:?}, existing: {:?}",
@@ -379,8 +348,8 @@ impl CatalogManager for LocalCatalogManager {
                    );
                    return TableExistsSnafu {
                        table: format_full_table_name(
-                            &catalog_name,
-                            &schema_name,
+                            catalog_name,
+                            schema_name,
                            &request.table_name,
                        ),
                    }
@@ -389,25 +358,24 @@ impl CatalogManager for LocalCatalogManager {
                // Try to register table with same table id, just ignore.
                Ok(false)
            } else {
-                // table does not exist
                let engine = request.table.table_info().meta.engine.to_string();
-                let table_name = request.table_name.clone();
-                let table_id = request.table_id;
-                let _ = self.catalogs.register_table(request).await?;
-                let _ = self
-                    .system
+                // table does not exist
+                self.system
                    .register_table(
                        catalog_name.clone(),
                        schema_name.clone(),
-                        table_name,
-                        table_id,
+                        request.table_name.clone(),
+                        request.table_id,
                        engine,
                    )
                    .await?;
+                schema
+                    .register_table(request.table_name, request.table)
+                    .await?;
                increment_gauge!(
                    crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
                    1.0,
-                    &[crate::metrics::db_label(&catalog_name, &schema_name)],
+                    &[crate::metrics::db_label(catalog_name, schema_name)],
                );
                Ok(true)
            }
@@ -415,27 +383,41 @@ impl CatalogManager for LocalCatalogManager {
    }

    async fn rename_table(&self, request: RenameTableRequest) -> Result<bool> {
-        self.check_state().await?;
+        let started = self.init_lock.lock().await;
+
+        ensure!(
+            *started,
+            IllegalManagerStateSnafu {
+                msg: "Catalog manager not started",
+            }
+        );

        let catalog_name = &request.catalog;
        let schema_name = &request.schema;

-        self.check_catalog_schema_exist(catalog_name, schema_name)
-            .await?;
+        let catalog = self
+            .catalogs
+            .catalog(catalog_name)
+            .await?
+            .context(CatalogNotFoundSnafu { catalog_name })?;
+
+        let schema = catalog
+            .schema(schema_name)
+            .await?
+            .with_context(|| SchemaNotFoundSnafu {
+                catalog: catalog_name,
+                schema: schema_name,
+            })?;
+
+        let _lock = self.register_lock.lock().await;
        ensure!(
-            self.catalogs
-                .table(catalog_name, schema_name, &request.new_table_name)
-                .await?
-                .is_none(),
+            !schema.table_exist(&request.new_table_name).await?,
            TableExistsSnafu {
                table: &request.new_table_name
            }
        );
-
-        let _lock = self.register_lock.lock().await;
-        let old_table = self
-            .catalogs
-            .table(catalog_name, schema_name, &request.table_name)
+        let old_table = schema
+            .table(&request.table_name)
            .await?
            .context(TableNotExistSnafu {
                table: &request.table_name,
@@ -443,8 +425,7 @@ impl CatalogManager for LocalCatalogManager {

        let engine = old_table.table_info().meta.engine.to_string();
        // rename table in system catalog
-        let _ = self
-            .system
+        self.system
            .register_table(
                catalog_name.clone(),
                schema_name.clone(),
@@ -454,11 +435,18 @@ impl CatalogManager for LocalCatalogManager {
            )
            .await?;

-        self.catalogs.rename_table(request).await
+        let renamed = schema
+            .rename_table(&request.table_name, request.new_table_name.clone())
+            .await
+            .is_ok();
+        Ok(renamed)
    }

-    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<()> {
-        self.check_state().await?;
+    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<bool> {
+        {
+            let started = *self.init_lock.lock().await;
+            ensure!(started, IllegalManagerStateSnafu { msg: "not started" });
+        }

        {
            let _ = self.register_lock.lock().await;
@@ -485,40 +473,52 @@ impl CatalogManager for LocalCatalogManager {
    }

    async fn register_schema(&self, request: RegisterSchemaRequest) -> Result<bool> {
-        self.check_state().await?;
-
+        let started = self.init_lock.lock().await;
+        ensure!(
+            *started,
+            IllegalManagerStateSnafu {
+                msg: "Catalog manager not started",
+            }
+        );
        let catalog_name = &request.catalog;
        let schema_name = &request.schema;

-        if !self.catalogs.catalog_exist(catalog_name).await? {
-            return CatalogNotFoundSnafu { catalog_name }.fail()?;
-        }
+        let catalog = self
+            .catalogs
+            .catalog(catalog_name)
+            .await?
+            .context(CatalogNotFoundSnafu { catalog_name })?;

        {
            let _lock = self.register_lock.lock().await;
            ensure!(
-                !self
-                    .catalogs
-                    .schema_exist(catalog_name, schema_name)
-                    .await?,
+                catalog.schema(schema_name).await?.is_none(),
                SchemaExistsSnafu {
                    schema: schema_name,
                }
            );
-            let _ = self
-                .system
-                .register_schema(request.catalog.clone(), schema_name.clone())
+            self.system
+                .register_schema(request.catalog, schema_name.clone())
                .await?;
-            self.catalogs.register_schema_sync(request)
+            catalog
+                .register_schema(request.schema, Arc::new(MemorySchemaProvider::new()))
+                .await?;
+
+            Ok(true)
        }
    }

    async fn register_system_table(&self, request: RegisterSystemTableRequest) -> Result<()> {
-        self.check_state().await?;
-
        let catalog_name = request.create_table_request.catalog_name.clone();
        let schema_name = request.create_table_request.schema_name.clone();

+        ensure!(
+            !*self.init_lock.lock().await,
+            IllegalManagerStateSnafu {
+                msg: "Catalog manager already started",
+            }
+        );
+
        let mut sys_table_requests = self.system_table_requests.lock().await;
        sys_table_requests.push(request);
        increment_gauge!(
@@ -529,8 +529,15 @@ impl CatalogManager for LocalCatalogManager {
        Ok(())
    }

-    async fn schema_exist(&self, catalog: &str, schema: &str) -> Result<bool> {
-        self.catalogs.schema_exist(catalog, schema).await
+    async fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>> {
+        self.catalogs
+            .catalog(catalog)
+            .await?
+            .context(CatalogNotFoundSnafu {
+                catalog_name: catalog,
+            })?
+            .schema(schema)
+            .await
    }

    async fn table(
@@ -539,44 +546,39 @@ impl CatalogManager for LocalCatalogManager {
        schema_name: &str,
        table_name: &str,
    ) -> Result<Option<TableRef>> {
-        if schema_name == INFORMATION_SCHEMA_NAME {
-            let manager: CatalogManagerRef = self.catalogs.clone() as _;
-            let provider =
-                InformationSchemaProvider::new(catalog_name.to_string(), Arc::downgrade(&manager));
-            return provider.table(table_name);
-        }
-
-        self.catalogs
-            .table(catalog_name, schema_name, table_name)
-            .await
+        let catalog = self
+            .catalogs
+            .catalog(catalog_name)
+            .await?
+            .context(CatalogNotFoundSnafu { catalog_name })?;
+        let schema = catalog
+            .schema(schema_name)
+            .await?
+            .with_context(|| SchemaNotFoundSnafu {
+                catalog: catalog_name,
+                schema: schema_name,
+            })?;
+        schema.table(table_name).await
    }

-    async fn catalog_exist(&self, catalog: &str) -> Result<bool> {
+    async fn catalog(&self, catalog: &str) -> Result<Option<CatalogProviderRef>> {
        if catalog.eq_ignore_ascii_case(SYSTEM_CATALOG_NAME) {
-            Ok(true)
+            Ok(Some(self.system.clone()))
        } else {
-            self.catalogs.catalog_exist(catalog).await
+            self.catalogs.catalog(catalog).await
        }
    }

-    async fn table_exist(&self, catalog: &str, schema: &str, table: &str) -> Result<bool> {
-        self.catalogs.table_exist(catalog, schema, table).await
-    }
-
    async fn catalog_names(&self) -> Result<Vec<String>> {
        self.catalogs.catalog_names().await
    }

-    async fn schema_names(&self, catalog_name: &str) -> Result<Vec<String>> {
-        self.catalogs.schema_names(catalog_name).await
-    }
-
-    async fn table_names(&self, catalog_name: &str, schema_name: &str) -> Result<Vec<String>> {
-        self.catalogs.table_names(catalog_name, schema_name).await
-    }
-
-    async fn register_catalog(&self, name: String) -> Result<bool> {
-        self.catalogs.register_catalog(name).await
+    async fn register_catalog(
+        &self,
+        name: String,
+        catalog: CatalogProviderRef,
+    ) -> Result<Option<CatalogProviderRef>> {
+        self.catalogs.register_catalog(name, catalog).await
    }

    fn as_any(&self) -> &dyn Any {
--- a/src/catalog/src/local/memory.rs
+++ b/src/catalog/src/local/memory.rs
@@ -18,27 +18,29 @@ use std::collections::HashMap;
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::{Arc, RwLock};

-use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, MIN_USER_TABLE_ID};
+use async_trait::async_trait;
+use common_catalog::consts::MIN_USER_TABLE_ID;
+use common_telemetry::error;
 use metrics::{decrement_gauge, increment_gauge};
-use snafu::OptionExt;
+use snafu::{ensure, OptionExt};
 use table::metadata::TableId;
 use table::table::TableIdProvider;
 use table::TableRef;

 use crate::error::{
-    CatalogNotFoundSnafu, Result, SchemaNotFoundSnafu, TableExistsSnafu, TableNotFoundSnafu,
+    self, CatalogNotFoundSnafu, Result, SchemaNotFoundSnafu, TableExistsSnafu, TableNotFoundSnafu,
 };
+use crate::schema::SchemaProvider;
 use crate::{
-    CatalogManager, DeregisterTableRequest, RegisterSchemaRequest, RegisterSystemTableRequest,
-    RegisterTableRequest, RenameTableRequest,
+    CatalogManager, CatalogProvider, CatalogProviderRef, DeregisterTableRequest,
+    RegisterSchemaRequest, RegisterSystemTableRequest, RegisterTableRequest, RenameTableRequest,
+    SchemaProviderRef,
 };

-type SchemaEntries = HashMap<String, HashMap<String, TableRef>>;
-
 /// Simple in-memory list of catalogs
 pub struct MemoryCatalogManager {
    /// Collection of catalogs containing schemas and ultimately Tables
-    pub catalogs: RwLock<HashMap<String, SchemaEntries>>,
+    pub catalogs: RwLock<HashMap<String, CatalogProviderRef>>,
    pub table_id: AtomicU32,
 }

@@ -48,14 +50,13 @@ impl Default for MemoryCatalogManager {
            table_id: AtomicU32::new(MIN_USER_TABLE_ID),
            catalogs: Default::default(),
        };
-
-        let catalog = HashMap::from([(DEFAULT_SCHEMA_NAME.to_string(), HashMap::new())]);
-        let _ = manager
-            .catalogs
-            .write()
-            .unwrap()
-            .insert(DEFAULT_CATALOG_NAME.to_string(), catalog);
-
+        let default_catalog = Arc::new(MemoryCatalogProvider::new());
+        manager
+            .register_catalog_sync("greptime".to_string(), default_catalog.clone())
+            .unwrap();
+        default_catalog
+            .register_schema_sync("public".to_string(), Arc::new(MemorySchemaProvider::new()))
+            .unwrap();
        manager
    }
 }
@@ -75,79 +76,82 @@ impl CatalogManager for MemoryCatalogManager {
    }

    async fn register_table(&self, request: RegisterTableRequest) -> Result<bool> {
-        let catalog = request.catalog.clone();
-        let schema = request.schema.clone();
-        let result = self.register_table_sync(request);
+        let schema = self
+            .catalog(&request.catalog)
+            .context(CatalogNotFoundSnafu {
+                catalog_name: &request.catalog,
+            })?
+            .schema(&request.schema)
+            .await?
+            .context(SchemaNotFoundSnafu {
+                catalog: &request.catalog,
+                schema: &request.schema,
+            })?;
        increment_gauge!(
            crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
            1.0,
-            &[crate::metrics::db_label(&catalog, &schema)],
+            &[crate::metrics::db_label(&request.catalog, &request.schema)],
        );
-        result
+        schema
+            .register_table(request.table_name, request.table)
+            .await
+            .map(|v| v.is_none())
    }

    async fn rename_table(&self, request: RenameTableRequest) -> Result<bool> {
-        let mut catalogs = self.catalogs.write().unwrap();
-        let schema = catalogs
-            .get_mut(&request.catalog)
-            .with_context(|| CatalogNotFoundSnafu {
+        let catalog = self
+            .catalog(&request.catalog)
+            .context(CatalogNotFoundSnafu {
                catalog_name: &request.catalog,
-            })?
-            .get_mut(&request.schema)
-            .with_context(|| SchemaNotFoundSnafu {
-                catalog: &request.catalog,
-                schema: &request.schema,
            })?;
-
-        // check old and new table names
-        if !schema.contains_key(&request.table_name) {
-            return TableNotFoundSnafu {
-                table_info: request.table_name.to_string(),
-            }
-            .fail()?;
-        }
-        if schema.contains_key(&request.new_table_name) {
-            return TableExistsSnafu {
-                table: &request.new_table_name,
-            }
-            .fail();
-        }
-
-        let table = schema.remove(&request.table_name).unwrap();
-        let _ = schema.insert(request.new_table_name, table);
-
-        Ok(true)
+        let schema =
+            catalog
+                .schema(&request.schema)
+                .await?
+                .with_context(|| SchemaNotFoundSnafu {
+                    catalog: &request.catalog,
+                    schema: &request.schema,
+                })?;
+        Ok(schema
+            .rename_table(&request.table_name, request.new_table_name)
+            .await
+            .is_ok())
    }

-    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<()> {
-        let mut catalogs = self.catalogs.write().unwrap();
-        let schema = catalogs
-            .get_mut(&request.catalog)
-            .with_context(|| CatalogNotFoundSnafu {
+    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<bool> {
+        let schema = self
+            .catalog(&request.catalog)
+            .context(CatalogNotFoundSnafu {
                catalog_name: &request.catalog,
            })?
-            .get_mut(&request.schema)
+            .schema(&request.schema)
+            .await?
            .with_context(|| SchemaNotFoundSnafu {
                catalog: &request.catalog,
                schema: &request.schema,
            })?;
-        let result = schema.remove(&request.table_name);
-        if result.is_some() {
-            decrement_gauge!(
-                crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-                1.0,
-                &[crate::metrics::db_label(&request.catalog, &request.schema)],
-            );
-        }
-        Ok(())
+        decrement_gauge!(
+            crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
+            1.0,
+            &[crate::metrics::db_label(&request.catalog, &request.schema)],
+        );
+        schema
+            .deregister_table(&request.table_name)
+            .await
+            .map(|v| v.is_some())
    }

    async fn register_schema(&self, request: RegisterSchemaRequest) -> Result<bool> {
-        let registered = self.register_schema_sync(request)?;
-        if registered {
-            increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_SCHEMA_COUNT, 1.0);
-        }
-        Ok(registered)
+        let catalog = self
+            .catalog(&request.catalog)
+            .context(CatalogNotFoundSnafu {
+                catalog_name: &request.catalog,
+            })?;
+        catalog
+            .register_schema(request.schema, Arc::new(MemorySchemaProvider::new()))
+            .await?;
+        increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_SCHEMA_COUNT, 1.0);
+        Ok(true)
    }

    async fn register_system_table(&self, _request: RegisterSystemTableRequest) -> Result<()> {
@@ -155,16 +159,12 @@ impl CatalogManager for MemoryCatalogManager {
        Ok(())
    }

-    async fn schema_exist(&self, catalog: &str, schema: &str) -> Result<bool> {
-        Ok(self
-            .catalogs
-            .read()
-            .unwrap()
-            .get(catalog)
-            .with_context(|| CatalogNotFoundSnafu {
-                catalog_name: catalog,
-            })?
-            .contains_key(schema))
+    async fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>> {
+        if let Some(c) = self.catalog(catalog) {
+            c.schema(schema).await
+        } else {
+            Ok(None)
+        }
    }

    async fn table(
@@ -173,73 +173,27 @@ impl CatalogManager for MemoryCatalogManager {
        schema: &str,
        table_name: &str,
    ) -> Result<Option<TableRef>> {
-        let result = try {
-            self.catalogs
-                .read()
-                .unwrap()
-                .get(catalog)?
-                .get(schema)?
-                .get(table_name)
-                .cloned()?
-        };
-        Ok(result)
+        let Some(catalog) = self
+            .catalog(catalog) else { return Ok(None)};
+        let Some(s) = catalog.schema(schema).await? else { return Ok(None) };
+        s.table(table_name).await
    }

-    async fn catalog_exist(&self, catalog: &str) -> Result<bool> {
-        Ok(self.catalogs.read().unwrap().get(catalog).is_some())
-    }
-
-    async fn table_exist(&self, catalog: &str, schema: &str, table: &str) -> Result<bool> {
-        let catalogs = self.catalogs.read().unwrap();
-        Ok(catalogs
-            .get(catalog)
-            .with_context(|| CatalogNotFoundSnafu {
-                catalog_name: catalog,
-            })?
-            .get(schema)
-            .with_context(|| SchemaNotFoundSnafu { catalog, schema })?
-            .contains_key(table))
+    async fn catalog(&self, catalog: &str) -> Result<Option<CatalogProviderRef>> {
+        Ok(self.catalogs.read().unwrap().get(catalog).cloned())
    }

    async fn catalog_names(&self) -> Result<Vec<String>> {
        Ok(self.catalogs.read().unwrap().keys().cloned().collect())
    }

-    async fn schema_names(&self, catalog_name: &str) -> Result<Vec<String>> {
-        Ok(self
-            .catalogs
-            .read()
-            .unwrap()
-            .get(catalog_name)
-            .with_context(|| CatalogNotFoundSnafu { catalog_name })?
-            .keys()
-            .cloned()
-            .collect())
-    }
-
-    async fn table_names(&self, catalog_name: &str, schema_name: &str) -> Result<Vec<String>> {
-        Ok(self
-            .catalogs
-            .read()
-            .unwrap()
-            .get(catalog_name)
-            .with_context(|| CatalogNotFoundSnafu { catalog_name })?
-            .get(schema_name)
-            .with_context(|| SchemaNotFoundSnafu {
-                catalog: catalog_name,
-                schema: schema_name,
-            })?
-            .keys()
-            .cloned()
-            .collect())
-    }
-
-    async fn register_catalog(&self, name: String) -> Result<bool> {
-        let registered = self.register_catalog_sync(name)?;
-        if registered {
-            increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_CATALOG_COUNT, 1.0);
-        }
-        Ok(registered)
+    async fn register_catalog(
+        &self,
+        name: String,
+        catalog: CatalogProviderRef,
+    ) -> Result<Option<CatalogProviderRef>> {
+        increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_CATALOG_COUNT, 1.0);
+        self.register_catalog_sync(name, catalog)
    }

    fn as_any(&self) -> &dyn Any {
@@ -248,78 +202,206 @@ impl CatalogManager for MemoryCatalogManager {
 }

 impl MemoryCatalogManager {
-    /// Registers a catalog and return the catalog already exist
-    pub fn register_catalog_if_absent(&self, name: String) -> bool {
+    /// Registers a catalog and return `None` if no catalog with the same name was already
+    /// registered, or `Some` with the previously registered catalog.
+    pub fn register_catalog_if_absent(
+        &self,
+        name: String,
+        catalog: CatalogProviderRef,
+    ) -> Option<CatalogProviderRef> {
        let mut catalogs = self.catalogs.write().unwrap();
        let entry = catalogs.entry(name);
        match entry {
-            Entry::Occupied(_) => true,
+            Entry::Occupied(v) => Some(v.get().clone()),
            Entry::Vacant(v) => {
-                let _ = v.insert(HashMap::new());
-                false
+                v.insert(catalog);
+                None
            }
        }
    }

-    pub fn register_catalog_sync(&self, name: String) -> Result<bool> {
+    pub fn register_catalog_sync(
+        &self,
+        name: String,
+        catalog: CatalogProviderRef,
+    ) -> Result<Option<CatalogProviderRef>> {
        let mut catalogs = self.catalogs.write().unwrap();
-        Ok(catalogs.insert(name, HashMap::new()).is_some())
+        Ok(catalogs.insert(name, catalog))
    }

-    pub fn register_schema_sync(&self, request: RegisterSchemaRequest) -> Result<bool> {
-        let mut catalogs = self.catalogs.write().unwrap();
-        let catalog = catalogs
-            .get_mut(&request.catalog)
-            .with_context(|| CatalogNotFoundSnafu {
-                catalog_name: &request.catalog,
-            })?;
-        if catalog.contains_key(&request.schema) {
-            return Ok(false);
+    fn catalog(&self, catalog_name: &str) -> Option<CatalogProviderRef> {
+        self.catalogs.read().unwrap().get(catalog_name).cloned()
+    }
+}
+
+impl Default for MemoryCatalogProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Simple in-memory implementation of a catalog.
+pub struct MemoryCatalogProvider {
+    schemas: RwLock<HashMap<String, Arc<dyn SchemaProvider>>>,
+}
+
+impl MemoryCatalogProvider {
+    /// Instantiates a new MemoryCatalogProvider with an empty collection of schemas.
+    pub fn new() -> Self {
+        Self {
+            schemas: RwLock::new(HashMap::new()),
        }
-        let _ = catalog.insert(request.schema, HashMap::new());
-        Ok(true)
    }

-    pub fn register_table_sync(&self, request: RegisterTableRequest) -> Result<bool> {
-        let mut catalogs = self.catalogs.write().unwrap();
-        let schema = catalogs
-            .get_mut(&request.catalog)
-            .with_context(|| CatalogNotFoundSnafu {
-                catalog_name: &request.catalog,
-            })?
-            .get_mut(&request.schema)
-            .with_context(|| SchemaNotFoundSnafu {
-                catalog: &request.catalog,
-                schema: &request.schema,
-            })?;
+    pub fn schema_names_sync(&self) -> Result<Vec<String>> {
+        let schemas = self.schemas.read().unwrap();
+        Ok(schemas.keys().cloned().collect())
+    }

-        if schema.contains_key(&request.table_name) {
-            return TableExistsSnafu {
-                table: &request.table_name,
+    pub fn register_schema_sync(
+        &self,
+        name: String,
+        schema: SchemaProviderRef,
+    ) -> Result<Option<SchemaProviderRef>> {
+        let mut schemas = self.schemas.write().unwrap();
+        ensure!(
+            !schemas.contains_key(&name),
+            error::SchemaExistsSnafu { schema: &name }
+        );
+        increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_SCHEMA_COUNT, 1.0);
+        Ok(schemas.insert(name, schema))
+    }
+
+    pub fn schema_sync(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>> {
+        let schemas = self.schemas.read().unwrap();
+        Ok(schemas.get(name).cloned())
+    }
+}
+
+#[async_trait::async_trait]
+impl CatalogProvider for MemoryCatalogProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    async fn schema_names(&self) -> Result<Vec<String>> {
+        self.schema_names_sync()
+    }
+
+    async fn register_schema(
+        &self,
+        name: String,
+        schema: SchemaProviderRef,
+    ) -> Result<Option<SchemaProviderRef>> {
+        self.register_schema_sync(name, schema)
+    }
+
+    async fn schema(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>> {
+        self.schema_sync(name)
+    }
+}
+
+/// Simple in-memory implementation of a schema.
+pub struct MemorySchemaProvider {
+    tables: RwLock<HashMap<String, TableRef>>,
+}
+
+impl MemorySchemaProvider {
+    /// Instantiates a new MemorySchemaProvider with an empty collection of tables.
+    pub fn new() -> Self {
+        Self {
+            tables: RwLock::new(HashMap::new()),
+        }
+    }
+
+    pub fn register_table_sync(&self, name: String, table: TableRef) -> Result<Option<TableRef>> {
+        let mut tables = self.tables.write().unwrap();
+        if let Some(existing) = tables.get(name.as_str()) {
+            // if table with the same name but different table id exists, then it's a fatal bug
+            if existing.table_info().ident.table_id != table.table_info().ident.table_id {
+                error!(
+                    "Unexpected table register: {:?}, existing: {:?}",
+                    table.table_info(),
+                    existing.table_info()
+                );
+                return TableExistsSnafu { table: name }.fail()?;
            }
-            .fail();
+            Ok(Some(existing.clone()))
+        } else {
+            Ok(tables.insert(name, table))
        }
-
-        Ok(schema.insert(request.table_name, request.table).is_none())
    }

-    #[cfg(any(test, feature = "testing"))]
-    pub fn new_with_table(table: TableRef) -> Self {
-        let manager = Self::default();
-        let request = RegisterTableRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: table.table_info().name.clone(),
-            table_id: table.table_info().ident.table_id,
-            table,
+    pub fn rename_table_sync(&self, name: &str, new_name: String) -> Result<TableRef> {
+        let mut tables = self.tables.write().unwrap();
+        let Some(table) = tables.remove(name) else {
+            return TableNotFoundSnafu {
+                table_info: name.to_string(),
+            }
+                .fail()?;
        };
-        let _ = manager.register_table_sync(request).unwrap();
-        manager
+        let e = match tables.entry(new_name) {
+            Entry::Vacant(e) => e,
+            Entry::Occupied(e) => {
+                return TableExistsSnafu { table: e.key() }.fail();
+            }
+        };
+        e.insert(table.clone());
+        Ok(table)
+    }
+
+    pub fn table_exist_sync(&self, name: &str) -> Result<bool> {
+        let tables = self.tables.read().unwrap();
+        Ok(tables.contains_key(name))
+    }
+
+    pub fn deregister_table_sync(&self, name: &str) -> Result<Option<TableRef>> {
+        let mut tables = self.tables.write().unwrap();
+        Ok(tables.remove(name))
+    }
+}
+
+impl Default for MemorySchemaProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl SchemaProvider for MemorySchemaProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    async fn table_names(&self) -> Result<Vec<String>> {
+        let tables = self.tables.read().unwrap();
+        Ok(tables.keys().cloned().collect())
+    }
+
+    async fn table(&self, name: &str) -> Result<Option<TableRef>> {
+        let tables = self.tables.read().unwrap();
+        Ok(tables.get(name).cloned())
+    }
+
+    async fn register_table(&self, name: String, table: TableRef) -> Result<Option<TableRef>> {
+        self.register_table_sync(name, table)
+    }
+
+    async fn rename_table(&self, name: &str, new_name: String) -> Result<TableRef> {
+        self.rename_table_sync(name, new_name)
+    }
+
+    async fn deregister_table(&self, name: &str) -> Result<Option<TableRef>> {
+        self.deregister_table_sync(name)
+    }
+
+    async fn table_exist(&self, name: &str) -> Result<bool> {
+        self.table_exist_sync(name)
    }
 }

 /// Create a memory catalog list contains a numbers table for test
-pub fn new_memory_catalog_manager() -> Result<Arc<MemoryCatalogManager>> {
+pub fn new_memory_catalog_list() -> Result<Arc<MemoryCatalogManager>> {
    Ok(Arc::new(MemoryCatalogManager::default()))
 }

@@ -328,99 +410,88 @@ mod tests {
    use common_catalog::consts::*;
    use common_error::ext::ErrorExt;
    use common_error::prelude::StatusCode;
-    use table::table::numbers::{NumbersTable, NUMBERS_TABLE_NAME};
+    use table::table::numbers::NumbersTable;

    use super::*;

    #[tokio::test]
    async fn test_new_memory_catalog_list() {
-        let catalog_list = new_memory_catalog_manager().unwrap();
-
-        let register_request = RegisterTableRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: NUMBERS_TABLE_NAME.to_string(),
-            table_id: NUMBERS_TABLE_ID,
-            table: Arc::new(NumbersTable::default()),
-        };
-
-        let _ = catalog_list.register_table(register_request).await.unwrap();
-        let table = catalog_list
-            .table(
-                DEFAULT_CATALOG_NAME,
-                DEFAULT_SCHEMA_NAME,
-                NUMBERS_TABLE_NAME,
-            )
-            .await
-            .unwrap();
-        let _ = table.unwrap();
-        assert!(catalog_list
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, "not_exists")
+        let catalog_list = new_memory_catalog_list().unwrap();
+        let default_catalog = CatalogManager::catalog(&*catalog_list, DEFAULT_CATALOG_NAME)
            .await
            .unwrap()
-            .is_none());
+            .unwrap();
+
+        let default_schema = default_catalog
+            .schema(DEFAULT_SCHEMA_NAME)
+            .await
+            .unwrap()
+            .unwrap();
+
+        default_schema
+            .register_table("numbers".to_string(), Arc::new(NumbersTable::default()))
+            .await
+            .unwrap();
+
+        let table = default_schema.table("numbers").await.unwrap();
+        assert!(table.is_some());
+        assert!(default_schema.table("not_exists").await.unwrap().is_none());
    }

    #[tokio::test]
-    async fn test_mem_manager_rename_table() {
-        let catalog = MemoryCatalogManager::default();
-        let table_name = "test_table";
-        assert!(!catalog
-            .table_exist(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap());
+    async fn test_mem_provider() {
+        let provider = MemorySchemaProvider::new();
+        let table_name = "numbers";
+        assert!(!provider.table_exist_sync(table_name).unwrap());
+        provider.deregister_table_sync(table_name).unwrap();
+        let test_table = NumbersTable::default();
+        // register table successfully
+        assert!(provider
+            .register_table_sync(table_name.to_string(), Arc::new(test_table))
+            .unwrap()
+            .is_none());
+        assert!(provider.table_exist_sync(table_name).unwrap());
+        let other_table = NumbersTable::new(12);
+        let result = provider.register_table_sync(table_name.to_string(), Arc::new(other_table));
+        let err = result.err().unwrap();
+        assert_eq!(StatusCode::TableAlreadyExists, err.status_code());
+    }
+
+    #[tokio::test]
+    async fn test_mem_provider_rename_table() {
+        let provider = MemorySchemaProvider::new();
+        let table_name = "num";
+        assert!(!provider.table_exist_sync(table_name).unwrap());
+        let test_table: TableRef = Arc::new(NumbersTable::default());
        // register test table
-        let table_id = 2333;
-        let register_request = RegisterTableRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: table_name.to_string(),
-            table_id,
-            table: Arc::new(NumbersTable::new(table_id)),
-        };
-        assert!(catalog.register_table(register_request).await.unwrap());
-        assert!(catalog
-            .table_exist(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap());
+        assert!(provider
+            .register_table_sync(table_name.to_string(), test_table.clone())
+            .unwrap()
+            .is_none());
+        assert!(provider.table_exist_sync(table_name).unwrap());

        // rename test table
-        let new_table_name = "test_table_renamed";
-        let rename_request = RenameTableRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: table_name.to_string(),
-            new_table_name: new_table_name.to_string(),
-            table_id,
-        };
-        let _ = catalog.rename_table(rename_request).await.unwrap();
+        let new_table_name = "numbers";
+        provider
+            .rename_table_sync(table_name, new_table_name.to_string())
+            .unwrap();

        // test old table name not exist
-        assert!(!catalog
-            .table_exist(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap());
+        assert!(!provider.table_exist_sync(table_name).unwrap());
+        provider.deregister_table_sync(table_name).unwrap();

        // test new table name exists
-        assert!(catalog
-            .table_exist(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, new_table_name)
-            .await
-            .unwrap());
-        let registered_table = catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, new_table_name)
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(registered_table.table_info().ident.table_id, table_id);
+        assert!(provider.table_exist_sync(new_table_name).unwrap());
+        let registered_table = provider.table(new_table_name).await.unwrap().unwrap();
+        assert_eq!(
+            registered_table.table_info().ident.table_id,
+            test_table.table_info().ident.table_id
+        );

-        let dup_register_request = RegisterTableRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: new_table_name.to_string(),
-            table_id: table_id + 1,
-            table: Arc::new(NumbersTable::new(table_id + 1)),
-        };
-        let result = catalog.register_table(dup_register_request).await;
+        let other_table = Arc::new(NumbersTable::new(2));
+        let result = provider
+            .register_table(new_table_name.to_string(), other_table)
+            .await;
        let err = result.err().unwrap();
        assert_eq!(StatusCode::TableAlreadyExists, err.status_code());
    }
@@ -428,11 +499,16 @@ mod tests {
    #[tokio::test]
    async fn test_catalog_rename_table() {
        let catalog = MemoryCatalogManager::default();
+        let schema = catalog
+            .schema(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME)
+            .await
+            .unwrap()
+            .unwrap();
+
+        // register table
        let table_name = "num";
        let table_id = 2333;
        let table: TableRef = Arc::new(NumbersTable::new(table_id));
-
-        // register table
        let register_table_req = RegisterTableRequest {
            catalog: DEFAULT_CATALOG_NAME.to_string(),
            schema: DEFAULT_SCHEMA_NAME.to_string(),
@@ -441,11 +517,7 @@ mod tests {
            table,
        };
        assert!(catalog.register_table(register_table_req).await.unwrap());
-        assert!(catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap()
-            .is_some());
+        assert!(schema.table_exist(table_name).await.unwrap());

        // rename table
        let new_table_name = "numbers_new";
@@ -457,16 +529,8 @@ mod tests {
            table_id,
        };
        assert!(catalog.rename_table(rename_table_req).await.unwrap());
-        assert!(catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap()
-            .is_none());
-        assert!(catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, new_table_name)
-            .await
-            .unwrap()
-            .is_some());
+        assert!(!schema.table_exist(table_name).await.unwrap());
+        assert!(schema.table_exist(new_table_name).await.unwrap());

        let registered_table = catalog
            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, new_table_name)
@@ -479,42 +543,50 @@ mod tests {
    #[test]
    pub fn test_register_if_absent() {
        let list = MemoryCatalogManager::default();
-        assert!(!list.register_catalog_if_absent("test_catalog".to_string(),));
-        assert!(list.register_catalog_if_absent("test_catalog".to_string()));
+        assert!(list
+            .register_catalog_if_absent(
+                "test_catalog".to_string(),
+                Arc::new(MemoryCatalogProvider::new())
+            )
+            .is_none());
+        list.register_catalog_if_absent(
+            "test_catalog".to_string(),
+            Arc::new(MemoryCatalogProvider::new()),
+        )
+        .unwrap();
+        list.as_any()
+            .downcast_ref::<MemoryCatalogManager>()
+            .unwrap();
    }

    #[tokio::test]
    pub async fn test_catalog_deregister_table() {
        let catalog = MemoryCatalogManager::default();
-        let table_name = "foo_table";
+        let schema = catalog
+            .schema(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME)
+            .await
+            .unwrap()
+            .unwrap();

        let register_table_req = RegisterTableRequest {
            catalog: DEFAULT_CATALOG_NAME.to_string(),
            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: table_name.to_string(),
+            table_name: "numbers".to_string(),
            table_id: 2333,
            table: Arc::new(NumbersTable::default()),
        };
-        let _ = catalog.register_table(register_table_req).await.unwrap();
-        assert!(catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap()
-            .is_some());
+        catalog.register_table(register_table_req).await.unwrap();
+        assert!(schema.table_exist("numbers").await.unwrap());

        let deregister_table_req = DeregisterTableRequest {
            catalog: DEFAULT_CATALOG_NAME.to_string(),
            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: table_name.to_string(),
+            table_name: "numbers".to_string(),
        };
        catalog
            .deregister_table(deregister_table_req)
            .await
            .unwrap();
-        assert!(catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap()
-            .is_none());
+        assert!(!schema.table_exist("numbers").await.unwrap());
    }
 }
--- a/src/catalog/src/remote.rs
+++ b/src/catalog/src/remote.rs
@@ -20,7 +20,7 @@ use std::sync::Arc;
 pub use client::{CachedMetaKvBackend, MetaKvBackend};
 use futures::Stream;
 use futures_util::StreamExt;
-pub use manager::RemoteCatalogManager;
+pub use manager::{RemoteCatalogManager, RemoteCatalogProvider, RemoteSchemaProvider};

 use crate::error::Error;

--- a/src/catalog/src/remote/client.rs
+++ b/src/catalog/src/remote/client.rs
@@ -240,7 +240,7 @@ impl KvBackend for MetaKvBackend {

    async fn move_value(&self, from_key: &[u8], to_key: &[u8]) -> Result<()> {
        let req = MoveValueRequest::new(from_key, to_key);
-        let _ = self.client.move_value(req).await.context(MetaSrvSnafu)?;
+        self.client.move_value(req).await.context(MetaSrvSnafu)?;
        Ok(())
    }

--- a/src/catalog/src/remote/manager.rs
+++ b/src/catalog/src/remote/manager.rs
--- a/src/catalog/src/remote/mock.rs
+++ b/src/catalog/src/remote/mock.rs
@@ -16,7 +16,8 @@ use std::any::Any;
 use std::collections::btree_map::Entry;
 use std::collections::{BTreeMap, HashMap};
 use std::fmt::{Display, Formatter};
-use std::sync::{Arc, RwLock as StdRwLock};
+use std::str::FromStr;
+use std::sync::Arc;

 use async_stream::stream;
 use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
@@ -26,7 +27,7 @@ use datatypes::data_type::ConcreteDataType;
 use datatypes::schema::{ColumnSchema, Schema};
 use datatypes::vectors::StringVector;
 use serde::Serializer;
-use table::engine::{CloseTableResult, EngineContext, TableEngine};
+use table::engine::{CloseTableResult, EngineContext, TableEngine, TableReference};
 use table::metadata::TableId;
 use table::requests::{
    AlterTableRequest, CloseTableRequest, CreateTableRequest, DropTableRequest, OpenTableRequest,
@@ -45,6 +46,7 @@ pub struct MockKvBackend {

 impl Default for MockKvBackend {
    fn default() -> Self {
+        let mut map = BTreeMap::default();
        let catalog_value = CatalogValue {}.as_bytes().unwrap();
        let schema_value = SchemaValue {}.as_bytes().unwrap();

@@ -59,11 +61,11 @@ impl Default for MockKvBackend {
        }
        .to_string();

-        let map = RwLock::new(BTreeMap::from([
-            // create default catalog and schema
-            (default_catalog_key.into(), catalog_value),
-            (default_schema_key.into(), schema_value),
-        ]));
+        // create default catalog and schema
+        map.insert(default_catalog_key.into(), catalog_value);
+        map.insert(default_schema_key.into(), schema_value);
+
+        let map = RwLock::new(map);
        Self { map }
    }
 }
@@ -108,7 +110,7 @@ impl KvBackend for MockKvBackend {

    async fn set(&self, key: &[u8], val: &[u8]) -> Result<(), Error> {
        let mut map = self.map.write().await;
-        let _ = map.insert(key.to_vec(), val.to_vec());
+        map.insert(key.to_vec(), val.to_vec());
        Ok(())
    }

@@ -123,7 +125,7 @@ impl KvBackend for MockKvBackend {
        match existing {
            Entry::Vacant(e) => {
                if expect.is_empty() {
-                    let _ = e.insert(val.to_vec());
+                    e.insert(val.to_vec());
                    Ok(Ok(()))
                } else {
                    Ok(Err(None))
@@ -131,7 +133,7 @@ impl KvBackend for MockKvBackend {
            }
            Entry::Occupied(mut existing) => {
                if existing.get() == expect {
-                    let _ = existing.insert(val.to_vec());
+                    existing.insert(val.to_vec());
                    Ok(Ok(()))
                } else {
                    Ok(Err(Some(existing.get().clone())))
@@ -165,7 +167,7 @@ impl KvBackend for MockKvBackend {

 #[derive(Default)]
 pub struct MockTableEngine {
-    tables: StdRwLock<HashMap<TableId, TableRef>>,
+    tables: RwLock<HashMap<String, TableRef>>,
 }

 #[async_trait::async_trait]
@@ -180,8 +182,21 @@ impl TableEngine for MockTableEngine {
        _ctx: &EngineContext,
        request: CreateTableRequest,
    ) -> table::Result<TableRef> {
-        let table_id = request.id;
+        let table_name = request.table_name.clone();
+        let catalog_name = request.catalog_name.clone();
+        let schema_name = request.schema_name.clone();
+        let table_full_name =
+            TableReference::full(&catalog_name, &schema_name, &table_name).to_string();

+        let default_table_id = "0".to_owned();
+        let table_id = TableId::from_str(
+            request
+                .table_options
+                .extra_options
+                .get("table_id")
+                .unwrap_or(&default_table_id),
+        )
+        .unwrap();
        let schema = Arc::new(Schema::new(vec![ColumnSchema::new(
            "name",
            ConcreteDataType::string_datatype(),
@@ -191,16 +206,16 @@ impl TableEngine for MockTableEngine {
        let data = vec![Arc::new(StringVector::from(vec!["a", "b", "c"])) as _];
        let record_batch = RecordBatch::new(schema, data).unwrap();
        let table: TableRef = Arc::new(MemTable::new_with_catalog(
-            &request.table_name,
+            &table_name,
            record_batch,
            table_id,
-            request.catalog_name,
-            request.schema_name,
+            catalog_name,
+            schema_name,
            vec![0],
        )) as Arc<_>;

-        let mut tables = self.tables.write().unwrap();
-        let _ = tables.insert(table_id, table.clone() as TableRef);
+        let mut tables = self.tables.write().await;
+        tables.insert(table_full_name, table.clone() as TableRef);
        Ok(table)
    }

@@ -209,7 +224,7 @@ impl TableEngine for MockTableEngine {
        _ctx: &EngineContext,
        request: OpenTableRequest,
    ) -> table::Result<Option<TableRef>> {
-        Ok(self.tables.read().unwrap().get(&request.table_id).cloned())
+        Ok(self.tables.read().await.get(&request.table_name).cloned())
    }

    async fn alter_table(
@@ -223,13 +238,25 @@ impl TableEngine for MockTableEngine {
    fn get_table(
        &self,
        _ctx: &EngineContext,
-        table_id: TableId,
+        table_ref: &TableReference,
    ) -> table::Result<Option<TableRef>> {
-        Ok(self.tables.read().unwrap().get(&table_id).cloned())
+        futures::executor::block_on(async {
+            Ok(self
+                .tables
+                .read()
+                .await
+                .get(&table_ref.to_string())
+                .cloned())
+        })
    }

-    fn table_exists(&self, _ctx: &EngineContext, table_id: TableId) -> bool {
-        self.tables.read().unwrap().contains_key(&table_id)
+    fn table_exists(&self, _ctx: &EngineContext, table_ref: &TableReference) -> bool {
+        futures::executor::block_on(async {
+            self.tables
+                .read()
+                .await
+                .contains_key(&table_ref.to_string())
+        })
    }

    async fn drop_table(
@@ -245,7 +272,11 @@ impl TableEngine for MockTableEngine {
        _ctx: &EngineContext,
        request: CloseTableRequest,
    ) -> table::Result<CloseTableResult> {
-        let _ = self.tables.write().unwrap().remove(&request.table_id);
+        let _ = self
+            .tables
+            .write()
+            .await
+            .remove(&request.table_ref().to_string());
        Ok(CloseTableResult::Released(vec![]))
    }

--- a/src/catalog/src/remote/region_alive_keeper.rs
+++ b/src/catalog/src/remote/region_alive_keeper.rs
@@ -92,7 +92,7 @@ impl RegionAliveKeepers {
        }

        let mut keepers = self.keepers.lock().await;
-        let _ = keepers.insert(table_ident.clone(), keeper.clone());
+        keepers.insert(table_ident.clone(), keeper.clone());

        if self.started.load(Ordering::Relaxed) {
            keeper.start().await;
@@ -237,7 +237,7 @@ impl RegionAliveKeeper {
        let countdown_task_handles = Arc::downgrade(&self.countdown_task_handles);
        let on_task_finished = async move {
            if let Some(x) = countdown_task_handles.upgrade() {
-                let _ = x.lock().await.remove(&region);
+                x.lock().await.remove(&region);
            } // Else the countdown task handles map could be dropped because the keeper is dropped.
        };
        let handle = Arc::new(CountdownTaskHandle::new(
@@ -248,7 +248,7 @@ impl RegionAliveKeeper {
        ));

        let mut handles = self.countdown_task_handles.lock().await;
-        let _ = handles.insert(region, handle.clone());
+        handles.insert(region, handle.clone());

        if self.started.load(Ordering::Relaxed) {
            handle.start(self.heartbeat_interval_millis).await;
@@ -475,7 +475,6 @@ impl CountdownTask {
                catalog_name: table_ident.catalog.clone(),
                schema_name: table_ident.schema.clone(),
                table_name: table_ident.table.clone(),
-                table_id: table_ident.table_id,
                region_numbers: vec![region],
                flush: true,
            };
@@ -500,7 +499,7 @@ mod test {
    use common_meta::heartbeat::mailbox::HeartbeatMailbox;
    use datatypes::schema::RawSchema;
    use table::engine::manager::MemoryTableEngineManager;
-    use table::engine::TableEngine;
+    use table::engine::{TableEngine, TableReference};
    use table::requests::{CreateTableRequest, TableOptions};
    use table::test_util::EmptyTable;

@@ -677,7 +676,7 @@ mod test {
        let region = 1;
        assert!(keeper.find_handle(&region).await.is_none());
        keeper.register_region(region).await;
-        let _ = keeper.find_handle(&region).await.unwrap();
+        assert!(keeper.find_handle(&region).await.is_some());

        let ten_seconds_later = || Instant::now() + Duration::from_secs(10);

@@ -720,7 +719,7 @@ mod test {
        let tx = handle.tx.clone();

        // assert countdown task is running
-        tx.send(CountdownCommand::Start(5000)).await.unwrap();
+        assert!(tx.send(CountdownCommand::Start(5000)).await.is_ok());
        assert!(!finished.load(Ordering::Relaxed));

        drop(handle);
@@ -752,9 +751,8 @@ mod test {
        let catalog = "my_catalog";
        let schema = "my_schema";
        let table = "my_table";
-        let table_id = 1;
        let request = CreateTableRequest {
-            id: table_id,
+            id: 1,
            catalog_name: catalog.to_string(),
            schema_name: schema.to_string(),
            table_name: table.to_string(),
@@ -770,15 +768,16 @@ mod test {
            table_options: TableOptions::default(),
            engine: "mito".to_string(),
        };
+        let table_ref = TableReference::full(catalog, schema, table);

        let table_engine = Arc::new(MockTableEngine::default());
-        let _ = table_engine.create_table(ctx, request).await.unwrap();
+        table_engine.create_table(ctx, request).await.unwrap();

        let table_ident = TableIdent {
            catalog: catalog.to_string(),
            schema: schema.to_string(),
            table: table.to_string(),
-            table_id,
+            table_id: 1024,
            engine: "mito".to_string(),
        };
        let (tx, rx) = mpsc::channel(10);
@@ -788,7 +787,7 @@ mod test {
            region: 1,
            rx,
        };
-        let _handle = common_runtime::spawn_bg(async move {
+        common_runtime::spawn_bg(async move {
            task.run().await;
        });

@@ -814,9 +813,9 @@ mod test {
        .unwrap();

        // assert the table is closed after deadline is reached
-        assert!(table_engine.table_exists(ctx, table_id));
+        assert!(table_engine.table_exists(ctx, &table_ref));
        // spare 500ms for the task to close the table
        tokio::time::sleep(Duration::from_millis(2000)).await;
-        assert!(!table_engine.table_exists(ctx, table_id));
+        assert!(!table_engine.table_exists(ctx, &table_ref));
    }
 }
--- a/src/catalog/src/schema.rs
+++ b/src/catalog/src/schema.rs
@@ -0,0 +1,69 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use table::TableRef;
+
+use crate::error::{NotSupportedSnafu, Result};
+
+/// Represents a schema, comprising a number of named tables.
+#[async_trait]
+pub trait SchemaProvider: Sync + Send {
+    /// Returns the schema provider as [`Any`](std::any::Any)
+    /// so that it can be downcast to a specific implementation.
+    fn as_any(&self) -> &dyn Any;
+
+    /// Retrieves the list of available table names in this schema.
+    async fn table_names(&self) -> Result<Vec<String>>;
+
+    /// Retrieves a specific table from the schema by name, provided it exists.
+    async fn table(&self, name: &str) -> Result<Option<TableRef>>;
+
+    /// If supported by the implementation, adds a new table to this schema.
+    /// If a table of the same name existed before, it returns "Table already exists" error.
+    async fn register_table(&self, name: String, _table: TableRef) -> Result<Option<TableRef>> {
+        NotSupportedSnafu {
+            op: format!("register_table({name}, <table>)"),
+        }
+        .fail()
+    }
+
+    /// If supported by the implementation, renames an existing table from this schema and returns it.
+    /// If no table of that name exists, returns "Table not found" error.
+    async fn rename_table(&self, name: &str, new_name: String) -> Result<TableRef> {
+        NotSupportedSnafu {
+            op: format!("rename_table({name}, {new_name})"),
+        }
+        .fail()
+    }
+
+    /// If supported by the implementation, removes an existing table from this schema and returns it.
+    /// If no table of that name exists, returns Ok(None).
+    async fn deregister_table(&self, name: &str) -> Result<Option<TableRef>> {
+        NotSupportedSnafu {
+            op: format!("deregister_table({name})"),
+        }
+        .fail()
+    }
+
+    /// If supported by the implementation, checks the table exist in the schema provider or not.
+    /// If no matched table in the schema provider, return false.
+    /// Otherwise, return true.
+    async fn table_exist(&self, name: &str) -> Result<bool>;
+}
+
+pub type SchemaProviderRef = Arc<dyn SchemaProvider>;
--- a/src/catalog/src/system.rs
+++ b/src/catalog/src/system.rs
@@ -20,6 +20,8 @@ use common_catalog::consts::{
    DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, INFORMATION_SCHEMA_NAME, MITO_ENGINE,
    SYSTEM_CATALOG_NAME, SYSTEM_CATALOG_TABLE_ID, SYSTEM_CATALOG_TABLE_NAME,
 };
+use common_query::logical_plan::Expr;
+use common_query::physical_plan::{PhysicalPlanRef, SessionContext};
 use common_recordbatch::SendableRecordBatchStream;
 use common_telemetry::debug;
 use common_time::util;
@@ -58,6 +60,15 @@ impl Table for SystemCatalogTable {
        self.0.schema()
    }

+    async fn scan(
+        &self,
+        projection: Option<&Vec<usize>>,
+        filters: &[Expr],
+        limit: Option<usize>,
+    ) -> table::Result<PhysicalPlanRef> {
+        self.0.scan(projection, filters, limit).await
+    }
+
    async fn scan_to_stream(&self, request: ScanRequest) -> TableResult<SendableRecordBatchStream> {
        self.0.scan_to_stream(request).await
    }
@@ -125,17 +136,14 @@ impl SystemCatalogTable {
    /// Create a stream of all entries inside system catalog table
    pub async fn records(&self) -> Result<SendableRecordBatchStream> {
        let full_projection = None;
-        let scan_req = ScanRequest {
-            sequence: None,
-            projection: full_projection,
-            filters: vec![],
-            output_ordering: None,
-            limit: None,
-        };
-        let stream = self
-            .scan_to_stream(scan_req)
+        let ctx = SessionContext::new();
+        let scan = self
+            .scan(full_projection, &[], None)
            .await
            .context(error::SystemCatalogTableScanSnafu)?;
+        let stream = scan
+            .execute(0, ctx.task_ctx())
+            .context(error::SystemCatalogTableScanExecSnafu)?;
        Ok(stream)
    }
 }
@@ -220,21 +228,21 @@ pub(crate) fn build_table_deletion_request(
 }

 fn build_primary_key_columns(entry_type: EntryType, key: &[u8]) -> HashMap<String, VectorRef> {
-    HashMap::from([
-        (
-            "entry_type".to_string(),
-            Arc::new(UInt8Vector::from_slice([entry_type as u8])) as VectorRef,
-        ),
-        (
-            "key".to_string(),
-            Arc::new(BinaryVector::from_slice(&[key])) as VectorRef,
-        ),
-        (
-            "timestamp".to_string(),
-            // Timestamp in key part is intentionally left to 0
-            Arc::new(TimestampMillisecondVector::from_slice([0])) as VectorRef,
-        ),
-    ])
+    let mut m = HashMap::with_capacity(3);
+    m.insert(
+        "entry_type".to_string(),
+        Arc::new(UInt8Vector::from_slice([entry_type as u8])) as _,
+    );
+    m.insert(
+        "key".to_string(),
+        Arc::new(BinaryVector::from_slice(&[key])) as _,
+    );
+    // Timestamp in key part is intentionally left to 0
+    m.insert(
+        "timestamp".to_string(),
+        Arc::new(TimestampMillisecondVector::from_slice([0])) as _,
+    );
+    m
 }

 pub fn build_schema_insert_request(catalog_name: String, schema_name: String) -> InsertRequest {
@@ -254,18 +262,18 @@ pub fn build_insert_request(entry_type: EntryType, key: &[u8], value: &[u8]) ->
    let mut columns_values = HashMap::with_capacity(6);
    columns_values.extend(primary_key_columns.into_iter());

-    let _ = columns_values.insert(
+    columns_values.insert(
        "value".to_string(),
        Arc::new(BinaryVector::from_slice(&[value])) as _,
    );

    let now = util::current_time_millis();
-    let _ = columns_values.insert(
+    columns_values.insert(
        "gmt_created".to_string(),
        Arc::new(TimestampMillisecondVector::from_slice([now])) as _,
    );

-    let _ = columns_values.insert(
+    columns_values.insert(
        "gmt_modified".to_string(),
        Arc::new(TimestampMillisecondVector::from_slice([now])) as _,
    );
@@ -474,13 +482,14 @@ mod tests {
    }

    #[test]
+    #[should_panic]
    pub fn test_decode_mismatch() {
-        assert!(decode_system_catalog(
+        decode_system_catalog(
            Some(EntryType::Table as u8),
            Some("some_catalog.some_schema.42".as_bytes()),
            None,
        )
-        .is_err());
+        .unwrap();
    }

    #[test]
@@ -495,7 +504,7 @@ mod tests {
        let dir = create_temp_dir("system-table-test");
        let store_dir = dir.path().to_string_lossy();
        let mut builder = object_store::services::Fs::default();
-        let _ = builder.root(&store_dir);
+        builder.root(&store_dir);
        let object_store = ObjectStore::new(builder).unwrap().finish();
        let noop_compaction_scheduler = Arc::new(NoopCompactionScheduler::default());
        let table_engine = Arc::new(MitoEngine::new(
--- a/src/catalog/src/table_source.rs
+++ b/src/catalog/src/table_source.rs
@@ -24,7 +24,10 @@ use session::context::QueryContext;
 use snafu::{ensure, OptionExt};
 use table::table::adapter::DfTableProviderAdapter;

-use crate::error::{QueryAccessDeniedSnafu, Result, TableNotExistSnafu};
+use crate::error::{
+    CatalogNotFoundSnafu, QueryAccessDeniedSnafu, Result, SchemaNotFoundSnafu, TableNotExistSnafu,
+};
+use crate::information_schema::InformationSchemaProvider;
 use crate::CatalogManagerRef;

 pub struct DfTableSourceProvider {
@@ -101,18 +104,41 @@ impl DfTableSourceProvider {
        let schema_name = table_ref.schema.as_ref();
        let table_name = table_ref.table.as_ref();

-        let table = self
-            .catalog_manager
-            .table(catalog_name, schema_name, table_name)
+        let schema = if schema_name != INFORMATION_SCHEMA_NAME {
+            let catalog = self
+                .catalog_manager
+                .catalog(catalog_name)
+                .await?
+                .context(CatalogNotFoundSnafu { catalog_name })?;
+            catalog
+                .schema(schema_name)
+                .await?
+                .context(SchemaNotFoundSnafu {
+                    catalog: catalog_name,
+                    schema: schema_name,
+                })?
+        } else {
+            let catalog_provider = self
+                .catalog_manager
+                .catalog(catalog_name)
+                .await?
+                .context(CatalogNotFoundSnafu { catalog_name })?;
+            Arc::new(InformationSchemaProvider::new(
+                catalog_name.to_string(),
+                catalog_provider,
+            ))
+        };
+        let table = schema
+            .table(table_name)
            .await?
            .with_context(|| TableNotExistSnafu {
                table: format_full_table_name(catalog_name, schema_name, table_name),
            })?;

-        let provider = DfTableProviderAdapter::new(table);
-        let source = provider_as_source(Arc::new(provider));
-        let _ = self.resolved_tables.insert(resolved_name, source.clone());
-        Ok(source)
+        let table = DfTableProviderAdapter::new(table);
+        let table = provider_as_source(Arc::new(table));
+        self.resolved_tables.insert(resolved_name, table.clone());
+        Ok(table)
    }
 }

@@ -136,14 +162,14 @@ mod tests {
            table: Cow::Borrowed("table_name"),
        };
        let result = table_provider.resolve_table_ref(table_ref);
-        let _ = result.unwrap();
+        assert!(result.is_ok());

        let table_ref = TableReference::Partial {
            schema: Cow::Borrowed("public"),
            table: Cow::Borrowed("table_name"),
        };
        let result = table_provider.resolve_table_ref(table_ref);
-        let _ = result.unwrap();
+        assert!(result.is_ok());

        let table_ref = TableReference::Partial {
            schema: Cow::Borrowed("wrong_schema"),
@@ -158,7 +184,7 @@ mod tests {
            table: Cow::Borrowed("table_name"),
        };
        let result = table_provider.resolve_table_ref(table_ref);
-        let _ = result.unwrap();
+        assert!(result.is_ok());

        let table_ref = TableReference::Full {
            catalog: Cow::Borrowed("wrong_catalog"),
@@ -172,14 +198,14 @@ mod tests {
            schema: Cow::Borrowed("information_schema"),
            table: Cow::Borrowed("columns"),
        };
-        let _ = table_provider.resolve_table_ref(table_ref).unwrap();
+        assert!(table_provider.resolve_table_ref(table_ref).is_ok());

        let table_ref = TableReference::Full {
            catalog: Cow::Borrowed("greptime"),
            schema: Cow::Borrowed("information_schema"),
            table: Cow::Borrowed("columns"),
        };
-        let _ = table_provider.resolve_table_ref(table_ref).unwrap();
+        assert!(table_provider.resolve_table_ref(table_ref).is_ok());

        let table_ref = TableReference::Full {
            catalog: Cow::Borrowed("dummy"),
--- a/src/catalog/src/tables.rs
+++ b/src/catalog/src/tables.rs
@@ -14,24 +14,50 @@

 // The `tables` table in system catalog keeps a record of all tables created by user.

+use std::any::Any;
 use std::sync::Arc;

+use async_trait::async_trait;
+use common_catalog::consts::{INFORMATION_SCHEMA_NAME, SYSTEM_CATALOG_TABLE_NAME};
 use common_telemetry::logging;
 use snafu::ResultExt;
 use table::metadata::TableId;
-use table::Table;
+use table::{Table, TableRef};

-use crate::error::{self, InsertCatalogRecordSnafu, Result as CatalogResult};
+use crate::error::{self, Error, InsertCatalogRecordSnafu, Result as CatalogResult};
 use crate::system::{
    build_schema_insert_request, build_table_deletion_request, build_table_insert_request,
    SystemCatalogTable,
 };
-use crate::DeregisterTableRequest;
+use crate::{CatalogProvider, DeregisterTableRequest, SchemaProvider, SchemaProviderRef};

 pub struct InformationSchema {
    pub system: Arc<SystemCatalogTable>,
 }

+#[async_trait]
+impl SchemaProvider for InformationSchema {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    async fn table_names(&self) -> Result<Vec<String>, Error> {
+        Ok(vec![SYSTEM_CATALOG_TABLE_NAME.to_string()])
+    }
+
+    async fn table(&self, name: &str) -> Result<Option<TableRef>, Error> {
+        if name.eq_ignore_ascii_case(SYSTEM_CATALOG_TABLE_NAME) {
+            Ok(Some(self.system.clone()))
+        } else {
+            Ok(None)
+        }
+    }
+
+    async fn table_exist(&self, name: &str) -> Result<bool, Error> {
+        Ok(name.eq_ignore_ascii_case(SYSTEM_CATALOG_TABLE_NAME))
+    }
+}
+
 pub struct SystemCatalog {
    pub information_schema: Arc<InformationSchema>,
 }
@@ -99,3 +125,30 @@ impl SystemCatalog {
            .context(InsertCatalogRecordSnafu)
    }
 }
+
+#[async_trait::async_trait]
+impl CatalogProvider for SystemCatalog {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    async fn schema_names(&self) -> Result<Vec<String>, Error> {
+        Ok(vec![INFORMATION_SCHEMA_NAME.to_string()])
+    }
+
+    async fn register_schema(
+        &self,
+        _name: String,
+        _schema: SchemaProviderRef,
+    ) -> Result<Option<SchemaProviderRef>, Error> {
+        panic!("System catalog does not support registering schema!")
+    }
+
+    async fn schema(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>, Error> {
+        if name.eq_ignore_ascii_case(INFORMATION_SCHEMA_NAME) {
+            Ok(Some(self.information_schema.clone()))
+        } else {
+            Ok(None)
+        }
+    }
+}
--- a/src/catalog/tests/remote_catalog_tests.rs
+++ b/src/catalog/tests/remote_catalog_tests.rs
@@ -24,8 +24,11 @@ mod tests {
    use catalog::helper::{CatalogKey, CatalogValue, SchemaKey, SchemaValue};
    use catalog::remote::mock::{MockKvBackend, MockTableEngine};
    use catalog::remote::region_alive_keeper::RegionAliveKeepers;
-    use catalog::remote::{CachedMetaKvBackend, KvBackend, KvBackendRef, RemoteCatalogManager};
-    use catalog::{CatalogManager, RegisterSchemaRequest, RegisterTableRequest};
+    use catalog::remote::{
+        CachedMetaKvBackend, KvBackend, KvBackendRef, RemoteCatalogManager, RemoteCatalogProvider,
+        RemoteSchemaProvider,
+    };
+    use catalog::{CatalogManager, RegisterTableRequest};
    use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, MITO_ENGINE};
    use common_meta::ident::TableIdent;
    use datatypes::schema::RawSchema;
@@ -37,7 +40,6 @@ mod tests {
    use tokio::time::Instant;

    struct TestingComponents {
-        #[allow(dead_code)]
        kv_backend: KvBackendRef,
        catalog_manager: Arc<RemoteCatalogManager>,
        table_engine_manager: TableEngineManagerRef,
@@ -82,7 +84,7 @@ mod tests {
        let mut res = HashSet::new();
        while let Some(r) = iter.next().await {
            let kv = r.unwrap();
-            let _ = res.insert(String::from_utf8_lossy(&kv.0).to_string());
+            res.insert(String::from_utf8_lossy(&kv.0).to_string());
        }
        assert_eq!(
            vec!["__c-greptime".to_string()],
@@ -109,7 +111,7 @@ mod tests {
            .unwrap();

        let ret = backend.get(b"__c-greptime").await.unwrap();
-        let _ = ret.unwrap();
+        assert!(ret.is_some());

        let _ = backend
            .compare_and_set(
@@ -121,11 +123,13 @@ mod tests {
            .unwrap();

        let ret = backend.get(b"__c-greptime").await.unwrap();
+        assert!(ret.is_some());
        assert_eq!(&b"123"[..], &(ret.as_ref().unwrap().1));

        let _ = backend.set(b"__c-greptime", b"1234").await;

        let ret = backend.get(b"__c-greptime").await.unwrap();
+        assert!(ret.is_some());
        assert_eq!(&b"1234"[..], &(ret.as_ref().unwrap().1));

        backend.delete(b"__c-greptime").await.unwrap();
@@ -175,12 +179,14 @@ mod tests {
            catalog_manager.catalog_names().await.unwrap()
        );

+        let default_catalog = catalog_manager
+            .catalog(DEFAULT_CATALOG_NAME)
+            .await
+            .unwrap()
+            .unwrap();
        assert_eq!(
            vec![DEFAULT_SCHEMA_NAME.to_string()],
-            catalog_manager
-                .schema_names(DEFAULT_CATALOG_NAME)
-                .await
-                .unwrap()
+            default_catalog.schema_names().await.unwrap()
        );
    }

@@ -236,15 +242,23 @@ mod tests {
    async fn test_register_table() {
        let node_id = 42;
        let components = prepare_components(node_id).await;
+        let catalog_manager = &components.catalog_manager;
+        let default_catalog = catalog_manager
+            .catalog(DEFAULT_CATALOG_NAME)
+            .await
+            .unwrap()
+            .unwrap();
        assert_eq!(
            vec![DEFAULT_SCHEMA_NAME.to_string()],
-            components
-                .catalog_manager
-                .schema_names(DEFAULT_CATALOG_NAME)
-                .await
-                .unwrap()
+            default_catalog.schema_names().await.unwrap()
        );

+        let default_schema = default_catalog
+            .schema(DEFAULT_SCHEMA_NAME)
+            .await
+            .unwrap()
+            .unwrap();
+
        // register a new table with an nonexistent catalog
        let catalog_name = DEFAULT_CATALOG_NAME.to_string();
        let schema_name = DEFAULT_SCHEMA_NAME.to_string();
@@ -279,18 +293,10 @@ mod tests {
            table_id,
            table,
        };
-        assert!(components
-            .catalog_manager
-            .register_table(reg_req)
-            .await
-            .unwrap());
+        assert!(catalog_manager.register_table(reg_req).await.unwrap());
        assert_eq!(
            vec![table_name],
-            components
-                .catalog_manager
-                .table_names(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME)
-                .await
-                .unwrap()
+            default_schema.table_names().await.unwrap()
        );
    }

@@ -298,28 +304,29 @@ mod tests {
    async fn test_register_catalog_schema_table() {
        let node_id = 42;
        let components = prepare_components(node_id).await;
+        let backend = &components.kv_backend;
+        let catalog_manager = components.catalog_manager.clone();
+        let engine_manager = components.table_engine_manager.clone();

        let catalog_name = "test_catalog".to_string();
        let schema_name = "nonexistent_schema".to_string();
+        let catalog = Arc::new(RemoteCatalogProvider::new(
+            catalog_name.clone(),
+            backend.clone(),
+            engine_manager.clone(),
+            node_id,
+            components.region_alive_keepers.clone(),
+        ));

        // register catalog to catalog manager
-        assert!(components
-            .catalog_manager
-            .register_catalog(catalog_name.clone())
+        CatalogManager::register_catalog(&*catalog_manager, catalog_name.clone(), catalog)
            .await
-            .is_ok());
+            .unwrap();
        assert_eq!(
            HashSet::<String>::from_iter(
                vec![DEFAULT_CATALOG_NAME.to_string(), catalog_name.clone()].into_iter()
            ),
-            HashSet::from_iter(
-                components
-                    .catalog_manager
-                    .catalog_names()
-                    .await
-                    .unwrap()
-                    .into_iter()
-            )
+            HashSet::from_iter(catalog_manager.catalog_names().await.unwrap().into_iter())
        );

        let table_to_register = components
@@ -352,34 +359,38 @@ mod tests {
        };
        // this register will fail since schema does not exist yet
        assert_matches!(
-            components
-                .catalog_manager
+            catalog_manager
                .register_table(reg_req.clone())
                .await
                .unwrap_err(),
            catalog::error::Error::SchemaNotFound { .. }
        );

-        let register_schema_request = RegisterSchemaRequest {
-            catalog: catalog_name.to_string(),
-            schema: schema_name.to_string(),
-        };
-        assert!(components
-            .catalog_manager
-            .register_schema(register_schema_request)
+        let new_catalog = catalog_manager
+            .catalog(&catalog_name)
            .await
-            .expect("Register schema should not fail"));
-        assert!(components
-            .catalog_manager
-            .register_table(reg_req)
+            .unwrap()
+            .expect("catalog should exist since it's already registered");
+        let schema = Arc::new(RemoteSchemaProvider::new(
+            catalog_name.clone(),
+            schema_name.clone(),
+            node_id,
+            engine_manager,
+            backend.clone(),
+            components.region_alive_keepers.clone(),
+        ));
+
+        let prev = new_catalog
+            .register_schema(schema_name.clone(), schema.clone())
            .await
-            .unwrap());
+            .expect("Register schema should not fail");
+        assert!(prev.is_none());
+        assert!(catalog_manager.register_table(reg_req).await.unwrap());

        assert_eq!(
            HashSet::from([schema_name.clone()]),
-            components
-                .catalog_manager
-                .schema_names(&catalog_name)
+            new_catalog
+                .schema_names()
                .await
                .unwrap()
                .into_iter()
--- a/src/client/Cargo.toml
+++ b/src/client/Cargo.toml
@@ -36,7 +36,6 @@ tonic.workspace = true

 [dev-dependencies]
 datanode = { path = "../datanode" }
-derive-new = "0.5"
 substrait = { path = "../common/substrait" }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
--- a/src/client/examples/stream_ingest.rs
+++ b/src/client/examples/stream_ingest.rs
@@ -1,183 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use api::v1::column::*;
-use api::v1::*;
-use client::{Client, Database, DEFAULT_SCHEMA_NAME};
-use derive_new::new;
-use tracing::{error, info};
-
-fn main() {
-    tracing::subscriber::set_global_default(tracing_subscriber::FmtSubscriber::builder().finish())
-        .unwrap();
-
-    run();
-}
-
-#[tokio::main]
-async fn run() {
-    let greptimedb_endpoint =
-        std::env::var("GREPTIMEDB_ENDPOINT").unwrap_or_else(|_| "localhost:4001".to_owned());
-
-    let greptimedb_dbname =
-        std::env::var("GREPTIMEDB_DBNAME").unwrap_or_else(|_| DEFAULT_SCHEMA_NAME.to_owned());
-
-    let grpc_client = Client::with_urls(vec![&greptimedb_endpoint]);
-
-    let client = Database::new_with_dbname(greptimedb_dbname, grpc_client);
-
-    let stream_inserter = client.streaming_inserter().unwrap();
-
-    if let Err(e) = stream_inserter
-        .insert(vec![to_insert_request(weather_records_1())])
-        .await
-    {
-        error!("Error: {e}");
-    }
-
-    if let Err(e) = stream_inserter
-        .insert(vec![to_insert_request(weather_records_2())])
-        .await
-    {
-        error!("Error: {e}");
-    }
-
-    let result = stream_inserter.finish().await;
-
-    match result {
-        Ok(rows) => {
-            info!("Rows written: {rows}");
-        }
-        Err(e) => {
-            error!("Error: {e}");
-        }
-    };
-}
-
-#[derive(new)]
-struct WeatherRecord {
-    timestamp_millis: i64,
-    collector: String,
-    temperature: f32,
-    humidity: i32,
-}
-
-fn weather_records_1() -> Vec<WeatherRecord> {
-    vec![
-        WeatherRecord::new(1686109527000, "c1".to_owned(), 26.4, 15),
-        WeatherRecord::new(1686023127000, "c1".to_owned(), 29.3, 20),
-        WeatherRecord::new(1685936727000, "c1".to_owned(), 31.8, 13),
-        WeatherRecord::new(1686109527000, "c2".to_owned(), 20.4, 67),
-        WeatherRecord::new(1686023127000, "c2".to_owned(), 18.0, 74),
-        WeatherRecord::new(1685936727000, "c2".to_owned(), 19.2, 81),
-    ]
-}
-
-fn weather_records_2() -> Vec<WeatherRecord> {
-    vec![
-        WeatherRecord::new(1686109527001, "c3".to_owned(), 26.4, 15),
-        WeatherRecord::new(1686023127002, "c3".to_owned(), 29.3, 20),
-        WeatherRecord::new(1685936727003, "c3".to_owned(), 31.8, 13),
-        WeatherRecord::new(1686109527004, "c4".to_owned(), 20.4, 67),
-        WeatherRecord::new(1686023127005, "c4".to_owned(), 18.0, 74),
-        WeatherRecord::new(1685936727006, "c4".to_owned(), 19.2, 81),
-    ]
-}
-
-/// This function generates some random data and bundle them into a
-/// `InsertRequest`.
-///
-/// Data structure:
-///
-/// - `ts`: a timestamp column
-/// - `collector`: a tag column
-/// - `temperature`: a value field of f32
-/// - `humidity`: a value field of i32
-///
-fn to_insert_request(records: Vec<WeatherRecord>) -> InsertRequest {
-    // convert records into columns
-    let rows = records.len();
-
-    // transpose records into columns
-    let (timestamp_millis, collectors, temp, humidity) = records.into_iter().fold(
-        (
-            Vec::with_capacity(rows),
-            Vec::with_capacity(rows),
-            Vec::with_capacity(rows),
-            Vec::with_capacity(rows),
-        ),
-        |mut acc, rec| {
-            acc.0.push(rec.timestamp_millis);
-            acc.1.push(rec.collector);
-            acc.2.push(rec.temperature);
-            acc.3.push(rec.humidity);
-
-            acc
-        },
-    );
-
-    let columns = vec![
-        // timestamp column: `ts`
-        Column {
-            column_name: "ts".to_owned(),
-            values: Some(column::Values {
-                ts_millisecond_values: timestamp_millis,
-                ..Default::default()
-            }),
-            semantic_type: SemanticType::Timestamp as i32,
-            datatype: ColumnDataType::TimestampMillisecond as i32,
-            ..Default::default()
-        },
-        // tag column: collectors
-        Column {
-            column_name: "collector".to_owned(),
-            values: Some(column::Values {
-                string_values: collectors.into_iter().collect(),
-                ..Default::default()
-            }),
-            semantic_type: SemanticType::Tag as i32,
-            datatype: ColumnDataType::String as i32,
-            ..Default::default()
-        },
-        // field column: temperature
-        Column {
-            column_name: "temperature".to_owned(),
-            values: Some(column::Values {
-                f32_values: temp,
-                ..Default::default()
-            }),
-            semantic_type: SemanticType::Field as i32,
-            datatype: ColumnDataType::Float32 as i32,
-            ..Default::default()
-        },
-        // field column: humidity
-        Column {
-            column_name: "humidity".to_owned(),
-            values: Some(column::Values {
-                i32_values: humidity,
-                ..Default::default()
-            }),
-            semantic_type: SemanticType::Field as i32,
-            datatype: ColumnDataType::Int32 as i32,
-            ..Default::default()
-        },
-    ];
-
-    InsertRequest {
-        table_name: "weather_demo".to_owned(),
-        columns,
-        row_count: rows as u32,
-        ..Default::default()
-    }
-}
--- a/src/client/src/client.rs
+++ b/src/client/src/client.rs
@@ -165,7 +165,7 @@ impl Client {
    pub async fn health_check(&self) -> Result<()> {
        let (_, channel) = self.find_channel()?;
        let mut client = HealthCheckClient::new(channel);
-        let _ = client.health_check(HealthCheckRequest {}).await?;
+        client.health_check(HealthCheckRequest {}).await?;
        Ok(())
    }
 }
--- a/src/client/src/database.rs
+++ b/src/client/src/database.rs
@@ -29,11 +29,14 @@ use common_telemetry::{logging, timer};
 use futures_util::{TryFutureExt, TryStreamExt};
 use prost::Message;
 use snafu::{ensure, ResultExt};
+use tokio::sync::mpsc::Sender;
+use tokio::sync::{mpsc, OnceCell};
+use tokio_stream::wrappers::ReceiverStream;

 use crate::error::{
    ConvertFlightDataSnafu, IllegalDatabaseResponseSnafu, IllegalFlightMessagesSnafu,
 };
-use crate::{error, metrics, Client, Result, StreamInserter};
+use crate::{error, metrics, Client, Result};

 #[derive(Clone, Debug, Default)]
 pub struct Database {
@@ -47,6 +50,7 @@ pub struct Database {
    dbname: String,

    client: Client,
+    streaming_client: OnceCell<Sender<GreptimeRequest>>,
    ctx: FlightContext,
 }

@@ -58,6 +62,7 @@ impl Database {
            schema: schema.into(),
            dbname: "".to_string(),
            client,
+            streaming_client: OnceCell::new(),
            ctx: FlightContext::default(),
        }
    }
@@ -75,6 +80,7 @@ impl Database {
            schema: "".to_string(),
            dbname: dbname.into(),
            client,
+            streaming_client: OnceCell::new(),
            ctx: FlightContext::default(),
        }
    }
@@ -114,24 +120,20 @@ impl Database {
        self.handle(Request::Inserts(requests)).await
    }

-    pub fn streaming_inserter(&self) -> Result<StreamInserter> {
-        self.streaming_inserter_with_channel_size(65536)
-    }
+    pub async fn insert_to_stream(&self, requests: InsertRequests) -> Result<()> {
+        let streaming_client = self
+            .streaming_client
+            .get_or_try_init(|| self.client_stream())
+            .await?;

-    pub fn streaming_inserter_with_channel_size(
-        &self,
-        channel_size: usize,
-    ) -> Result<StreamInserter> {
-        let client = self.client.make_database_client()?.inner;
+        let request = self.to_rpc_request(Request::Inserts(requests));

-        let stream_inserter = StreamInserter::new(
-            client,
-            self.dbname().to_string(),
-            self.ctx.auth_header.clone(),
-            channel_size,
-        );
-
-        Ok(stream_inserter)
+        streaming_client.send(request).await.map_err(|e| {
+            error::ClientStreamingSnafu {
+                err_msg: e.to_string(),
+            }
+            .build()
+        })
    }

    pub async fn delete(&self, request: DeleteRequest) -> Result<u32> {
@@ -167,6 +169,14 @@ impl Database {
        }
    }

+    async fn client_stream(&self) -> Result<Sender<GreptimeRequest>> {
+        let mut client = self.client.make_database_client()?.inner;
+        let (sender, receiver) = mpsc::channel::<GreptimeRequest>(65536);
+        let receiver = ReceiverStream::new(receiver);
+        client.handle_requests(receiver).await?;
+        Ok(sender)
+    }
+
    pub async fn sql(&self, sql: &str) -> Result<Output> {
        let _timer = timer!(metrics::METRIC_GRPC_SQL);
        self.do_get(Request::Query(QueryRequest {
--- a/src/client/src/lib.rs
+++ b/src/client/src/lib.rs
@@ -18,7 +18,6 @@ mod database;
 mod error;
 pub mod load_balance;
 mod metrics;
-mod stream_insert;

 pub use api;
 pub use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
@@ -26,4 +25,3 @@ pub use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
 pub use self::client::Client;
 pub use self::database::Database;
 pub use self::error::{Error, Result};
-pub use self::stream_insert::StreamInserter;
--- a/src/client/src/load_balance.rs
+++ b/src/client/src/load_balance.rs
@@ -60,7 +60,7 @@ mod tests {
        let random = Random;
        for _ in 0..100 {
            let peer = random.get_peer(&peers).unwrap();
-            assert!(all.contains(peer));
+            all.contains(peer);
        }
    }
 }
--- a/src/client/src/stream_insert.rs
+++ b/src/client/src/stream_insert.rs
@@ -1,115 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use api::v1::greptime_database_client::GreptimeDatabaseClient;
-use api::v1::greptime_request::Request;
-use api::v1::{
-    greptime_response, AffectedRows, AuthHeader, GreptimeRequest, GreptimeResponse, InsertRequest,
-    InsertRequests, RequestHeader,
-};
-use snafu::OptionExt;
-use tokio::sync::mpsc;
-use tokio::task::JoinHandle;
-use tokio_stream::wrappers::ReceiverStream;
-use tonic::transport::Channel;
-use tonic::{Response, Status};
-
-use crate::error::{self, IllegalDatabaseResponseSnafu, Result};
-
-/// A structure that provides some methods for streaming data insert.
-///
-/// [`StreamInserter`] cannot be constructed via the `StreamInserter::new` method.
-/// You can use the following way to obtain [`StreamInserter`].
-///
-/// ```ignore
-/// let grpc_client = Client::with_urls(vec!["127.0.0.1:4002"]);
-/// let client = Database::new_with_dbname("db_name", grpc_client);
-/// let stream_inserter = client.streaming_inserter().unwrap();
-/// ```
-///
-/// If you want to see a concrete usage example, please see
-/// [stream_inserter.rs](https://github.com/GreptimeTeam/greptimedb/blob/develop/src/client/examples/stream_ingest.rs).
-pub struct StreamInserter {
-    sender: mpsc::Sender<GreptimeRequest>,
-
-    auth_header: Option<AuthHeader>,
-
-    dbname: String,
-
-    join: JoinHandle<std::result::Result<Response<GreptimeResponse>, Status>>,
-}
-
-impl StreamInserter {
-    pub(crate) fn new(
-        mut client: GreptimeDatabaseClient<Channel>,
-        dbname: String,
-        auth_header: Option<AuthHeader>,
-        channel_size: usize,
-    ) -> StreamInserter {
-        let (send, recv) = tokio::sync::mpsc::channel(channel_size);
-
-        let join: JoinHandle<std::result::Result<Response<GreptimeResponse>, Status>> =
-            tokio::spawn(async move {
-                let recv_stream = ReceiverStream::new(recv);
-                client.handle_requests(recv_stream).await
-            });
-
-        StreamInserter {
-            sender: send,
-            auth_header,
-            dbname,
-            join,
-        }
-    }
-
-    pub async fn insert(&self, requests: Vec<InsertRequest>) -> Result<()> {
-        let inserts = InsertRequests { inserts: requests };
-        let request = self.to_rpc_request(Request::Inserts(inserts));
-
-        self.sender.send(request).await.map_err(|e| {
-            error::ClientStreamingSnafu {
-                err_msg: e.to_string(),
-            }
-            .build()
-        })
-    }
-
-    pub async fn finish(self) -> Result<u32> {
-        drop(self.sender);
-
-        let response = self.join.await.unwrap()?;
-
-        let response = response
-            .into_inner()
-            .response
-            .context(IllegalDatabaseResponseSnafu {
-                err_msg: "GreptimeResponse is empty",
-            })?;
-
-        let greptime_response::Response::AffectedRows(AffectedRows { value }) = response;
-
-        Ok(value)
-    }
-
-    fn to_rpc_request(&self, request: Request) -> GreptimeRequest {
-        GreptimeRequest {
-            header: Some(RequestHeader {
-                authorization: self.auth_header.clone(),
-                dbname: self.dbname.clone(),
-                ..Default::default()
-            }),
-            request: Some(request),
-        }
-    }
-}
--- a/src/cmd/src/cli/repl.rs
+++ b/src/cmd/src/cli/repl.rs
@@ -19,7 +19,6 @@ use std::time::Instant;
 use catalog::remote::CachedMetaKvBackend;
 use client::client_manager::DatanodeClients;
 use client::{Client, Database, DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
-use common_base::Plugins;
 use common_error::prelude::ErrorExt;
 use common_query::Output;
 use common_recordbatch::RecordBatches;
@@ -108,7 +107,7 @@ impl Repl {
            Ok(ref line) => {
                let request = line.trim();

-                let _ = self.rl.add_history_entry(request.to_string());
+                self.rl.add_history_entry(request.to_string());

                request.try_into()
            }
@@ -137,7 +136,7 @@ impl Repl {
                    }
                }
                ReplCommand::Sql { sql } => {
-                    let _ = self.execute_sql(sql).await;
+                    self.execute_sql(sql).await;
                }
                ReplCommand::Exit => {
                    return Ok(());
@@ -267,14 +266,13 @@ async fn create_query_engine(meta_addr: &str) -> Result<DatafusionQueryEngine> {
        partition_manager,
        datanode_clients,
    ));
-    let plugins: Arc<Plugins> = Default::default();
    let state = Arc::new(QueryEngineState::new(
        catalog_list,
        false,
        None,
        None,
-        plugins.clone(),
+        Default::default(),
    ));

-    Ok(DatafusionQueryEngine::new(state, plugins))
+    Ok(DatafusionQueryEngine::new(state))
 }
--- a/src/cmd/src/datanode.rs
+++ b/src/cmd/src/datanode.rs
@@ -170,9 +170,7 @@ impl StartCommand {
        logging::info!("Datanode start command: {:#?}", self);
        logging::info!("Datanode options: {:#?}", opts);

-        let datanode = Datanode::new(opts, Default::default())
-            .await
-            .context(StartDatanodeSnafu)?;
+        let datanode = Datanode::new(opts).await.context(StartDatanodeSnafu)?;

        Ok(Instance { datanode })
    }
@@ -326,12 +324,12 @@ mod tests {
        .is_err());

        // Providing node_id but leave metasrv_addr absent is ok since metasrv_addr has default value
-        assert!((StartCommand {
+        (StartCommand {
            node_id: Some(42),
            ..Default::default()
        })
        .load_options(TopLevelOptions::default())
-        .is_ok());
+        .unwrap();
    }

    #[test]
--- a/src/cmd/src/frontend.rs
+++ b/src/cmd/src/frontend.rs
@@ -339,15 +339,19 @@ mod tests {
        };

        let plugins = load_frontend_plugins(&command.user_provider);
+        assert!(plugins.is_ok());
        let plugins = plugins.unwrap();
-        let provider = plugins.get::<UserProviderRef>().unwrap();
+        let provider = plugins.get::<UserProviderRef>();
+        assert!(provider.is_some());
+
+        let provider = provider.unwrap();
        let result = provider
            .authenticate(
                Identity::UserId("test", None),
                Password::PlainText("test".to_string().into()),
            )
            .await;
-        let _ = result.unwrap();
+        assert!(result.is_ok());
    }

    #[test]
--- a/src/cmd/src/standalone.rs
+++ b/src/cmd/src/standalone.rs
@@ -308,7 +308,7 @@ impl StartCommand {
            fe_opts, dn_opts
        );

-        let datanode = Datanode::new(dn_opts.clone(), Default::default())
+        let datanode = Datanode::new(dn_opts.clone())
            .await
            .context(StartDatanodeSnafu)?;

@@ -356,15 +356,18 @@ mod tests {
        };

        let plugins = load_frontend_plugins(&command.user_provider);
+        assert!(plugins.is_ok());
        let plugins = plugins.unwrap();
-        let provider = plugins.get::<UserProviderRef>().unwrap();
+        let provider = plugins.get::<UserProviderRef>();
+        assert!(provider.is_some());
+        let provider = provider.unwrap();
        let result = provider
            .authenticate(
                Identity::UserId("test", None),
                Password::PlainText("test".to_string().into()),
            )
            .await;
-        let _ = result.unwrap();
+        assert!(result.is_ok());
    }

    #[test]
--- a/src/cmd/tests/cli.rs
+++ b/src/cmd/tests/cli.rs
@@ -27,10 +27,10 @@ mod tests {

    impl Repl {
        fn send_line(&mut self, line: &str) {
-            let _ = self.repl.send_line(line).unwrap();
+            self.repl.send_line(line).unwrap();

            // read a line to consume the prompt
-            let _ = self.read_line();
+            self.read_line();
        }

        fn read_line(&mut self) -> String {
@@ -76,7 +76,7 @@ mod tests {
        std::thread::sleep(Duration::from_secs(3));

        let mut repl_cmd = Command::new("./greptime");
-        let _ = repl_cmd.current_dir(bin_path).args([
+        repl_cmd.current_dir(bin_path).args([
            "--log-level=off",
            "cli",
            "attach",
@@ -105,7 +105,7 @@ mod tests {
        test_select(repl);

        datanode.kill().unwrap();
-        let _ = datanode.wait().unwrap();
+        datanode.wait().unwrap();
    }

    fn test_create_database(repl: &mut Repl) {
--- a/src/common/base/src/lib.rs
+++ b/src/common/base/src/lib.rs
@@ -41,7 +41,7 @@ impl Plugins {
    }

    pub fn insert<T: 'static + Send + Sync>(&self, value: T) {
-        let _ = self.lock().insert(value);
+        self.lock().insert(value);
    }

    pub fn get<T: 'static + Send + Sync + Clone>(&self) -> Option<T> {
--- a/src/common/base/tests/buffer_tests.rs
+++ b/src/common/base/tests/buffer_tests.rs
@@ -119,7 +119,7 @@ mod tests {
                    #[test]
                    fn [<test_read_write_ $num_ty _from_vec_buffer>]() {
                        let mut buf = vec![];
-                        let _ = buf.[<write_ $num_ty _le>]($num_ty::MAX).unwrap();
+                        assert!(buf.[<write_ $num_ty _le>]($num_ty::MAX).is_ok());
                        assert_eq!($num_ty::MAX, buf.as_slice().[<read_ $num_ty _le>]().unwrap());
                    }
                }
@@ -132,7 +132,7 @@ mod tests {
    #[test]
    pub fn test_peek_write_from_vec_buffer() {
        let mut buf: Vec<u8> = vec![];
-        buf.write_from_slice("hello".as_bytes()).unwrap();
+        assert!(buf.write_from_slice("hello".as_bytes()).is_ok());
        let mut slice = buf.as_slice();
        assert_eq!(104, slice.peek_u8_le().unwrap());
        slice.advance_by(1);
--- a/src/common/catalog/src/consts.rs
+++ b/src/common/catalog/src/consts.rs
@@ -27,8 +27,6 @@ pub const MAX_SYS_TABLE_ID: u32 = MIN_USER_TABLE_ID - 1;
 pub const SYSTEM_CATALOG_TABLE_ID: u32 = 0;
 /// scripts table id
 pub const SCRIPTS_TABLE_ID: u32 = 1;
-/// numbers table id
-pub const NUMBERS_TABLE_ID: u32 = 2;

 pub const MITO_ENGINE: &str = "mito";
 pub const IMMUTABLE_FILE_ENGINE: &str = "file";
--- a/src/common/datasource/Cargo.toml
+++ b/src/common/datasource/Cargo.toml
@@ -24,7 +24,6 @@ datafusion.workspace = true
 derive_builder = "0.12"
 futures.workspace = true
 object-store = { path = "../../object-store" }
-orc-rust = { git = "https://github.com/WenyXu/orc-rs.git", rev = "0319acd32456e403c20f135cc012441a76852605" }
 regex = "1.7"
 snafu.workspace = true
 tokio.workspace = true
--- a/src/common/datasource/src/error.rs
+++ b/src/common/datasource/src/error.rs
@@ -54,12 +54,6 @@ pub enum Error {
        location: Location,
    },

-    #[snafu(display("Failed to build orc reader, source: {}", source))]
-    OrcReader {
-        location: Location,
-        source: orc_rust::error::Error,
-    },
-
    #[snafu(display("Failed to read object from path: {}, source: {}", path, source))]
    ReadObject {
        path: String,
@@ -177,8 +171,7 @@ impl ErrorExt for Error {
            | ReadRecordBatch { .. }
            | WriteRecordBatch { .. }
            | EncodeRecordBatch { .. }
-            | BufferedWriterClosed { .. }
-            | OrcReader { .. } => StatusCode::Unexpected,
+            | BufferedWriterClosed { .. } => StatusCode::Unexpected,
        }
    }

@@ -189,7 +182,6 @@ impl ErrorExt for Error {
    fn location_opt(&self) -> Option<common_error::snafu::Location> {
        use Error::*;
        match self {
-            OrcReader { location, .. } => Some(*location),
            BuildBackend { location, .. } => Some(*location),
            ReadObject { location, .. } => Some(*location),
            ListObjects { location, .. } => Some(*location),
--- a/src/common/datasource/src/file_format.rs
+++ b/src/common/datasource/src/file_format.rs
@@ -14,7 +14,6 @@

 pub mod csv;
 pub mod json;
-pub mod orc;
 pub mod parquet;
 #[cfg(test)]
 pub mod tests;
@@ -39,7 +38,6 @@ use snafu::ResultExt;

 use self::csv::CsvFormat;
 use self::json::JsonFormat;
-use self::orc::OrcFormat;
 use self::parquet::ParquetFormat;
 use crate::buffered_writer::{DfRecordBatchEncoder, LazyBufferedWriter};
 use crate::compression::CompressionType;
@@ -58,7 +56,6 @@ pub enum Format {
    Csv(CsvFormat),
    Json(JsonFormat),
    Parquet(ParquetFormat),
-    Orc(OrcFormat),
 }

 impl Format {
@@ -67,7 +64,6 @@ impl Format {
            Format::Csv(_) => ".csv",
            Format::Json(_) => ".json",
            Format::Parquet(_) => ".parquet",
-            &Format::Orc(_) => ".orc",
        }
    }
 }
@@ -85,7 +81,6 @@ impl TryFrom<&HashMap<String, String>> for Format {
            "CSV" => Ok(Self::Csv(CsvFormat::try_from(options)?)),
            "JSON" => Ok(Self::Json(JsonFormat::try_from(options)?)),
            "PARQUET" => Ok(Self::Parquet(ParquetFormat::default())),
-            "ORC" => Ok(Self::Orc(OrcFormat)),
            _ => error::UnsupportedFormatSnafu { format: &format }.fail(),
        }
    }
@@ -213,7 +208,7 @@ pub async fn stream_to_file<T: DfRecordBatchEncoder, U: Fn(SharedBuffer) -> T>(
    }

    // Flushes all pending writes
-    let _ = writer.try_flush(true).await?;
+    writer.try_flush(true).await?;
    writer.close_inner_writer().await?;

    Ok(rows)
--- a/src/common/datasource/src/file_format/csv.rs
+++ b/src/common/datasource/src/file_format/csv.rs
@@ -291,20 +291,20 @@ mod tests {

    #[test]
    fn test_try_from() {
-        let map = HashMap::new();
+        let mut map = HashMap::new();
        let format: CsvFormat = CsvFormat::try_from(&map).unwrap();

        assert_eq!(format, CsvFormat::default());

-        let map = HashMap::from([
-            (
-                FORMAT_SCHEMA_INFER_MAX_RECORD.to_string(),
-                "2000".to_string(),
-            ),
-            (FORMAT_COMPRESSION_TYPE.to_string(), "zstd".to_string()),
-            (FORMAT_DELIMITER.to_string(), b'\t'.to_string()),
-            (FORMAT_HAS_HEADER.to_string(), "false".to_string()),
-        ]);
+        map.insert(
+            FORMAT_SCHEMA_INFER_MAX_RECORD.to_string(),
+            "2000".to_string(),
+        );
+
+        map.insert(FORMAT_COMPRESSION_TYPE.to_string(), "zstd".to_string());
+        map.insert(FORMAT_DELIMITER.to_string(), b'\t'.to_string());
+        map.insert(FORMAT_HAS_HEADER.to_string(), "false".to_string());
+
        let format = CsvFormat::try_from(&map).unwrap();

        assert_eq!(
--- a/src/common/datasource/src/file_format/json.rs
+++ b/src/common/datasource/src/file_format/json.rs
@@ -214,18 +214,18 @@ mod tests {

    #[test]
    fn test_try_from() {
-        let map = HashMap::new();
+        let mut map = HashMap::new();
        let format = JsonFormat::try_from(&map).unwrap();

        assert_eq!(format, JsonFormat::default());

-        let map = HashMap::from([
-            (
-                FORMAT_SCHEMA_INFER_MAX_RECORD.to_string(),
-                "2000".to_string(),
-            ),
-            (FORMAT_COMPRESSION_TYPE.to_string(), "zstd".to_string()),
-        ]);
+        map.insert(
+            FORMAT_SCHEMA_INFER_MAX_RECORD.to_string(),
+            "2000".to_string(),
+        );
+
+        map.insert(FORMAT_COMPRESSION_TYPE.to_string(), "zstd".to_string());
+
        let format = JsonFormat::try_from(&map).unwrap();

        assert_eq!(
--- a/src/common/datasource/src/file_format/orc.rs
+++ b/src/common/datasource/src/file_format/orc.rs
@@ -1,102 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use arrow_schema::{Schema, SchemaRef};
-use async_trait::async_trait;
-use datafusion::arrow::record_batch::RecordBatch as DfRecordBatch;
-use datafusion::error::{DataFusionError, Result as DfResult};
-use datafusion::physical_plan::RecordBatchStream;
-use futures::Stream;
-use object_store::ObjectStore;
-use orc_rust::arrow_reader::{create_arrow_schema, Cursor};
-use orc_rust::async_arrow_reader::ArrowStreamReader;
-pub use orc_rust::error::Error as OrcError;
-use orc_rust::reader::Reader;
-use snafu::ResultExt;
-use tokio::io::{AsyncRead, AsyncSeek};
-
-use crate::error::{self, Result};
-use crate::file_format::FileFormat;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub struct OrcFormat;
-
-pub async fn new_orc_cursor<R: AsyncRead + AsyncSeek + Unpin + Send + 'static>(
-    reader: R,
-) -> Result<Cursor<R>> {
-    let reader = Reader::new_async(reader)
-        .await
-        .context(error::OrcReaderSnafu)?;
-    let cursor = Cursor::root(reader).context(error::OrcReaderSnafu)?;
-    Ok(cursor)
-}
-
-pub async fn new_orc_stream_reader<R: AsyncRead + AsyncSeek + Unpin + Send + 'static>(
-    reader: R,
-) -> Result<ArrowStreamReader<R>> {
-    let cursor = new_orc_cursor(reader).await?;
-    Ok(ArrowStreamReader::new(cursor, None))
-}
-
-pub async fn infer_orc_schema<R: AsyncRead + AsyncSeek + Unpin + Send + 'static>(
-    reader: R,
-) -> Result<Schema> {
-    let cursor = new_orc_cursor(reader).await?;
-    Ok(create_arrow_schema(&cursor))
-}
-
-pub struct OrcArrowStreamReaderAdapter<T: AsyncRead + AsyncSeek + Unpin + Send + 'static> {
-    stream: ArrowStreamReader<T>,
-}
-
-impl<T: AsyncRead + AsyncSeek + Unpin + Send + 'static> OrcArrowStreamReaderAdapter<T> {
-    pub fn new(stream: ArrowStreamReader<T>) -> Self {
-        Self { stream }
-    }
-}
-
-impl<T: AsyncRead + AsyncSeek + Unpin + Send + 'static> RecordBatchStream
-    for OrcArrowStreamReaderAdapter<T>
-{
-    fn schema(&self) -> SchemaRef {
-        self.stream.schema()
-    }
-}
-
-impl<T: AsyncRead + AsyncSeek + Unpin + Send + 'static> Stream for OrcArrowStreamReaderAdapter<T> {
-    type Item = DfResult<DfRecordBatch>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let batch = futures::ready!(Pin::new(&mut self.stream).poll_next(cx))
-            .map(|r| r.map_err(|e| DataFusionError::External(Box::new(e))));
-        Poll::Ready(batch)
-    }
-}
-
-#[async_trait]
-impl FileFormat for OrcFormat {
-    async fn infer_schema(&self, store: &ObjectStore, path: &str) -> Result<Schema> {
-        let reader = store
-            .reader(path)
-            .await
-            .context(error::ReadObjectSnafu { path })?;
-
-        let schema = infer_orc_schema(reader).await?;
-
-        Ok(schema)
-    }
-}
--- a/src/common/datasource/src/object_store/fs.rs
+++ b/src/common/datasource/src/object_store/fs.rs
@@ -20,7 +20,7 @@ use crate::error::{BuildBackendSnafu, Result};

 pub fn build_fs_backend(root: &str) -> Result<ObjectStore> {
    let mut builder = Fs::default();
-    let _ = builder.root(root);
+    builder.root(root);
    let object_store = ObjectStore::new(builder)
        .context(BuildBackendSnafu)?
        .finish();
--- a/src/common/datasource/src/object_store/s3.rs
+++ b/src/common/datasource/src/object_store/s3.rs
@@ -34,26 +34,28 @@ pub fn build_s3_backend(
 ) -> Result<ObjectStore> {
    let mut builder = S3::default();

-    let _ = builder.root(path).bucket(host);
+    builder.root(path);
+
+    builder.bucket(host);

    if let Some(endpoint) = connection.get(ENDPOINT_URL) {
-        let _ = builder.endpoint(endpoint);
+        builder.endpoint(endpoint);
    }

    if let Some(region) = connection.get(REGION) {
-        let _ = builder.region(region);
+        builder.region(region);
    }

    if let Some(key_id) = connection.get(ACCESS_KEY_ID) {
-        let _ = builder.access_key_id(key_id);
+        builder.access_key_id(key_id);
    }

    if let Some(key) = connection.get(SECRET_ACCESS_KEY) {
-        let _ = builder.secret_access_key(key);
+        builder.secret_access_key(key);
    }

    if let Some(session_token) = connection.get(SESSION_TOKEN) {
-        let _ = builder.security_token(session_token);
+        builder.security_token(session_token);
    }

    if let Some(enable_str) = connection.get(ENABLE_VIRTUAL_HOST_STYLE) {
@@ -67,7 +69,7 @@ pub fn build_s3_backend(
            .build()
        })?;
        if enable {
-            let _ = builder.enable_virtual_host_style();
+            builder.enable_virtual_host_style();
        }
    }

--- a/src/common/datasource/src/test_util.rs
+++ b/src/common/datasource/src/test_util.rs
@@ -55,7 +55,7 @@ pub fn format_schema(schema: Schema) -> Vec<String> {

 pub fn test_store(root: &str) -> ObjectStore {
    let mut builder = Fs::default();
-    let _ = builder.root(root);
+    builder.root(root);

    ObjectStore::new(builder).unwrap().finish()
 }
@@ -64,7 +64,7 @@ pub fn test_tmp_store(root: &str) -> (ObjectStore, TempDir) {
    let dir = create_temp_dir(root);

    let mut builder = Fs::default();
-    let _ = builder.root("/");
+    builder.root("/");

    (ObjectStore::new(builder).unwrap().finish(), dir)
 }
@@ -113,14 +113,14 @@ pub async fn setup_stream_to_json_test(origin_path: &str, threshold: impl Fn(usi

    let output_path = format!("{}/{}", dir.path().display(), "output");

-    assert!(stream_to_json(
+    stream_to_json(
        Box::pin(stream),
        tmp_store.clone(),
        &output_path,
        threshold(size),
    )
    .await
-    .is_ok());
+    .unwrap();

    let written = tmp_store.read(&output_path).await.unwrap();
    let origin = store.read(origin_path).await.unwrap();
@@ -155,14 +155,14 @@ pub async fn setup_stream_to_csv_test(origin_path: &str, threshold: impl Fn(usiz

    let output_path = format!("{}/{}", dir.path().display(), "output");

-    assert!(stream_to_csv(
+    stream_to_csv(
        Box::pin(stream),
        tmp_store.clone(),
        &output_path,
        threshold(size),
    )
    .await
-    .is_ok());
+    .unwrap();

    let written = tmp_store.read(&output_path).await.unwrap();
    let origin = store.read(origin_path).await.unwrap();
--- a/src/common/datasource/tests/orc/README.md
+++ b/src/common/datasource/tests/orc/README.md
@@ -1,11 +0,0 @@
-## Generate orc data
-
-```bash
-python3 -m venv venv
-venv/bin/pip install -U pip
-venv/bin/pip install -U pyorc
-
-./venv/bin/python write.py
-
-cargo test
-```
--- a/src/common/datasource/tests/orc/test.orc
+++ b/src/common/datasource/tests/orc/test.orc
--- a/src/common/datasource/tests/orc/write.py
+++ b/src/common/datasource/tests/orc/write.py
@@ -1,103 +0,0 @@
-# Copyright 2023 Greptime Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import random
-import datetime
-import pyorc
-
-data = {
-    "double_a": [1.0, 2.0, 3.0, 4.0, 5.0],
-    "a": [1.0, 2.0, None, 4.0, 5.0],
-    "b": [True, False, None, True, False],
-    "str_direct": ["a", "cccccc", None, "ddd", "ee"],
-    "d": ["a", "bb", None, "ccc", "ddd"],
-    "e": ["ddd", "cc", None, "bb", "a"],
-    "f": ["aaaaa", "bbbbb", None, "ccccc", "ddddd"],
-    "int_short_repeated": [5, 5, None, 5, 5],
-    "int_neg_short_repeated": [-5, -5, None, -5, -5],
-    "int_delta": [1, 2, None, 4, 5],
-    "int_neg_delta": [5, 4, None, 2, 1],
-    "int_direct": [1, 6, None, 3, 2],
-    "int_neg_direct": [-1, -6, None, -3, -2],
-    "bigint_direct": [1, 6, None, 3, 2],
-    "bigint_neg_direct": [-1, -6, None, -3, -2],
-    "bigint_other": [5, -5, 1, 5, 5],
-    "utf8_increase": ["a", "bb", "ccc", "dddd", "eeeee"],
-    "utf8_decrease": ["eeeee", "dddd", "ccc", "bb", "a"],
-    "timestamp_simple": [datetime.datetime(2023, 4, 1, 20, 15, 30, 2000), datetime.datetime.fromtimestamp(int('1629617204525777000')/1000000000), datetime.datetime(2023, 1, 1), datetime.datetime(2023, 2, 1), datetime.datetime(2023, 3, 1)],
-    "date_simple": [datetime.date(2023, 4, 1), datetime.date(2023, 3, 1), datetime.date(2023, 1, 1), datetime.date(2023, 2, 1), datetime.date(2023, 3, 1)]
-}
-
-def infer_schema(data):
-    schema = "struct<"
-    for key, value in data.items():
-        dt = type(value[0])
-        if dt == float:
-            dt = "float"
-        elif dt == int:
-            dt = "int"
-        elif dt == bool:
-            dt = "boolean"
-        elif dt == str:
-            dt = "string"
-        elif key.startswith("timestamp"):
-            dt = "timestamp"
-        elif key.startswith("date"):
-            dt = "date"
-        else:
-            print(key,value,dt)
-            raise NotImplementedError
-        if key.startswith("double"):
-            dt = "double"
-        if key.startswith("bigint"):
-            dt = "bigint"
-        schema += key + ":" + dt + ","
-
-    schema = schema[:-1] + ">"
-    return schema
-
-
-
-def _write(
-    schema: str,
-    data,
-    file_name: str,
-    compression=pyorc.CompressionKind.NONE,
-    dict_key_size_threshold=0.0,
-):
-    output = open(file_name, "wb")
-    writer = pyorc.Writer(
-        output,
-        schema,
-        dict_key_size_threshold=dict_key_size_threshold,
-        # use a small number to ensure that compression crosses value boundaries
-        compression_block_size=32,
-        compression=compression,
-    )
-    num_rows = len(list(data.values())[0])
-    for x in range(num_rows):
-        row = tuple(values[x] for values in data.values())
-        writer.write(row)
-    writer.close()
-
-    with open(file_name, "rb") as f:
-        reader = pyorc.Reader(f)
-        list(reader)
-
-
-_write(
-    infer_schema(data),
-    data,
-    "test.orc",
-)
--- a/src/common/function-macro/tests/test_derive.rs
+++ b/src/common/function-macro/tests/test_derive.rs
@@ -22,7 +22,7 @@ struct Foo {}
 #[test]
 #[allow(clippy::extra_unused_type_parameters)]
 fn test_derive() {
-    let _ = Foo::default();
+    Foo::default();
    assert_fields!(Foo: input_types);
    assert_impl_all!(Foo: std::fmt::Debug, Default, AggrFuncTypeStore);
 }
--- a/src/common/function/src/scalars/aggregate/argmax.rs
+++ b/src/common/function/src/scalars/aggregate/argmax.rs
@@ -158,19 +158,19 @@ mod test {
    fn test_update_batch() {
        // test update empty batch, expect not updating anything
        let mut argmax = Argmax::<i32>::default();
-        argmax.update_batch(&[]).unwrap();
+        assert!(argmax.update_batch(&[]).is_ok());
        assert_eq!(Value::Null, argmax.evaluate().unwrap());

        // test update one not-null value
        let mut argmax = Argmax::<i32>::default();
        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Some(42)]))];
-        argmax.update_batch(&v).unwrap();
+        assert!(argmax.update_batch(&v).is_ok());
        assert_eq!(Value::from(0_u64), argmax.evaluate().unwrap());

        // test update one null value
        let mut argmax = Argmax::<i32>::default();
        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Option::<i32>::None]))];
-        argmax.update_batch(&v).unwrap();
+        assert!(argmax.update_batch(&v).is_ok());
        assert_eq!(Value::Null, argmax.evaluate().unwrap());

        // test update no null-value batch
@@ -180,7 +180,7 @@ mod test {
            Some(1),
            Some(3),
        ]))];
-        argmax.update_batch(&v).unwrap();
+        assert!(argmax.update_batch(&v).is_ok());
        assert_eq!(Value::from(2_u64), argmax.evaluate().unwrap());

        // test update null-value batch
@@ -190,7 +190,7 @@ mod test {
            None,
            Some(4),
        ]))];
-        argmax.update_batch(&v).unwrap();
+        assert!(argmax.update_batch(&v).is_ok());
        assert_eq!(Value::from(2_u64), argmax.evaluate().unwrap());

        // test update with constant vector
@@ -199,7 +199,7 @@ mod test {
            Arc::new(Int32Vector::from_vec(vec![4])),
            10,
        ))];
-        argmax.update_batch(&v).unwrap();
+        assert!(argmax.update_batch(&v).is_ok());
        assert_eq!(Value::from(0_u64), argmax.evaluate().unwrap());
    }
 }
--- a/src/common/function/src/scalars/aggregate/argmin.rs
+++ b/src/common/function/src/scalars/aggregate/argmin.rs
@@ -166,19 +166,19 @@ mod test {
    fn test_update_batch() {
        // test update empty batch, expect not updating anything
        let mut argmin = Argmin::<i32>::default();
-        argmin.update_batch(&[]).unwrap();
+        assert!(argmin.update_batch(&[]).is_ok());
        assert_eq!(Value::Null, argmin.evaluate().unwrap());

        // test update one not-null value
        let mut argmin = Argmin::<i32>::default();
        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Some(42)]))];
-        argmin.update_batch(&v).unwrap();
+        assert!(argmin.update_batch(&v).is_ok());
        assert_eq!(Value::from(0_u32), argmin.evaluate().unwrap());

        // test update one null value
        let mut argmin = Argmin::<i32>::default();
        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Option::<i32>::None]))];
-        argmin.update_batch(&v).unwrap();
+        assert!(argmin.update_batch(&v).is_ok());
        assert_eq!(Value::Null, argmin.evaluate().unwrap());

        // test update no null-value batch
@@ -188,7 +188,7 @@ mod test {
            Some(1),
            Some(3),
        ]))];
-        argmin.update_batch(&v).unwrap();
+        assert!(argmin.update_batch(&v).is_ok());
        assert_eq!(Value::from(0_u32), argmin.evaluate().unwrap());

        // test update null-value batch
@@ -198,7 +198,7 @@ mod test {
            None,
            Some(4),
        ]))];
-        argmin.update_batch(&v).unwrap();
+        assert!(argmin.update_batch(&v).is_ok());
        assert_eq!(Value::from(0_u32), argmin.evaluate().unwrap());

        // test update with constant vector
@@ -207,7 +207,7 @@ mod test {
            Arc::new(Int32Vector::from_vec(vec![4])),
            10,
        ))];
-        argmin.update_batch(&v).unwrap();
+        assert!(argmin.update_batch(&v).is_ok());
        assert_eq!(Value::from(0_u32), argmin.evaluate().unwrap());
    }
 }
--- a/src/common/function/src/scalars/aggregate/diff.rs
+++ b/src/common/function/src/scalars/aggregate/diff.rs
@@ -192,20 +192,20 @@ mod test {
    fn test_update_batch() {
        // test update empty batch, expect not updating anything
        let mut diff = Diff::<i32, i64>::default();
-        diff.update_batch(&[]).unwrap();
+        assert!(diff.update_batch(&[]).is_ok());
        assert!(diff.values.is_empty());
        assert_eq!(Value::Null, diff.evaluate().unwrap());

        // test update one not-null value
        let mut diff = Diff::<i32, i64>::default();
        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Some(42)]))];
-        diff.update_batch(&v).unwrap();
+        assert!(diff.update_batch(&v).is_ok());
        assert_eq!(Value::Null, diff.evaluate().unwrap());

        // test update one null value
        let mut diff = Diff::<i32, i64>::default();
        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Option::<i32>::None]))];
-        diff.update_batch(&v).unwrap();
+        assert!(diff.update_batch(&v).is_ok());
        assert_eq!(Value::Null, diff.evaluate().unwrap());

        // test update no null-value batch
@@ -216,7 +216,7 @@ mod test {
            Some(2),
        ]))];
        let values = vec![Value::from(2_i64), Value::from(1_i64)];
-        diff.update_batch(&v).unwrap();
+        assert!(diff.update_batch(&v).is_ok());
        assert_eq!(
            Value::List(ListValue::new(
                Some(Box::new(values)),
@@ -234,7 +234,7 @@ mod test {
            Some(4),
        ]))];
        let values = vec![Value::from(5_i64), Value::from(1_i64)];
-        diff.update_batch(&v).unwrap();
+        assert!(diff.update_batch(&v).is_ok());
        assert_eq!(
            Value::List(ListValue::new(
                Some(Box::new(values)),
@@ -250,7 +250,7 @@ mod test {
            4,
        ))];
        let values = vec![Value::from(0_i64), Value::from(0_i64), Value::from(0_i64)];
-        diff.update_batch(&v).unwrap();
+        assert!(diff.update_batch(&v).is_ok());
        assert_eq!(
            Value::List(ListValue::new(
                Some(Box::new(values)),
--- a/src/common/function/src/scalars/aggregate/mean.rs
+++ b/src/common/function/src/scalars/aggregate/mean.rs
@@ -188,19 +188,19 @@ mod test {
    fn test_update_batch() {
        // test update empty batch, expect not updating anything
        let mut mean = Mean::<i32>::default();
-        mean.update_batch(&[]).unwrap();
+        assert!(mean.update_batch(&[]).is_ok());
        assert_eq!(Value::Null, mean.evaluate().unwrap());

        // test update one not-null value
        let mut mean = Mean::<i32>::default();
        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Some(42)]))];
-        mean.update_batch(&v).unwrap();
+        assert!(mean.update_batch(&v).is_ok());
        assert_eq!(Value::from(42.0_f64), mean.evaluate().unwrap());

        // test update one null value
        let mut mean = Mean::<i32>::default();
        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Option::<i32>::None]))];
-        mean.update_batch(&v).unwrap();
+        assert!(mean.update_batch(&v).is_ok());
        assert_eq!(Value::Null, mean.evaluate().unwrap());

        // test update no null-value batch
@@ -210,7 +210,7 @@ mod test {
            Some(1),
            Some(2),
        ]))];
-        mean.update_batch(&v).unwrap();
+        assert!(mean.update_batch(&v).is_ok());
        assert_eq!(Value::from(0.6666666666666666), mean.evaluate().unwrap());

        // test update null-value batch
@@ -221,7 +221,7 @@ mod test {
            Some(3),
            Some(4),
        ]))];
-        mean.update_batch(&v).unwrap();
+        assert!(mean.update_batch(&v).is_ok());
        assert_eq!(Value::from(1.6666666666666667), mean.evaluate().unwrap());

        // test update with constant vector
@@ -230,7 +230,7 @@ mod test {
            Arc::new(Int32Vector::from_vec(vec![4])),
            10,
        ))];
-        mean.update_batch(&v).unwrap();
+        assert!(mean.update_batch(&v).is_ok());
        assert_eq!(Value::from(4.0), mean.evaluate().unwrap());
    }
 }
--- a/src/common/function/src/scalars/aggregate/percentile.rs
+++ b/src/common/function/src/scalars/aggregate/percentile.rs
@@ -299,7 +299,7 @@ mod test {
    fn test_update_batch() {
        // test update empty batch, expect not updating anything
        let mut percentile = Percentile::<i32>::default();
-        percentile.update_batch(&[]).unwrap();
+        assert!(percentile.update_batch(&[]).is_ok());
        assert!(percentile.not_greater.is_empty());
        assert!(percentile.greater.is_empty());
        assert_eq!(Value::Null, percentile.evaluate().unwrap());
@@ -310,7 +310,7 @@ mod test {
            Arc::new(Int32Vector::from(vec![Some(42)])),
            Arc::new(Float64Vector::from(vec![Some(100.0_f64)])),
        ];
-        percentile.update_batch(&v).unwrap();
+        assert!(percentile.update_batch(&v).is_ok());
        assert_eq!(Value::from(42.0_f64), percentile.evaluate().unwrap());

        // test update one null value
@@ -319,7 +319,7 @@ mod test {
            Arc::new(Int32Vector::from(vec![Option::<i32>::None])),
            Arc::new(Float64Vector::from(vec![Some(100.0_f64)])),
        ];
-        percentile.update_batch(&v).unwrap();
+        assert!(percentile.update_batch(&v).is_ok());
        assert_eq!(Value::Null, percentile.evaluate().unwrap());

        // test update no null-value batch
@@ -332,7 +332,7 @@ mod test {
                Some(100.0_f64),
            ])),
        ];
-        percentile.update_batch(&v).unwrap();
+        assert!(percentile.update_batch(&v).is_ok());
        assert_eq!(Value::from(2_f64), percentile.evaluate().unwrap());

        // test update null-value batch
@@ -346,7 +346,7 @@ mod test {
                Some(100.0_f64),
            ])),
        ];
-        percentile.update_batch(&v).unwrap();
+        assert!(percentile.update_batch(&v).is_ok());
        assert_eq!(Value::from(4_f64), percentile.evaluate().unwrap());

        // test update with constant vector
@@ -358,7 +358,7 @@ mod test {
            )),
            Arc::new(Float64Vector::from(vec![Some(100.0_f64), Some(100.0_f64)])),
        ];
-        percentile.update_batch(&v).unwrap();
+        assert!(percentile.update_batch(&v).is_ok());
        assert_eq!(Value::from(4_f64), percentile.evaluate().unwrap());

        // test left border
@@ -371,7 +371,7 @@ mod test {
                Some(0.0_f64),
            ])),
        ];
-        percentile.update_batch(&v).unwrap();
+        assert!(percentile.update_batch(&v).is_ok());
        assert_eq!(Value::from(-1.0_f64), percentile.evaluate().unwrap());

        // test medium
@@ -384,7 +384,7 @@ mod test {
                Some(50.0_f64),
            ])),
        ];
-        percentile.update_batch(&v).unwrap();
+        assert!(percentile.update_batch(&v).is_ok());
        assert_eq!(Value::from(1.0_f64), percentile.evaluate().unwrap());

        // test right border
@@ -397,7 +397,7 @@ mod test {
                Some(100.0_f64),
            ])),
        ];
-        percentile.update_batch(&v).unwrap();
+        assert!(percentile.update_batch(&v).is_ok());
        assert_eq!(Value::from(2.0_f64), percentile.evaluate().unwrap());

        // the following is the result of numpy.percentile
@@ -414,7 +414,7 @@ mod test {
                Some(40.0_f64),
            ])),
        ];
-        percentile.update_batch(&v).unwrap();
+        assert!(percentile.update_batch(&v).is_ok());
        assert_eq!(Value::from(6.400000000_f64), percentile.evaluate().unwrap());

        // the following is the result of numpy.percentile
@@ -430,7 +430,7 @@ mod test {
                Some(95.0_f64),
            ])),
        ];
-        percentile.update_batch(&v).unwrap();
+        assert!(percentile.update_batch(&v).is_ok());
        assert_eq!(
            Value::from(9.700_000_000_000_001_f64),
            percentile.evaluate().unwrap()
--- a/src/common/function/src/scalars/aggregate/polyval.rs
+++ b/src/common/function/src/scalars/aggregate/polyval.rs
@@ -267,7 +267,7 @@ mod test {
    fn test_update_batch() {
        // test update empty batch, expect not updating anything
        let mut polyval = Polyval::<i32, i64>::default();
-        polyval.update_batch(&[]).unwrap();
+        assert!(polyval.update_batch(&[]).is_ok());
        assert!(polyval.values.is_empty());
        assert_eq!(Value::Null, polyval.evaluate().unwrap());

@@ -277,7 +277,7 @@ mod test {
            Arc::new(Int32Vector::from(vec![Some(3)])),
            Arc::new(Int64Vector::from(vec![Some(2_i64)])),
        ];
-        polyval.update_batch(&v).unwrap();
+        assert!(polyval.update_batch(&v).is_ok());
        assert_eq!(Value::Int64(3), polyval.evaluate().unwrap());

        // test update one null value
@@ -286,7 +286,7 @@ mod test {
            Arc::new(Int32Vector::from(vec![Option::<i32>::None])),
            Arc::new(Int64Vector::from(vec![Some(2_i64)])),
        ];
-        polyval.update_batch(&v).unwrap();
+        assert!(polyval.update_batch(&v).is_ok());
        assert_eq!(Value::Null, polyval.evaluate().unwrap());

        // test update no null-value batch
@@ -299,7 +299,7 @@ mod test {
                Some(2_i64),
            ])),
        ];
-        polyval.update_batch(&v).unwrap();
+        assert!(polyval.update_batch(&v).is_ok());
        assert_eq!(Value::Int64(13), polyval.evaluate().unwrap());

        // test update null-value batch
@@ -313,7 +313,7 @@ mod test {
                Some(2_i64),
            ])),
        ];
-        polyval.update_batch(&v).unwrap();
+        assert!(polyval.update_batch(&v).is_ok());
        assert_eq!(Value::Int64(13), polyval.evaluate().unwrap());

        // test update with constant vector
@@ -325,7 +325,7 @@ mod test {
            )),
            Arc::new(Int64Vector::from(vec![Some(5_i64), Some(5_i64)])),
        ];
-        polyval.update_batch(&v).unwrap();
+        assert!(polyval.update_batch(&v).is_ok());
        assert_eq!(Value::Int64(24), polyval.evaluate().unwrap());
    }
 }
--- a/src/common/function/src/scalars/aggregate/scipy_stats_norm_cdf.rs
+++ b/src/common/function/src/scalars/aggregate/scipy_stats_norm_cdf.rs
@@ -231,7 +231,7 @@ mod test {
    fn test_update_batch() {
        // test update empty batch, expect not updating anything
        let mut scipy_stats_norm_cdf = ScipyStatsNormCdf::<i32>::default();
-        scipy_stats_norm_cdf.update_batch(&[]).unwrap();
+        assert!(scipy_stats_norm_cdf.update_batch(&[]).is_ok());
        assert!(scipy_stats_norm_cdf.values.is_empty());
        assert_eq!(Value::Null, scipy_stats_norm_cdf.evaluate().unwrap());

@@ -245,7 +245,7 @@ mod test {
                Some(2.0_f64),
            ])),
        ];
-        scipy_stats_norm_cdf.update_batch(&v).unwrap();
+        assert!(scipy_stats_norm_cdf.update_batch(&v).is_ok());
        assert_eq!(
            Value::from(0.8086334555398362),
            scipy_stats_norm_cdf.evaluate().unwrap()
@@ -262,7 +262,7 @@ mod test {
                Some(2.0_f64),
            ])),
        ];
-        scipy_stats_norm_cdf.update_batch(&v).unwrap();
+        assert!(scipy_stats_norm_cdf.update_batch(&v).is_ok());
        assert_eq!(
            Value::from(0.5412943699039795),
            scipy_stats_norm_cdf.evaluate().unwrap()
--- a/src/common/function/src/scalars/aggregate/scipy_stats_norm_pdf.rs
+++ b/src/common/function/src/scalars/aggregate/scipy_stats_norm_pdf.rs
@@ -232,7 +232,7 @@ mod test {
    fn test_update_batch() {
        // test update empty batch, expect not updating anything
        let mut scipy_stats_norm_pdf = ScipyStatsNormPdf::<i32>::default();
-        scipy_stats_norm_pdf.update_batch(&[]).unwrap();
+        assert!(scipy_stats_norm_pdf.update_batch(&[]).is_ok());
        assert!(scipy_stats_norm_pdf.values.is_empty());
        assert_eq!(Value::Null, scipy_stats_norm_pdf.evaluate().unwrap());

@@ -246,7 +246,7 @@ mod test {
                Some(2.0_f64),
            ])),
        ];
-        scipy_stats_norm_pdf.update_batch(&v).unwrap();
+        assert!(scipy_stats_norm_pdf.update_batch(&v).is_ok());
        assert_eq!(
            Value::from(0.17843340219081558),
            scipy_stats_norm_pdf.evaluate().unwrap()
@@ -263,7 +263,7 @@ mod test {
                Some(2.0_f64),
            ])),
        ];
-        scipy_stats_norm_pdf.update_batch(&v).unwrap();
+        assert!(scipy_stats_norm_pdf.update_batch(&v).is_ok());
        assert_eq!(
            Value::from(0.12343972049858312),
            scipy_stats_norm_pdf.evaluate().unwrap()
--- a/src/common/function/src/scalars/function_registry.rs
+++ b/src/common/function/src/scalars/function_registry.rs
@@ -32,16 +32,14 @@ pub struct FunctionRegistry {

 impl FunctionRegistry {
    pub fn register(&self, func: FunctionRef) {
-        let _ = self
-            .functions
+        self.functions
            .write()
            .unwrap()
            .insert(func.name().to_string(), func);
    }

    pub fn register_aggregate_function(&self, func: AggregateFunctionMetaRef) {
-        let _ = self
-            .aggregate_functions
+        self.aggregate_functions
            .write()
            .unwrap()
            .insert(func.name(), func);
@@ -94,7 +92,7 @@ mod tests {
        assert!(registry.get_function("test_and").is_none());
        assert!(registry.functions().is_empty());
        registry.register(func);
-        let _ = registry.get_function("test_and").unwrap();
+        assert!(registry.get_function("test_and").is_some());
        assert_eq!(1, registry.functions().len());
    }
 }
--- a/src/common/grpc-expr/src/alter.rs
+++ b/src/common/grpc-expr/src/alter.rs
@@ -34,7 +34,7 @@ const LOCATION_TYPE_FIRST: i32 = LocationType::First as i32;
 const LOCATION_TYPE_AFTER: i32 = LocationType::After as i32;

 /// Convert an [`AlterExpr`] to an [`AlterTableRequest`]
-pub fn alter_expr_to_request(table_id: TableId, expr: AlterExpr) -> Result<AlterTableRequest> {
+pub fn alter_expr_to_request(expr: AlterExpr) -> Result<AlterTableRequest> {
    let catalog_name = expr.catalog_name;
    let schema_name = expr.schema_name;
    let kind = expr.kind.context(MissingFieldSnafu { field: "kind" })?;
@@ -69,7 +69,6 @@ pub fn alter_expr_to_request(table_id: TableId, expr: AlterExpr) -> Result<Alter
                catalog_name,
                schema_name,
                table_name: expr.table_name,
-                table_id,
                alter_kind,
            };
            Ok(request)
@@ -83,7 +82,6 @@ pub fn alter_expr_to_request(table_id: TableId, expr: AlterExpr) -> Result<Alter
                catalog_name,
                schema_name,
                table_name: expr.table_name,
-                table_id,
                alter_kind,
            };
            Ok(request)
@@ -94,7 +92,6 @@ pub fn alter_expr_to_request(table_id: TableId, expr: AlterExpr) -> Result<Alter
                catalog_name,
                schema_name,
                table_name: expr.table_name,
-                table_id,
                alter_kind,
            };
            Ok(request)
@@ -242,7 +239,7 @@ mod tests {
            })),
        };

-        let alter_request = alter_expr_to_request(1, expr).unwrap();
+        let alter_request = alter_expr_to_request(expr).unwrap();
        assert_eq!(alter_request.catalog_name, "");
        assert_eq!(alter_request.schema_name, "");
        assert_eq!("monitor".to_string(), alter_request.table_name);
@@ -299,7 +296,7 @@ mod tests {
            })),
        };

-        let alter_request = alter_expr_to_request(1, expr).unwrap();
+        let alter_request = alter_expr_to_request(expr).unwrap();
        assert_eq!(alter_request.catalog_name, "");
        assert_eq!(alter_request.schema_name, "");
        assert_eq!("monitor".to_string(), alter_request.table_name);
@@ -347,7 +344,7 @@ mod tests {
            })),
        };

-        let alter_request = alter_expr_to_request(1, expr).unwrap();
+        let alter_request = alter_expr_to_request(expr).unwrap();
        assert_eq!(alter_request.catalog_name, "test_catalog");
        assert_eq!(alter_request.schema_name, "test_schema");
        assert_eq!("monitor".to_string(), alter_request.table_name);
--- a/src/common/grpc-expr/src/insert.rs
+++ b/src/common/grpc-expr/src/insert.rs
@@ -77,7 +77,7 @@ pub fn find_new_columns(schema: &SchemaRef, columns: &[Column]) -> Result<Option
                is_key: *semantic_type == TAG_SEMANTIC_TYPE,
                location: None,
            });
-            let _ = new_columns.insert(column_name.to_string());
+            new_columns.insert(column_name.to_string());
        }
    }

@@ -239,7 +239,7 @@ pub fn build_create_expr_from_insertion(

            let column_def = build_column_def(column_name, *datatype, is_nullable);
            column_defs.push(column_def);
-            let _ = new_columns.insert(column_name.to_string());
+            new_columns.insert(column_name.to_string());
        }
    }

--- a/src/common/grpc/benches/channel_manager.rs
+++ b/src/common/grpc/benches/channel_manager.rs
@@ -27,7 +27,7 @@ async fn do_bench_channel_manager() {
            for _ in 0..10000 {
                let idx = rand::random::<usize>() % 100;
                let ret = m_clone.get(format!("{idx}"));
-                let _ = ret.unwrap();
+                assert!(ret.is_ok());
            }
        });
        joins.push(join);
@@ -39,7 +39,7 @@ async fn do_bench_channel_manager() {
 }

 fn bench_channel_manager(c: &mut Criterion) {
-    let _ = c.bench_function("bench channel manager", |b| {
+    c.bench_function("bench channel manager", |b| {
        b.iter(do_bench_channel_manager);
    });
 }
--- a/src/common/grpc/src/channel_manager.rs
+++ b/src/common/grpc/src/channel_manager.rs
@@ -66,7 +66,7 @@ impl ChannelManager {
        }

        let pool = self.pool.clone();
-        let _handle = common_runtime::spawn_bg(async {
+        common_runtime::spawn_bg(async {
            recycle_channel_in_loop(pool, RECYCLE_CHANNEL_INTERVAL_SECS).await;
        });
        info!("Channel recycle is started, running in the background!");
@@ -398,7 +398,7 @@ impl Channel {

    #[inline]
    pub fn increase_access(&self) {
-        let _ = self.access.fetch_add(1, Ordering::Relaxed);
+        self.access.fetch_add(1, Ordering::Relaxed);
    }
 }

@@ -427,7 +427,7 @@ impl Pool {
    }

    fn put(&self, addr: &str, channel: Channel) {
-        let _ = self.channels.insert(addr.to_string(), channel);
+        self.channels.insert(addr.to_string(), channel);
    }

    fn retain_channel<F>(&self, f: F)
@@ -442,7 +442,7 @@ async fn recycle_channel_in_loop(pool: Arc<Pool>, interval_secs: u64) {
    let mut interval = tokio::time::interval(Duration::from_secs(interval_secs));

    loop {
-        let _ = interval.tick().await;
+        interval.tick().await;
        pool.retain_channel(|_, c| c.access.swap(0, Ordering::Relaxed) != 0)
    }
 }
@@ -577,7 +577,7 @@ mod tests {

        let res = mgr.build_endpoint("test_addr");

-        let _ = res.unwrap();
+        assert!(res.is_ok());
    }

    #[tokio::test]
@@ -586,7 +586,7 @@ mod tests {

        let addr = "test_addr";
        let res = mgr.get(addr);
-        let _ = res.unwrap();
+        assert!(res.is_ok());

        mgr.retain_channel(|addr, channel| {
            assert_eq!("test_addr", addr);
@@ -604,7 +604,7 @@ mod tests {
            }),
        );

-        let _ = res.unwrap();
+        assert!(res.is_ok());

        mgr.retain_channel(|addr, channel| {
            assert_eq!("test_addr", addr);
--- a/src/common/grpc/src/flight.rs
+++ b/src/common/grpc/src/flight.rs
@@ -265,7 +265,7 @@ mod test {
        let FlightMessage::Schema(decoded_schema) = message else { unreachable!() };
        assert_eq!(decoded_schema, schema);

-        let _ = decoder.schema.as_ref().unwrap();
+        assert!(decoder.schema.is_some());

        let message = decoder.try_decode(d2.clone()).unwrap();
        assert!(matches!(message, FlightMessage::Recordbatch(_)));
--- a/src/common/grpc/src/writer.rs
+++ b/src/common/grpc/src/writer.rs
@@ -217,7 +217,7 @@ impl LinesWriter {
                    datatype: datatype as i32,
                    null_mask: Vec::default(),
                });
-                let _ = column_names.insert(column_name.to_string(), new_idx);
+                column_names.insert(column_name.to_string(), new_idx);
                new_idx
            }
        };
--- a/src/common/grpc/tests/mod.rs
+++ b/src/common/grpc/tests/mod.rs
@@ -38,8 +38,9 @@ async fn test_mtls_config() {
        client_key_path: "tests/tls/corrupted".to_string(),
    });

-    let re = ChannelManager::with_tls_config(config).unwrap();
-    let re = re.get("127.0.0.1:0");
+    let re = ChannelManager::with_tls_config(config);
+    assert!(re.is_ok());
+    let re = re.unwrap().get("127.0.0.1:0");
    assert!(re.is_err());

    // success
@@ -49,7 +50,8 @@ async fn test_mtls_config() {
        client_key_path: "tests/tls/client.key.pem".to_string(),
    });

-    let re = ChannelManager::with_tls_config(config).unwrap();
-    let re = re.get("127.0.0.1:0");
-    let _ = re.unwrap();
+    let re = ChannelManager::with_tls_config(config);
+    assert!(re.is_ok());
+    let re = re.unwrap().get("127.0.0.1:0");
+    assert!(re.is_ok());
 }
--- a/src/common/mem-prof/src/lib.rs
+++ b/src/common/mem-prof/src/lib.rs
@@ -62,8 +62,7 @@ pub async fn dump_profile() -> error::Result<Vec<u8>> {
        .await
        .context(OpenTempFileSnafu { path: &path })?;
    let mut buf = vec![];
-    let _ = f
-        .read_to_end(&mut buf)
+    f.read_to_end(&mut buf)
        .await
        .context(OpenTempFileSnafu { path })?;
    Ok(buf)
--- a/src/common/meta/src/rpc/router.rs
+++ b/src/common/meta/src/rpc/router.rs
@@ -202,13 +202,13 @@ impl TableRoute {
            .iter()
            .filter_map(|x| x.leader_peer.as_ref())
            .for_each(|p| {
-                let _ = peers.insert(p.clone());
+                peers.insert(p.clone());
            });
        self.region_routes
            .iter()
            .flat_map(|x| x.follower_peers.iter())
            .for_each(|p| {
-                let _ = peers.insert(p.clone());
+                peers.insert(p.clone());
            });
        let mut peers = peers.into_iter().map(Into::into).collect::<Vec<PbPeer>>();
        peers.sort_by_key(|x| x.id);
--- a/src/common/procedure/src/local.rs
+++ b/src/common/procedure/src/local.rs
@@ -292,7 +292,7 @@ impl ManagerContext {
    fn remove_messages(&self, procedure_ids: &[ProcedureId]) {
        let mut messages = self.messages.lock().unwrap();
        for procedure_id in procedure_ids {
-            let _ = messages.remove(procedure_id);
+            messages.remove(procedure_id);
        }
    }

@@ -319,7 +319,7 @@ impl ManagerContext {
            while let Some((id, finish_time)) = finished_procedures.front() {
                if finish_time.elapsed() > ttl {
                    ids_to_remove.push(*id);
-                    let _ = finished_procedures.pop_front();
+                    finished_procedures.pop_front();
                } else {
                    // The rest procedures are finished later, so we can break
                    // the loop.
@@ -335,7 +335,7 @@ impl ManagerContext {

        let mut procedures = self.procedures.write().unwrap();
        for id in ids {
-            let _ = procedures.remove(&id);
+            procedures.remove(&id);
        }
    }
 }
@@ -419,7 +419,7 @@ impl LocalManager {
            DuplicateProcedureSnafu { procedure_id },
        );

-        let _handle = common_runtime::spawn_bg(async move {
+        common_runtime::spawn_bg(async move {
            // Run the root procedure.
            runner.run().await;
        });
@@ -434,7 +434,7 @@ impl ProcedureManager for LocalManager {
        let mut loaders = self.manager_ctx.loaders.lock().unwrap();
        ensure!(!loaders.contains_key(name), LoaderConflictSnafu { name });

-        let _ = loaders.insert(name.to_string(), loader);
+        loaders.insert(name.to_string(), loader);

        Ok(())
    }
@@ -559,7 +559,7 @@ mod test_util {
    pub(crate) fn new_object_store(dir: &TempDir) -> ObjectStore {
        let store_dir = dir.path().to_str().unwrap();
        let mut builder = Builder::default();
-        let _ = builder.root(store_dir);
+        builder.root(store_dir);
        ObjectStore::new(builder).unwrap().finish()
    }
 }
@@ -742,7 +742,7 @@ mod tests {
        manager.recover().await.unwrap();

        // The manager should submit the root procedure.
-        let _ = manager.procedure_state(root_id).await.unwrap().unwrap();
+        assert!(manager.procedure_state(root_id).await.unwrap().is_some());
        // Since the mocked root procedure actually doesn't submit subprocedures, so there is no
        // related state.
        assert!(manager.procedure_state(child_id).await.unwrap().is_none());
@@ -770,13 +770,13 @@ mod tests {

        let mut procedure = ProcedureToLoad::new("submit");
        procedure.lock_key = LockKey::single("test.submit");
-        assert!(manager
+        manager
            .submit(ProcedureWithId {
                id: procedure_id,
                procedure: Box::new(procedure),
            })
            .await
-            .is_ok());
+            .unwrap();
        assert!(manager
            .procedure_state(procedure_id)
            .await
@@ -877,13 +877,13 @@ mod tests {
        let mut procedure = ProcedureToLoad::new("submit");
        procedure.lock_key = LockKey::single("test.submit");
        let procedure_id = ProcedureId::random();
-        assert!(manager
+        manager
            .submit(ProcedureWithId {
                id: procedure_id,
                procedure: Box::new(procedure),
            })
            .await
-            .is_ok());
+            .unwrap();
        let mut watcher = manager.procedure_watcher(procedure_id).unwrap();
        watcher.changed().await.unwrap();
        manager.start().unwrap();
@@ -899,13 +899,13 @@ mod tests {
        let mut procedure = ProcedureToLoad::new("submit");
        procedure.lock_key = LockKey::single("test.submit");
        let procedure_id = ProcedureId::random();
-        assert!(manager
+        manager
            .submit(ProcedureWithId {
                id: procedure_id,
                procedure: Box::new(procedure),
            })
            .await
-            .is_ok());
+            .unwrap();
        let mut watcher = manager.procedure_watcher(procedure_id).unwrap();
        watcher.changed().await.unwrap();
        tokio::time::sleep(Duration::from_millis(10)).await;
--- a/src/common/procedure/src/local/lock.rs
+++ b/src/common/procedure/src/local/lock.rs
@@ -88,7 +88,7 @@ impl LockMap {
                // expect that a procedure should not wait for two lock simultaneously.
                lock.waiters.push_back(meta.clone());
            } else {
-                let _ = locks.insert(key.to_string(), Lock::from_owner(meta));
+                locks.insert(key.to_string(), Lock::from_owner(meta));

                return;
            }
@@ -111,7 +111,7 @@ impl LockMap {

            if !lock.switch_owner() {
                // No body waits for this lock, we can remove the lock entry.
-                let _ = locks.remove(key);
+                locks.remove(key);
            }
        }
    }
--- a/src/common/procedure/src/local/runner.rs
+++ b/src/common/procedure/src/local/runner.rs
@@ -332,7 +332,7 @@ impl Runner {
        // Add the id of the subprocedure to the metadata.
        self.meta.push_child(procedure_id);

-        let _handle = common_runtime::spawn_bg(async move {
+        common_runtime::spawn_bg(async move {
            // Run the root procedure.
            runner.run().await
        });
--- a/src/common/procedure/src/procedure.rs
+++ b/src/common/procedure/src/procedure.rs
@@ -388,6 +388,6 @@ mod tests {
            StatusCode::Unexpected,
        ))));
        assert!(state.is_failed());
-        let _ = state.error().unwrap();
+        assert!(state.error().is_some());
    }
 }
--- a/src/common/procedure/src/store.rs
+++ b/src/common/procedure/src/store.rs
@@ -198,7 +198,7 @@ impl ProcedureStore {
                    entry.1 = value;
                }
            } else {
-                let _ = procedure_key_values.insert(curr_key.procedure_id, (curr_key, value));
+                procedure_key_values.insert(curr_key.procedure_id, (curr_key, value));
            }
        }

@@ -211,7 +211,7 @@ impl ProcedureStore {
                    // procedures are loaded.
                    continue;
                };
-                let _ = messages.insert(procedure_id, message);
+                messages.insert(procedure_id, message);
            } else {
                finished_ids.push(procedure_id);
            }
@@ -331,7 +331,7 @@ mod tests {
    fn procedure_store_for_test(dir: &TempDir) -> ProcedureStore {
        let store_dir = dir.path().to_str().unwrap();
        let mut builder = Builder::default();
-        let _ = builder.root(store_dir);
+        builder.root(store_dir);
        let object_store = ObjectStore::new(builder).unwrap().finish();

        ProcedureStore::from_object_store(object_store)
--- a/src/common/procedure/src/store/state_store.rs
+++ b/src/common/procedure/src/store/state_store.rs
@@ -173,7 +173,7 @@ mod tests {
        let dir = create_temp_dir("state_store");
        let store_dir = dir.path().to_str().unwrap();
        let mut builder = Builder::default();
-        let _ = builder.root(store_dir);
+        builder.root(store_dir);

        let object_store = ObjectStore::new(builder).unwrap().finish();
        let state_store = ObjectStateStore::new(object_store);
@@ -244,7 +244,7 @@ mod tests {
        let dir = create_temp_dir("state_store_list");
        let store_dir = dir.path().to_str().unwrap();
        let mut builder = Builder::default();
-        let _ = builder.root(store_dir);
+        builder.root(store_dir);

        let object_store = ObjectStore::new(builder).unwrap().finish();
        let state_store = ObjectStateStore::new(object_store);
--- a/src/common/query/src/physical_plan.rs
+++ b/src/common/query/src/physical_plan.rs
@@ -22,7 +22,6 @@ use datafusion::arrow::datatypes::SchemaRef as DfSchemaRef;
 use datafusion::error::Result as DfResult;
 pub use datafusion::execution::context::{SessionContext, TaskContext};
 use datafusion::physical_plan::expressions::PhysicalSortExpr;
-use datafusion::physical_plan::metrics::{BaselineMetrics, ExecutionPlanMetricsSet, MetricsSet};
 pub use datafusion::physical_plan::Partitioning;
 use datafusion::physical_plan::Statistics;
 use datatypes::schema::SchemaRef;
@@ -70,10 +69,6 @@ pub trait PhysicalPlan: Debug + Send + Sync {
        partition: usize,
        context: Arc<TaskContext>,
    ) -> Result<SendableRecordBatchStream>;
-
-    fn metrics(&self) -> Option<MetricsSet> {
-        None
-    }
 }

 /// Adapt DataFusion's [`ExecutionPlan`](DfPhysicalPlan) to GreptimeDB's [`PhysicalPlan`].
@@ -81,16 +76,11 @@ pub trait PhysicalPlan: Debug + Send + Sync {
 pub struct PhysicalPlanAdapter {
    schema: SchemaRef,
    df_plan: Arc<dyn DfPhysicalPlan>,
-    metric: ExecutionPlanMetricsSet,
 }

 impl PhysicalPlanAdapter {
    pub fn new(schema: SchemaRef, df_plan: Arc<dyn DfPhysicalPlan>) -> Self {
-        Self {
-            schema,
-            df_plan,
-            metric: ExecutionPlanMetricsSet::new(),
-        }
+        Self { schema, df_plan }
    }

    pub fn df_plan(&self) -> Arc<dyn DfPhysicalPlan> {
@@ -137,21 +127,15 @@ impl PhysicalPlan for PhysicalPlanAdapter {
        partition: usize,
        context: Arc<TaskContext>,
    ) -> Result<SendableRecordBatchStream> {
-        let baseline_metric = BaselineMetrics::new(&self.metric, partition);
-
        let df_plan = self.df_plan.clone();
        let stream = df_plan
            .execute(partition, context)
            .context(error::GeneralDataFusionSnafu)?;
-        let adapter = RecordBatchStreamAdapter::try_new_with_metrics(stream, baseline_metric)
+        let adapter = RecordBatchStreamAdapter::try_new(stream)
            .context(error::ConvertDfRecordBatchStreamSnafu)?;

        Ok(Box::pin(adapter))
    }
-
-    fn metrics(&self) -> Option<MetricsSet> {
-        self.df_plan.metrics()
-    }
 }

 #[derive(Debug)]
@@ -212,10 +196,6 @@ impl DfPhysicalPlan for DfPhysicalPlanAdapter {
    fn statistics(&self) -> Statistics {
        Statistics::default()
    }
-
-    fn metrics(&self) -> Option<MetricsSet> {
-        self.0.metrics()
-    }
 }

 #[cfg(test)]
@@ -373,7 +353,7 @@ mod test {
            Arc::new(Schema::try_from(df_schema.clone()).unwrap()),
            Arc::new(EmptyExec::new(true, df_schema.clone())),
        );
-        let _ = plan.df_plan.as_any().downcast_ref::<EmptyExec>().unwrap();
+        assert!(plan.df_plan.as_any().downcast_ref::<EmptyExec>().is_some());

        let df_plan = DfPhysicalPlanAdapter(Arc::new(plan));
        assert_eq!(df_schema, df_plan.schema());
--- a/src/common/recordbatch/src/adapter.rs
+++ b/src/common/recordbatch/src/adapter.rs
@@ -20,7 +20,6 @@ use std::task::{Context, Poll};
 use datafusion::arrow::datatypes::SchemaRef as DfSchemaRef;
 use datafusion::error::Result as DfResult;
 use datafusion::parquet::arrow::async_reader::{AsyncFileReader, ParquetRecordBatchStream};
-use datafusion::physical_plan::metrics::BaselineMetrics;
 use datafusion::physical_plan::RecordBatchStream as DfRecordBatchStream;
 use datafusion_common::DataFusionError;
 use datatypes::schema::{Schema, SchemaRef};
@@ -116,31 +115,13 @@ impl Stream for DfRecordBatchStreamAdapter {
 pub struct RecordBatchStreamAdapter {
    schema: SchemaRef,
    stream: DfSendableRecordBatchStream,
-    metrics: Option<BaselineMetrics>,
 }

 impl RecordBatchStreamAdapter {
    pub fn try_new(stream: DfSendableRecordBatchStream) -> Result<Self> {
        let schema =
            Arc::new(Schema::try_from(stream.schema()).context(error::SchemaConversionSnafu)?);
-        Ok(Self {
-            schema,
-            stream,
-            metrics: None,
-        })
-    }
-
-    pub fn try_new_with_metrics(
-        stream: DfSendableRecordBatchStream,
-        metrics: BaselineMetrics,
-    ) -> Result<Self> {
-        let schema =
-            Arc::new(Schema::try_from(stream.schema()).context(error::SchemaConversionSnafu)?);
-        Ok(Self {
-            schema,
-            stream,
-            metrics: Some(metrics),
-        })
+        Ok(Self { schema, stream })
    }
 }

@@ -154,12 +135,6 @@ impl Stream for RecordBatchStreamAdapter {
    type Item = Result<RecordBatch>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let timer = self
-            .metrics
-            .as_ref()
-            .map(|m| m.elapsed_compute().clone())
-            .unwrap_or_default();
-        let _guard = timer.timer();
        match Pin::new(&mut self.stream).poll_next(cx) {
            Poll::Pending => Poll::Pending,
            Poll::Ready(Some(df_record_batch)) => {
--- a/src/common/recordbatch/src/recordbatch.rs
+++ b/src/common/recordbatch/src/recordbatch.rs
@@ -164,7 +164,7 @@ impl RecordBatch {
                vector.clone()
            };

-            let _ = vectors.insert(column_name.clone(), vector);
+            vectors.insert(column_name.clone(), vector);
        }

        Ok(vectors)
--- a/src/common/runtime/src/repeated_task.rs
+++ b/src/common/runtime/src/repeated_task.rs
@@ -172,7 +172,8 @@ mod tests {
        }

        async fn call(&mut self) -> Result<()> {
-            let _ = self.n.fetch_add(1, Ordering::Relaxed);
+            self.n.fetch_add(1, Ordering::Relaxed);
+
            Ok(())
        }
    }
--- a/src/common/runtime/src/runtime.rs
+++ b/src/common/runtime/src/runtime.rs
@@ -47,7 +47,7 @@ pub struct Dropper {
 impl Drop for Dropper {
    fn drop(&mut self) {
        // Send a signal to say i am dropping.
-        let _ = self.close.take().map(|v| v.send(()));
+        self.close.take().map(|v| v.send(()));
    }
 }

@@ -104,7 +104,7 @@ impl Builder {
    ///
    /// This can be any number above 0. The default value is the number of cores available to the system.
    pub fn worker_threads(&mut self, val: usize) -> &mut Self {
-        let _ = self.builder.worker_threads(val);
+        self.builder.worker_threads(val);
        self
    }

@@ -114,7 +114,7 @@ impl Builder {
    /// they are not always active and will exit if left idle for too long, You can change this timeout duration
    /// with thread_keep_alive. The default value is 512.
    pub fn max_blocking_threads(&mut self, val: usize) -> &mut Self {
-        let _ = self.builder.max_blocking_threads(val);
+        self.builder.max_blocking_threads(val);
        self
    }

@@ -122,7 +122,7 @@ impl Builder {
    ///
    /// By default, the timeout for a thread is set to 10 seconds.
    pub fn thread_keep_alive(&mut self, duration: Duration) -> &mut Self {
-        let _ = self.builder.thread_keep_alive(duration);
+        self.builder.thread_keep_alive(duration);
        self
    }

@@ -212,6 +212,7 @@ mod tests {
            .worker_threads(2)
            .thread_name("test_spawn_join")
            .build();
+        assert!(runtime.is_ok());
        Arc::new(runtime.unwrap())
    }

@@ -226,7 +227,7 @@ mod tests {
        // wait threads created
        thread::sleep(Duration::from_millis(50));

-        let _handle = runtime.spawn(async {
+        runtime.spawn(async {
            thread::sleep(Duration::from_millis(50));
        });

@@ -246,7 +247,7 @@ mod tests {
        let out = runtime.block_on(async {
            let (tx, rx) = oneshot::channel();

-            let _ = thread::spawn(move || {
+            thread::spawn(move || {
                thread::sleep(Duration::from_millis(50));
                tx.send("ZOMG").unwrap();
            });
--- a/src/common/telemetry/src/panic_hook.rs
+++ b/src/common/telemetry/src/panic_hook.rs
@@ -46,7 +46,7 @@ pub fn set_panic_hook() {
    }));

    #[cfg(feature = "deadlock_detection")]
-    let _ = std::thread::spawn(move || loop {
+    std::thread::spawn(move || loop {
        std::thread::sleep(Duration::from_secs(5));
        let deadlocks = parking_lot::deadlock::check_deadlock();
        if deadlocks.is_empty() {
--- a/src/common/time/src/timestamp.rs
+++ b/src/common/time/src/timestamp.rs
@@ -879,14 +879,14 @@ mod tests {

    #[test]
    fn test_split_overflow() {
-        let _ = Timestamp::new(i64::MAX, TimeUnit::Second).split();
-        let _ = Timestamp::new(i64::MIN, TimeUnit::Second).split();
-        let _ = Timestamp::new(i64::MAX, TimeUnit::Millisecond).split();
-        let _ = Timestamp::new(i64::MIN, TimeUnit::Millisecond).split();
-        let _ = Timestamp::new(i64::MAX, TimeUnit::Microsecond).split();
-        let _ = Timestamp::new(i64::MIN, TimeUnit::Microsecond).split();
-        let _ = Timestamp::new(i64::MAX, TimeUnit::Nanosecond).split();
-        let _ = Timestamp::new(i64::MIN, TimeUnit::Nanosecond).split();
+        Timestamp::new(i64::MAX, TimeUnit::Second).split();
+        Timestamp::new(i64::MIN, TimeUnit::Second).split();
+        Timestamp::new(i64::MAX, TimeUnit::Millisecond).split();
+        Timestamp::new(i64::MIN, TimeUnit::Millisecond).split();
+        Timestamp::new(i64::MAX, TimeUnit::Microsecond).split();
+        Timestamp::new(i64::MIN, TimeUnit::Microsecond).split();
+        Timestamp::new(i64::MAX, TimeUnit::Nanosecond).split();
+        Timestamp::new(i64::MIN, TimeUnit::Nanosecond).split();
        let (sec, nsec) = Timestamp::new(i64::MIN, TimeUnit::Nanosecond).split();
        let time = NaiveDateTime::from_timestamp_opt(sec, nsec).unwrap();
        assert_eq!(sec, time.timestamp());
--- a/src/datanode/src/datanode.rs
+++ b/src/datanode/src/datanode.rs
@@ -18,8 +18,6 @@ use std::sync::Arc;
 use std::time::Duration;

 use common_base::readable_size::ReadableSize;
-use common_base::Plugins;
-use common_error::prelude::BoxedError;
 use common_telemetry::info;
 use common_telemetry::logging::LoggingOptions;
 use meta_client::MetaClientOptions;
@@ -27,15 +25,13 @@ use secrecy::SecretString;
 use serde::{Deserialize, Serialize};
 use servers::http::HttpOptions;
 use servers::Mode;
-use snafu::ResultExt;
 use storage::config::{
    EngineConfig as StorageEngineConfig, DEFAULT_AUTO_FLUSH_INTERVAL, DEFAULT_MAX_FLUSH_TASKS,
    DEFAULT_PICKER_SCHEDULE_INTERVAL, DEFAULT_REGION_WRITE_BUFFER_SIZE,
 };
 use storage::scheduler::SchedulerConfig;

-use crate::error::{Result, ShutdownInstanceSnafu};
-use crate::heartbeat::HeartbeatTask;
+use crate::error::Result;
 use crate::instance::{Instance, InstanceRef};
 use crate::server::Services;

@@ -344,7 +340,6 @@ pub struct DatanodeOptions {
    pub rpc_addr: String,
    pub rpc_hostname: Option<String>,
    pub rpc_runtime_size: usize,
-    pub heartbeat_interval_millis: u64,
    pub http_opts: HttpOptions,
    pub meta_client_options: Option<MetaClientOptions>,
    pub wal: WalConfig,
@@ -368,7 +363,6 @@ impl Default for DatanodeOptions {
            storage: StorageConfig::default(),
            procedure: ProcedureConfig::default(),
            logging: LoggingOptions::default(),
-            heartbeat_interval_millis: 5000,
        }
    }
 }
@@ -384,12 +378,11 @@ pub struct Datanode {
    opts: DatanodeOptions,
    services: Option<Services>,
    instance: InstanceRef,
-    heartbeat_task: Option<HeartbeatTask>,
 }

 impl Datanode {
-    pub async fn new(opts: DatanodeOptions, plugins: Arc<Plugins>) -> Result<Datanode> {
-        let (instance, heartbeat_task) = Instance::with_opts(&opts, plugins).await?;
+    pub async fn new(opts: DatanodeOptions) -> Result<Datanode> {
+        let instance = Arc::new(Instance::with_opts(&opts).await?);
        let services = match opts.mode {
            Mode::Distributed => Some(Services::try_new(instance.clone(), &opts).await?),
            Mode::Standalone => None,
@@ -398,7 +391,6 @@ impl Datanode {
            opts,
            services,
            instance,
-            heartbeat_task,
        })
    }

@@ -410,11 +402,7 @@ impl Datanode {

    /// Start only the internal component of datanode.
    pub async fn start_instance(&mut self) -> Result<()> {
-        let _ = self.instance.start().await;
-        if let Some(task) = &self.heartbeat_task {
-            task.start().await?;
-        }
-        Ok(())
+        self.instance.start().await
    }

    /// Start services of datanode. This method call will block until services are shutdown.
@@ -431,15 +419,7 @@ impl Datanode {
    }

    pub async fn shutdown_instance(&self) -> Result<()> {
-        if let Some(heartbeat_task) = &self.heartbeat_task {
-            heartbeat_task
-                .close()
-                .await
-                .map_err(BoxedError::new)
-                .context(ShutdownInstanceSnafu)?;
-        }
-        let _ = self.instance.shutdown().await;
-        Ok(())
+        self.instance.shutdown().await
    }

    async fn shutdown_services(&self) -> Result<()> {
--- a/src/datanode/src/error.rs
+++ b/src/datanode/src/error.rs
@@ -196,11 +196,8 @@ pub enum Error {
        source: sql::error::Error,
    },

-    #[snafu(display("Missing insert body, source: {source}"))]
-    MissingInsertBody {
-        source: sql::error::Error,
-        location: Location,
-    },
+    #[snafu(display("Missing insert body"))]
+    MissingInsertBody { location: Location },

    #[snafu(display("Failed to insert value to table: {}, source: {}", table_name, source))]
    Insert {
@@ -530,6 +527,7 @@ impl ErrorExt for Error {
            | ConstraintNotSupported { .. }
            | SchemaExists { .. }
            | ParseTimestamp { .. }
+            | MissingInsertBody { .. }
            | DatabaseNotFound { .. }
            | MissingNodeId { .. }
            | MissingMetasrvOpts { .. }
@@ -557,7 +555,6 @@ impl ErrorExt for Error {
            | Catalog { .. }
            | MissingRequiredField { .. }
            | IncorrectInternalState { .. }
-            | MissingInsertBody { .. }
            | ShutdownInstance { .. }
            | CloseTableEngine { .. }
            | JoinTask { .. } => StatusCode::Internal,
--- a/src/datanode/src/heartbeat.rs
+++ b/src/datanode/src/heartbeat.rs
@@ -89,7 +89,7 @@ impl HeartbeatTask {
        let client_id = meta_client.id();

        let (tx, mut rx) = meta_client.heartbeat().await.context(MetaClientInitSnafu)?;
-        let _handle = common_runtime::spawn_bg(async move {
+        common_runtime::spawn_bg(async move {
            while let Some(res) = match rx.message().await {
                Ok(m) => m,
                Err(e) => {
@@ -160,7 +160,7 @@ impl HeartbeatTask {
        .await?;

        let epoch = self.region_alive_keepers.epoch();
-        let _handle = common_runtime::spawn_bg(async move {
+        common_runtime::spawn_bg(async move {
            let sleep = tokio::time::sleep(Duration::from_millis(0));
            tokio::pin!(sleep);

--- a/src/datanode/src/heartbeat/handler/close_region.rs
+++ b/src/datanode/src/heartbeat/handler/close_region.rs
@@ -56,7 +56,7 @@ impl HeartbeatResponseHandler for CloseRegionHandler {

        let mailbox = ctx.mailbox.clone();
        let self_ref = Arc::new(self.clone());
-        let _handle = common_runtime::spawn_bg(async move {
+        common_runtime::spawn_bg(async move {
            let result = self_ref.close_region_inner(region_ident).await;

            if let Err(e) = mailbox
@@ -164,7 +164,7 @@ impl CloseRegionHandler {
        }

        if engine
-            .get_table(&ctx, region_ident.table_ident.table_id)
+            .get_table(&ctx, table_ref)
            .with_context(|_| error::GetTableSnafu {
                table_name: table_ref.to_string(),
            })?
@@ -178,7 +178,6 @@ impl CloseRegionHandler {
                        schema_name: table_ref.schema.to_string(),
                        table_name: table_ref.table.to_string(),
                        region_numbers: region_numbers.clone(),
-                        table_id: region_ident.table_ident.table_id,
                        flush: true,
                    },
                )
@@ -189,14 +188,15 @@ impl CloseRegionHandler {
                })? {
                CloseTableResult::NotFound | CloseTableResult::Released(_) => {
                    // Deregister table if The table released.
-                    self.deregister_table(table_ref).await?;
+                    let deregistered = self.deregister_table(table_ref).await?;

-                    let _ = self
-                        .region_alive_keepers
-                        .deregister_table(table_ident)
-                        .await;
+                    if deregistered {
+                        self.region_alive_keepers
+                            .deregister_table(table_ident)
+                            .await;
+                    }

-                    Ok(true)
+                    Ok(deregistered)
                }
                CloseTableResult::PartialClosed(regions) => {
                    // Requires caller to update the region_numbers
@@ -219,7 +219,7 @@ impl CloseRegionHandler {
        Ok(true)
    }

-    async fn deregister_table(&self, table_ref: &TableReference<'_>) -> Result<()> {
+    async fn deregister_table(&self, table_ref: &TableReference<'_>) -> Result<bool> {
        self.catalog_manager
            .deregister_table(DeregisterTableRequest {
                catalog: table_ref.catalog.to_string(),
--- a/src/datanode/src/heartbeat/handler/open_region.rs
+++ b/src/datanode/src/heartbeat/handler/open_region.rs
@@ -58,7 +58,7 @@ impl HeartbeatResponseHandler for OpenRegionHandler {
        let self_ref = Arc::new(self.clone());

        let region_alive_keepers = self.region_alive_keepers.clone();
-        let _handle = common_runtime::spawn_bg(async move {
+        common_runtime::spawn_bg(async move {
            let table_ident = &region_ident.table_ident;
            let request = OpenTableRequest {
                catalog_name: table_ident.catalog.clone(),
--- a/src/datanode/src/instance.rs
+++ b/src/datanode/src/instance.rs
@@ -22,7 +22,6 @@ use catalog::remote::region_alive_keeper::RegionAliveKeepers;
 use catalog::remote::{CachedMetaKvBackend, RemoteCatalogManager};
 use catalog::{CatalogManager, CatalogManagerRef, RegisterTableRequest};
 use common_base::paths::{CLUSTER_DIR, WAL_DIR};
-use common_base::Plugins;
 use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, MIN_USER_TABLE_ID};
 use common_error::prelude::BoxedError;
 use common_grpc::channel_manager::{ChannelConfig, ChannelManager};
@@ -49,7 +48,7 @@ use storage::config::EngineConfig as StorageEngineConfig;
 use storage::scheduler::{LocalScheduler, SchedulerConfig};
 use storage::EngineImpl;
 use store_api::logstore::LogStore;
-use table::engine::manager::{MemoryTableEngineManager, TableEngineManagerRef};
+use table::engine::manager::MemoryTableEngineManager;
 use table::engine::{TableEngine, TableEngineProcedureRef};
 use table::requests::FlushTableRequest;
 use table::table::numbers::NumbersTable;
@@ -79,16 +78,14 @@ pub struct Instance {
    pub(crate) sql_handler: SqlHandler,
    pub(crate) catalog_manager: CatalogManagerRef,
    pub(crate) table_id_provider: Option<TableIdProviderRef>,
+    pub(crate) heartbeat_task: Option<HeartbeatTask>,
    procedure_manager: ProcedureManagerRef,
 }

 pub type InstanceRef = Arc<Instance>;

 impl Instance {
-    pub async fn with_opts(
-        opts: &DatanodeOptions,
-        plugins: Arc<Plugins>,
-    ) -> Result<(InstanceRef, Option<HeartbeatTask>)> {
+    pub async fn with_opts(opts: &DatanodeOptions) -> Result<Self> {
        let meta_client = match opts.mode {
            Mode::Standalone => None,
            Mode::Distributed => {
@@ -105,61 +102,14 @@ impl Instance {

        let compaction_scheduler = create_compaction_scheduler(opts);

-        Self::new(opts, meta_client, compaction_scheduler, plugins).await
-    }
-
-    fn build_heartbeat_task(
-        opts: &DatanodeOptions,
-        meta_client: Option<Arc<MetaClient>>,
-        catalog_manager: CatalogManagerRef,
-        engine_manager: TableEngineManagerRef,
-        region_alive_keepers: Option<Arc<RegionAliveKeepers>>,
-    ) -> Result<Option<HeartbeatTask>> {
-        Ok(match opts.mode {
-            Mode::Standalone => None,
-            Mode::Distributed => {
-                let node_id = opts.node_id.context(MissingNodeIdSnafu)?;
-                let meta_client = meta_client.context(IncorrectInternalStateSnafu {
-                    state: "meta client is not provided when building heartbeat task",
-                })?;
-                let region_alive_keepers =
-                    region_alive_keepers.context(IncorrectInternalStateSnafu {
-                        state: "region_alive_keepers is not provided when building heartbeat task",
-                    })?;
-                let handlers_executor = HandlerGroupExecutor::new(vec![
-                    Arc::new(ParseMailboxMessageHandler::default()),
-                    Arc::new(OpenRegionHandler::new(
-                        catalog_manager.clone(),
-                        engine_manager.clone(),
-                        region_alive_keepers.clone(),
-                    )),
-                    Arc::new(CloseRegionHandler::new(
-                        catalog_manager.clone(),
-                        engine_manager,
-                        region_alive_keepers.clone(),
-                    )),
-                    region_alive_keepers.clone(),
-                ]);
-
-                Some(HeartbeatTask::new(
-                    node_id,
-                    opts,
-                    meta_client,
-                    catalog_manager,
-                    Arc::new(handlers_executor),
-                    opts.heartbeat_interval_millis,
-                    region_alive_keepers,
-                ))
-            }
-        })
+        Self::new(opts, meta_client, compaction_scheduler).await
    }

    pub(crate) async fn new(
        opts: &DatanodeOptions,
        meta_client: Option<Arc<MetaClient>>,
        compaction_scheduler: CompactionSchedulerRef<RaftEngineLogStore>,
-        plugins: Arc<Plugins>,
-    ) -> Result<(InstanceRef, Option<HeartbeatTask>)> {
+    ) -> Result<Self> {
        let object_store = store::new_object_store(&opts.storage.store).await?;
        let log_store = Arc::new(create_log_store(&opts.storage.store, &opts.wal).await?);

@@ -177,21 +127,21 @@ impl Instance {
            object_store.clone(),
        ));

+        let mut engine_procedures = HashMap::with_capacity(2);
+        engine_procedures.insert(
+            mito_engine.name().to_string(),
+            mito_engine.clone() as TableEngineProcedureRef,
+        );
+
        let immutable_file_engine = Arc::new(ImmutableFileTableEngine::new(
            file_table_engine::config::EngineConfig::default(),
            object_store.clone(),
        ));
+        engine_procedures.insert(
+            immutable_file_engine.name().to_string(),
+            immutable_file_engine.clone() as TableEngineProcedureRef,
+        );

-        let engine_procedures = HashMap::from([
-            (
-                mito_engine.name().to_string(),
-                mito_engine.clone() as TableEngineProcedureRef,
-            ),
-            (
-                immutable_file_engine.name().to_string(),
-                immutable_file_engine.clone() as TableEngineProcedureRef,
-            ),
-        ]);
        let engine_manager = Arc::new(
            MemoryTableEngineManager::with(vec![
                mito_engine.clone(),
@@ -201,13 +151,13 @@ impl Instance {
        );

        // create remote catalog manager
-        let (catalog_manager, table_id_provider, region_alive_keepers) = match opts.mode {
+        let (catalog_manager, table_id_provider, heartbeat_task) = match opts.mode {
            Mode::Standalone => {
                if opts.enable_memory_catalog {
                    let catalog = Arc::new(catalog::local::MemoryCatalogManager::default());
                    let table = NumbersTable::new(MIN_USER_TABLE_ID);

-                    let _ = catalog
+                    catalog
                        .register_table(RegisterTableRequest {
                            table_id: MIN_USER_TABLE_ID,
                            table_name: table.table_info().name.to_string(),
@@ -239,15 +189,17 @@ impl Instance {
            }

            Mode::Distributed => {
-                let meta_client = meta_client.clone().context(IncorrectInternalStateSnafu {
+                let meta_client = meta_client.context(IncorrectInternalStateSnafu {
                    state: "meta client is not provided when creating distributed Datanode",
                })?;

-                let kv_backend = Arc::new(CachedMetaKvBackend::new(meta_client));
+                let kv_backend = Arc::new(CachedMetaKvBackend::new(meta_client.clone()));
+
+                let heartbeat_interval_millis = 5000;

                let region_alive_keepers = Arc::new(RegionAliveKeepers::new(
                    engine_manager.clone(),
-                    opts.heartbeat_interval_millis,
+                    heartbeat_interval_millis,
                ));

                let catalog_manager = Arc::new(RemoteCatalogManager::new(
@@ -257,22 +209,36 @@ impl Instance {
                    region_alive_keepers.clone(),
                ));

-                (
-                    catalog_manager as CatalogManagerRef,
-                    None,
-                    Some(region_alive_keepers),
-                )
+                let handlers_executor = HandlerGroupExecutor::new(vec![
+                    Arc::new(ParseMailboxMessageHandler::default()),
+                    Arc::new(OpenRegionHandler::new(
+                        catalog_manager.clone(),
+                        engine_manager.clone(),
+                        region_alive_keepers.clone(),
+                    )),
+                    Arc::new(CloseRegionHandler::new(
+                        catalog_manager.clone(),
+                        engine_manager.clone(),
+                        region_alive_keepers.clone(),
+                    )),
+                    region_alive_keepers.clone(),
+                ]);
+
+                let heartbeat_task = Some(HeartbeatTask::new(
+                    opts.node_id.context(MissingNodeIdSnafu)?,
+                    opts,
+                    meta_client,
+                    catalog_manager.clone(),
+                    Arc::new(handlers_executor),
+                    heartbeat_interval_millis,
+                    region_alive_keepers,
+                ));
+
+                (catalog_manager as CatalogManagerRef, None, heartbeat_task)
            }
        };

-        catalog_manager.start().await.context(CatalogSnafu)?;
-        let factory = QueryEngineFactory::new_with_plugins(
-            catalog_manager.clone(),
-            false,
-            None,
-            None,
-            plugins,
-        );
+        let factory = QueryEngineFactory::new(catalog_manager.clone(), false);
        let query_engine = factory.query_engine();

        let procedure_manager =
@@ -291,27 +257,18 @@ impl Instance {
            &*procedure_manager,
        );

-        let instance = Arc::new(Self {
+        Ok(Self {
            query_engine: query_engine.clone(),
            sql_handler: SqlHandler::new(
-                engine_manager.clone(),
+                engine_manager,
                catalog_manager.clone(),
                procedure_manager.clone(),
            ),
-            catalog_manager: catalog_manager.clone(),
+            catalog_manager,
+            heartbeat_task,
            table_id_provider,
            procedure_manager,
-        });
-
-        let heartbeat_task = Instance::build_heartbeat_task(
-            opts,
-            meta_client,
-            catalog_manager,
-            engine_manager,
-            region_alive_keepers,
-        )?;
-
-        Ok((instance, heartbeat_task))
+        })
    }

    pub async fn start(&self) -> Result<()> {
@@ -319,6 +276,9 @@ impl Instance {
            .start()
            .await
            .context(NewCatalogSnafu)?;
+        if let Some(task) = &self.heartbeat_task {
+            task.start().await?;
+        }

        // Recover procedures after the catalog manager is started, so we can
        // ensure we can access all tables from the catalog manager.
@@ -337,6 +297,13 @@ impl Instance {
            .stop()
            .await
            .context(StopProcedureManagerSnafu)?;
+        if let Some(heartbeat_task) = &self.heartbeat_task {
+            heartbeat_task
+                .close()
+                .await
+                .map_err(BoxedError::new)
+                .context(ShutdownInstanceSnafu)?;
+        }

        self.flush_tables().await?;

@@ -348,10 +315,15 @@ impl Instance {
    }

    pub async fn flush_tables(&self) -> Result<()> {
-        info!("going to flush all schemas under {DEFAULT_CATALOG_NAME}");
+        info!("going to flush all schemas");
        let schema_list = self
            .catalog_manager
-            .schema_names(DEFAULT_CATALOG_NAME)
+            .catalog(DEFAULT_CATALOG_NAME)
+            .await
+            .map_err(BoxedError::new)
+            .context(ShutdownInstanceSnafu)?
+            .expect("Default schema not found")
+            .schema_names()
            .await
            .map_err(BoxedError::new)
            .context(ShutdownInstanceSnafu)?;
@@ -376,7 +348,7 @@ impl Instance {
        .map_err(BoxedError::new)
        .context(ShutdownInstanceSnafu);
        info!("Flushed all tables result: {}", flush_result.is_ok());
-        let _ = flush_result?;
+        flush_result?;

        Ok(())
    }
--- a/src/datanode/src/instance/grpc.rs
+++ b/src/datanode/src/instance/grpc.rs
@@ -42,9 +42,9 @@ use table::requests::CreateDatabaseRequest;
 use table::table::adapter::DfTableProviderAdapter;

 use crate::error::{
-    self, CatalogSnafu, DecodeLogicalPlanSnafu, DeleteExprToRequestSnafu, DeleteSnafu,
-    ExecuteLogicalPlanSnafu, ExecuteSqlSnafu, InsertDataSnafu, InsertSnafu, JoinTaskSnafu,
-    PlanStatementSnafu, Result, TableNotFoundSnafu,
+    self, CatalogNotFoundSnafu, CatalogSnafu, DecodeLogicalPlanSnafu, DeleteExprToRequestSnafu,
+    DeleteSnafu, ExecuteLogicalPlanSnafu, ExecuteSqlSnafu, InsertDataSnafu, InsertSnafu,
+    JoinTaskSnafu, PlanStatementSnafu, Result, SchemaNotFoundSnafu, TableNotFoundSnafu,
 };
 use crate::instance::Instance;

@@ -231,10 +231,19 @@ impl DummySchemaProvider {
        schema_name: String,
        catalog_manager: CatalogManagerRef,
    ) -> Result<Self> {
-        let table_names = catalog_manager
-            .table_names(&catalog_name, &schema_name)
+        let catalog = catalog_manager
+            .catalog(&catalog_name)
            .await
-            .unwrap();
+            .context(CatalogSnafu)?
+            .context(CatalogNotFoundSnafu {
+                name: &catalog_name,
+            })?;
+        let schema = catalog
+            .schema(&schema_name)
+            .await
+            .context(CatalogSnafu)?
+            .context(SchemaNotFoundSnafu { name: &schema_name })?;
+        let table_names = schema.table_names().await.context(CatalogSnafu)?;
        Ok(Self {
            catalog: catalog_name,
            schema: schema_name,
@@ -281,11 +290,11 @@ async fn new_dummy_catalog_list(
    )
    .await?;
    let catalog_provider = MemoryCatalogProvider::new();
-    assert!(catalog_provider
+    catalog_provider
        .register_schema(schema_name, Arc::new(schema_provider) as Arc<_>)
-        .is_ok());
+        .unwrap();
    let catalog_list = MemoryCatalogList::new();
-    let _ = catalog_list.register_catalog(
+    catalog_list.register_catalog(
        catalog_name.to_string(),
        Arc::new(catalog_provider) as Arc<_>,
    );
@@ -438,12 +447,9 @@ mod test {
    async fn test_handle_insert() {
        let instance = MockInstance::new("test_handle_insert").await;
        let instance = instance.inner();
-        assert!(test_util::create_test_table(
-            instance,
-            ConcreteDataType::timestamp_millisecond_datatype()
-        )
-        .await
-        .is_ok());
+        test_util::create_test_table(instance, ConcreteDataType::timestamp_millisecond_datatype())
+            .await
+            .unwrap();

        let insert = InsertRequest {
            table_name: "demo".to_string(),
@@ -511,12 +517,9 @@ mod test {
    async fn test_handle_delete() {
        let instance = MockInstance::new("test_handle_delete").await;
        let instance = instance.inner();
-        assert!(test_util::create_test_table(
-            instance,
-            ConcreteDataType::timestamp_millisecond_datatype()
-        )
-        .await
-        .is_ok());
+        test_util::create_test_table(instance, ConcreteDataType::timestamp_millisecond_datatype())
+            .await
+            .unwrap();

        let query = GrpcRequest::Query(QueryRequest {
            query: Some(Query::Sql(
@@ -580,12 +583,9 @@ mod test {
    async fn test_handle_query() {
        let instance = MockInstance::new("test_handle_query").await;
        let instance = instance.inner();
-        assert!(test_util::create_test_table(
-            instance,
-            ConcreteDataType::timestamp_millisecond_datatype()
-        )
-        .await
-        .is_ok());
+        test_util::create_test_table(instance, ConcreteDataType::timestamp_millisecond_datatype())
+            .await
+            .unwrap();

        let query = GrpcRequest::Query(QueryRequest {
            query: Some(Query::Sql(
--- a/src/datanode/src/instance/sql.rs
+++ b/src/datanode/src/instance/sql.rs
@@ -41,12 +41,9 @@ impl Instance {
    async fn do_execute_sql(&self, stmt: Statement, query_ctx: QueryContextRef) -> Result<Output> {
        match stmt {
            Statement::Insert(insert) => {
-                let request = SqlHandler::insert_to_request(
-                    self.catalog_manager.clone(),
-                    &insert,
-                    query_ctx.clone(),
-                )
-                .await?;
+                let request =
+                    SqlHandler::insert_to_request(self.catalog_manager.clone(), *insert, query_ctx)
+                        .await?;
                self.sql_handler.insert(request).await
            }
            Statement::CreateDatabase(create_database) => {
@@ -109,13 +106,7 @@ impl Instance {
                let name = alter_table.table_name().clone();
                let (catalog, schema, table) = table_idents_to_full_name(&name, query_ctx.clone())?;
                let table_ref = TableReference::full(&catalog, &schema, &table);
-                // Currently, we have to get the table multiple times. Consider remove the sql handler in the future.
-                let table = self.sql_handler.get_table(&table_ref).await?;
-                let req = SqlHandler::alter_to_request(
-                    alter_table,
-                    table_ref,
-                    table.table_info().ident.table_id,
-                )?;
+                let req = SqlHandler::alter_to_request(alter_table, table_ref)?;
                self.sql_handler
                    .execute(SqlRequest::Alter(req), query_ctx)
                    .await
@@ -123,13 +114,10 @@ impl Instance {
            Statement::DropTable(drop_table) => {
                let (catalog_name, schema_name, table_name) =
                    table_idents_to_full_name(drop_table.table_name(), query_ctx.clone())?;
-                let table_ref = TableReference::full(&catalog_name, &schema_name, &table_name);
-                let table = self.sql_handler.get_table(&table_ref).await?;
                let req = DropTableRequest {
                    catalog_name,
                    schema_name,
                    table_name,
-                    table_id: table.table_info().ident.table_id,
                };
                self.sql_handler
                    .execute(SqlRequest::DropTable(req), query_ctx)
--- a/src/datanode/src/lib.rs
+++ b/src/datanode/src/lib.rs
@@ -17,7 +17,7 @@

 pub mod datanode;
 pub mod error;
-pub mod heartbeat;
+mod heartbeat;
 pub mod instance;
 pub mod metrics;
 mod mock;
--- a/src/datanode/src/mock.rs
+++ b/src/datanode/src/mock.rs
@@ -21,30 +21,18 @@ use storage::compaction::noop::NoopCompactionScheduler;

 use crate::datanode::DatanodeOptions;
 use crate::error::Result;
-use crate::heartbeat::HeartbeatTask;
-use crate::instance::{Instance, InstanceRef};
+use crate::instance::Instance;

 impl Instance {
-    pub async fn with_mock_meta_client(
-        opts: &DatanodeOptions,
-    ) -> Result<(InstanceRef, Option<HeartbeatTask>)> {
+    pub async fn with_mock_meta_client(opts: &DatanodeOptions) -> Result<Self> {
        let mock_info = meta_srv::mocks::mock_with_memstore().await;
        Self::with_mock_meta_server(opts, mock_info).await
    }

-    pub async fn with_mock_meta_server(
-        opts: &DatanodeOptions,
-        meta_srv: MockInfo,
-    ) -> Result<(InstanceRef, Option<HeartbeatTask>)> {
+    pub async fn with_mock_meta_server(opts: &DatanodeOptions, meta_srv: MockInfo) -> Result<Self> {
        let meta_client = Arc::new(mock_meta_client(meta_srv, opts.node_id.unwrap_or(42)).await);
        let compaction_scheduler = Arc::new(NoopCompactionScheduler::default());
-        Instance::new(
-            opts,
-            Some(meta_client),
-            compaction_scheduler,
-            Default::default(),
-        )
-        .await
+        Instance::new(opts, Some(meta_client), compaction_scheduler).await
    }
 }

--- a/src/datanode/src/server.rs
+++ b/src/datanode/src/server.rs
@@ -72,7 +72,7 @@ impl Services {
        })?;
        let grpc = self.grpc_server.start(grpc_addr);
        let http = self.http_server.start(http_addr);
-        let _ = future::try_join_all(vec![grpc, http])
+        future::try_join_all(vec![grpc, http])
            .await
            .context(StartServerSnafu)?;

--- a/src/datanode/src/server/grpc.rs
+++ b/src/datanode/src/server/grpc.rs
@@ -14,7 +14,6 @@

 use api::v1::{AlterExpr, CreateTableExpr, DropTableExpr, FlushTableExpr};
 use common_catalog::consts::IMMUTABLE_FILE_ENGINE;
-use common_catalog::format_full_table_name;
 use common_grpc_expr::{alter_expr_to_request, create_expr_to_request};
 use common_query::Output;
 use common_telemetry::info;
@@ -23,8 +22,8 @@ use snafu::prelude::*;
 use table::requests::{DropTableRequest, FlushTableRequest};

 use crate::error::{
-    AlterExprToRequestSnafu, BumpTableIdSnafu, CatalogSnafu, CreateExprToRequestSnafu,
-    IncorrectInternalStateSnafu, Result, TableNotFoundSnafu,
+    AlterExprToRequestSnafu, BumpTableIdSnafu, CreateExprToRequestSnafu,
+    IncorrectInternalStateSnafu, Result,
 };
 use crate::instance::Instance;
 use crate::sql::SqlRequest;
@@ -70,45 +69,17 @@ impl Instance {
    }

    pub(crate) async fn handle_alter(&self, expr: AlterExpr) -> Result<Output> {
-        let table = self
-            .catalog_manager
-            .table(&expr.catalog_name, &expr.schema_name, &expr.table_name)
-            .await
-            .context(CatalogSnafu)?
-            .with_context(|| TableNotFoundSnafu {
-                table_name: format_full_table_name(
-                    &expr.catalog_name,
-                    &expr.schema_name,
-                    &expr.table_name,
-                ),
-            })?;
-
-        let request = alter_expr_to_request(table.table_info().ident.table_id, expr)
-            .context(AlterExprToRequestSnafu)?;
+        let request = alter_expr_to_request(expr).context(AlterExprToRequestSnafu)?;
        self.sql_handler()
            .execute(SqlRequest::Alter(request), QueryContext::arc())
            .await
    }

    pub(crate) async fn handle_drop_table(&self, expr: DropTableExpr) -> Result<Output> {
-        let table = self
-            .catalog_manager
-            .table(&expr.catalog_name, &expr.schema_name, &expr.table_name)
-            .await
-            .context(CatalogSnafu)?
-            .with_context(|| TableNotFoundSnafu {
-                table_name: format_full_table_name(
-                    &expr.catalog_name,
-                    &expr.schema_name,
-                    &expr.table_name,
-                ),
-            })?;
-
        let req = DropTableRequest {
            catalog_name: expr.catalog_name,
            schema_name: expr.schema_name,
            table_name: expr.table_name,
-            table_id: table.table_info().ident.table_id,
        };
        self.sql_handler()
            .execute(SqlRequest::DropTable(req), QueryContext::arc())
--- a/src/datanode/src/sql/alter.rs
+++ b/src/datanode/src/sql/alter.rs
@@ -19,7 +19,6 @@ use snafu::prelude::*;
 use sql::statements::alter::{AlterTable, AlterTableOperation};
 use sql::statements::column_def_to_schema;
 use table::engine::TableReference;
-use table::metadata::TableId;
 use table::requests::{AddColumnRequest, AlterKind, AlterTableRequest};
 use table_procedure::AlterTableProcedure;

@@ -61,7 +60,6 @@ impl SqlHandler {
    pub(crate) fn alter_to_request(
        alter_table: AlterTable,
        table_ref: TableReference,
-        table_id: TableId,
    ) -> Result<AlterTableRequest> {
        let alter_kind = match &alter_table.alter_operation() {
            AlterTableOperation::AddConstraint(table_constraint) => {
@@ -93,7 +91,6 @@ impl SqlHandler {
            catalog_name: table_ref.catalog.to_string(),
            schema_name: table_ref.schema.to_string(),
            table_name: table_ref.table.to_string(),
-            table_id,
            alter_kind,
        })
    }
@@ -131,7 +128,6 @@ mod tests {
        let req = SqlHandler::alter_to_request(
            alter_table,
            TableReference::full("greptime", "public", "my_metric_1"),
-            1,
        )
        .unwrap();
        assert_eq!(req.catalog_name, "greptime");
@@ -158,7 +154,6 @@ mod tests {
        let req = SqlHandler::alter_to_request(
            alter_table,
            TableReference::full("greptime", "public", "test_table"),
-            1,
        )
        .unwrap();
        assert_eq!(req.catalog_name, "greptime");
--- a/src/datanode/src/sql/create.rs
+++ b/src/datanode/src/sql/create.rs
@@ -48,9 +48,10 @@ impl SqlHandler {
        let schema = req.db_name;
        if self
            .catalog_manager
-            .schema_exist(&catalog, &schema)
+            .schema(&catalog, &schema)
            .await
            .context(CatalogSnafu)?
+            .is_some()
        {
            return if req.create_if_not_exists {
                Ok(Output::AffectedRows(1))
@@ -63,8 +64,7 @@ impl SqlHandler {
            catalog,
            schema: schema.clone(),
        };
-        let _ = self
-            .catalog_manager
+        self.catalog_manager
            .register_schema(reg_req)
            .await
            .context(RegisterSchemaSnafu)?;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
LFC	6ed6e39673	release v0.3.1	2023-06-21 16:28:41 +08:00
LFC	e5c61ec290	release v0.3.1	2023-06-21 16:28:07 +08:00