feat: support like syntax in show tables statement

interpreters/src/show.rs

@@ -14,6 +14,7 @@ use sql::{
     ast::ShowCreateObject,
     plan::{ShowCreatePlan, ShowPlan},
 };
+use sql::plan::ShowTablesPlan;
 
 use crate::{
     context::Context,
@@ -94,16 +95,25 @@ impl ShowInterpreter {
         show_create.execute_show_create()
     }
 
-    fn show_tables(ctx: Context, catalog_manager: ManagerRef) -> Result<Output> {
+    fn show_tables(ctx: Context, catalog_manager: ManagerRef,plan: ShowTablesPlan) -> Result<Output> {
         let schema = get_default_schema(&ctx, &catalog_manager)?;
 
-        let tables_names = schema
-            .all_tables()
-            .context(FetchTables)?
-            .iter()
-            .map(|t| t.name().to_string())
-            .collect::<Vec<_>>();
-
+        let tables_names =  match plan.if_fuzzy  {
+            true  => schema
+                .all_tables()
+                .context(FetchTables)?
+                .iter()
+                .filter(|t| t.name().contains::<&str>(plan.fuzzy_target.as_ref().unwrap().as_ref()))
+                .map(|t| t.name().to_string())
+                .collect::<Vec<_>>(),
+            false =>
+                schema
+                    .all_tables()
+                    .context(FetchTables)?
+                    .iter()
+                    .map(|t| t.name().to_string())
+                    .collect::<Vec<_>>(),
+        };
         let schema = DataSchema::new(vec![Field::new(
             SHOW_TABLES_COLUMN_SCHEMA,
             DataType::Utf8,
@@ -113,7 +123,7 @@ impl ShowInterpreter {
             Arc::new(schema),
             vec![Arc::new(StringArray::from(tables_names))],
         )
-        .context(CreateRecordBatch)?;
+            .context(CreateRecordBatch)?;
 
         let record_batch = record_batch.try_into().context(ToCommonRecordType)?;
 
@@ -151,8 +161,8 @@ impl Interpreter for ShowInterpreter {
     async fn execute(self: Box<Self>) -> InterpreterResult<Output> {
         match self.plan {
             ShowPlan::ShowCreatePlan(t) => Self::show_create(t).context(ShowCreateTable),
-            ShowPlan::ShowTables => {
-                Self::show_tables(self.ctx, self.catalog_manager).context(ShowTables)
+            ShowPlan::ShowTablesPlan(t) => {
+                Self::show_tables(self.ctx, self.catalog_manager, t).context(ShowTables)
             }
             ShowPlan::ShowDatabase => {
                 Self::show_databases(self.ctx, self.catalog_manager).context(ShowDatabases)

sql/src/ast.rs

@@ -22,7 +22,7 @@ pub enum Statement {
     /// SHOW CREATE TABLE
     ShowCreate(ShowCreate),
     ShowDatabases,
-    ShowTables,
+    ShowTables(ShowTables),
     Exists(ExistsTable),
 }
 
@@ -96,6 +96,12 @@ pub struct AlterAddColumn {
     pub columns: Vec<ColumnDef>,
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub struct ShowTables {
+    pub if_fuzzy: bool,
+    pub fuzzy_target: Option<String>,
+}
+
 #[derive(Debug, PartialEq, Eq)]
 pub struct ShowCreate {
     pub obj_type: ShowCreateObject,

sql/src/parser.rs

@@ -16,7 +16,7 @@ use table_engine::ANALYTIC_ENGINE_TYPE;
 
 use crate::ast::{
     AlterAddColumn, AlterModifySetting, CreateTable, DescribeTable, DropTable, ExistsTable,
-    ShowCreate, ShowCreateObject, Statement,
+    ShowCreate, ShowCreateObject, Statement, ShowTables,
 };
 
 define_result!(ParserError);
@@ -223,7 +223,7 @@ impl<'a> Parser<'a> {
 
     pub fn parse_show(&mut self) -> Result<Statement> {
         if self.consume_token("TABLES") {
-            Ok(Statement::ShowTables)
+            Ok(self.parse_show_tables()?)
         } else if self.consume_token("DATABASES") {
             Ok(Statement::ShowDatabases)
         } else if self.consume_token("CREATE") {
@@ -233,6 +233,22 @@ impl<'a> Parser<'a> {
         }
     }
 
+    fn parse_show_tables(&mut self) -> Result<Statement> {
+        let (if_fuzzy, fuzzy_target)= match self.parser.next_token() {
+            Token::Word(w) =>
+                match w.keyword {
+                    Keyword::LIKE => (true, Some(self.parser.next_token().to_string())),
+                    _ => (false, None)
+                },
+
+            _ => (false, None),
+        };
+        Ok(Statement::ShowTables(ShowTables{
+            if_fuzzy,
+            fuzzy_target,
+        }))
+    }
+
     fn parse_show_create(&mut self) -> Result<Statement> {
         let obj_type = match self.parser.expect_one_of_keywords(&[Keyword::TABLE])? {
             Keyword::TABLE => Ok(ShowCreateObject::Table),

sql/src/plan.rs

@@ -156,12 +156,18 @@ pub struct ShowCreatePlan {
     pub obj_type: ShowCreateObject,
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub struct ShowTablesPlan {
+    pub if_fuzzy: bool,
+    pub fuzzy_target: Option<String>,
+}
+
 #[derive(Debug)]
 pub enum ShowPlan {
     /// show create table
     ShowCreatePlan(ShowCreatePlan),
     /// show tables
-    ShowTables,
+    ShowTablesPlan(ShowTablesPlan),
     /// show database
     ShowDatabase,
 }

sql/src/planner.rs

@@ -39,13 +39,13 @@ use table_engine::table::TableRef;
 use crate::{
     ast::{
         AlterAddColumn, AlterModifySetting, CreateTable, DescribeTable, DropTable, ExistsTable,
-        ShowCreate, Statement, TableName,
+        ShowCreate, Statement, TableName, ShowTables
     },
     container::TableReference,
     parser,
     plan::{
         AlterTableOperation, AlterTablePlan, CreateTablePlan, DescribeTablePlan, DropTablePlan,
-        ExistsTablePlan, InsertPlan, Plan, QueryPlan, ShowCreatePlan, ShowPlan,
+        ExistsTablePlan, InsertPlan, Plan, QueryPlan, ShowCreatePlan, ShowPlan, ShowTablesPlan,
     },
     promql::{ColumnNames, Expr as PromExpr},
     provider::{ContextProviderAdapter, MetaProvider},
@@ -246,7 +246,7 @@ impl<'a, P: MetaProvider> Planner<'a, P> {
             Statement::AlterModifySetting(s) => planner.alter_modify_setting_to_plan(s),
             Statement::AlterAddColumn(s) => planner.alter_add_column_to_plan(s),
             Statement::ShowCreate(s) => planner.show_create_to_plan(s),
-            Statement::ShowTables => planner.show_tables_to_plan(),
+            Statement::ShowTables(s) => planner.show_tables_to_plan(s),
             Statement::ShowDatabases => planner.show_databases_to_plan(),
             Statement::Exists(s) => planner.exists_table_to_plan(s),
         }
@@ -598,8 +598,12 @@ impl<'a, P: MetaProvider> PlannerDelegate<'a, P> {
         Ok(Plan::Show(ShowPlan::ShowCreatePlan(plan)))
     }
 
-    fn show_tables_to_plan(&self) -> Result<Plan> {
-        Ok(Plan::Show(ShowPlan::ShowTables))
+    fn show_tables_to_plan(&self,show_tables: ShowTables) -> Result<Plan> {
+        let plan = ShowTablesPlan {
+            if_fuzzy : show_tables.if_fuzzy,
+            fuzzy_target: show_tables.fuzzy_target,
+        };
+        Ok(Plan::Show(ShowPlan::ShowTablesPlan(plan)))
     }
 
     fn show_databases_to_plan(&self) -> Result<Plan> {