fix: resolve backslash escapes in StringValue.getNotExcapedValue() (#2791)

getNotExcapedValue() only collapsed doubled single quotes. With MySQL
backslash escapes it returned 'it\'s' as it\'s and 'a\\b' as a\\b,
PostgreSQL E'it\'s' kept its backslash, and "it""s" kept both quotes.

Record at parse time how a literal's backslashes were read: MySQL and
MariaDB backslash escapes, including the default configuration with
backslash escapes enabled, PostgreSQL escape strings, or standard SQL.
getNotExcapedValue() resolves the literal's own doubled quote and these
escapes; PostgreSQL octal and hexadecimal escapes are decoded as UTF-8
bytes. Constructed values and other dialects keep the standard reading.

Signed-off-by: minleejae <mmj9808@gmail.com>

Author: minleejae

src/main/java/net/sf/jsqlparser/expression/StringValue.java

@@ -9,6 +9,8 @@
  */
 package net.sf.jsqlparser.expression;
 
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
@@ -22,9 +24,24 @@ public final class StringValue extends ASTNodeAccessImpl implements Expression {
 
     public static final List<String> ALLOWED_PREFIXES =
             Arrays.asList("N", "U", "E", "R", "B", "RB", "_utf8", "Q");
+
+    /**
+     * How a backslash in the literal body was read. The parser records the escaping of the
+     * configuration that lexed the literal; constructed values default to {@link #STANDARD}.
+     */
+    public enum Escaping {
+        /** Only a doubled quote character is an escape, as in standard SQL. */
+        STANDARD,
+        /** MySQL/MariaDB backslash escapes, for example {@code \n}, {@code \'} and {@code \\}. */
+        MYSQL_BACKSLASH,
+        /** PostgreSQL escape string escapes, for example {@code E'\n'} and {@code E'\x41'}. */
+        POSTGRESQL_ESCAPE_STRING
+    }
+
     private String value = "";
     private String prefix = null;
     private String quoteStr = "'";
+    private Escaping escaping = Escaping.STANDARD;
 
     public StringValue() {
         // empty constructor
@@ -119,19 +136,175 @@ public StringValue setQuoteStr(String quoteStr) {
         return this;
     }
 
+    public Escaping getEscaping() {
+        return escaping;
+    }
+
+    public void setEscaping(Escaping escaping) {
+        this.escaping = escaping == null ? Escaping.STANDARD : escaping;
+    }
+
+    public StringValue withEscaping(Escaping escaping) {
+        setEscaping(escaping);
+        return this;
+    }
+
+    /**
+     * Returns the literal's characters with its escapes resolved: a doubled quote character and,
+     * depending on {@link #getEscaping()}, backslash escape sequences. PostgreSQL octal and
+     * hexadecimal escapes denote bytes, which are decoded as UTF-8. Dollar-quoted bodies are
+     * returned unchanged.
+     */
     public String getNotExcapedValue() {
         if (quoteStr != null && quoteStr.startsWith("$")) {
             return value;
         }
-        StringBuilder buffer = new StringBuilder(value.length());
-        int from = 0;
-        int index;
-        while ((index = value.indexOf("''", from)) != -1) {
-            buffer.append(value, from, index + 1);
-            from = index + 2;
+        char quote = "\"".equals(quoteStr) ? '"' : '\'';
+        Unescaped result = new Unescaped(value.length());
+        int i = 0;
+        while (i < value.length()) {
+            char c = value.charAt(i);
+            if (c == '\\' && escaping != Escaping.STANDARD && i + 1 < value.length()) {
+                i = escaping == Escaping.MYSQL_BACKSLASH
+                        ? appendMySqlEscape(result, value.charAt(i + 1), i + 1)
+                        : appendPostgresEscape(result, value, i + 1);
+            } else if (c == quote && i + 1 < value.length() && value.charAt(i + 1) == quote) {
+                result.append(quote);
+                i += 2;
+            } else {
+                result.append(c);
+                i++;
+            }
+        }
+        return result.toString();
+    }
+
+    /** Appends the MySQL escape {@code c} at {@code index} and returns the index after it. */
+    private static int appendMySqlEscape(Unescaped result, char c, int index) {
+        switch (c) {
+            case '0':
+                result.append('\0');
+                break;
+            case 'b':
+                result.append('\b');
+                break;
+            case 'n':
+                result.append('\n');
+                break;
+            case 'r':
+                result.append('\r');
+                break;
+            case 't':
+                result.append('\t');
+                break;
+            case 'Z':
+                result.append((char) 0x1A);
+                break;
+            case '%':
+            case '_':
+                // kept with the backslash, so that LIKE patterns still match them literally
+                result.append('\\');
+                result.append(c);
+                break;
+            default:
+                result.append(c);
+        }
+        return index + 1;
+    }
+
+    /** Appends the PostgreSQL escape string escape at {@code index}; returns the next index. */
+    private static int appendPostgresEscape(Unescaped result, String text, int index) {
+        char c = text.charAt(index);
+        switch (c) {
+            case 'b':
+                result.append('\b');
+                return index + 1;
+            case 'f':
+                result.append('\f');
+                return index + 1;
+            case 'n':
+                result.append('\n');
+                return index + 1;
+            case 'r':
+                result.append('\r');
+                return index + 1;
+            case 't':
+                result.append('\t');
+                return index + 1;
+            case 'x':
+                return appendNumber(result, text, index + 1, 16, 1, 2, c, true);
+            case 'u':
+                return appendNumber(result, text, index + 1, 16, 4, 4, c, false);
+            case 'U':
+                return appendNumber(result, text, index + 1, 16, 8, 8, c, false);
+            default:
+                if (c >= '0' && c <= '7') {
+                    return appendNumber(result, text, index, 8, 1, 3, c, true);
+                }
+                result.append(c);
+                return index + 1;
+        }
+    }
+
+    /**
+     * Appends the byte or code point spelled by {@code min} to {@code max} digits at {@code start},
+     * or {@code fallback} when fewer digits follow, and returns the next index.
+     */
+    private static int appendNumber(Unescaped result, String text, int start, int radix,
+            int min, int max, char fallback, boolean isByte) {
+        int end = start;
+        while (end < text.length() && end - start < max
+                && Character.digit(text.charAt(end), radix) >= 0) {
+            end++;
+        }
+        if (end - start < min) {
+            result.append(fallback);
+            return start;
+        }
+        int number = Integer.parseInt(text.substring(start, end), radix);
+        if (isByte) {
+            result.appendByte(number);
+        } else {
+            result.appendCodePoint(number);
+        }
+        return end;
+    }
+
+    /** Collects unescaped characters; consecutive escaped bytes are decoded as UTF-8. */
+    private static final class Unescaped {
+        private final StringBuilder chars;
+        private final ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+
+        Unescaped(int capacity) {
+            chars = new StringBuilder(capacity);
+        }
+
+        void append(char c) {
+            flushBytes();
+            chars.append(c);
+        }
+
+        void appendCodePoint(int codePoint) {
+            flushBytes();
+            chars.appendCodePoint(codePoint);
+        }
+
+        void appendByte(int value) {
+            bytes.write(value);
+        }
+
+        private void flushBytes() {
+            if (bytes.size() > 0) {
+                chars.append(new String(bytes.toByteArray(), StandardCharsets.UTF_8));
+                bytes.reset();
+            }
+        }
+
+        @Override
+        public String toString() {
+            flushBytes();
+            return chars.toString();
         }
-        buffer.append(value, from, value.length());
-        return buffer.toString();
     }
 
     @Override