Merge pull request #135 from andygrove/show-columns

Support MySQL `SHOW COLUMNS` statement

Author: benesch

src/ast/mod.rs

@@ -440,6 +440,29 @@ pub enum Statement {
         /// `RESTRICT` or no drop behavior at all was specified.
         cascade: bool,
     },
+    /// SET <variable>
+    ///
+    /// Note: this is not a standard SQL statement, but it is supported by at
+    /// least MySQL and PostgreSQL. Not all MySQL-specific syntatic forms are
+    /// supported yet.
+    SetVariable {
+        local: bool,
+        variable: Ident,
+        value: SetVariableValue,
+    },
+    /// SHOW <variable>
+    ///
+    /// Note: this is a PostgreSQL-specific statement.
+    ShowVariable { variable: Ident },
+    /// SHOW COLUMNS
+    ///
+    /// Note: this is a MySQL-specific statement.
+    ShowColumns {
+        extended: bool,
+        full: bool,
+        table_name: ObjectName,
+        filter: Option<ShowStatementFilter>,
+    },
     /// `{ BEGIN [ TRANSACTION | WORK ] | START TRANSACTION } ...`
     StartTransaction { modes: Vec<TransactionMode> },
     /// `SET TRANSACTION ...`
@@ -451,6 +474,9 @@ pub enum Statement {
 }
 
 impl fmt::Display for Statement {
+    // Clippy thinks this function is too complicated, but it is painful to
+    // split up without extracting structs for each `Statement` variant.
+    #[allow(clippy::cognitive_complexity)]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Statement::Query(s) => write!(f, "{}", s),
@@ -589,6 +615,37 @@ impl fmt::Display for Statement {
                 display_comma_separated(names),
                 if *cascade { " CASCADE" } else { "" },
             ),
+            Statement::SetVariable {
+                local,
+                variable,
+                value,
+            } => {
+                f.write_str("SET ")?;
+                if *local {
+                    f.write_str("LOCAL ")?;
+                }
+                write!(f, "{} = {}", variable, value)
+            }
+            Statement::ShowVariable { variable } => write!(f, "SHOW {}", variable),
+            Statement::ShowColumns {
+                extended,
+                full,
+                table_name,
+                filter,
+            } => {
+                f.write_str("SHOW ")?;
+                if *extended {
+                    f.write_str("EXTENDED ")?;
+                }
+                if *full {
+                    f.write_str("FULL ")?;
+                }
+                write!(f, "COLUMNS FROM {}", table_name)?;
+                if let Some(filter) = filter {
+                    write!(f, " {}", filter)?;
+                }
+                Ok(())
+            }
             Statement::StartTransaction { modes } => {
                 write!(f, "START TRANSACTION")?;
                 if !modes.is_empty() {
@@ -780,3 +837,35 @@ impl fmt::Display for TransactionIsolationLevel {
         })
     }
 }
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ShowStatementFilter {
+    Like(String),
+    Where(Expr),
+}
+
+impl fmt::Display for ShowStatementFilter {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use ShowStatementFilter::*;
+        match self {
+            Like(pattern) => write!(f, "LIKE '{}'", value::escape_single_quote_string(pattern)),
+            Where(expr) => write!(f, "WHERE {}", expr),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum SetVariableValue {
+    Ident(Ident),
+    Literal(Value),
+}
+
+impl fmt::Display for SetVariableValue {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use SetVariableValue::*;
+        match self {
+            Ident(ident) => f.write_str(ident),
+            Literal(literal) => write!(f, "{}", literal),
+        }
+    }
+}

src/ast/value.rs

@@ -140,7 +140,8 @@ impl fmt::Display for DateTimeField {
     }
 }
 
-struct EscapeSingleQuoteString<'a>(&'a str);
+pub struct EscapeSingleQuoteString<'a>(&'a str);
+
 impl<'a> fmt::Display for EscapeSingleQuoteString<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         for c in self.0.chars() {
@@ -153,6 +154,7 @@ impl<'a> fmt::Display for EscapeSingleQuoteString<'a> {
         Ok(())
     }
 }
-fn escape_single_quote_string(s: &str) -> EscapeSingleQuoteString<'_> {
+
+pub fn escape_single_quote_string(s: &str) -> EscapeSingleQuoteString<'_> {
     EscapeSingleQuoteString(s)
 }

src/dialect/keywords.rs

