This is an automated email from the ASF dual-hosted git repository.
JackieTien97 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/master by this push:
new 90e3d967f97 Fix stale query cleanup for abandoned queries and query
statements in executeBatch
90e3d967f97 is described below
commit 90e3d967f9799086df50fd33084452b9268f25c0
Author: Jackie Tien <[email protected]>
AuthorDate: Fri Nov 20 09:08:46 2026 +0800
Fix stale query cleanup for abandoned queries and query statements in
executeBatch
---
.../apache/iotdb/db/it/IoTDBExecuteBatchIT.java | 31 ++++
.../org/apache/iotdb/db/it/IoTDBShowQueriesIT.java | 57 +++++++
.../it/insertquery/IoTDBInsertQueryIT.java | 42 +++++
.../protocol/thrift/impl/ClientRPCServiceImpl.java | 35 +++-
.../iotdb/db/queryengine/plan/Coordinator.java | 10 +-
.../plan/execution/IQueryExecution.java | 2 +
.../queryengine/plan/execution/QueryExecution.java | 4 +-
.../plan/execution/config/ConfigExecution.java | 2 +-
.../queryengine/execution/ConfigExecutionTest.java | 24 +++
.../iotdb/db/queryengine/plan/CoordinatorTest.java | 184 ++++++++++++++++++++-
.../execution/QueryExecutionLifecycleTest.java | 23 +++
11 files changed, 403 insertions(+), 11 deletions(-)
diff --git
a/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBExecuteBatchIT.java
b/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBExecuteBatchIT.java
index 9ba4e4e7ce9..6f53ef1c0df 100644
---
a/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBExecuteBatchIT.java
+++
b/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBExecuteBatchIT.java
@@ -93,6 +93,37 @@ public class IoTDBExecuteBatchIT {
}
}
+ @Test
+ public void testJDBCExecuteBatchWithSelectInto() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ try {
+ statement.addBatch("insert into root.batch_into.src(timestamp,s1)
values(1,1.0)");
+ statement.addBatch("insert into root.batch_into.src(timestamp,s1)
values(2,2.0)");
+ statement.addBatch("select s1 into root.batch_into.dst(s1) from
root.batch_into.src");
+ statement.executeBatch();
+ statement.clearBatch();
+ // A batch has no result set to fetch, so the rows must be written
when it returns.
+ ResultSet resultSet = statement.executeQuery("select s1 from
root.batch_into.dst");
+ int count = 0;
+
+ long[] timestamps = {1, 2};
+ double[] values = {1.0, 2.0};
+
+ while (resultSet.next()) {
+ assertEquals(timestamps[count],
resultSet.getLong(ColumnHeaderConstant.TIME));
+ assertEquals(values[count],
resultSet.getDouble("root.batch_into.dst.s1"), 0.0);
+ count++;
+ }
+ assertEquals(timestamps.length, count);
+ } finally {
+ executeQuietly(statement, "DELETE DATABASE root.batch_into");
+ }
+ } catch (SQLException e) {
+ fail(e.getMessage());
+ }
+ }
+
@Test
public void testJDBCExecuteBatchForCreateMultiTimeSeriesPlan() {
try (Connection connection = EnvFactory.getEnv().getConnection();
diff --git
a/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBShowQueriesIT.java
b/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBShowQueriesIT.java
index 991cda2c750..67413545b3b 100644
---
a/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBShowQueriesIT.java
+++
b/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBShowQueriesIT.java
@@ -39,7 +39,12 @@ import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;
+import java.sql.Connection;
+import java.sql.Statement;
+import java.util.Collections;
+import java.util.HashSet;
import java.util.List;
+import java.util.Set;
import static
org.apache.iotdb.commons.schema.column.ColumnHeaderConstant.QUERY_ID;
import static
org.apache.iotdb.commons.schema.column.ColumnHeaderConstant.STATEMENT;
@@ -60,6 +65,8 @@ public class IoTDBShowQueriesIT {
private static final String KILL_USER = "show_queries_kill_user";
private static final String PASSWORD = "password123456";
private static final String PENDING_QUERY = "SELECT s1 FROM " + DEVICE;
+ private static final String SHOW_QUERIES = "SHOW QUERIES";
+ private static final String TEMPLATE = "show_queries_template";
// Leave one default 1,000-row TsBlock after the initial Session fetch.
private static final int STREAMING_QUERY_ROW_COUNT =
SessionConfig.DEFAULT_FETCH_SIZE + 1_000;
@@ -128,6 +135,35 @@ public class IoTDBShowQueriesIT {
}
}
+ @Test
+ public void queryInBatchReleaseTest() throws Exception {
+ try (ISession adminSession = EnvFactory.getEnv().getSessionConnection();
+ Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ Set<String> queryIdsBefore = getOtherQueryIds(adminSession);
+ statement.addBatch(PENDING_QUERY);
+ statement.executeBatch();
+ // A batch only returns the status of its statements, so nobody can
fetch or close the query.
+ assertNoQueryIsLeft(adminSession, queryIdsBefore);
+ }
+ }
+
+ @Test
+ public void schemaTemplateQueryReleaseTest() throws Exception {
+ try (ISession adminSession = EnvFactory.getEnv().getSessionConnection()) {
+ adminSession.executeNonQueryStatement("CREATE DEVICE TEMPLATE " +
TEMPLATE + " (s1 INT32)");
+ try {
+ Set<String> queryIdsBefore = getOtherQueryIds(adminSession);
+ // The measurements come back in the response, so nothing is left to
fetch or close.
+ Assert.assertEquals(
+ Collections.singletonList("s1"),
adminSession.showMeasurementsInTemplate(TEMPLATE));
+ assertNoQueryIsLeft(adminSession, queryIdsBefore);
+ } finally {
+ adminSession.executeNonQueryStatement("DROP DEVICE TEMPLATE " +
TEMPLATE);
+ }
+ }
+ }
+
private static boolean containsQuery(ISession session, String query) throws
Exception {
try (SessionDataSet dataSet = session.executeQueryStatement("SHOW
QUERIES")) {
SessionDataSet.DataIterator iterator = dataSet.iterator();
@@ -152,4 +188,25 @@ public class IoTDBShowQueriesIT {
Assert.fail("Query not found: " + query);
return null;
}
+
+ /** Ids of the registered queries, except the SHOW QUERIES statement that
lists them. */
+ private static Set<String> getOtherQueryIds(ISession session) throws
Exception {
+ Set<String> queryIds = new HashSet<>();
+ try (SessionDataSet dataSet = session.executeQueryStatement(SHOW_QUERIES))
{
+ SessionDataSet.DataIterator iterator = dataSet.iterator();
+ while (iterator.next()) {
+ if (!SHOW_QUERIES.equals(iterator.getString(STATEMENT))) {
+ queryIds.add(iterator.getString(QUERY_ID));
+ }
+ }
+ }
+ return queryIds;
+ }
+
+ private static void assertNoQueryIsLeft(ISession session, Set<String>
queryIdsBefore)
+ throws Exception {
+ Set<String> leftQueryIds = getOtherQueryIds(session);
+ leftQueryIds.removeAll(queryIdsBefore);
+ Assert.assertEquals(Collections.emptySet(), leftQueryIds);
+ }
}
diff --git
a/integration-test/src/test/java/org/apache/iotdb/relational/it/insertquery/IoTDBInsertQueryIT.java
b/integration-test/src/test/java/org/apache/iotdb/relational/it/insertquery/IoTDBInsertQueryIT.java
index 58b3f0774df..69fa8f483e6 100644
---
a/integration-test/src/test/java/org/apache/iotdb/relational/it/insertquery/IoTDBInsertQueryIT.java
+++
b/integration-test/src/test/java/org/apache/iotdb/relational/it/insertquery/IoTDBInsertQueryIT.java
@@ -167,6 +167,48 @@ public class IoTDBInsertQueryIT {
}
}
+ /** A batch has no result set to fetch, so the rows must be written when the
batch returns. */
+ @Test
+ public void testInsertQueryInBatch() throws SQLException {
+ try (Connection connection =
EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ List<String> expectedHeader = new ArrayList<>();
+ List<String> expectedRetArray = new ArrayList<>();
+
+ statement.execute("USE test");
+ ResultSet resultSet =
+ statement.executeQuery("select * from vehicle0 order by time,
deviceId, manufacturer");
+ buildExpectedResult(resultSet, expectedHeader, expectedRetArray);
+
+ statement.execute(String.format(createTableTemplate, 1));
+ String insertQuery = String.format(insertIntoQuery, 1);
+ statement.addBatch(insertQuery);
+ statement.executeBatch();
+ statement.clearBatch();
+
+ // 3 devices with 400 rows each, see prepareData
+ try (ResultSet countResult = statement.executeQuery("SELECT count(*)
FROM vehicle1")) {
+ Assert.assertTrue(countResult.next());
+ assertEquals(1200, countResult.getLong(1));
+ }
+ ResultSet r1 =
+ statement.executeQuery(
+ String.format("SELECT * FROM vehicle%d order by time, deviceId,
manufacturer", 1));
+ resultSetEqualTest(r1, expectedHeader, expectedRetArray);
+
+ // Nobody can fetch or close the statement of a batch, so it must not
stay registered.
+ try (ResultSet queries =
+ statement.executeQuery(
+ "SELECT statement FROM information_schema.queries WHERE
statement = '"
+ + insertQuery
+ + "'")) {
+ assertFalse(queries.next());
+ }
+
+ statement.execute(String.format(dropTableTemplate, 1));
+ }
+ }
+
/** Insert a table's own rows at shifted timestamps and verify that its row
count doubles. */
@Test
public void testInsertIntoSourceTable() throws SQLException {
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java
index e6eedc4b636..54b09bdf889 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java
@@ -588,6 +588,19 @@ public class ClientRPCServiceImpl implements
IClientRPCServiceWithHandler {
clientSession.removeQueryId(statementId, queryId);
}
+ /** Runs a query to its end and discards its result. */
+ private static void consumeResult(IQueryExecution queryExecution) throws
IoTDBException {
+ if (queryExecution == null) {
+ // only queries are registered, any other statement has already been
executed
+ return;
+ }
+ while (queryExecution.hasNextResult()) {
+ if (!queryExecution.getBatchResult().isPresent()) {
+ break;
+ }
+ }
+ }
+
/** Adapter that wraps TSExecuteStatementReq to implement
NativeStatementRequest. */
private static class TSExecuteStatementReqAdapter implements
NativeStatementRequest {
private final TSExecuteStatementReq req;
@@ -2190,8 +2203,9 @@ public class ClientRPCServiceImpl implements
IClientRPCServiceWithHandler {
long t2 = System.nanoTime();
String type = null;
OperationQuota quota = null;
+ Long queryId = null;
+ Throwable t = null;
try {
- long queryId;
ExecutionResult result;
if (clientSession.getSqlDialect() == SqlDialect.TREE) {
Statement s = StatementGenerator.createStatement(statement,
clientSession.getZoneId());
@@ -2314,9 +2328,15 @@ public class ClientRPCServiceImpl implements
IClientRPCServiceWithHandler {
if (result.status.getCode() !=
TSStatusCode.SUCCESS_STATUS.getStatusCode()
&& result.status.getCode() !=
TSStatusCode.REDIRECTION_RECOMMEND.getStatusCode()) {
isAllSuccessful = false;
+ } else if (queryId != null) {
+ // A batch returns no result set, so nobody fetches the result of
a statement that is a
+ // query. Without a consumer such a statement is not run to its
end, which matters for
+ // the ones that write, such as SELECT INTO.
+ consumeResult(COORDINATOR.getQueryExecution(queryId));
}
results.add(result.status);
} catch (Exception e) {
+ t = e;
LOGGER.warn(DataNodeMiscMessages.ERROR_EXECUTING_BATCH_STATEMENT, e);
TSStatus status =
onQueryException(
@@ -2324,6 +2344,10 @@ public class ClientRPCServiceImpl implements
IClientRPCServiceWithHandler {
isAllSuccessful = false;
results.add(status);
} finally {
+ if (queryId != null) {
+ // Nobody can fetch or close the query of this statement once the
batch has returned.
+ COORDINATOR.cleanupQueryExecution(queryId, req, t);
+ }
CommonUtils.addStatementExecutionLatency(
OperationType.EXECUTE_STATEMENT, type, System.nanoTime() - t2);
if (quota != null) {
@@ -3226,6 +3250,8 @@ public class ClientRPCServiceImpl implements
IClientRPCServiceWithHandler {
Statement statement, TSQueryTemplateReq req, TSQueryTemplateResp resp) {
long startTime = System.nanoTime();
OperationQuota quota = null;
+ Long queryId = null;
+ Throwable t = null;
try {
IClientSession clientSession =
SESSION_MANAGER.getCurrSessionAndUpdateIdleTime();
// permission check
@@ -3245,7 +3271,7 @@ public class ClientRPCServiceImpl implements
IClientRPCServiceWithHandler {
DataNodeThrottleQuotaManager.getInstance()
.checkQuota(SESSION_MANAGER.getCurrSession().getUsername(),
statement);
- long queryId = SESSION_MANAGER.requestQueryId();
+ queryId = SESSION_MANAGER.requestQueryId();
// create and cache dataset
ExecutionResult executionResult =
COORDINATOR.executeForTreeModel(
@@ -3292,10 +3318,15 @@ public class ClientRPCServiceImpl implements
IClientRPCServiceWithHandler {
return resp;
}
} catch (Exception e) {
+ t = e;
resp.setStatus(
onQueryException(e, "\"" + statement + "\". " +
OperationType.EXECUTE_STATEMENT));
return null;
} finally {
+ if (queryId != null) {
+ // The whole result is part of the response, so nobody can fetch or
close the query later.
+ COORDINATOR.cleanupQueryExecution(queryId, req, t);
+ }
CommonUtils.addStatementExecutionLatency(
OperationType.EXECUTE_STATEMENT,
statement.getType().name(),
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java
index 32ea59c26c2..0de29995226 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java
@@ -1024,14 +1024,18 @@ public class Coordinator {
* We need to reclaim resources from queries that have exceeded their
timeout by more than one
* minute. This indicates that the associated clients have failed to perform
proper resource
* cleanup.
+ *
+ * <p>Whether an RPC of the query is in progress does not matter here. The
timeout bounds the
+ * whole lifetime of a query, so a query without an RPC in progress has been
abandoned by its
+ * client, and an RPC that is still in progress this long after the timeout
is stuck, e.g. in a
+ * dispatch that never returns, and is only unblocked by stopping the query.
Sparing the queries
+ * with an RPC in progress would also keep forever every query whose caller
never reports the end
+ * of its RPC through {@link #recordExecutionTime}.
*/
public void cleanUpStaleQueries() {
long currentTime = System.currentTimeMillis();
queryExecutionMap.forEach(
(queryId, queryExecution) -> {
- if (queryExecution.isActive()) {
- return;
- }
long timeout = queryExecution.getTimeout();
long queryStartTime = queryExecution.getStartExecutionTime();
long executeTime = currentTime - queryStartTime;
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/IQueryExecution.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/IQueryExecution.java
index f4beb09917c..f79443a7827 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/IQueryExecution.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/IQueryExecution.java
@@ -82,6 +82,8 @@ public interface IQueryExecution {
* finishes. On the other hand, if there is no active RPC, it means that the
client has finished
* fetching results or has not started fetching results yet, and the
QueryExecution can be safely
* cleaned up.
+ *
+ * @return true if an RPC of this query is in progress, false otherwise
*/
boolean isActive();
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecution.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecution.java
index 5ab3b122e1c..422c99da247 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecution.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecution.java
@@ -595,7 +595,7 @@ public class QueryExecution implements IQueryExecution {
* ClientRPCServiceImpl is responsible for performing the cleanup.
*/
private synchronized void cleanUpCoordinatorContextMapIfNeeded(Throwable t) {
- if (isActive()) {
+ if (!isActive()) {
Coordinator.getInstance()
.cleanupQueryExecution(
context.getLocalQueryId(), (org.apache.thrift.TBase<?, ?>) null,
t);
@@ -611,7 +611,7 @@ public class QueryExecution implements IQueryExecution {
* cleaned up.
*/
public synchronized boolean isActive() {
- return startTimeOfCurrentRpc == -1;
+ return startTimeOfCurrentRpc != -1;
}
/**
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/ConfigExecution.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/ConfigExecution.java
index 148dab7de71..665213af7ce 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/ConfigExecution.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/ConfigExecution.java
@@ -346,7 +346,7 @@ public class ConfigExecution implements IQueryExecution {
@Override
public boolean isActive() {
- return startTimeOfCurrentRpc == -1;
+ return startTimeOfCurrentRpc != -1;
}
@Override
diff --git
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/ConfigExecutionTest.java
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/ConfigExecutionTest.java
index 3d11defae7b..74e49cf5e9a 100644
---
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/ConfigExecutionTest.java
+++
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/ConfigExecutionTest.java
@@ -48,6 +48,7 @@ import java.util.concurrent.ExecutorService;
import static com.google.common.util.concurrent.Futures.immediateFuture;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class ConfigExecutionTest {
@@ -184,6 +185,29 @@ public class ConfigExecutionTest {
}
}
+ @Test
+ public void isActiveTellsWhetherAnRpcOfTheQueryIsInProgress() {
+ ExecutorService executor = getExecutor();
+ try {
+ IConfigTask task =
+ (clientManager) -> immediateFuture(new
ConfigTaskResult(TSStatusCode.SUCCESS_STATUS));
+ ConfigExecution execution = new ConfigExecution(genMPPQueryContext(),
executor, task);
+ // the execution is created by the RPC that executes the statement
+ assertTrue(execution.isActive());
+ // that RPC returns, and the client has not asked for the result yet
+ execution.recordExecutionTime(1);
+ assertFalse(execution.isActive());
+ // an RPC that fetches the result arrives
+ execution.updateCurrentRpcStartTime(System.nanoTime());
+ assertTrue(execution.isActive());
+ // and returns as well
+ execution.recordExecutionTime(1);
+ assertFalse(execution.isActive());
+ } finally {
+ executor.shutdownNow();
+ }
+ }
+
private MPPQueryContext genMPPQueryContext() {
MPPQueryContext context = new MPPQueryContext(new QueryId("query1"));
context.setQueryType(QueryType.OTHER);
diff --git
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/CoordinatorTest.java
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/CoordinatorTest.java
index 361236936f7..303be7e747e 100644
---
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/CoordinatorTest.java
+++
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/CoordinatorTest.java
@@ -30,7 +30,10 @@ import
org.apache.iotdb.db.queryengine.plan.analyze.QueryType;
import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution;
import org.apache.iotdb.db.queryengine.plan.execution.QueryExecution;
import org.apache.iotdb.db.queryengine.plan.planner.IPlanner;
+import org.apache.iotdb.rpc.TSStatusCode;
+import org.apache.tsfile.read.common.block.TsBlock;
+import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
@@ -39,13 +42,17 @@ import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.time.ZoneId;
+import java.util.ArrayList;
+import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicLong;
import java.util.function.BiFunction;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
@@ -54,10 +61,18 @@ import static org.mockito.Mockito.when;
public class CoordinatorTest {
private static final long QUERY_ID = 10_000L;
+ // A query id is never reused, as a terminated query releases itself
asynchronously by its id
+ private static final AtomicLong NEXT_QUERY_ID = new AtomicLong(QUERY_ID + 1);
+
+ private static final long QUERY_TIMEOUT_IN_MS = 2_000L;
+ // Coordinator.cleanUpStaleQueries spares a query until it exceeds its
timeout by this long
+ private static final long STALE_QUERY_GRACE_PERIOD_IN_MS = 60_000L;
private static int previousDataNodeId;
private static ExecutorService stateMachineExecutor;
+ private final List<Long> executedQueryIds = new ArrayList<>();
+
@BeforeClass
public static void setUp() throws Exception {
// the coordinator builds its query id generator from the data node id of
this node
@@ -73,6 +88,12 @@ public class CoordinatorTest {
IoTDBDescriptor.getInstance().getConfig().setDataNodeId(previousDataNodeId);
}
+ @After
+ public void releaseExecutedQueries() {
+ // a query that had to be left alone is still registered
+ executedQueryIds.forEach(Coordinator.getInstance()::cleanupQueryExecution);
+ }
+
@Test
public void testRejectedReadOnlyInternalQueryClosesUDFQueryScope() throws
Exception {
// Only the analysis tells that an IoTDBLocal statement is not a query. By
then it may have
@@ -107,8 +128,165 @@ public class CoordinatorTest {
assertUDFQueryScopeClosed(createdExecution[0]);
}
+ @Test
+ public void testStaleQueryWithoutRpcInProgressIsCleanedUp() throws Throwable
{
+ QueryExecution execution = executeQuery(QUERY_TIMEOUT_IN_MS);
+ // the RPC that executed the statement returns, and the client never
fetches the result
+ finishRpc(execution);
+ setElapsedTime(execution, QUERY_TIMEOUT_IN_MS +
STALE_QUERY_GRACE_PERIOD_IN_MS + 1_000L);
+
+ Coordinator.getInstance().cleanUpStaleQueries();
+
+
assertNull(Coordinator.getInstance().getQueryExecution(queryIdOf(execution)));
+ assertEquals(TSStatusCode.QUERY_TIMEOUT.getStatusCode(),
statusCodeOf(execution));
+ assertUDFQueryScopeClosed(execution);
+ }
+
+ @Test
+ public void testStaleQueryWithRpcInProgressIsCleanedUp() throws Throwable {
+ // the RPC that executed the statement has not returned yet, or its caller
never reports that
+ // it returned
+ QueryExecution executing = executeQuery(QUERY_TIMEOUT_IN_MS);
+ // that RPC returned, and a later RPC is fetching the result
+ QueryExecution fetching = executeQuery(QUERY_TIMEOUT_IN_MS);
+ finishRpc(fetching);
+ fetching.updateCurrentRpcStartTime(System.nanoTime());
+ long elapsedTime = QUERY_TIMEOUT_IN_MS + STALE_QUERY_GRACE_PERIOD_IN_MS +
1_000L;
+ setElapsedTime(executing, elapsedTime);
+ setElapsedTime(fetching, elapsedTime);
+
+ Coordinator.getInstance().cleanUpStaleQueries();
+
+ // an RPC still in progress that long after the timeout is stuck, and
stopping the query is
+ // what unblocks it
+ for (QueryExecution execution : new QueryExecution[] {executing,
fetching}) {
+
assertNull(Coordinator.getInstance().getQueryExecution(queryIdOf(execution)));
+ assertEquals(TSStatusCode.QUERY_TIMEOUT.getStatusCode(),
statusCodeOf(execution));
+ assertUDFQueryScopeClosed(execution);
+ }
+ }
+
+ @Test
+ public void testQueryWithRpcInProgressWithinGracePeriodIsLeftAlone() throws
Throwable {
+ QueryExecution execution = executeQuery(QUERY_TIMEOUT_IN_MS);
+ // timed out, but not yet by more than the grace period
+ setElapsedTime(execution, QUERY_TIMEOUT_IN_MS +
STALE_QUERY_GRACE_PERIOD_IN_MS / 2);
+
+ Coordinator.getInstance().cleanUpStaleQueries();
+
+ assertLeftAlone(execution);
+ }
+
+ @Test
+ public void testIdleQueryWithinGracePeriodIsLeftAlone() throws Throwable {
+ QueryExecution execution = executeQuery(QUERY_TIMEOUT_IN_MS);
+ finishRpc(execution);
+ // timed out, but not yet by more than the grace period
+ setElapsedTime(execution, QUERY_TIMEOUT_IN_MS +
STALE_QUERY_GRACE_PERIOD_IN_MS / 2);
+
+ Coordinator.getInstance().cleanUpStaleQueries();
+
+ assertLeftAlone(execution);
+ }
+
+ @Test
+ public void testIdleQueryWithoutPositiveTimeoutIsLeftAlone() throws
Throwable {
+ QueryExecution zeroTimeout = executeQuery(0L);
+ QueryExecution negativeTimeout = executeQuery(-1L);
+ finishRpc(zeroTimeout);
+ finishRpc(negativeTimeout);
+ setElapsedTime(zeroTimeout, 10 * STALE_QUERY_GRACE_PERIOD_IN_MS);
+ setElapsedTime(negativeTimeout, 10 * STALE_QUERY_GRACE_PERIOD_IN_MS);
+
+ Coordinator.getInstance().cleanUpStaleQueries();
+
+ assertLeftAlone(zeroTimeout);
+ assertLeftAlone(negativeTimeout);
+ }
+
+ @Test
+ public void testKilledQueryIsReleasedUnlessAnRpcIsInProgress() throws
Throwable {
+ // the RPC that executed the statement has not returned yet
+ QueryExecution executing = executeQuery(QUERY_TIMEOUT_IN_MS);
+ // that RPC returned, and the client has not fetched the result yet
+ QueryExecution idle = executeQuery(QUERY_TIMEOUT_IN_MS);
+ finishRpc(idle);
+
+ executing.cancel();
+ idle.cancel();
+
+ // the state machine thread answers getStatus after it has run the cleanup
of the killed query
+ assertEquals(TSStatusCode.QUERY_WAS_KILLED.getStatusCode(),
statusCodeOf(executing));
+ assertEquals(TSStatusCode.QUERY_WAS_KILLED.getStatusCode(),
statusCodeOf(idle));
+ // the RPC in progress releases its query when it returns, nothing would
release the idle one
+ assertSame(executing,
Coordinator.getInstance().getQueryExecution(queryIdOf(executing)));
+ assertNull(Coordinator.getInstance().getQueryExecution(queryIdOf(idle)));
+ }
+
+ /**
+ * Executes a query the way a client RPC does. When this method returns the
query is RUNNING and
+ * registered in the coordinator, and the RPC that created it is still in
progress. The result of
+ * the query is already in memory, so no fragment instance is dispatched.
+ */
+ private QueryExecution executeQuery(long timeout) throws Throwable {
+ long queryId = NEXT_QUERY_ID.getAndIncrement();
+ executedQueryIds.add(queryId);
+ IAnalysis analysis = mock(IAnalysis.class);
+ when(analysis.canSkipExecute(any(MPPQueryContext.class))).thenReturn(true);
+ when(analysis.constructResultForMemorySource(any(MPPQueryContext.class)))
+ .thenReturn(new TsBlock(0));
+ IPlanner planner = mock(IPlanner.class);
+ when(planner.analyze(any(MPPQueryContext.class))).thenReturn(analysis);
+ QueryExecution[] createdExecution = new QueryExecution[1];
+ execute(
+ queryId,
+ "SELECT s FROM t1",
+ false,
+ (queryContext, startTime) -> {
+ queryContext.setTimeOut(timeout);
+ queryContext.setStartTime(startTime);
+ createdExecution[0] = new QueryExecution(planner, queryContext,
stateMachineExecutor);
+ return createdExecution[0];
+ });
+ return createdExecution[0];
+ }
+
+ /** What the RPC in progress does when it returns to the client. */
+ private static void finishRpc(QueryExecution execution) {
+ Coordinator.getInstance().recordExecutionTime(queryIdOf(execution), 1L);
+ }
+
+ /** Makes the query look as if it had been started {@code elapsedTimeInMs}
ago. */
+ private static void setElapsedTime(QueryExecution execution, long
elapsedTimeInMs) {
+ execution.getContext().setStartTime(System.currentTimeMillis() -
elapsedTimeInMs);
+ }
+
+ private static long queryIdOf(QueryExecution execution) {
+ return execution.getContext().getLocalQueryId();
+ }
+
+ private static int statusCodeOf(QueryExecution execution) {
+ return execution.getStatus().status.getCode();
+ }
+
+ private static void assertLeftAlone(QueryExecution execution) {
+ assertSame(execution,
Coordinator.getInstance().getQueryExecution(queryIdOf(execution)));
+ // still running, so its result can still be fetched
+ assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(),
statusCodeOf(execution));
+ }
+
private static void executeReadOnlyInternalQuery(
BiFunction<MPPQueryContext, Long, IQueryExecution>
queryExecutionFactory) throws Throwable {
+ execute(
+ QUERY_ID, "INSERT INTO t2(time, s) SELECT time, f(s) FROM t1", true,
queryExecutionFactory);
+ }
+
+ private static void execute(
+ long queryId,
+ String sql,
+ boolean readOnlyInternalQuery,
+ BiFunction<MPPQueryContext, Long, IQueryExecution> queryExecutionFactory)
+ throws Throwable {
Method execution =
Coordinator.class.getDeclaredMethod(
"execution",
@@ -123,12 +301,12 @@ public class CoordinatorTest {
try {
execution.invoke(
Coordinator.getInstance(),
- QUERY_ID,
+ queryId,
new SessionInfo(0, "test", ZoneId.systemDefault()),
- "INSERT INTO t2(time, s) SELECT time, f(s) FROM t1",
+ sql,
false,
false,
- true,
+ readOnlyInternalQuery,
queryExecutionFactory);
} catch (InvocationTargetException e) {
throw e.getCause();
diff --git
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecutionLifecycleTest.java
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecutionLifecycleTest.java
index 3dfbb376951..a4729bd4e57 100644
---
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecutionLifecycleTest.java
+++
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecutionLifecycleTest.java
@@ -38,6 +38,7 @@ import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
@@ -153,6 +154,28 @@ public class QueryExecutionLifecycleTest {
}
}
+ @Test
+ public void isActiveTellsWhetherAnRpcOfTheQueryIsInProgress() throws
Exception {
+ ExecutorService notifications = Executors.newSingleThreadExecutor();
+ try {
+ QueryExecution execution = new QueryExecution(planner(), context(),
notifications);
+ // the execution is created by the RPC that executes the statement
+ assertTrue(execution.isActive());
+ // that RPC returns, and the client has not asked for the result yet
+ execution.recordExecutionTime(1);
+ assertFalse(execution.isActive());
+ // an RPC that fetches the result arrives
+ execution.updateCurrentRpcStartTime(System.nanoTime());
+ assertTrue(execution.isActive());
+ // and returns as well
+ execution.recordExecutionTime(1);
+ assertFalse(execution.isActive());
+ } finally {
+ notifications.shutdownNow();
+ assertTrue(notifications.awaitTermination(10, TimeUnit.SECONDS));
+ }
+ }
+
private static IPlanner planner() {
IPlanner planner = mock(IPlanner.class);
when(planner.analyze(any())).thenReturn(mock(IAnalysis.class));