Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(redshift): rewrite Redshift table DDL keywords for a PostgreSQL backend (#2947)

Vũ Thế Huy17ea9a9aac9b
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftSqlInterceptor.java b/src/main/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftSqlInterceptor.java
new file mode 100644
index 0000000000..d8440709f7
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftSqlInterceptor.java
@@ -0,0 +1,147 @@
+package io.github.hectorvent.floci.services.redshift.proxy;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Rewrites Redshift-specific table DDL so a plain PostgreSQL backend accepts it.
+ *
+ * <p>The rewrite is deliberately narrow so the "fail-open" contract stays honest:
+ * we must never silently drop a column or clause from a statement we do not
+ * fully understand:
+ * <ul>
+ * <li>It only runs when the statement's first keyword is {@code CREATE TABLE}
+ * or {@code ALTER TABLE}. A {@code SELECT}, an {@code INSERT}, a function
+ * body or a string literal that merely contains {@code DISTKEY} is
+ * returned untouched.</li>
+ * <li>Single-quoted string literals are masked out before any pattern runs, so
+ * a {@code DEFAULT 'a,)'} or {@code CHECK (x <> 'SORTKEY')} is never
+ * mangled, including the second statement of a multi-statement {@code 'Q'}
+ * whose batch begins with a {@code CREATE TABLE}.</li>
+ * <li>Table-level {@code DISTKEY}/{@code SORTKEY} without parentheses is only
+ * stripped after the column-list's closing {@code )}, not when it looks
+ * like a column definition.</li>
+ * <li>{@code ENCODE} is only stripped when followed by a real Redshift column
+ * encoding (or {@code AUTO}), so a column literally named {@code encode} of
+ * an ordinary type survives.</li>
+ * </ul>
+ * String-literal masking recognizes both single-quoted literals and
+ * dollar-quoted literals ({@code $$ ... $$}, {@code $tag$ ... $tag$}). It is
+ * <em>not</em> comment-aware and does not recognise escape strings ({@code E'...'}); an
+ * apostrophe inside a {@code --} or block comment can therefore make the rewrite
+ * skip a real clause. Every such case fails safe: the unrewritten statement
+ * reaches PostgreSQL, which returns its own syntax error. The residual ambiguity
+ * (a column named {@code distkey}/{@code sortkey}/{@code encode} whose declared
+ * type is itself the bare keyword that would follow such a constraint)
+ * describes no valid PostgreSQL type, so in practice nothing legitimate is
+ * dropped.
+ */
+public final class RedshiftSqlInterceptor {
+
+ /** Leading whitespace / SQL comments, then CREATE|ALTER ... TABLE. */
+ private static final Pattern TABLE_DDL_PROBE = Pattern.compile(
+ "(?is)^\\s*(?:(?:--[^\\n]*\\n)|(?:/\\*.*?\\*/)|\\s)*(?:CREATE|ALTER)\\s+(?:(?:GLOBAL|LOCAL)\\s+)?"
+ + "(?:(?:TEMP|TEMPORARY|UNLOGGED)\\s+)?TABLE\\b");
+
+ /** Single-quoted string literal (doubled '' is escaped quote) and PostgreSQL dollar-quoted string literal ($tag$...$tag$). */
+ private static final Pattern STRING_LITERAL_PATTERN = Pattern.compile(
+ "'(?:[^']|'')*'|(?s)\\$([^$\\s]*)\\$.*?\\$\\1\\$");
+
+ private static final Pattern DISTSTYLE_PATTERN = Pattern.compile("(?i)\\bDISTSTYLE\\s+(ALL|EVEN|KEY|AUTO)\\b");
+ private static final Pattern DISTKEY_PAREN_PATTERN = Pattern.compile("(?i)\\bDISTKEY\\s*\\([^)]*\\)");
+ private static final Pattern SORTKEY_PAREN_PATTERN = Pattern.compile("(?i)\\b(?:COMPOUND|INTERLEAVED)?\\s*SORTKEY\\s*\\([^)]*\\)");
+ /** Table-level {@code DISTKEY col} / {@code SORTKEY col}: only after the column list closes. */
+ private static final Pattern TABLE_LEVEL_KEY_IDENT_PATTERN = Pattern.compile(
+ "(?i)(?<=\\))\\s*(?:COMPOUND\\s+|INTERLEAVED\\s+)?(?:DISTKEY|SORTKEY)\\s+\"?[a-zA-Z_]\\w*\"?(?=\\s*(?:[;]|\\b(?:DISTSTYLE|DISTKEY|SORTKEY|ENCODE)\\b|$))");
+ /**
+ * Bare {@code DISTKEY} / {@code SORTKEY} as a column-level attribute: it sits
+ * right after the column type and is followed by a comma, the closing paren of
+ * the column list, another column attribute ({@code ENCODE ...}), or a column
+ * constraint ({@code NOT NULL}, {@code PRIMARY KEY}, etc.). The trailing
+ * lookahead is what stops this from matching a column literally <em>named</em>
+ * {@code distkey} (which would be followed by its type).
+ */
+ private static final Pattern KEY_COLUMN_CONSTRAINT_PATTERN = Pattern.compile(
+ "(?i)\\s+(?:COMPOUND\\s+|INTERLEAVED\\s+)?(?:DISTKEY|SORTKEY)\\s*(?=[,)]|\\s+(?:ENCODE|DISTKEY|SORTKEY|NOT\\s+NULL|NULL|UNIQUE|PRIMARY\\s+KEY|REFERENCES|DEFAULT|COLLATE|CHECK|CONSTRAINT|IDENTITY|GENERATED)\\b)");
+ /** {@code ENCODE <codec>} where {@code <codec>} is an actual Redshift column encoding or {@code AUTO}. */
+ private static final Pattern ENCODE_PATTERN = Pattern.compile(
+ "(?i)\\bENCODE\\s+(RAW|AZ64|BYTEDICT|DELTA32K|DELTA|LZO|MOSTLY8|MOSTLY16|MOSTLY32|RUNLENGTH|TEXT255|TEXT32K|ZSTD|AUTO)\\b");
+ private static final Pattern DOUBLE_COMMA_PATTERN = Pattern.compile(",(?:\\s*,)+");
+ private static final Pattern COMMA_CLOSE_PAREN_PATTERN = Pattern.compile(",\\s*\\)");
+
+ /** Non-word, non-whitespace control char that cannot occur in a PostgreSQL statement. */
+ private static final String MASK_SENTINEL = String.valueOf((char) 1);
+ private static final Pattern MASK_PLACEHOLDER_PATTERN =
+ Pattern.compile(Pattern.quote(MASK_SENTINEL) + "(\\d+)" + Pattern.quote(MASK_SENTINEL));
+
+ private RedshiftSqlInterceptor() {
+ }
+
+ public static String rewrite(String sql) {
+ if (sql == null || sql.isEmpty()) {
+ return sql;
+ }
+
+ List<String> literals = new ArrayList<>();
+ String masked = maskStringLiterals(sql, literals);
+
+ String[] statements = masked.split(";", -1);
+ boolean anyRewritten = false;
+ for (int i = 0; i < statements.length; i++) {
+ if (TABLE_DDL_PROBE.matcher(statements[i]).find()) {
+ String rewritten = rewriteTableDdl(statements[i]);
+ if (!rewritten.equals(statements[i])) {
+ statements[i] = rewritten;
+ anyRewritten = true;
+ }
+ }
+ }
+
+ if (!anyRewritten) {
+ return sql; // nothing matched: hand back the original instance
+ }
+ String joined = String.join(";", statements);
+ return unmaskStringLiterals(joined.trim(), literals);
+ }
+
+ private static String rewriteTableDdl(String maskedDdl) {
+ String s = DISTSTYLE_PATTERN.matcher(maskedDdl).replaceAll("");
+ s = DISTKEY_PAREN_PATTERN.matcher(s).replaceAll("");
+ s = SORTKEY_PAREN_PATTERN.matcher(s).replaceAll("");
+ s = KEY_COLUMN_CONSTRAINT_PATTERN.matcher(s).replaceAll("");
+ s = TABLE_LEVEL_KEY_IDENT_PATTERN.matcher(s).replaceAll("");
+ s = ENCODE_PATTERN.matcher(s).replaceAll("");
+ s = DOUBLE_COMMA_PATTERN.matcher(s).replaceAll(",");
+ s = COMMA_CLOSE_PAREN_PATTERN.matcher(s).replaceAll(")");
+ return s;
+ }
+
+ private static String maskStringLiterals(String sql, List<String> out) {
+ Matcher m = STRING_LITERAL_PATTERN.matcher(sql);
+ StringBuilder sb = new StringBuilder(sql.length());
+ while (m.find()) {
+ out.add(m.group());
+ m.appendReplacement(sb, Matcher.quoteReplacement(MASK_SENTINEL + (out.size() - 1) + MASK_SENTINEL));
+ }
+ m.appendTail(sb);
+ return sb.toString();
+ }
+
+ /** Single pass so already-restored text is never re-scanned. */
+ private static String unmaskStringLiterals(String masked, List<String> literals) {
+ if (literals.isEmpty()) {
+ return masked;
+ }
+ Matcher m = MASK_PLACEHOLDER_PATTERN.matcher(masked);
+ StringBuilder sb = new StringBuilder(masked.length());
+ while (m.find()) {
+ int idx = Integer.parseInt(m.group(1));
+ String literal = (idx >= 0 && idx < literals.size()) ? literals.get(idx) : m.group();
+ m.appendReplacement(sb, Matcher.quoteReplacement(literal));
+ }
+ m.appendTail(sb);
+ return sb.toString();
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftSqlInterceptorTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftSqlInterceptorTest.java
new file mode 100644
index 0000000000..0cd43a8fc2
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftSqlInterceptorTest.java
@@ -0,0 +1,274 @@
+package io.github.hectorvent.floci.services.redshift.proxy;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class RedshiftSqlInterceptorTest {
+
+ @Test
+ void shouldReturnNullAndEmptyAsIs() {
+ assertNull(RedshiftSqlInterceptor.rewrite(null));
+ assertEquals("", RedshiftSqlInterceptor.rewrite(""));
+ }
+
+ @Test
+ void shouldReturnSameInstanceWhenNoMatchOccursFastPath() {
+ String sql = "SELECT * FROM my_table WHERE id = 1";
+ String rewritten = RedshiftSqlInterceptor.rewrite(sql);
+ assertSame(sql, rewritten, "Fast-path must return the identical string reference");
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"ALL", "EVEN", "KEY", "AUTO", "all", "even", "key", "auto"})
+ void shouldRemoveDiststyle(String style) {
+ String sql = "CREATE TABLE users (id INT, name VARCHAR(50)) DISTSTYLE " + style + ";";
+ String rewritten = RedshiftSqlInterceptor.rewrite(sql);
+ assertTrue(!rewritten.contains("DISTSTYLE") && !rewritten.contains("diststyle"),
+ "Rewritten SQL should not contain DISTSTYLE: " + rewritten);
+ }
+
+ @Test
+ void shouldRemoveDistkeyParenAndIdent() {
+ String sql1 = "CREATE TABLE t (id INT) DISTKEY (id);";
+ String rewritten1 = RedshiftSqlInterceptor.rewrite(sql1);
+ assertTrue(!rewritten1.contains("DISTKEY"), "Should remove DISTKEY (col): " + rewritten1);
+
+ String sql2 = "CREATE TABLE t (id INT) DISTKEY id;";
+ String rewritten2 = RedshiftSqlInterceptor.rewrite(sql2);
+ assertTrue(!rewritten2.contains("DISTKEY"), "Should remove DISTKEY col: " + rewritten2);
+
+ String sql3 = "CREATE TABLE t (id INT) DISTKEY \"id\";";
+ String rewritten3 = RedshiftSqlInterceptor.rewrite(sql3);
+ assertTrue(!rewritten3.contains("DISTKEY"), "Should remove quoted DISTKEY \"col\": " + rewritten3);
+
+ String sql4 = "CREATE TABLE t (id INT DISTKEY, name VARCHAR(50));";
+ String rewritten4 = RedshiftSqlInterceptor.rewrite(sql4);
+ assertTrue(!rewritten4.contains("DISTKEY"), "Should remove column-level DISTKEY: " + rewritten4);
+
+ String sql5 = "CREATE TABLE t (id INT DISTKEY NOT NULL, name VARCHAR(50));";
+ String rewritten5 = RedshiftSqlInterceptor.rewrite(sql5);
+ assertTrue(!rewritten5.contains("DISTKEY"), "Should remove column-level DISTKEY followed by NOT NULL: " + rewritten5);
+ assertTrue(rewritten5.contains("id INT NOT NULL"), "Should preserve 'id INT NOT NULL': " + rewritten5);
+
+ String sql6 = "CREATE TABLE t (id INT DISTKEY PRIMARY KEY, code VARCHAR(10) DISTKEY UNIQUE);";
+ String rewritten6 = RedshiftSqlInterceptor.rewrite(sql6);
+ assertTrue(!rewritten6.contains("DISTKEY"), "Should remove column-level DISTKEY before PRIMARY KEY/UNIQUE: " + rewritten6);
+ assertTrue(rewritten6.contains("id INT PRIMARY KEY"), "Should preserve PRIMARY KEY: " + rewritten6);
+ assertTrue(rewritten6.contains("code VARCHAR(10) UNIQUE"), "Should preserve UNIQUE: " + rewritten6);
+ }
+
+ @Test
+ void shouldRemoveSortkeyVariants() {
+ String sql1 = "CREATE TABLE t (id INT, created_at TIMESTAMP) SORTKEY (created_at);";
+ String rewritten1 = RedshiftSqlInterceptor.rewrite(sql1);
+ assertTrue(!rewritten1.contains("SORTKEY"), "Should remove SORTKEY (col): " + rewritten1);
+
+ String sql2 = "CREATE TABLE t (id INT, c1 INT, c2 INT) COMPOUND SORTKEY (c1, c2);";
+ String rewritten2 = RedshiftSqlInterceptor.rewrite(sql2);
+ assertTrue(!rewritten2.contains("SORTKEY") && !rewritten2.contains("COMPOUND"),
+ "Should remove COMPOUND SORTKEY (c1, c2): " + rewritten2);
+
+ String sql3 = "CREATE TABLE t (id INT, c1 INT, c2 INT) INTERLEAVED SORTKEY (c1, c2);";
+ String rewritten3 = RedshiftSqlInterceptor.rewrite(sql3);
+ assertTrue(!rewritten3.contains("SORTKEY") && !rewritten3.contains("INTERLEAVED"),
+ "Should remove INTERLEAVED SORTKEY (c1, c2): " + rewritten3);
+
+ String sql4 = "CREATE TABLE t (id INT) SORTKEY id;";
+ String rewritten4 = RedshiftSqlInterceptor.rewrite(sql4);
+ assertTrue(!rewritten4.contains("SORTKEY"), "Should remove SORTKEY col: " + rewritten4);
+
+ String sql5 = "CREATE TABLE t (id INT SORTKEY, name VARCHAR(50));";
+ String rewritten5 = RedshiftSqlInterceptor.rewrite(sql5);
+ assertTrue(!rewritten5.contains("SORTKEY"), "Should remove column-level SORTKEY: " + rewritten5);
+
+ String sql6 = "CREATE TABLE t (id INT SORTKEY NOT NULL, name VARCHAR(50));";
+ String rewritten6 = RedshiftSqlInterceptor.rewrite(sql6);
+ assertTrue(!rewritten6.contains("SORTKEY"), "Should remove column-level SORTKEY followed by NOT NULL: " + rewritten6);
+ assertTrue(rewritten6.contains("id INT NOT NULL"), "Should preserve 'id INT NOT NULL': " + rewritten6);
+
+ String sql7 = "CREATE TABLE t (id INT DISTKEY SORTKEY NOT NULL, name VARCHAR(50));";
+ String rewritten7 = RedshiftSqlInterceptor.rewrite(sql7);
+ assertTrue(!rewritten7.contains("DISTKEY") && !rewritten7.contains("SORTKEY"),
+ "Should remove both DISTKEY and SORTKEY: " + rewritten7);
+ assertTrue(rewritten7.contains("id INT NOT NULL"), "Should preserve 'id INT NOT NULL': " + rewritten7);
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"zstd", "az64", "RAW", "raw", "lzo", "delta", "mostly8", "text255", "text32k"})
+ void shouldRemoveEncode(String codec) {
+ String sql = "CREATE TABLE t (id INT ENCODE " + codec + ", name VARCHAR(50) ENCODE " + codec + ");";
+ String rewritten = RedshiftSqlInterceptor.rewrite(sql);
+ assertTrue(!rewritten.contains("ENCODE") && !rewritten.contains("encode"),
+ "Should remove ENCODE " + codec + ": " + rewritten);
+ }
+
+ @Test
+ void shouldCleanOrphanedAndDoubleCommas() {
+ String sqlWithTrailingComma = "CREATE TABLE t (\n id INT,\n name VARCHAR(50),\n DISTKEY (id)\n);";
+ String rewritten1 = RedshiftSqlInterceptor.rewrite(sqlWithTrailingComma);
+ assertTrue(!rewritten1.contains(",\n)") && !rewritten1.contains(", )") && !rewritten1.contains(",\n )"),
+ "Should remove comma before closing parenthesis: " + rewritten1);
+
+ String sqlWithDoubleComma = "CREATE TABLE t (\n id INT,\n DISTKEY (id),\n name VARCHAR(50)\n);";
+ String rewritten2 = RedshiftSqlInterceptor.rewrite(sqlWithDoubleComma);
+ assertTrue(!rewritten2.contains(",\n ,") && !rewritten2.contains(", ,"),
+ "Should clean double commas: " + rewritten2);
+ }
+
+ @Test
+ void shouldBeIdempotent() {
+ String complexSql = """
+ CREATE TABLE sales (
+ sale_id INT ENCODE az64,
+ cust_id INT ENCODE zstd,
+ sale_date DATE ENCODE raw,
+ amount NUMERIC(10,2) ENCODE az64
+ )
+ DISTSTYLE KEY
+ DISTKEY (cust_id)
+ COMPOUND SORTKEY (sale_date, cust_id);
+ """;
+
+ String once = RedshiftSqlInterceptor.rewrite(complexSql);
+ String twice = RedshiftSqlInterceptor.rewrite(once);
+
+ assertEquals(once, twice, "Subsequent rewrite must produce identical result");
+ }
+
+ @Test
+ void shouldNotTouchNonTableDdlEvenIfItMentionsKeywords() {
+ // A query that merely contains the words distkey/sortkey/encode must pass through untouched.
+ String select = "SELECT distkey, sortkey FROM catalog WHERE encode = 'az64' ORDER BY distkey";
+ assertSame(select, RedshiftSqlInterceptor.rewrite(select));
+
+ String insert = "INSERT INTO audit (action) VALUES ('ran UNLOAD with ENCODE zstd')";
+ assertSame(insert, RedshiftSqlInterceptor.rewrite(insert));
+ }
+
+ @Test
+ void shouldKeepColumnNamedLikeAKeyword() {
+ // 'sortkey' / 'distkey' as real column names (followed by a type) survive;
+ // only the trailing table-level clause is stripped.
+ String sql = "CREATE TABLE t (id INT, sortkey VARCHAR(20), distkey INT) DISTKEY (id) SORTKEY (sortkey);";
+ String rewritten = RedshiftSqlInterceptor.rewrite(sql);
+ assertTrue(rewritten.contains("sortkey VARCHAR(20)"), "column 'sortkey' must survive: " + rewritten);
+ assertTrue(rewritten.contains("distkey INT"), "column 'distkey' must survive: " + rewritten);
+ assertTrue(!rewritten.contains("DISTKEY (") && !rewritten.contains("SORTKEY ("),
+ "table-level key clauses must be gone: " + rewritten);
+
+ String sqlWithConstraints = "CREATE TABLE t (distkey INT NOT NULL, sortkey VARCHAR(20) NOT NULL);";
+ String rewrittenWithConstraints = RedshiftSqlInterceptor.rewrite(sqlWithConstraints);
+ assertTrue(rewrittenWithConstraints.contains("distkey INT NOT NULL"), "column 'distkey INT NOT NULL' must survive: " + rewrittenWithConstraints);
+ assertTrue(rewrittenWithConstraints.contains("sortkey VARCHAR(20) NOT NULL"), "column 'sortkey VARCHAR(20) NOT NULL' must survive: " + rewrittenWithConstraints);
+ }
+
+ @Test
+ void shouldNotStripEncodeWhenFollowedByAnOrdinaryType() {
+ // A column literally named 'encode' of type varchar is not a Redshift ENCODE clause.
+ String sql = "CREATE TABLE t (id INT, encode VARCHAR(50));";
+ String rewritten = RedshiftSqlInterceptor.rewrite(sql);
+ assertTrue(rewritten.contains("encode VARCHAR(50)"), "column 'encode' must survive: " + rewritten);
+ }
+
+ @Test
+ void shouldRemoveEncodeAuto() {
+ String col = RedshiftSqlInterceptor.rewrite("CREATE TABLE t (a int ENCODE AUTO, b text);");
+ assertTrue(!col.contains("ENCODE"), "column-level ENCODE AUTO must be stripped: " + col);
+ String table = RedshiftSqlInterceptor.rewrite("CREATE TABLE t (a int) ENCODE AUTO;");
+ assertTrue(!table.contains("ENCODE"), "table-level ENCODE AUTO must be stripped: " + table);
+ }
+
+ @Test
+ void shouldStripDistkeyRegardlessOfColumnAttributeOrder() {
+ String sql = "CREATE TABLE t (id INT DISTKEY ENCODE az64, d date);";
+ String rewritten = RedshiftSqlInterceptor.rewrite(sql);
+ assertTrue(!rewritten.contains("DISTKEY") && !rewritten.contains("ENCODE"),
+ "both column attributes must be stripped regardless of order: " + rewritten);
+ assertEquals(rewritten, RedshiftSqlInterceptor.rewrite(rewritten), "must be idempotent");
+ }
+
+ @Test
+ void shouldNotMangleStringLiteralsInsideDdl() {
+ String sql = "CREATE TABLE t (a text DEFAULT 'x,)' CHECK (a <> 'SORTKEY'), b int) DISTKEY (b);";
+ String rewritten = RedshiftSqlInterceptor.rewrite(sql);
+ assertTrue(rewritten.contains("DEFAULT 'x,)'"), "string default must be intact: " + rewritten);
+ assertTrue(rewritten.contains("'SORTKEY'"), "string literal must be intact: " + rewritten);
+ assertTrue(!rewritten.contains("DISTKEY (b)"), "table-level DISTKEY clause must be gone: " + rewritten);
+ }
+
+ @Test
+ void shouldNotTouchSecondStatementOfAMultiStatementBatch() {
+ // The batch starts with CREATE TABLE, but the INSERT's string literal must survive verbatim.
+ String sql = "CREATE TABLE a (x int); INSERT INTO log VALUES ('DISTKEY (y)');";
+ assertSame(sql, RedshiftSqlInterceptor.rewrite(sql));
+ }
+
+ @Test
+ void shouldPreserveNonDdlStatementsInMultiStatementBatch() {
+ // Functions or column identifiers named like Redshift keywords in later statements must not be rewritten.
+ String sql = "CREATE TABLE t (x int DISTKEY); SELECT distkey(a), encode FROM s;";
+ String rewritten = RedshiftSqlInterceptor.rewrite(sql);
+ assertEquals("CREATE TABLE t (x int); SELECT distkey(a), encode FROM s;", rewritten);
+
+ String sql2 = "CREATE TABLE t (x int DISTKEY); SELECT a, distkey, b FROM s;";
+ String rewritten2 = RedshiftSqlInterceptor.rewrite(sql2);
+ assertEquals("CREATE TABLE t (x int); SELECT a, distkey, b FROM s;", rewritten2);
+ }
+
+ @Test
+ void shouldHandleSemicolonInsideStringLiteralInDdl() {
+ String sql = "CREATE TABLE t (x varchar DEFAULT ';', id int DISTKEY);";
+ String rewritten = RedshiftSqlInterceptor.rewrite(sql);
+ assertEquals("CREATE TABLE t (x varchar DEFAULT ';', id int);", rewritten);
+ }
+
+ @Test
+ void shouldPreserveDollarQuotedStringsWithDdlKeywordsAndSemicolons() {
+ String sql = "CREATE TABLE t (code text DEFAULT $$a; CREATE TABLE fake (id int DISTKEY)$$);";
+ String rewritten = RedshiftSqlInterceptor.rewrite(sql);
+ assertEquals(sql, rewritten, "Dollar-quoted string literal containing DDL text must not be altered");
+
+ String sqlTagged = "CREATE TABLE t (code text DEFAULT $tag$a; CREATE TABLE fake (id int DISTKEY)$tag$);";
+ String rewrittenTagged = RedshiftSqlInterceptor.rewrite(sqlTagged);
+ assertEquals(sqlTagged, rewrittenTagged, "Tagged dollar-quoted string must not be altered");
+
+ String sqlCustomTag = "CREATE TABLE t (code text DEFAULT $custom_tag$a; CREATE TABLE fake (id int DISTKEY)$custom_tag$);";
+ String rewrittenCustomTag = RedshiftSqlInterceptor.rewrite(sqlCustomTag);
+ assertEquals(sqlCustomTag, rewrittenCustomTag, "Custom-tagged dollar-quoted string must not be altered");
+
+ String sqlWithDistkey = "CREATE TABLE t (code text DEFAULT $$a; CREATE TABLE fake (id int DISTKEY)$$, id int DISTKEY);";
+ String rewrittenWithDistkey = RedshiftSqlInterceptor.rewrite(sqlWithDistkey);
+ assertEquals("CREATE TABLE t (code text DEFAULT $$a; CREATE TABLE fake (id int DISTKEY)$$, id int);", rewrittenWithDistkey);
+ }
+
+ @Test
+ void shouldHandleComprehensiveComplexDdl() {
+ String complexSql = """
+ CREATE TABLE public.orders (
+ order_id BIGINT NOT NULL ENCODE az64,
+ customer_id INT NOT NULL ENCODE zstd,
+ order_status VARCHAR(20) ENCODE lzo,
+ order_date TIMESTAMP WITHOUT TIME ZONE NOT NULL ENCODE raw,
+ total_amount NUMERIC(12, 4) ENCODE az64,
+ PRIMARY KEY (order_id)
+ )
+ DISTSTYLE AUTO
+ DISTKEY (customer_id)
+ INTERLEAVED SORTKEY (order_date, customer_id);
+ """;
+
+ String rewritten = RedshiftSqlInterceptor.rewrite(complexSql);
+ assertTrue(!rewritten.contains("ENCODE"), "Should not contain ENCODE: " + rewritten);
+ assertTrue(!rewritten.contains("DISTSTYLE"), "Should not contain DISTSTYLE: " + rewritten);
+ assertTrue(!rewritten.contains("DISTKEY"), "Should not contain DISTKEY: " + rewritten);
+ assertTrue(!rewritten.contains("SORTKEY"), "Should not contain SORTKEY: " + rewritten);
+ assertTrue(!rewritten.contains("INTERLEAVED"), "Should not contain INTERLEAVED: " + rewritten);
+ assertTrue(!rewritten.contains(",\n)"), "Should not contain trailing comma before parenthesis: " + rewritten);
+ }
+}