feat: Support KILL [CONNECTION | QUERY] processlist_id

Author: ovr

src/ast/mod.rs

@@ -951,6 +951,13 @@ pub enum Statement {
         data_types: Vec<DataType>,
         statement: Box<Statement>,
     },
+    /// See <https://clickhouse.com/docs/ru/sql-reference/statements/kill/>
+    /// See <https://dev.mysql.com/doc/refman/8.0/en/kill.html>
+    Kill {
+        modifier: Option<KillType>,
+        // processlist_id
+        id: u64,
+    },
     /// EXPLAIN TABLE
     /// Note: this is a MySQL-specific statement. See <https://dev.mysql.com/doc/refman/8.0/en/explain.html>
     ExplainTable {
@@ -993,6 +1000,15 @@ impl fmt::Display for Statement {
     #[allow(clippy::cognitive_complexity)]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
+            Statement::Kill { modifier, id } => {
+                write!(f, "KILL ")?;
+
+                if let Some(m) = modifier {
+                    write!(f, "{} ", m)?;
+                }
+
+                write!(f, "{}", id)
+            }
             Statement::ExplainTable {
                 describe_alias,
                 table_name,
@@ -2058,6 +2074,26 @@ impl fmt::Display for ObjectType {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum KillType {
+    Connection,
+    Query,
+    Mutation,
+}
+
+impl fmt::Display for KillType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match self {
+            // MySQL
+            KillType::Connection => "CONNECTION",
+            KillType::Query => "QUERY",
+            // Clickhouse supports Mutation
+            KillType::Mutation => "Mutation",
+        })
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum HiveDistributionStyle {

src/keywords.rs

@@ -137,6 +137,7 @@ define_keywords!(
     COMPUTE,
     CONDITION,
     CONNECT,
+    CONNECTION,
     CONSTRAINT,
     CONTAINS,
     CONVERT,
@@ -280,6 +281,7 @@ define_keywords!(
     JSONFILE,
     JULIAN,
     KEY,
+    KILL,
     LAG,
     LANGUAGE,
     LARGE,
@@ -383,6 +385,7 @@ define_keywords!(
     PROGRAM,
     PURGE,
     QUARTER,
+    QUERY,
     QUOTE,
     RANGE,
     RANK,

src/parser.rs

@@ -154,6 +154,7 @@ impl<'a> Parser<'a> {
     pub fn parse_statement(&mut self) -> Result<Statement, ParserError> {
         match self.next_token() {
             Token::Word(w) => match w.keyword {
+                Keyword::KILL => Ok(self.parse_kill()?),
                 Keyword::DESCRIBE => Ok(self.parse_explain(true)?),
                 Keyword::EXPLAIN => Ok(self.parse_explain(false)?),
                 Keyword::ANALYZE => Ok(self.parse_analyze()?),
@@ -2797,6 +2798,21 @@ impl<'a> Parser<'a> {
         })
     }
 
+    // KILL [CONNECTION | QUERY] processlist_id
+    pub fn parse_kill(&mut self) -> Result<Statement, ParserError> {
+        let modifier_keyword = self.parse_one_of_keywords(&[Keyword::CONNECTION, Keyword::QUERY]);
+
+        let id = self.parse_literal_uint()?;
+
+        let modifier = match modifier_keyword {
+            Some(Keyword::CONNECTION) => Some(KillType::Connection),
+            Some(Keyword::QUERY) => Some(KillType::Query),
+            _ => None,
+        };
+
+        Ok(Statement::Kill { modifier, id })
+    }
+
     pub fn parse_explain(&mut self, describe_alias: bool) -> Result<Statement, ParserError> {
         let analyze = self.parse_keyword(Keyword::ANALYZE);
         let verbose = self.parse_keyword(Keyword::VERBOSE);

tests/sqlparser_mysql.rs

@@ -819,6 +819,36 @@ fn parse_show_variables() {
     mysql().verified_stmt("SHOW VARIABLES WHERE value = '3306'");
 }
 
+#[test]
+fn parse_kill() {
+    let stmt = mysql_and_generic().verified_stmt("KILL CONNECTION 5");
+    assert_eq!(
+        stmt,
+        Statement::Kill {
+            modifier: Some(KillType::Connection),
+            id: 5,
+        }
+    );
+
+    let stmt = mysql_and_generic().verified_stmt("KILL QUERY 5");
+    assert_eq!(
+        stmt,
+        Statement::Kill {
+            modifier: Some(KillType::Query),
+            id: 5,
+        }
+    );
+
+    let stmt = mysql_and_generic().verified_stmt("KILL 5");
+    assert_eq!(
+        stmt,
+        Statement::Kill {
+            modifier: None,
+            id: 5,
+        }
+    );
+}
+
 #[test]
 fn parse_set_names() {
     let stmt = mysql_and_generic().verified_stmt("SET NAMES utf8mb4");