sqlancer
diff --git a/src/sqlancer/clickhouse/gen/ClickHouseInsertGenerator.java b/src/sqlancer/clickhouse/gen/ClickHouseInsertGenerator.java
@@ -1,6 +1,5 @@
 package sqlancer.clickhouse.gen;
 
-import java.sql.SQLException;
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -29,19 +28,19 @@ public ClickHouseInsertGenerator(ClickHouseGlobalState globalState) {
         ClickHouseErrors.addExpectedExpressionErrors(errors);
     }
 
-    public static SQLQueryAdapter getQuery(ClickHouseGlobalState globalState) throws SQLException {
-        return new ClickHouseInsertGenerator(globalState).get();
+    public static SQLQueryAdapter getQuery(ClickHouseGlobalState globalState) {
+        return new ClickHouseInsertGenerator(globalState).getStatement();
     }
 
-    private SQLQueryAdapter get() {
+    @Override
+    public void buildStatement() {
         ClickHouseTable table = globalState.getSchema().getRandomTable(t -> !t.isView());
         List<ClickHouseColumn> columns = Collections.emptyList();
         while (columns.isEmpty()) {
             columns = table.getRandomNonEmptyColumnSubset().stream().filter(c -> !c.isAlias() && !c.isMaterialized())
                     .collect(Collectors.toList());
         }
         buildInsertInto(table.getName(), columns);
-        return new SQLQueryAdapter(sb.toString(), errors);
     }
 
     @Override

diff --git a/src/sqlancer/cockroachdb/gen/CockroachDBDeleteGenerator.java b/src/sqlancer/cockroachdb/gen/CockroachDBDeleteGenerator.java
@@ -6,17 +6,23 @@
 import sqlancer.cockroachdb.CockroachDBSchema.CockroachDBDataType;
 import sqlancer.cockroachdb.CockroachDBSchema.CockroachDBTable;
 import sqlancer.cockroachdb.CockroachDBVisitor;
-import sqlancer.common.query.ExpectedErrors;
+import sqlancer.common.gen.AbstractDeleteGenerator;
 import sqlancer.common.query.SQLQueryAdapter;
 
-public final class CockroachDBDeleteGenerator {
+public final class CockroachDBDeleteGenerator extends AbstractDeleteGenerator {
 
-    private CockroachDBDeleteGenerator() {
+    private final CockroachDBGlobalState globalState;
+
+    private CockroachDBDeleteGenerator(CockroachDBGlobalState globalState) {
+        this.globalState = globalState;
     }
 
     public static SQLQueryAdapter delete(CockroachDBGlobalState globalState) {
-        ExpectedErrors errors = new ExpectedErrors();
-        StringBuilder sb = new StringBuilder();
+        return new CockroachDBDeleteGenerator(globalState).getStatement();
+    }
+
+    @Override
+    public void buildStatement() {
         CockroachDBTable table = globalState.getSchema().getRandomTable(t -> !t.isView());
         sb.append("DELETE FROM ");
         sb.append(table.getName());
@@ -30,7 +36,6 @@ public static SQLQueryAdapter delete(CockroachDBGlobalState globalState) {
         }
         errors.add("foreign key violation");
         CockroachDBErrors.addTransactionErrors(errors);
-        return new SQLQueryAdapter(sb.toString(), errors);
     }
 
 }
diff --git a/src/sqlancer/cockroachdb/gen/CockroachDBIndexGenerator.java b/src/sqlancer/cockroachdb/gen/CockroachDBIndexGenerator.java
@@ -21,7 +21,7 @@ public static SQLQueryAdapter create(CockroachDBGlobalState s) {
         if (s.getSchema().getIndexCount() >= s.getDbmsSpecificOptions().maxNumIndexes) {
             throw new IgnoreMeException();
         }
-        return new CockroachDBIndexGenerator(s).getQuery();
+        return new CockroachDBIndexGenerator(s).getStatement();
     }
 
     @Override

diff --git a/src/sqlancer/cockroachdb/gen/CockroachDBTableGenerator.java b/src/sqlancer/cockroachdb/gen/CockroachDBTableGenerator.java
@@ -32,7 +32,7 @@ public static SQLQueryAdapter generate(CockroachDBGlobalState globalState) {
         if (globalState.getSchema().getDatabaseTables().size() > globalState.getDbmsSpecificOptions().maxNumTables) {
             throw new IgnoreMeException();
         }
-        return new CockroachDBTableGenerator(globalState).getQuery();
+        return new CockroachDBTableGenerator(globalState).getStatement();
     }
 
     @Override

diff --git a/src/sqlancer/cockroachdb/gen/CockroachDBUpdateGenerator.java b/src/sqlancer/cockroachdb/gen/CockroachDBUpdateGenerator.java
@@ -22,10 +22,11 @@ private CockroachDBUpdateGenerator(CockroachDBGlobalState globalState) {
     }
 
     public static SQLQueryAdapter gen(CockroachDBGlobalState globalState) {
-        return new CockroachDBUpdateGenerator(globalState).generate();
+        return new CockroachDBUpdateGenerator(globalState).getStatement();
     }
 
-    private SQLQueryAdapter generate() {
+    @Override
+    public void buildStatement() {
         CockroachDBTable table = globalState.getSchema().getRandomTable(t -> !t.isView());
         List<CockroachDBColumn> columns = table.getRandomNonEmptyColumnSubset();
         gen = new CockroachDBExpressionGenerator(globalState).setColumns(columns);
@@ -51,7 +52,6 @@ private SQLQueryAdapter generate() {
         errors.add("cannot write directly to computed column");
         CockroachDBErrors.addExpressionErrors(errors);
         CockroachDBErrors.addTransactionErrors(errors);
-        return new SQLQueryAdapter(sb.toString(), errors);
     }
 
     @Override

diff --git a/src/sqlancer/common/gen/AbstractDeleteGenerator.java b/src/sqlancer/common/gen/AbstractDeleteGenerator.java
@@ -0,0 +1,8 @@
+package sqlancer.common.gen;
+
+public abstract class AbstractDeleteGenerator extends AbstractGenerator {
+
+    protected AbstractDeleteGenerator() {
+    }
+
+}
diff --git a/src/sqlancer/common/gen/AbstractGenerator.java b/src/sqlancer/common/gen/AbstractGenerator.java
@@ -8,10 +8,11 @@ public abstract class AbstractGenerator {
     protected final ExpectedErrors errors = new ExpectedErrors();
     protected final StringBuilder sb = new StringBuilder();
     protected boolean canAffectSchema;
+    protected boolean canonicalizeString = true;
 
-    public SQLQueryAdapter getQuery() {
+    public SQLQueryAdapter getStatement() {
         buildStatement();
-        return new SQLQueryAdapter(sb.toString(), errors, canAffectSchema);
+        return new SQLQueryAdapter(sb.toString(), errors, canAffectSchema, canonicalizeString);
     }
 
     public abstract void buildStatement();

diff --git a/src/sqlancer/common/gen/AbstractInsertGenerator.java b/src/sqlancer/common/gen/AbstractInsertGenerator.java
@@ -4,13 +4,9 @@
 import java.util.stream.Collectors;
 
 import sqlancer.Randomly;
-import sqlancer.common.query.ExpectedErrors;
 import sqlancer.common.schema.AbstractTableColumn;
 
-public abstract class AbstractInsertGenerator<C extends AbstractTableColumn<?, ?>> {
-
-    protected StringBuilder sb = new StringBuilder();
-    protected ExpectedErrors errors = new ExpectedErrors();
+public abstract class AbstractInsertGenerator<C extends AbstractTableColumn<?, ?>> extends AbstractGenerator {
 
     protected void appendColumnList(List<C> columns) {
         sb.append("(");

diff --git a/src/sqlancer/common/gen/AbstractUpdateGenerator.java b/src/sqlancer/common/gen/AbstractUpdateGenerator.java
@@ -2,13 +2,9 @@
 
 import java.util.List;
 
-import sqlancer.common.query.ExpectedErrors;
 import sqlancer.common.schema.AbstractTableColumn;
 
-public abstract class AbstractUpdateGenerator<C extends AbstractTableColumn<?, ?>> {
-
-    protected final ExpectedErrors errors = new ExpectedErrors();
-    protected StringBuilder sb = new StringBuilder();
+public abstract class AbstractUpdateGenerator<C extends AbstractTableColumn<?, ?>> extends AbstractGenerator {
 
     protected void updateColumns(List<C> columns) {
         for (int nrColumn = 0; nrColumn < columns.size(); nrColumn++) {

diff --git a/src/sqlancer/databend/gen/DatabendDeleteGenerator.java b/src/sqlancer/databend/gen/DatabendDeleteGenerator.java
@@ -1,29 +1,35 @@
 package sqlancer.databend.gen;
 
 import sqlancer.Randomly;
-import sqlancer.common.query.ExpectedErrors;
+import sqlancer.common.gen.AbstractDeleteGenerator;
 import sqlancer.common.query.SQLQueryAdapter;
 import sqlancer.databend.DatabendErrors;
 import sqlancer.databend.DatabendProvider.DatabendGlobalState;
 import sqlancer.databend.DatabendSchema.DatabendDataType;
 import sqlancer.databend.DatabendToStringVisitor;
 
-public final class DatabendDeleteGenerator {
+public final class DatabendDeleteGenerator extends AbstractDeleteGenerator {
 
-    private DatabendDeleteGenerator() {
+    private final DatabendGlobalState globalState;
+
+    private DatabendDeleteGenerator(DatabendGlobalState globalState) {
+        this.globalState = globalState;
     }
 
     public static SQLQueryAdapter generate(DatabendGlobalState globalState) {
-        StringBuilder sb = new StringBuilder("DELETE FROM ");
-        ExpectedErrors errors = new ExpectedErrors();
+        return new DatabendDeleteGenerator(globalState).getStatement();
+    }
+
+    @Override
+    public void buildStatement() {
+        sb.append("DELETE FROM ");
         sb.append(globalState.getSchema().getRandomTable(t -> !t.isView()).getName());
         if (Randomly.getBoolean()) {
             sb.append(" WHERE ");
             sb.append(DatabendToStringVisitor.asString(
                     new DatabendNewExpressionGenerator(globalState).generateExpression(DatabendDataType.BOOLEAN)));
             DatabendErrors.addExpressionErrors(errors);
         }
-        return new SQLQueryAdapter(sb.toString(), errors);
     }
 
 }
diff --git a/src/sqlancer/databend/gen/DatabendInsertGenerator.java b/src/sqlancer/databend/gen/DatabendInsertGenerator.java
@@ -19,15 +19,15 @@ public DatabendInsertGenerator(DatabendGlobalState globalState) {
     }
 
     public static SQLQueryAdapter getQuery(DatabendGlobalState globalState) {
-        return new DatabendInsertGenerator(globalState).generate();
+        return new DatabendInsertGenerator(globalState).getStatement();
     }
 
-    private SQLQueryAdapter generate() {
+    @Override
+    public void buildStatement() {
         DatabendTable table = globalState.getSchema().getRandomTable(t -> !t.isView());
         List<DatabendColumn> columns = table.getRandomNonEmptyColumnSubset();
         buildInsertInto(table.getName(), columns);
         DatabendErrors.addInsertErrors(errors);
-        return new SQLQueryAdapter(sb.toString(), errors);
     }
 
     @Override

diff --git a/src/sqlancer/datafusion/gen/DataFusionInsertGenerator.java b/src/sqlancer/datafusion/gen/DataFusionInsertGenerator.java
@@ -13,22 +13,24 @@
 public class DataFusionInsertGenerator extends AbstractInsertGenerator<DataFusionColumn> {
 
     private final DataFusionGlobalState globalState;
+    private final DataFusionTable targetTable;
 
-    public DataFusionInsertGenerator(DataFusionGlobalState globalState) {
+    public DataFusionInsertGenerator(DataFusionGlobalState globalState, DataFusionTable targetTable) {
         this.globalState = globalState;
+        this.targetTable = targetTable;
     }
 
     public static SQLQueryAdapter getQuery(DataFusionGlobalState globalState, DataFusionTable targetTable) {
-        return new DataFusionInsertGenerator(globalState).generate(targetTable);
+        return new DataFusionInsertGenerator(globalState, targetTable).getStatement();
     }
 
-    private SQLQueryAdapter generate(DataFusionTable targetTable) {
+    @Override
+    public void buildStatement() {
         if (targetTable.getColumns().isEmpty()) {
             throw new IgnoreMeException();
         }
         List<DataFusionColumn> columns = targetTable.getRandomNonEmptyColumnSubset();
         buildInsertInto(targetTable.getName(), columns);
-        return new SQLQueryAdapter(sb.toString(), errors);
     }
 
     @Override

diff --git a/src/sqlancer/doris/gen/DorisDeleteGenerator.java b/src/sqlancer/doris/gen/DorisDeleteGenerator.java
@@ -1,22 +1,29 @@
 package sqlancer.doris.gen;
 
 import sqlancer.Randomly;
-import sqlancer.common.query.ExpectedErrors;
+import sqlancer.common.gen.AbstractDeleteGenerator;
 import sqlancer.common.query.SQLQueryAdapter;
 import sqlancer.doris.DorisErrors;
 import sqlancer.doris.DorisProvider.DorisGlobalState;
 import sqlancer.doris.DorisSchema;
 import sqlancer.doris.DorisSchema.DorisTable;
 import sqlancer.doris.visitor.DorisToStringVisitor;
 
-public final class DorisDeleteGenerator {
+public final class DorisDeleteGenerator extends AbstractDeleteGenerator {
 
-    private DorisDeleteGenerator() {
+    private final DorisGlobalState globalState;
+
+    private DorisDeleteGenerator(DorisGlobalState globalState) {
+        this.globalState = globalState;
     }
 
     public static SQLQueryAdapter generate(DorisGlobalState globalState) {
-        StringBuilder sb = new StringBuilder("DELETE FROM ");
-        ExpectedErrors errors = new ExpectedErrors();
+        return new DorisDeleteGenerator(globalState).getStatement();
+    }
+
+    @Override
+    public void buildStatement() {
+        sb.append("DELETE FROM ");
         DorisTable table = globalState.getSchema().getRandomTable(t -> !t.isView());
         sb.append(table.getName());
         if (Randomly.getBoolean()) {
@@ -25,7 +32,6 @@ public static SQLQueryAdapter generate(DorisGlobalState globalState) {
                     .setColumns(table.getColumns()).generateExpression(DorisSchema.DorisDataType.BOOLEAN)));
             DorisErrors.addExpressionErrors(errors);
         }
-        return new SQLQueryAdapter(sb.toString(), errors);
     }
 
 }
diff --git a/src/sqlancer/doris/gen/DorisInsertGenerator.java b/src/sqlancer/doris/gen/DorisInsertGenerator.java
@@ -20,15 +20,15 @@ public DorisInsertGenerator(DorisGlobalState globalState) {
     }
 
     public static SQLQueryAdapter getQuery(DorisGlobalState globalState) {
-        return new DorisInsertGenerator(globalState).generate();
+        return new DorisInsertGenerator(globalState).getStatement();
     }
 
-    private SQLQueryAdapter generate() {
+    @Override
+    public void buildStatement() {
         DorisTable table = globalState.getSchema().getRandomTable(t -> !t.isView());
-        List<DorisColumn> columns = table.getRandomNonEmptyInsertColumns();
+        List<DorisColumn> columns = table.getRandomNonEmptyColumnSubset();
         buildInsertInto(table.getName(), columns);
         DorisErrors.addInsertErrors(errors);
-        return new SQLQueryAdapter(sb.toString(), errors);
     }
 
     @Override

diff --git a/src/sqlancer/doris/gen/DorisUpdateGenerator.java b/src/sqlancer/doris/gen/DorisUpdateGenerator.java
@@ -23,10 +23,11 @@ private DorisUpdateGenerator(DorisGlobalState globalState) {
     }
 
     public static SQLQueryAdapter getQuery(DorisGlobalState globalState) {
-        return new DorisUpdateGenerator(globalState).generate();
+        return new DorisUpdateGenerator(globalState).getStatement();
     }
 
-    private SQLQueryAdapter generate() {
+    @Override
+    public void buildStatement() {
         DorisTable table = globalState.getSchema().getRandomTable(t -> !t.isView());
         List<DorisColumn> columns = table.getRandomNonEmptyColumnSubset();
         gen = new DorisNewExpressionGenerator(globalState).setColumns(table.getColumns());
@@ -37,7 +38,6 @@ private SQLQueryAdapter generate() {
         sb.append(" WHERE ");
         sb.append(DorisToStringVisitor.asString(gen.generateExpression(DorisSchema.DorisDataType.BOOLEAN)));
         DorisErrors.addInsertErrors(errors);
-        return new SQLQueryAdapter(sb.toString(), errors);
     }
 
     @Override

diff --git a/src/sqlancer/duckdb/gen/DuckDBDeleteGenerator.java b/src/sqlancer/duckdb/gen/DuckDBDeleteGenerator.java
@@ -1,21 +1,28 @@
 package sqlancer.duckdb.gen;
 
 import sqlancer.Randomly;
-import sqlancer.common.query.ExpectedErrors;
+import sqlancer.common.gen.AbstractDeleteGenerator;
 import sqlancer.common.query.SQLQueryAdapter;
 import sqlancer.duckdb.DuckDBErrors;
 import sqlancer.duckdb.DuckDBProvider.DuckDBGlobalState;
 import sqlancer.duckdb.DuckDBSchema.DuckDBTable;
 import sqlancer.duckdb.DuckDBToStringVisitor;
 
-public final class DuckDBDeleteGenerator {
+public final class DuckDBDeleteGenerator extends AbstractDeleteGenerator {
 
-    private DuckDBDeleteGenerator() {
+    private final DuckDBGlobalState globalState;
+
+    private DuckDBDeleteGenerator(DuckDBGlobalState globalState) {
+        this.globalState = globalState;
     }
 
     public static SQLQueryAdapter generate(DuckDBGlobalState globalState) {
-        StringBuilder sb = new StringBuilder("DELETE FROM ");
-        ExpectedErrors errors = new ExpectedErrors();
+        return new DuckDBDeleteGenerator(globalState).getStatement();
+    }
+
+    @Override
+    public void buildStatement() {
+        sb.append("DELETE FROM ");
         DuckDBTable table = globalState.getSchema().getRandomTable(t -> !t.isView());
         sb.append(table.getName());
         if (Randomly.getBoolean()) {
@@ -24,7 +31,6 @@ public static SQLQueryAdapter generate(DuckDBGlobalState globalState) {
                     new DuckDBExpressionGenerator(globalState).setColumns(table.getColumns()).generateExpression()));
         }
         DuckDBErrors.addExpressionErrors(errors);
-        return new SQLQueryAdapter(sb.toString(), errors);
     }
 
 }
diff --git a/src/sqlancer/duckdb/gen/DuckDBInsertGenerator.java b/src/sqlancer/duckdb/gen/DuckDBInsertGenerator.java
@@ -20,15 +20,15 @@ public DuckDBInsertGenerator(DuckDBGlobalState globalState) {
     }
 
     public static SQLQueryAdapter getQuery(DuckDBGlobalState globalState) {
-        return new DuckDBInsertGenerator(globalState).generate();
+        return new DuckDBInsertGenerator(globalState).getStatement();
     }
 
-    private SQLQueryAdapter generate() {
+    @Override
+    public void buildStatement() {
         DuckDBTable table = globalState.getSchema().getRandomTable(t -> !t.isView());
         List<DuckDBColumn> columns = table.getRandomNonEmptyColumnSubsetFilter(p -> !p.getName().equals("rowid"));
         buildInsertInto(table.getName(), columns);
         DuckDBErrors.addInsertErrors(errors);
-        return new SQLQueryAdapter(sb.toString(), errors);
     }
 
     @Override