feat: Frontend show tables and databases (#504)

* feat: Frontend show tables and databases

Co-authored-by: luofucong <luofucong@greptime.com>

src/query/src/error.rs

@@ -1,7 +1,77 @@
+use std::any::Any;
+
+use common_error::prelude::*;
 use datafusion::error::DataFusionError;
+use snafu::{Backtrace, ErrorCompat, Snafu};
 
 common_error::define_opaque_error!(Error);
 
+#[derive(Debug, Snafu)]
+#[snafu(visibility(pub))]
+pub enum InnerError {
+    #[snafu(display("Unsupported expr type: {}", name))]
+    UnsupportedExpr { name: String, backtrace: Backtrace },
+
+    #[snafu(display("General catalog error: {}", source))]
+    Catalog {
+        #[snafu(backtrace)]
+        source: catalog::error::Error,
+    },
+
+    #[snafu(display("Catalog not found: {}", catalog))]
+    CatalogNotFound {
+        catalog: String,
+        backtrace: Backtrace,
+    },
+
+    #[snafu(display("Schema not found: {}", schema))]
+    SchemaNotFound {
+        schema: String,
+        backtrace: Backtrace,
+    },
+
+    #[snafu(display("Failed to do vector computation, source: {}", source))]
+    VectorComputation {
+        #[snafu(backtrace)]
+        source: datatypes::error::Error,
+    },
+
+    #[snafu(display("Failed to create RecordBatch, source: {}", source))]
+    CreateRecordBatch {
+        #[snafu(backtrace)]
+        source: common_recordbatch::error::Error,
+    },
+}
+
+impl ErrorExt for InnerError {
+    fn status_code(&self) -> StatusCode {
+        use InnerError::*;
+
+        match self {
+            UnsupportedExpr { .. } | CatalogNotFound { .. } | SchemaNotFound { .. } => {
+                StatusCode::InvalidArguments
+            }
+            Catalog { source } => source.status_code(),
+            VectorComputation { source } => source.status_code(),
+            CreateRecordBatch { source } => source.status_code(),
+        }
+    }
+
+    fn backtrace_opt(&self) -> Option<&Backtrace> {
+        ErrorCompat::backtrace(self)
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+impl From<InnerError> for Error {
+    fn from(e: InnerError) -> Error {
+        Error::new(e)
+    }
+}
+
 pub type Result<T> = std::result::Result<T, Error>;
 
 impl From<Error> for DataFusionError {

src/query/src/lib.rs

@@ -11,5 +11,6 @@ pub mod physical_planner;
 pub mod plan;
 pub mod planner;
 pub mod query_engine;
+pub mod sql;
 
 pub use crate::query_engine::{QueryContext, QueryEngine, QueryEngineFactory, QueryEngineRef};

src/query/src/sql.rs

@@ -0,0 +1,81 @@
+use std::sync::Arc;
+
+use catalog::CatalogManagerRef;
+use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
+use common_query::Output;
+use common_recordbatch::RecordBatches;
+use datatypes::prelude::*;
+use datatypes::schema::{ColumnSchema, Schema};
+use datatypes::vectors::{Helper, StringVector};
+use snafu::{ensure, OptionExt, ResultExt};
+use sql::statements::show::{ShowDatabases, ShowKind, ShowTables};
+
+use crate::error::{self, Result};
+
+const SCHEMAS_COLUMN: &str = "Schemas";
+const TABLES_COLUMN: &str = "Tables";
+
+pub fn show_databases(stmt: ShowDatabases, catalog_manager: CatalogManagerRef) -> Result<Output> {
+    // TODO(LFC): supports WHERE
+    ensure!(
+        matches!(stmt.kind, ShowKind::All | ShowKind::Like(_)),
+        error::UnsupportedExprSnafu {
+            name: stmt.kind.to_string(),
+        }
+    );
+
+    let catalog = catalog_manager
+        .catalog(DEFAULT_CATALOG_NAME)
+        .context(error::CatalogSnafu)?
+        .context(error::CatalogNotFoundSnafu {
+            catalog: DEFAULT_CATALOG_NAME,
+        })?;
+    let databases = catalog.schema_names().context(error::CatalogSnafu)?;
+
+    let databases = if let ShowKind::Like(ident) = stmt.kind {
+        Helper::like_utf8(databases, &ident.value).context(error::VectorComputationSnafu)?
+    } else {
+        Arc::new(StringVector::from(databases))
+    };
+
+    let schema = Arc::new(Schema::new(vec![ColumnSchema::new(
+        SCHEMAS_COLUMN,
+        ConcreteDataType::string_datatype(),
+        false,
+    )]));
+    let records = RecordBatches::try_from_columns(schema, vec![databases])
+        .context(error::CreateRecordBatchSnafu)?;
+    Ok(Output::RecordBatches(records))
+}
+
+pub fn show_tables(stmt: ShowTables, catalog_manager: CatalogManagerRef) -> Result<Output> {
+    // TODO(LFC): supports WHERE
+    ensure!(
+        matches!(stmt.kind, ShowKind::All | ShowKind::Like(_)),
+        error::UnsupportedExprSnafu {
+            name: stmt.kind.to_string(),
+        }
+    );
+
+    let schema = stmt.database.as_deref().unwrap_or(DEFAULT_SCHEMA_NAME);
+    let schema = catalog_manager
+        .schema(DEFAULT_CATALOG_NAME, schema)
+        .context(error::CatalogSnafu)?
+        .context(error::SchemaNotFoundSnafu { schema })?;
+    let tables = schema.table_names().context(error::CatalogSnafu)?;
+
+    let tables = if let ShowKind::Like(ident) = stmt.kind {
+        Helper::like_utf8(tables, &ident.value).context(error::VectorComputationSnafu)?
+    } else {
+        Arc::new(StringVector::from(tables))
+    };
+
+    let schema = Arc::new(Schema::new(vec![ColumnSchema::new(
+        TABLES_COLUMN,
+        ConcreteDataType::string_datatype(),
+        false,
+    )]));
+    let records = RecordBatches::try_from_columns(schema, vec![tables])
+        .context(error::CreateRecordBatchSnafu)?;
+    Ok(Output::RecordBatches(records))
+}