sqlancer
diff --git a/‎src/sqlancer/common/gen/EETDMLGenerator.java‎
Lines changed: 29 additions & 3 deletions b/‎src/sqlancer/common/gen/EETDMLGenerator.java‎
Lines changed: 29 additions & 3 deletions
diff --git a/‎src/sqlancer/common/oracle/EETDMLOracle.java‎
Lines changed: 11 additions & 2 deletions b/‎src/sqlancer/common/oracle/EETDMLOracle.java‎
Lines changed: 11 additions & 2 deletions
@@ -1,5 +1,8 @@
 package sqlancer.common.gen;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import sqlancer.common.ast.newast.Expression;
 import sqlancer.common.oracle.EETTransformer;
 import sqlancer.common.schema.AbstractTable;
@@ -122,17 +125,40 @@ default String selectRowIdsStatement(T table) {
     }
 
     /**
-     * SQL that deletes the rows of {@code table} matching {@code predicate}.
+     * SQL that deletes the rows of {@code table} matching {@code predicate}, optionally limited to the first
+     * {@code limit} rows.
+     *
+     * <p>
+     * When {@code limit} is non-null, the statement is ordered by {@code orderByColumns} followed by
+     * {@link #ROW_ID_COLUMN} as a tiebreaker. Because the identifiers are unique, this is always a total order (even when
+     * the ordering columns tie), so the "first {@code limit}" rows are identical for the original and
+     * transformed statements. Varying the ordering columns exercises more access
+     * paths than the row id alone would. The caller must pass the same {@code orderByColumns} and {@code limit}
+     * to both statements; neither is transformed.
      *
      * @param table
      *            the table to delete from
      * @param predicate
      *            the WHERE predicate; rendered via {@link #asString}
+     * @param orderByColumns
+     *            the columns to order by before the row-id tiebreaker (may be empty); only used when {@code limit} is
+     *            non-null
+     * @param limit
+     *            the maximum number of rows to delete, or {@code null} for no limit
      *
      * @return the SQL statement
      */
-    default String deleteStatement(T table, E predicate) {
-        return "DELETE FROM " + table.getName() + " WHERE " + asString(predicate);
+    default String deleteStatement(T table, E predicate, List<C> orderByColumns, Integer limit) {
+        String statement = "DELETE FROM " + table.getName() + " WHERE " + asString(predicate);
+        if (limit != null) {
+            List<String> orderBy = new ArrayList<>();
+            for (C column : orderByColumns) {
+                orderBy.add(column.getName());
+            }
+            orderBy.add(ROW_ID_COLUMN); // unique tiebreaker: guarantees a total order regardless of the columns above
+            statement += " ORDER BY " + String.join(", ", orderBy) + " LIMIT " + limit;
+        }
+        return statement;
     }
 
     /**
 
@@ -84,8 +84,17 @@ public void check() throws SQLException {
         // The WHERE predicate is evaluated in a boolean context.
         E transformedPredicate = transformer.transform(predicate, true);
 
-        String originalDelete = gen.deleteStatement(table, predicate);
-        String transformedDelete = gen.deleteStatement(table, transformedPredicate);
+        // Optionally cap the DELETE with a LIMIT. The limit and its ordering (a random column subset, made a total
+        // order by the row-id tiebreaker) are decided once and applied identically to both statements, so the capped
+        // row set is deterministic and equal across the runs while still exercising varied orderings.
+        Integer limit = null;
+        List<C> orderByColumns = List.of();
+        if (Randomly.getBoolean()) {
+            limit = (int) Randomly.getNotCachedInteger(0, 10);
+            orderByColumns = Randomly.subset(table.getColumns());
+        }
+        String originalDelete = gen.deleteStatement(table, predicate, orderByColumns, limit);
+        String transformedDelete = gen.deleteStatement(table, transformedPredicate, orderByColumns, limit);
         generatedQueryString = originalDelete;
 
         // Add the auxiliary column outside the try, then guard everything after it with the finally that drops it: