feat: Support SHOW TABLES

Author: MazterQyou

src/ast/mod.rs

@@ -881,6 +881,15 @@ pub enum Statement {
         table_name: ObjectName,
         filter: Option<ShowStatementFilter>,
     },
+    /// SHOW TABLES
+    ///
+    /// Note: this is a MySQL-specific statement.
+    ShowTables {
+        extended: bool,
+        full: bool,
+        db_name: Option<Ident>,
+        filter: Option<ShowStatementFilter>,
+    },
     /// `{ BEGIN [ TRANSACTION | WORK ] | START TRANSACTION } ...`
     StartTransaction { modes: Vec<TransactionMode> },
     /// `SET TRANSACTION ...`
@@ -1573,6 +1582,26 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
+            Statement::ShowTables {
+                extended,
+                full,
+                db_name,
+                filter,
+            } => {
+                write!(
+                    f,
+                    "SHOW {extended}{full}TABLES",
+                    extended = if *extended { "EXTENDED " } else { "" },
+                    full = if *full { "FULL " } else { "" },
+                )?;
+                if let Some(db_name) = db_name {
+                    write!(f, " FROM {}", db_name)?;
+                }
+                if let Some(filter) = filter {
+                    write!(f, " {}", filter)?;
+                }
+                Ok(())
+            }
             Statement::StartTransaction { modes } => {
                 write!(f, "START TRANSACTION")?;
                 if !modes.is_empty() {

src/parser.rs

@@ -3270,17 +3270,19 @@ impl<'a> Parser<'a> {
     }
 
     pub fn parse_show(&mut self) -> Result<Statement, ParserError> {
+        let extended = self.parse_keyword(Keyword::EXTENDED);
+        let full = self.parse_keyword(Keyword::FULL);
         if self
-            .parse_one_of_keywords(&[
-                Keyword::EXTENDED,
-                Keyword::FULL,
-                Keyword::COLUMNS,
-                Keyword::FIELDS,
-            ])
+            .parse_one_of_keywords(&[Keyword::COLUMNS, Keyword::FIELDS])
             .is_some()
         {
-            self.prev_token();
-            Ok(self.parse_show_columns()?)
+            Ok(self.parse_show_columns(extended, full)?)
+        } else if self.parse_keyword(Keyword::TABLES) {
+            Ok(self.parse_show_tables(extended, full)?)
+        } else if extended || full {
+            Err(ParserError::ParserError(
+                "EXTENDED/FULL are not supported with this type of SHOW query".to_string(),
+            ))
         } else if self.parse_one_of_keywords(&[Keyword::CREATE]).is_some() {
             Ok(self.parse_show_create()?)
         } else if self.parse_one_of_keywords(&[Keyword::VARIABLES]).is_some() {
@@ -3318,10 +3320,7 @@ impl<'a> Parser<'a> {
         Ok(Statement::ShowCreate { obj_type, obj_name })
     }
 
-    pub fn parse_show_columns(&mut self) -> Result<Statement, ParserError> {
-        let extended = self.parse_keyword(Keyword::EXTENDED);
-        let full = self.parse_keyword(Keyword::FULL);
-        self.expect_one_of_keywords(&[Keyword::COLUMNS, Keyword::FIELDS])?;
+    fn parse_show_columns(&mut self, extended: bool, full: bool) -> Result<Statement, ParserError> {
         self.expect_one_of_keywords(&[Keyword::FROM, Keyword::IN])?;
         let table_name = self.parse_object_name()?;
         let double_from = self.parse_one_of_keywords(&[Keyword::FROM, Keyword::IN]);
@@ -3349,9 +3348,21 @@ impl<'a> Parser<'a> {
         })
     }
 
-    pub fn parse_show_statement_filter(
-        &mut self,
-    ) -> Result<Option<ShowStatementFilter>, ParserError> {
+    fn parse_show_tables(&mut self, extended: bool, full: bool) -> Result<Statement, ParserError> {
+        let db_name = match self.parse_one_of_keywords(&[Keyword::FROM, Keyword::IN]) {
+            Some(_) => Some(self.parse_identifier()?),
+            None => None,
+        };
+        let filter = self.parse_show_statement_filter()?;
+        Ok(Statement::ShowTables {
+            extended,
+            full,
+            db_name,
+            filter,
+        })
+    }
+
+    fn parse_show_statement_filter(&mut self) -> Result<Option<ShowStatementFilter>, ParserError> {
         if self.parse_keyword(Keyword::LIKE) {
             Ok(Some(ShowStatementFilter::Like(
                 self.parse_literal_string()?,

tests/sqlparser_mysql.rs

@@ -101,6 +101,67 @@ fn parse_show_columns() {
     );
 }
 
+#[test]
+fn parse_show_tables() {
+    assert_eq!(
+        mysql_and_generic().verified_stmt("SHOW TABLES"),
+        Statement::ShowTables {
+            extended: false,
+            full: false,
+            db_name: None,
+            filter: None,
+        }
+    );
+    assert_eq!(
+        mysql_and_generic().verified_stmt("SHOW TABLES FROM mydb"),
+        Statement::ShowTables {
+            extended: false,
+            full: false,
+            db_name: Some(Ident::new("mydb")),
+            filter: None,
+        }
+    );
+    assert_eq!(
+        mysql_and_generic().verified_stmt("SHOW EXTENDED TABLES"),
+        Statement::ShowTables {
+            extended: true,
+            full: false,
+            db_name: None,
+            filter: None,
+        }
+    );
+    assert_eq!(
+        mysql_and_generic().verified_stmt("SHOW FULL TABLES"),
+        Statement::ShowTables {
+            extended: false,
+            full: true,
+            db_name: None,
+            filter: None,
+        }
+    );
+    assert_eq!(
+        mysql_and_generic().verified_stmt("SHOW TABLES LIKE 'pattern'"),
+        Statement::ShowTables {
+            extended: false,
+            full: false,
+            db_name: None,
+            filter: Some(ShowStatementFilter::Like("pattern".into())),
+        }
+    );
+    assert_eq!(
+        mysql_and_generic().verified_stmt("SHOW TABLES WHERE 1 = 2"),
+        Statement::ShowTables {
+            extended: false,
+            full: false,
+            db_name: None,
+            filter: Some(ShowStatementFilter::Where(
+                mysql_and_generic().verified_expr("1 = 2")
+            )),
+        }
+    );
+    mysql_and_generic().one_statement_parses_to("SHOW TABLES IN mydb", "SHOW TABLES FROM mydb");
+}
+
 #[test]
 fn parse_show_create() {
     let obj_name = ObjectName(vec![Ident::new("myident")]);