Merge branch 'main' into feat/spark-tlp

codebreaker32 · web-flow · commit 15c0cbae4f18 · 2026-04-03T11:47:23.000+05:30
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
diff --git a/pom.xml b/pom.xml
@@ -89,7 +89,7 @@
       <plugin>
         <groupId>org.jacoco</groupId>
         <artifactId>jacoco-maven-plugin</artifactId>
-        <version>0.8.8</version>
+        <version>0.8.12</version>
         <executions>
           <execution>
             <goals>
diff --git a/src/sqlancer/clickhouse/ClickHouseErrors.java b/src/sqlancer/clickhouse/ClickHouseErrors.java
@@ -41,6 +41,7 @@ public static List<String> getExpectedExpressionErrors() {
                 "Cannot convert out of range floating point value to integer type",
                 "Unexpected inf or nan to integer conversion", "No such name in Block::erase", // https://github.com/ClickHouse/ClickHouse/issues/42769
                 "EMPTY_LIST_OF_COLUMNS_QUERIED", // https://github.com/ClickHouse/ClickHouse/issues/43003
+                "EMPTY_LIST_OF_COLUMNS_PASSED", // https://github.com/ClickHouse/ClickHouse/pull/81835
                 "cannot get JOIN keys. (INVALID_JOIN_ON_EXPRESSION)", "AMBIGUOUS_IDENTIFIER", "CYCLIC_ALIASES",
                 "Positional argument numeric constant expression is not representable as",
                 "Positional argument must be constant with numeric type", " is out of bounds. Expected in range",
diff --git a/src/sqlancer/materialize/MaterializeProvider.java b/src/sqlancer/materialize/MaterializeProvider.java
@@ -240,12 +240,17 @@ protected void readFunctions(MaterializeGlobalState globalState) throws SQLExcep
     }
 
     protected void createTables(MaterializeGlobalState globalState, int numTables) throws Exception {
-        while (globalState.getSchema().getDatabaseTables().size() < numTables) {
+        int existingTables = globalState.getSchema().getDatabaseTables().size();
+        int createdTables = 0;
+        int nextTableIndex = existingTables;
+        while (existingTables + createdTables < numTables) {
             try {
-                String tableName = DBMSCommon.createTableName(globalState.getSchema().getDatabaseTables().size());
+                String tableName = DBMSCommon.createTableName(nextTableIndex++);
                 SQLQueryAdapter createTable = MaterializeTableGenerator.generate(tableName, globalState.getSchema(),
                         generateOnlyKnown, globalState);
-                globalState.executeStatement(createTable);
+                if (globalState.executeStatement(createTable)) {
+                    createdTables++;
+                }
             } catch (IgnoreMeException e) {
 
             }
diff --git a/src/sqlancer/materialize/gen/MaterializeExpressionGenerator.java b/src/sqlancer/materialize/gen/MaterializeExpressionGenerator.java
@@ -600,6 +600,7 @@ public String generateOptimizedQueryString(MaterializeSelect select, Materialize
             }
             select.setSelectType(SelectType.ALL);
         }
+        select.setWhereClause(whereCondition);
 
         return select.asString();
     }
diff --git a/src/sqlancer/materialize/gen/MaterializeInsertGenerator.java b/src/sqlancer/materialize/gen/MaterializeInsertGenerator.java
@@ -26,7 +26,7 @@ public static SQLQueryAdapter insert(MaterializeGlobalState globalState) {
         MaterializeCommon.addCommonExpressionErrors(errors);
         errors.add("multiple assignments to same column");
         errors.add("violates foreign key constraint");
-        errors.add("value too long for type character varying");
+        errors.add("value too long for type character");
         errors.add("conflicting key value violates exclusion constraint");
         errors.add("violates not-null constraint");
         errors.add("current transaction is aborted");
diff --git a/src/sqlancer/materialize/gen/MaterializeTableGenerator.java b/src/sqlancer/materialize/gen/MaterializeTableGenerator.java
@@ -52,6 +52,7 @@ public MaterializeTableGenerator(String tableName, MaterializeSchema newSchema,
         errors.add("no collation was derived for partition key column");
         errors.add("inherits from generated column but specifies identity");
         errors.add("inherits from generated column but specifies default");
+        errors.add("already exists");
         MaterializeCommon.addCommonExpressionErrors(errors);
         MaterializeCommon.addCommonTableErrors(errors);
     }
diff --git a/src/sqlancer/mysql/MySQLErrors.java b/src/sqlancer/mysql/MySQLErrors.java
@@ -33,6 +33,7 @@ public static List<Pattern> getExpressionRegexErrors() {
         }
 
         errors.add(Pattern.compile("Unknown column '.*' in 'order clause'"));
+        errors.add(Pattern.compile("Unknown column '.*' in 'EXISTS subquery'"));
 
         return errors;
     }
diff --git a/src/sqlancer/mysql/gen/MySQLSetGenerator.java b/src/sqlancer/mysql/gen/MySQLSetGenerator.java
@@ -99,7 +99,6 @@ private enum Action {
         SCHEMA_DEFINITION_CACHE("schema_definition_cache", (r) -> r.getLong(256, 524288), Scope.GLOBAL), //
         SHOW_CREATE_TABLE_VERBOSITY("show_create_table_verbosity", (r) -> Randomly.fromOptions("OFF", "ON"),
                 Scope.GLOBAL, Scope.SESSION), //
-        SHOW_OLD_TEMPORALS("show_old_temporals", (r) -> Randomly.fromOptions("OFF", "ON"), Scope.GLOBAL, Scope.SESSION),
         /*
          * sort_buffer_size is commented out as a workaround for https://bugs.mysql.com/bug.php?id=95969
          */
diff --git a/src/sqlancer/mysql/oracle/MySQLPivotedQuerySynthesisOracle.java b/src/sqlancer/mysql/oracle/MySQLPivotedQuerySynthesisOracle.java
@@ -38,6 +38,7 @@ public MySQLPivotedQuerySynthesisOracle(MySQLGlobalState globalState) throws SQL
         super(globalState);
         MySQLErrors.addExpressionErrors(errors);
         errors.add("in 'order clause'"); // e.g., Unknown column '2067708013' in 'order clause'
+        errors.add("in 'EXISTS subquery'"); // e.g., Unknown column '2067708013' in 'EXISTS subquery' (MySQL 8.4+)
     }
 
     @Override
diff --git a/src/sqlancer/postgres/PostgresSchema.java b/src/sqlancer/postgres/PostgresSchema.java
@@ -164,13 +164,26 @@ public enum TableType {
         private final TableType tableType;
         private final List<PostgresStatisticsObject> statistics;
         private final boolean isInsertable;
+        private final boolean isPartitioned;
 
         public PostgresTable(String tableName, List<PostgresColumn> columns, List<PostgresIndex> indexes,
                 TableType tableType, List<PostgresStatisticsObject> statistics, boolean isView, boolean isInsertable) {
             super(tableName, columns, indexes, isView);
             this.statistics = statistics;
             this.isInsertable = isInsertable;
             this.tableType = tableType;
+            // TODO: simple adapter for other implementations
+            this.isPartitioned = false;
+        }
+
+        public PostgresTable(String tableName, List<PostgresColumn> columns, List<PostgresIndex> indexes,
+                TableType tableType, List<PostgresStatisticsObject> statistics, boolean isView, boolean isInsertable,
+                boolean isPartitioned) {
+            super(tableName, columns, indexes, isView);
+            this.statistics = statistics;
+            this.isInsertable = isInsertable;
+            this.tableType = tableType;
+            this.isPartitioned = isPartitioned;
         }
 
         public List<PostgresStatisticsObject> getStatistics() {
@@ -185,6 +198,10 @@ public boolean isInsertable() {
             return isInsertable;
         }
 
+        public boolean isPartitioned() {
+            return isPartitioned;
+        }
+
     }
 
     public static final class PostgresStatisticsObject {
@@ -225,11 +242,12 @@ public static PostgresSchema fromConnection(SQLConnection con, String databaseNa
             List<PostgresTable> databaseTables = new ArrayList<>();
             try (Statement s = con.createStatement()) {
                 try (ResultSet rs = s.executeQuery(
-                        "SELECT table_name, table_schema, table_type, is_insertable_into FROM information_schema.tables WHERE table_schema='public' OR table_schema LIKE 'pg_temp_%' ORDER BY table_name;")) {
+                        "SELECT t.table_name, t.table_schema, t.table_type, t.is_insertable_into, c.relkind FROM information_schema.tables t JOIN pg_class c ON c.relname = t.table_name JOIN pg_namespace n ON n.oid = c.relnamespace AND n.nspname = t.table_schema WHERE t.table_schema='public' OR t.table_schema LIKE 'pg_temp_%' ORDER BY t.table_name;")) {
                     while (rs.next()) {
                         String tableName = rs.getString("table_name");
                         String tableTypeSchema = rs.getString("table_schema");
                         boolean isInsertable = rs.getBoolean("is_insertable_into");
+                        boolean isPartitioned = "p".equals(rs.getString("relkind"));
                         // TODO: also check insertable
                         // TODO: insert into view?
                         boolean isView = tableName.startsWith("v"); // tableTypeStr.contains("VIEW") ||
@@ -240,7 +258,7 @@ public static PostgresSchema fromConnection(SQLConnection con, String databaseNa
                         List<PostgresIndex> indexes = getIndexes(con, tableName);
                         List<PostgresStatisticsObject> statistics = getStatistics(con);
                         PostgresTable t = new PostgresTable(tableName, databaseColumns, indexes, tableType, statistics,
-                                isView, isInsertable);
+                                isView, isInsertable, isPartitioned);
                         for (PostgresColumn c : databaseColumns) {
                             c.setTable(t);
                         }
diff --git a/src/sqlancer/postgres/ast/PostgresBinaryComparisonOperation.java b/src/sqlancer/postgres/ast/PostgresBinaryComparisonOperation.java
@@ -1,5 +1,6 @@
 package sqlancer.postgres.ast;
 
+import sqlancer.IgnoreMeException;
 import sqlancer.Randomly;
 import sqlancer.common.ast.BinaryOperatorNode;
 import sqlancer.common.ast.BinaryOperatorNode.Operator;
@@ -126,7 +127,7 @@ public PostgresConstant getExpectedValue() {
         PostgresConstant leftExpectedValue = getLeft().getExpectedValue();
         PostgresConstant rightExpectedValue = getRight().getExpectedValue();
         if (leftExpectedValue == null || rightExpectedValue == null) {
-            return null;
+            throw new IgnoreMeException();
         }
         return getOp().getExpectedValue(leftExpectedValue, rightExpectedValue);
     }
diff --git a/src/sqlancer/postgres/gen/PostgresAlterTableGenerator.java b/src/sqlancer/postgres/gen/PostgresAlterTableGenerator.java
@@ -127,6 +127,9 @@ public List<Action> getActions(ExpectedErrors errors) {
         if (!randomTable.hasIndexes()) {
             action.remove(Action.ADD_TABLE_CONSTRAINT_USING_INDEX);
         }
+        if (randomTable.isPartitioned()) {
+            action.remove(Action.SET_LOGGED_UNLOGGED);
+        }
         if (action.isEmpty()) {
             throw new IgnoreMeException();
         }
@@ -235,6 +238,8 @@ public SQLQueryAdapter generate() {
                     errors.add("is in a primary key");
                     errors.add("is an identity column");
                     errors.add("is in index used as replica identity");
+                    // PG18 update: otherwise we need to encode contraint inheritance info in PostgreColumn
+                    errors.add("cannot drop inherited constraint");
                 }
                 break;
             case ALTER_COLUMN_SET_STATISTICS:
diff --git a/src/sqlancer/postgres/gen/PostgresCommon.java b/src/sqlancer/postgres/gen/PostgresCommon.java
@@ -48,6 +48,7 @@ public static List<String> getCommonTableErrors() {
 
         errors.add("is not commutative"); // exclude
         errors.add("operator requires run-time type coercion"); // exclude
+        errors.add("partitioned tables cannot be unlogged");
 
         return errors;
     }
@@ -59,6 +60,8 @@ public static void addCommonTableErrors(ExpectedErrors errors) {
     public static List<String> getCommonExpressionErrors() {
         ArrayList<String> errors = new ArrayList<>();
 
+        errors.add("for encoding \"SQL_ASCII\" does not exist");
+        errors.add("invalid byte sequence for encoding");
         errors.add("You might need to add explicit type casts");
         errors.add("invalid regular expression");
         errors.add("could not determine which collation to use");

Original file line number	Diff line number	Diff line change
`@@ -600,6 +600,7 @@ public String generateOptimizedQueryString(MaterializeSelect select, Materialize`
`600`	`600`	`}`
`601`	`601`	`select.setSelectType(SelectType.ALL);`
`602`	`602`	`}`
	`603`	`+ select.setWhereClause(whereCondition);`
`603`	`604`
`604`	`605`	`return select.asString();`
`605`	`606`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,6 +52,7 @@ public MaterializeTableGenerator(String tableName, MaterializeSchema newSchema,`
`52`	`52`	`errors.add("no collation was derived for partition key column");`
`53`	`53`	`errors.add("inherits from generated column but specifies identity");`
`54`	`54`	`errors.add("inherits from generated column but specifies default");`
	`55`	`+ errors.add("already exists");`
`55`	`56`	`MaterializeCommon.addCommonExpressionErrors(errors);`
`56`	`57`	`MaterializeCommon.addCommonTableErrors(errors);`
`57`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,7 @@ public static List<Pattern> getExpressionRegexErrors() {`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`errors.add(Pattern.compile("Unknown column '.*' in 'order clause'"));`
	`36`	`+ errors.add(Pattern.compile("Unknown column '.*' in 'EXISTS subquery'"));`
`36`	`37`
`37`	`38`	`return errors;`
`38`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,6 +38,7 @@ public MySQLPivotedQuerySynthesisOracle(MySQLGlobalState globalState) throws SQL`
`38`	`38`	`super(globalState);`
`39`	`39`	`MySQLErrors.addExpressionErrors(errors);`
`40`	`40`	`errors.add("in 'order clause'"); // e.g., Unknown column '2067708013' in 'order clause'`
	`41`	`+ errors.add("in 'EXISTS subquery'"); // e.g., Unknown column '2067708013' in 'EXISTS subquery' (MySQL 8.4+)`
`41`	`42`	`}`
`42`	`43`
`43`	`44`	`@Override`