the right way I suppose v3

Author: DanCodedThis

src/dialect/snowflake.rs

@@ -79,9 +79,7 @@ impl Dialect for SnowflakeDialect {
     }
 
     // See https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#escape_sequences
-    fn supports_string_literal_backslash_escape(&self) -> bool {
-        false
-    }
+    fn supports_string_literal_backslash_escape(&self) -> bool { true }
 
     fn supports_within_after_array_aggregation(&self) -> bool {
         true

src/tokenizer.rs

@@ -2004,21 +2004,21 @@ impl<'a> Tokenizer<'a> {
                         return Ok(s);
                     }
                 }
-                char if dialect_of!(self is SnowflakeDialect) && char.is_ascii_control() => {
-                    // let n = match char {
-                    //     '\x00' => '\0',
-                    //     '\x07' => '\u{7}',
-                    //     '\x08' => '\u{8}',
-                    //     '\x12' => '\u{c}',
-                    //     '\x10' => '\n',
-                    //     '\x13' => '\r',
-                    //     '\x09' => '\t',
-                    //     '\x26' => '\u{1a}',
-                    //     _ => char,
-                    // };
-                    s.push('\0');
-                    chars.next(); // consume symbol
-                }
+                // char if dialect_of!(self is SnowflakeDialect) && char.is_ascii_control() => {
+                //     let n = match char {
+                //         '\x00' => '\0',
+                //         '\x07' => '\u{7}',
+                //         '\x08' => '\u{8}',
+                //         '\x12' => '\u{c}',
+                //         '\x10' => '\n',
+                //         '\x13' => '\r',
+                //         '\x09' => '\t',
+                //         '\x26' => '\u{1a}',
+                //         _ => char,
+                //     };
+                //     s.push('\0');
+                //     chars.next(); // consume symbol
+                // }
                 '\\' if settings.backslash_escape => {
                     // consume backslash
                     chars.next();
@@ -2031,6 +2031,15 @@ impl<'a> Tokenizer<'a> {
                             s.push(ch);
                             s.push(*next);
                             chars.next(); // consume next
+                        //if [\\]\\b -> [\\]b    
+                        } else if dialect_of!(self is SnowflakeDialect) && *next == '\\' {
+                            s.push(*next);
+                            chars.next();
+                            //if [\\]b -> \\[b] 
+                            if let Some(next) = chars.peek() {
+                                s.push(*next);
+                                chars.next();
+                            }
                         } else {
                             let n = match next {
                                 '0' => '\0',