sigmacomputing · markwongsk · Aug 25, 2021 · Aug 23, 2021 · Aug 23, 2021 · Aug 23, 2021
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -473,10 +473,10 @@ pub enum IsCheck {
     NULL,
     FALSE,
     TRUE,
-    UNKNOWN
+    UNKNOWN,
 }
 
-impl fmt::Display for IsCheck{
+impl fmt::Display for IsCheck {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             IsCheck::NULL => write!(f, "NULL"),

diff --git a/src/ast/query.rs b/src/ast/query.rs
@@ -468,7 +468,7 @@ impl fmt::Display for Join {
                 _ => "",
             }
         }
-        
+
         #[allow(clippy::needless_lifetimes)]
         fn suffix<'a>(constraint: &'a JoinConstraint) -> impl fmt::Display + 'a {
             struct Suffix<'a>(&'a JoinConstraint);

diff --git a/src/ast/value.rs b/src/ast/value.rs
@@ -65,8 +65,8 @@ impl fmt::Display for Value {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Value::Number(v) => write!(f, "{}", v),
-            Value::SingleQuotedString(v) => write!(f, "'{}'", v),
-            Value::DoubleQuotedString(v) => write!(f, "\"{}\"", v),
+            Value::SingleQuotedString(v) => write!(f, "'{}'", escape_single_quote_string(v)),
+            Value::DoubleQuotedString(v) => write!(f, "\"{}\"", escape_double_quote_string(v)),
             Value::RegexLiteral { ref value, quote } => write!(f, "{}{}{}", quote, value, quote),
             Value::NationalStringLiteral(v) => write!(f, "N'{}'", v),
             Value::HexStringLiteral(v) => write!(f, "X'{}'", v),
@@ -190,6 +190,25 @@ impl<'a> fmt::Display for EscapeSingleQuoteString<'a> {
     }
 }
 
+pub struct EscapeDoubleQuoteString<'a>(&'a str);
+
+impl<'a> fmt::Display for EscapeDoubleQuoteString<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for c in self.0.chars() {
+            if c == '"' {
+                write!(f, "\"\"")?;
+            } else {
+                write!(f, "{}", c)?;
+            }
+        }
+        Ok(())
+    }
+}
+
 pub fn escape_single_quote_string(s: &str) -> EscapeSingleQuoteString<'_> {
     EscapeSingleQuoteString(s)
 }
