Move the fix to the correct function

Author: agusaldasoro

core/src/main/kotlin/org/evomaster/core/problem/api/service/ApiWsStructureMutator.kt

@@ -277,7 +277,6 @@ abstract class ApiWsStructureMutator : StructureMutator() {
         val oldSqlActions = mutableListOf<EnvironmentAction>().plus(ind.seeInitializingActions())
 
         val failedWhereQueries = evaluatedIndividual.fitness.getViewOfAggregatedFailedWhereQueries()
-            .filter { it.isNotBlank() }
         val addedSqlInsertions = handleFailedWhereSQL(ind, fw, failedWhereQueries, mutatedGenes, sampler)
 
         ind.repairInitializationActions(randomness)

core/src/main/kotlin/org/evomaster/core/search/FitnessValue.kt

@@ -152,7 +152,15 @@ class FitnessValue(
 
         aggregatedFailedWhereQueries.clear()
         aggregatedFailedWhereQueries.addAll(
-            databaseExecutions.values.flatMap { a -> a.executionInfo }.map{ b -> b.sqlCommand }
+            databaseExecutions.values
+                // Only executions that actually had failing WHERE clauses are relevant;
+                // collecting from all executions would include unrelated INSERT/UPDATE/DELETE/etc.
+                .filter { it.failedWhere.isNotEmpty() }
+                .flatMap { it.executionInfo }
+                .map { it.sqlCommand }
+                // JSQLParser >= 4.9 may produce empty-string SQL commands (it used to throw, now
+                // parses "" to null). Guard here at the source rather than at every call site.
+                .filter { it.isNotBlank() }
         )
     }
     fun aggregateMongoDatabaseData(){

core/src/test/kotlin/org/evomaster/core/search/FitnessValueTest.kt

@@ -7,6 +7,7 @@ import org.evomaster.client.java.instrumentation.shared.ObjectiveNaming
 import org.evomaster.core.search.service.IdMapper
 import org.evomaster.core.sql.DatabaseExecution
 import org.evomaster.core.sql.SqlExecutionInfo
+import org.evomaster.core.sql.schema.TableId
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
@@ -126,36 +127,77 @@ class FitnessValueTest {
     }
 
     @Test
-    fun testAggregatedFailedWhereQueriesExcludesBlankEntries() {
+    fun testAggregatedFailedWhereQueriesOnlyFromExecutionsWithFailedWhere() {
         val fv = FitnessValue(1.0)
 
-        val execution = DatabaseExecution(
+        val tableId = TableId("foo")
+
+        // Execution that has a failing WHERE clause — its queries should be collected
+        val executionWithFailedWhere = DatabaseExecution(
+            queriedData = emptyMap(),
+            updatedData = emptyMap(),
+            insertedData = emptyMap(),
+            failedWhere = mapOf(tableId to setOf("id")),
+            deletedData = emptyList(),
+            numberOfSqlCommands = 1,
+            sqlParseFailureCount = 0,
+            executionInfo = listOf(
+                SqlExecutionInfo("SELECT * FROM foo WHERE id = 1", false, 10L)
+            )
+        )
+
+        // Execution with no failing WHERE clause — its queries must NOT be collected,
+        // even though it has executionInfo entries
+        val executionWithoutFailedWhere = DatabaseExecution(
             queriedData = emptyMap(),
             updatedData = emptyMap(),
             insertedData = emptyMap(),
             failedWhere = emptyMap(),
             deletedData = emptyList(),
+            numberOfSqlCommands = 1,
+            sqlParseFailureCount = 0,
+            executionInfo = listOf(
+                SqlExecutionInfo("INSERT INTO bar VALUES (1)", false, 5L)
+            )
+        )
+
+        fv.setDatabaseExecution(0, executionWithFailedWhere)
+        fv.setDatabaseExecution(1, executionWithoutFailedWhere)
+        fv.aggregateDatabaseData()
+
+        val queries = fv.getViewOfAggregatedFailedWhereQueries()
+        assertEquals(1, queries.size)
+        assertTrue(queries.contains("SELECT * FROM foo WHERE id = 1"))
+    }
+
+    @Test
+    fun testAggregatedFailedWhereQueriesExcludesBlankSqlCommands() {
+        val fv = FitnessValue(1.0)
+
+        val tableId = TableId("foo")
+
+        // JSQLParser >= 4.9 can produce empty-string SQL commands; they must be filtered out
+        // at the source in aggregateDatabaseData() rather than at every call site
+        val execution = DatabaseExecution(
+            queriedData = emptyMap(),
+            updatedData = emptyMap(),
+            insertedData = emptyMap(),
+            failedWhere = mapOf(tableId to setOf("id")),
+            deletedData = emptyList(),
             numberOfSqlCommands = 3,
             sqlParseFailureCount = 0,
             executionInfo = listOf(
                 SqlExecutionInfo("SELECT * FROM foo WHERE id = 1", false, 10L),
                 SqlExecutionInfo("", false, 5L),
-                SqlExecutionInfo("   ", false, 5L),
-                SqlExecutionInfo("SELECT * FROM bar WHERE name = 'x'", false, 8L)
+                SqlExecutionInfo("   ", false, 5L)
             )
         )
         fv.setDatabaseExecution(0, execution)
         fv.aggregateDatabaseData()
 
-        val allQueries = fv.getViewOfAggregatedFailedWhereQueries()
-        assertEquals(4, allQueries.size)
-
-        // Simulate the filter applied in ApiWsStructureMutator before sending queries to the solver
-        val nonBlankQueries = allQueries.filter { it.isNotBlank() }
-        assertEquals(2, nonBlankQueries.size)
-        assertTrue(nonBlankQueries.none { it.isBlank() })
-        assertTrue(nonBlankQueries.contains("SELECT * FROM foo WHERE id = 1"))
-        assertTrue(nonBlankQueries.contains("SELECT * FROM bar WHERE name = 'x'"))
+        val queries = fv.getViewOfAggregatedFailedWhereQueries()
+        assertEquals(1, queries.size)
+        assertTrue(queries.contains("SELECT * FROM foo WHERE id = 1"))
     }
 
 }