@@ -102,6 +102,7 @@ define_keywords!(
     COLLATE,
     COLLECT,
     COLUMN,
+    COLUMNS,
     COMMIT,
     COMMITTED,
     CONDITION,
@@ -166,10 +167,12 @@ define_keywords!(
     EXECUTE,
     EXISTS,
     EXP,
+    EXTENDED,
     EXTERNAL,
     EXTRACT,
     FALSE,
     FETCH,
+    FIELDS,
     FIRST,
     FILTER,
     FIRST_VALUE,
@@ -332,8 +335,10 @@ define_keywords!(
     SELECT,
     SENSITIVE,
     SERIALIZABLE,
+    SESSION,
     SESSION_USER,
     SET,
+    SHOW,
     SIMILAR,
     SMALLINT,
     SOME,

src/dialect/mod.rs

@@ -14,13 +14,15 @@ mod ansi;
 mod generic;
 pub mod keywords;
 mod mssql;
+mod mysql;
 mod postgresql;
 
 use std::fmt::Debug;
 
 pub use self::ansi::AnsiDialect;
 pub use self::generic::GenericDialect;
 pub use self::mssql::MsSqlDialect;
+pub use self::mysql::MySqlDialect;
 pub use self::postgresql::PostgreSqlDialect;
 
 pub trait Dialect: Debug {

src/dialect/mysql.rs

@@ -0,0 +1,33 @@
+// 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 crate::dialect::Dialect;
+
+#[derive(Debug)]
+pub struct MySqlDialect {}
+
+impl Dialect for MySqlDialect {
+    fn is_identifier_start(&self, ch: char) -> bool {
+        // See https://dev.mysql.com/doc/refman/8.0/en/identifiers.html.
+        // We don't yet support identifiers beginning with numbers, as that
+        // makes it hard to distinguish numeric literals.
+        (ch >= 'a' && ch <= 'z')
+            || (ch >= 'A' && ch <= 'Z')
+            || ch == '_'
+            || ch == '$'
+            || (ch >= '\u{0080}' && ch <= '\u{ffff}')
+    }
+
+    fn is_identifier_part(&self, ch: char) -> bool {
+        self.is_identifier_start(ch) || (ch >= '0' && ch <= '9')
+    }
+}

src/parser.rs

@@ -125,8 +125,9 @@ impl Parser {
                     "UPDATE" => Ok(self.parse_update()?),
                     "ALTER" => Ok(self.parse_alter()?),
                     "COPY" => Ok(self.parse_copy()?),
+                    "SET" => Ok(self.parse_set()?),
+                    "SHOW" => Ok(self.parse_show()?),
                     "START" => Ok(self.parse_start_transaction()?),
-                    "SET" => Ok(self.parse_set_transaction()?),
                     // `BEGIN` is a nonstandard but common alias for the
                     // standard `START TRANSACTION` statement. It is supported
                     // by at least PostgreSQL and MySQL.
@@ -763,7 +764,11 @@ impl Parser {
     #[must_use]
     pub fn parse_one_of_keywords(&mut self, keywords: &[&'static str]) -> Option<&'static str> {
         for keyword in keywords {
-            assert!(keywords::ALL_KEYWORDS.contains(keyword));
+            assert!(
+                keywords::ALL_KEYWORDS.contains(keyword),
+                "{} is not contained in keyword list",
+                keyword
+            );
         }
         match self.peek_token() {
             Some(Token::Word(ref k)) => keywords
@@ -1597,6 +1602,74 @@ impl Parser {
         })
     }
 
+    pub fn parse_set(&mut self) -> Result<Statement, ParserError> {
+        let modifier = self.parse_one_of_keywords(&["SESSION", "LOCAL"]);
+        let variable = self.parse_identifier()?;
+        if self.consume_token(&Token::Eq) || self.parse_keyword("TO") {
+            let token = self.peek_token();
+            let value = match (self.parse_value(), token) {
+                (Ok(value), _) => SetVariableValue::Literal(value),
+                (Err(_), Some(Token::Word(ident))) => SetVariableValue::Ident(ident.as_ident()),
+                (Err(_), other) => self.expected("variable value", other)?,
+            };
+            Ok(Statement::SetVariable {
+                local: modifier == Some("LOCAL"),
+                variable,
+                value,
+            })
+        } else if variable == "TRANSACTION" && modifier.is_none() {
+            Ok(Statement::SetTransaction {
+                modes: self.parse_transaction_modes()?,
+            })
+        } else {
+            self.expected("equals sign or TO", self.peek_token())
+        }
+    }
+
+    pub fn parse_show(&mut self) -> Result<Statement, ParserError> {
+        if self
+            .parse_one_of_keywords(&["EXTENDED", "FULL", "COLUMNS", "FIELDS"])
+            .is_some()
+        {
+            self.prev_token();
+            self.parse_show_columns()
+        } else {
+            Ok(Statement::ShowVariable {
+                variable: self.parse_identifier()?,
+            })
+        }
+    }
+
+    fn parse_show_columns(&mut self) -> Result<Statement, ParserError> {
+        let extended = self.parse_keyword("EXTENDED");
+        let full = self.parse_keyword("FULL");
+        self.expect_one_of_keywords(&["COLUMNS", "FIELDS"])?;
+        self.expect_one_of_keywords(&["FROM", "IN"])?;
+        let table_name = self.parse_object_name()?;
+        // MySQL also supports FROM <database> here. In other words, MySQL
+        // allows both FROM <table> FROM <database> and FROM <database>.<table>,
+        // while we only support the latter for now.
+        let filter = self.parse_show_statement_filter()?;
+        Ok(Statement::ShowColumns {
+            extended,
+            full,
+            table_name,
+            filter,
+        })
+    }
+
+    fn parse_show_statement_filter(&mut self) -> Result<Option<ShowStatementFilter>, ParserError> {
+        if self.parse_keyword("LIKE") {
+            Ok(Some(ShowStatementFilter::Like(
+                self.parse_literal_string()?,
+            )))
+        } else if self.parse_keyword("WHERE") {
+            Ok(Some(ShowStatementFilter::Where(self.parse_expr()?)))
+        } else {
+            Ok(None)
+        }
+    }
+
     pub fn parse_table_and_joins(&mut self) -> Result<TableWithJoins, ParserError> {
         let relation = self.parse_table_factor()?;
 
@@ -1932,13 +2005,6 @@ impl Parser {
         })
     }
 
-    pub fn parse_set_transaction(&mut self) -> Result<Statement, ParserError> {
-        self.expect_keyword("TRANSACTION")?;
-        Ok(Statement::SetTransaction {
-            modes: self.parse_transaction_modes()?,
-        })
-    }
-
     pub fn parse_transaction_modes(&mut self) -> Result<Vec<TransactionMode>, ParserError> {
         let mut modes = vec![];
         let mut required = false;