fixes

Author: vasilev-alex

src/ast/mod.rs

@@ -11,7 +11,6 @@
 // limitations under the License.
 
 //! SQL Abstract Syntax Tree (AST) types
-
 mod data_type;
 mod ddl;
 mod operator;

src/ast/value.rs

@@ -143,14 +143,12 @@ pub struct EscapeSingleQuoteString<'a>(&'a str);
 
 impl<'a> fmt::Display for EscapeSingleQuoteString<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut cur_escaped = false;
         for c in self.0.chars() {
             if c == '\'' {
-                write!(f, "{}", if cur_escaped { "\'" } else { "\'\'" })?;
+                write!(f, "\'\'")?;
             } else {
                 write!(f, "{}", c)?;
             }
-            cur_escaped = c == '\\';
         }
         Ok(())
     }

src/dialect/mod.rs

@@ -35,7 +35,7 @@ pub use self::sqlite::SQLiteDialect;
 pub use crate::keywords;
 
 /// `dialect_of!(parser is SQLiteDialect |  GenericDialect)` evaluates
-/// to `true` iff `parser.dialect` is one of the `Dialect`s specified.
+/// to `true` if `parser.dialect` is one of the `Dialect`s specified.
 macro_rules! dialect_of {
     ( $parsed_dialect: ident is $($dialect_type: ty)|+ ) => {
         ($($parsed_dialect.dialect.is::<$dialect_type>())||+)

src/tokenizer.rs

@@ -31,8 +31,8 @@ use core::str::Chars;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use crate::dialect::Dialect;
 use crate::dialect::SnowflakeDialect;
+use crate::dialect::{Dialect, MySqlDialect};
 use crate::keywords::{Keyword, ALL_KEYWORDS, ALL_KEYWORDS_INDEX};
 
 /// SQL Token enumeration
@@ -637,35 +637,30 @@ impl<'a> Tokenizer<'a> {
     ) -> Result<String, TokenizerError> {
         let mut s = String::new();
         chars.next(); // consume the opening quote
+
+        // slash escaping is specific to MySQL dialect
+        let mut is_escaped = false;
         while let Some(&ch) = chars.peek() {
             match ch {
                 '\'' => {
                     chars.next(); // consume
-                    let escaped_quote = chars.peek().map(|c| *c == '\'').unwrap_or(false);
-                    if escaped_quote {
-                        s.push('\'');
+                    if is_escaped {
+                        s.push(ch);
+                        is_escaped = false;
+                    } else if chars.peek().map(|c| *c == '\'').unwrap_or(false) {
+                        s.push(ch);
                         chars.next();
                     } else {
                         return Ok(s);
                     }
                 }
                 '\\' => {
-                    chars.next();
-                    match chars.peek() {
-                        None => {
-                            return self.tokenizer_error("Unterminated escape sequence");
-                        }
-                        Some(&c) => {
-                            chars.next();
-                            match c {
-                                '\'' => {
-                                    s.push('\\');
-                                    s.push('\'');
-                                }
-                                x => s.push(x),
-                            }
-                        }
+                    if dialect_of!(self is MySqlDialect) {
+                        is_escaped = !is_escaped;
+                    } else {
+                        s.push(ch);
                     }
+                    chars.next();
                 }
                 _ => {
                     chars.next(); // consume

tests/sqlparser_mysql.rs

@@ -19,6 +19,8 @@ mod test_utils;
 
 use test_utils::*;
 
+use sqlparser::ast::Expr;
+use sqlparser::ast::Value;
 use sqlparser::ast::*;
 use sqlparser::dialect::{GenericDialect, MySqlDialect};
 use sqlparser::tokenizer::Token;
@@ -176,19 +178,36 @@ fn parse_quote_identifiers() {
     }
 }
 
+#[test]
+fn parse_unterminated_escape() {
+    let sql = r#"SELECT 'I\'m not fine\'"#;
+    let result = std::panic::catch_unwind(|| mysql().one_statement_parses_to(sql, ""));
+    assert!(result.is_err());
+
+    let sql = r#"SELECT 'I\\'m not fine'"#;
+    let result = std::panic::catch_unwind(|| mysql().one_statement_parses_to(sql, ""));
+    assert!(result.is_err());
+}
+
 #[test]
 fn parse_escaped_string() {
     let sql = r#"SELECT 'I\'m fine'"#;
 
-    let projection = mysql().verified_only_select(sql).projection;
-    let item = projection.get(0).unwrap();
+    let stmt = mysql().one_statement_parses_to(sql, "");
 
-    match &item {
-        SelectItem::UnnamedExpr(Expr::Value(value)) => {
-            assert_eq!("'I\\'m fine'", value.to_string());
-        }
+    match stmt {
+        Statement::Query(query) => match query.body {
+            SetExpr::Select(value) => {
+                let expr = expr_from_projection(only(&value.projection));
+                assert_eq!(
+                    *expr,
+                    Expr::Value(Value::SingleQuotedString("I'm fine".to_string()))
+                );
+            }
+            _ => unreachable!(),
+        },
         _ => unreachable!(),
-    }
+    };
 
     let sql = r#"SELECT 'I''m fine'"#;
 
@@ -197,7 +216,7 @@ fn parse_escaped_string() {
 
     match &item {
         SelectItem::UnnamedExpr(Expr::Value(value)) => {
-            assert_eq!("'I''m fine'", value.to_string());
+            assert_eq!(*value, Value::SingleQuotedString("I'm fine".to_string()));
         }
         _ => unreachable!(),
     }