+
+pub fn escape_double_quote_string(s: &str) -> EscapeDoubleQuoteString<'_> {
+    EscapeDoubleQuoteString(s)
+}
diff --git a/src/dialect/generic.rs b/src/dialect/generic.rs
@@ -17,7 +17,11 @@ pub struct GenericDialect;
 
 impl Dialect for GenericDialect {
     fn is_identifier_start(&self, ch: char) -> bool {
-        ('a'..='z').contains(&ch) || ('A'..='Z').contains(&ch) || ch == '_' || ch == '#' || ch == '@'
+        ('a'..='z').contains(&ch)
+            || ('A'..='Z').contains(&ch)
+            || ch == '_'
+            || ch == '#'
+            || ch == '@'
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {

diff --git a/src/dialect/keywords.rs b/src/dialect/keywords.rs
@@ -496,11 +496,11 @@ define_keywords!(
     WEDNESDAY,
     WEEK,
     WEEKDAY,
+    WEEKDAY_ISO,
+    WEEKISO,
     WEEKOFYEAR,
     WEEKOFYEARISO,
     WEEKOFYEAR_ISO,
-    WEEKISO,
-    WEEKDAY_ISO,
     WEEK_ISO,
     WHEN,
     WHENEVER,
@@ -511,8 +511,8 @@ define_keywords!(
     WITHIN,
     WITHOUT,
     WK,
-    WOY,
     WORK,
+    WOY,
     WRITE,
     WY,
     Y,

diff --git a/src/dialect/mssql.rs b/src/dialect/mssql.rs
@@ -23,7 +23,11 @@ impl Dialect for MsSqlDialect {
     fn is_identifier_start(&self, ch: char) -> bool {
         // See https://docs.microsoft.com/en-us/sql/relational-databases/databases/database-identifiers?view=sql-server-2017#rules-for-regular-identifiers
         // We don't support non-latin "letters" currently.
-        ('a'..='z').contains(&ch) || ('A'..='Z').contains(&ch) || ch == '_' || ch == '#' || ch == '@'
+        ('a'..='z').contains(&ch)
+            || ('A'..='Z').contains(&ch)
+            || ch == '_'
+            || ch == '#'
+            || ch == '@'
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {

diff --git a/src/parser.rs b/src/parser.rs
@@ -979,9 +979,9 @@ impl<'a> Parser<'a> {
                     } else if self.parse_keyword(Keyword::BETWEEN) {
                         Ok((self.parse_between(expr, negated)?, true))
                     } else if self.parse_keyword(Keyword::LIKE) {
-                        Ok((self.parse_like(expr, true, negated)?, true))
+                        Ok((self.parse_like(expr, true, negated, precedence)?, true))
                     } else if self.parse_keyword(Keyword::ILIKE) {
-                        Ok((self.parse_like(expr, false, negated)?, true))
+                        Ok((self.parse_like(expr, false, negated, precedence)?, true))
                     } else if self.parse_keywords(&[Keyword::SIMILAR, Keyword::TO]) {
                         Ok((self.parse_similar(expr, negated)?, true))
                     } else {
@@ -1067,10 +1067,11 @@ impl<'a> Parser<'a> {
         expr: Expr,
         case_sensitive: bool,
         negated: bool,
+        precedence: u8,
     ) -> Result<Expr, ParserError> {
-        let pat = self.parse_expr()?;
+        let pat = self.parse_subexpr(precedence)?;
         let esc = if self.parse_keyword(Keyword::ESCAPE) {
-            Some(self.parse_expr()?)
+            Some(self.parse_subexpr(precedence)?)
         } else {
             None
         };
@@ -1936,6 +1937,9 @@ impl<'a> Parser<'a> {
     }
 
     pub fn preceding_toks(&self) -> String {
+        if self.tokens.is_empty() {
+            return "".to_string();
+        }
         let slice_start = if self.index < 20 { 0 } else { self.index - 20 };
         let slice_end = if self.index >= self.tokens.len() {
             self.tokens.len() - 1
@@ -2596,7 +2600,9 @@ impl<'a> Parser<'a> {
             // followed by some joins or (B) another level of nesting.
             let mut table_and_joins = self.parse_table_and_joins()?;
 
-            if !table_and_joins.joins.is_empty() || matches!(&table_and_joins.relation, TableFactor::NestedJoin(_)) {
+            if !table_and_joins.joins.is_empty()
+                || matches!(&table_and_joins.relation, TableFactor::NestedJoin(_))
+            {
                 // (B): `table_and_joins` (what we found inside the parentheses)
                 // is a nested join `(foo JOIN bar)`, not followed by other joins.
                 self.expect_token(&Token::RParen)?;

diff --git a/src/tokenizer.rs b/src/tokenizer.rs
@@ -728,7 +728,7 @@ impl<'a> Tokenizer<'a> {
             match ch {
                 // allow backslash to escape the next character, whatever it is
                 '\\' => {
-                    s.push('\\');
+                    chars.next(); // consume the escape char
                     if let Some(next_ch) = chars.next() {
                         s.push(next_ch);
                     }
@@ -739,7 +739,6 @@ impl<'a> Tokenizer<'a> {
                     && ch == quote_ch
                     && next_char_is_quote =>
                 {
-                    s.push(quote_ch);
                     s.push(quote_ch);
                     chars.next(); // consume quote_ch
                 }