From 564caed8603f4086151ab41172544ee0f93944ac Mon Sep 17 00:00:00 2001 From: Caideyipi <87789683+Caideyipi@users.noreply.github.com> Date: Fri, 20 Nov 2026 15:49:44 +0800 Subject: [PATCH 1/2] Track and clean schema deletion mod-file progress --- .../db/it/schema/IoTDBDeleteTimeSeriesIT.java | 37 +- .../confignode/manager/ProcedureManager.java | 23 +- .../procedure/CompletedProcedureRecycler.java | 9 + .../ProcedureWithPendingCleanup.java | 25 ++ .../schema/DeleteTimeSeriesProcedure.java | 72 +++- .../impl/schema/ModFileDeletionProgress.java | 399 ++++++++++++++++++ .../table/DropTableColumnProcedure.java | 23 +- .../impl/schema/table/DropTableProcedure.java | 23 +- .../table/TableDeletionModProgress.java | 222 ---------- .../manager/AsyncTimeSeriesDeletionTest.java | 55 +++ .../CompletedProcedureRecyclerTest.java | 33 ++ .../schema/DeleteTimeSeriesProcedureTest.java | 19 +- .../schema/ModFileDeletionProgressTest.java | 324 ++++++++++++++ .../table/DropTableColumnProcedureTest.java | 3 +- .../schema/table/DropTableProcedureTest.java | 19 +- .../dataregion/DataExecutionVisitor.java | 14 +- .../impl/DataNodeInternalRPCServiceImpl.java | 108 ++--- .../impl/InternalSchemaTaskExecutor.java | 108 +++++ .../sys/ShowDeleteTimeSeriesProgressTask.java | 14 +- .../node/pipe/PipeEnrichedDeleteDataNode.java | 10 + .../node/write/AbstractDeleteDataNode.java | 10 + .../storageengine/dataregion/DataRegion.java | 81 +++- ...ss.java => SchemaDeletionModProgress.java} | 50 ++- .../dataregion/DataExecutionVisitorTest.java | 11 +- .../impl/DataNodeInternalSchemaTaskTest.java | 128 ++++++ .../write/RelationalDeleteDataNodeTest.java | 10 +- .../dataregion/DataRegionTest.java | 150 ++++++- .../schema/column/ColumnHeaderConstant.java | 4 +- .../src/main/thrift/confignode.thrift | 2 + .../src/main/thrift/datanode.thrift | 5 + 30 files changed, 1582 insertions(+), 409 deletions(-) create mode 100644 iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/ProcedureWithPendingCleanup.java create mode 100644 iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/ModFileDeletionProgress.java delete mode 100644 iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/TableDeletionModProgress.java create mode 100644 iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/ModFileDeletionProgressTest.java create mode 100644 iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/InternalSchemaTaskExecutor.java rename iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/modification/{DropTableModProgress.java => SchemaDeletionModProgress.java} (53%) create mode 100644 iotdb-core/datanode/src/test/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalSchemaTaskTest.java diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/schema/IoTDBDeleteTimeSeriesIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/schema/IoTDBDeleteTimeSeriesIT.java index 50212cd6b54e1..200d16cb6967d 100644 --- a/integration-test/src/test/java/org/apache/iotdb/db/it/schema/IoTDBDeleteTimeSeriesIT.java +++ b/integration-test/src/test/java/org/apache/iotdb/db/it/schema/IoTDBDeleteTimeSeriesIT.java @@ -67,19 +67,22 @@ public void tearDown() throws Exception { @Test public void testAsynchronousDeletionProgress() throws Exception { - final String path = "root.async_progress.d.s"; - final String sql = "DELETE TIMESERIES " + path; + final String device = "root.async_progress.d"; + final String firstPath = device + ".s1"; + final String secondPath = device + ".s2"; + final String sql = "DELETE TIMESERIES " + firstPath + ", " + secondPath; try (Connection connection = EnvFactory.getEnv().getConnection(); Statement statement = TestUtils.createSingleNodeStatement(connection)) { - statement.execute("INSERT INTO root.async_progress.d(time,s) VALUES(1,1)"); + statement.execute("INSERT INTO " + device + "(time,s1,s2) VALUES(1,1,2)"); + statement.execute("FLUSH"); statement.execute(sql); - boolean found = false; + long procedureId = -1; try (ResultSet result = statement.executeQuery("SHOW DELETE TIMESERIES PROGRESS")) { - Assert.assertEquals(6, result.getMetaData().getColumnCount()); + Assert.assertEquals(8, result.getMetaData().getColumnCount()); while (result.next()) { - if (("[" + path + "]").equals(result.getString("Paths"))) { - found = true; - Assert.assertTrue(result.getLong("ProcedureId") >= 0); + final String paths = result.getString("Paths"); + if (paths.contains(firstPath) && paths.contains(secondPath)) { + procedureId = result.getLong("ProcedureId"); Assert.assertNotNull(result.getString("QueryId")); Assert.assertNotNull(result.getString("Progress")); Assert.assertTrue( @@ -89,9 +92,23 @@ public void testAsynchronousDeletionProgress() throws Exception { } } } - Assert.assertTrue("Accepted deletion must be visible immediately", found); + Assert.assertTrue("Accepted deletion must be visible immediately", procedureId >= 0); TestUtils.waitForTimeSeriesDeletion(statement, sql); - try (ResultSet result = statement.executeQuery("SHOW TIMESERIES " + path)) { + boolean foundCompleted = false; + try (ResultSet result = statement.executeQuery("SHOW DELETE TIMESERIES PROGRESS")) { + while (result.next()) { + if (result.getLong("ProcedureId") == procedureId) { + foundCompleted = true; + Assert.assertEquals("SUCCESS", result.getString("State")); + Assert.assertEquals(1, result.getLong("WrittenModFileCount")); + Assert.assertEquals(0, result.getLong("RemainingModFileCount")); + Assert.assertFalse(result.wasNull()); + break; + } + } + } + Assert.assertTrue("Completed deletion must retain its mod file counts", foundCompleted); + try (ResultSet result = statement.executeQuery("SHOW TIMESERIES " + device + ".*")) { Assert.assertFalse(result.next()); } // A nonexistent path is accepted too; the error belongs to the asynchronous task. diff --git a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/ProcedureManager.java b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/ProcedureManager.java index ca6350176d51c..d068cd0ed7952 100644 --- a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/ProcedureManager.java +++ b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/ProcedureManager.java @@ -512,6 +512,9 @@ public List getDeleteTimeSeriesProcedures() { .filter(p -> p instanceof DeleteTimeSeriesProcedure) .map(p -> (DeleteTimeSeriesProcedure) p) .forEach(p -> procedures.put(p.getProcId(), p)); + procedures.values().stream() + .filter(procedure -> !procedure.isFinished() || procedure.hasPendingCleanup()) + .forEach(DeleteTimeSeriesProcedure::updateModFileProgress); return procedures.values().stream() .sorted(Comparator.comparingLong(Procedure::getProcId)) .map( @@ -540,6 +543,16 @@ public List getDeleteTimeSeriesProcedures() { + p.getException().getMessage()); } } + final TDropTableModProgress modProgress = p.getModFileProgress(); + if (modProgress != null) { + info.setWrittenModFileCount(modProgress.getWrittenModFileCount()); + if (modProgress.isSetRemainingModFileCount()) { + info.setRemainingModFileCount(modProgress.getRemainingModFileCount()); + } + } + if (p.isSuccess()) { + info.setRemainingModFileCount(0); + } return info; }) .collect(Collectors.toList()); @@ -2996,7 +3009,7 @@ public List getDropTableProcedures() { .map(procedure -> (DropTableProcedure) procedure) .forEach(procedure -> dropProcedures.put(procedure.getProcId(), procedure)); dropProcedures.values().stream() - .filter(procedure -> !procedure.isFinished()) + .filter(procedure -> !procedure.isFinished() || procedure.hasPendingCleanup()) .forEach(DropTableProcedure::updateModFileProgress); return dropProcedures.values().stream() .map( @@ -3015,6 +3028,9 @@ public List getDropTableProcedures() { info.setRemainingModFileCount(modProgress.getRemainingModFileCount()); } } + if (procedure.isSuccess()) { + info.setRemainingModFileCount(0); + } if (procedure.hasException()) { info.setErrorMessage(procedure.getException().getMessage()); } @@ -3034,7 +3050,7 @@ public List getDropTableColumnProcedures() { .map(procedure -> (DropTableColumnProcedure) procedure) .forEach(procedure -> dropProcedures.put(procedure.getProcId(), procedure)); dropProcedures.values().stream() - .filter(procedure -> !procedure.isFinished()) + .filter(procedure -> !procedure.isFinished() || procedure.hasPendingCleanup()) .forEach(DropTableColumnProcedure::updateModFileProgress); return dropProcedures.values().stream() .map( @@ -3060,6 +3076,9 @@ public List getDropTableColumnProcedures() { info.setRemainingModFileCount(modProgress.getRemainingModFileCount()); } } + if (procedure.isSuccess()) { + info.setRemainingModFileCount(0); + } if (procedure.hasException()) { info.setErrorMessage(procedure.getException().getMessage()); } diff --git a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/CompletedProcedureRecycler.java b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/CompletedProcedureRecycler.java index 633d315487a42..ef5d7e4314d5f 100644 --- a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/CompletedProcedureRecycler.java +++ b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/CompletedProcedureRecycler.java @@ -76,6 +76,15 @@ protected void periodicExecute(final Env env) { final CompletedProcedureContainer retainer = entry.getValue(); final Procedure proc = retainer.getProcedure(); if (retainer.isExpired(now, evictTTLInMs)) { + if (proc instanceof ProcedureWithPendingCleanup) { + final ProcedureWithPendingCleanup cleanup = (ProcedureWithPendingCleanup) proc; + if (cleanup.hasPendingCleanup()) { + cleanup.retryPendingCleanup(); + if (cleanup.hasPendingCleanup()) { + continue; + } + } + } // Failed procedures aren't persisted in WAL. batchIds[batchCount++] = entry.getKey(); if (batchCount == batchIds.length) { diff --git a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/ProcedureWithPendingCleanup.java b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/ProcedureWithPendingCleanup.java new file mode 100644 index 0000000000000..f5fdb9be02c7e --- /dev/null +++ b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/ProcedureWithPendingCleanup.java @@ -0,0 +1,25 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.iotdb.confignode.procedure; + +public interface ProcedureWithPendingCleanup { + boolean hasPendingCleanup(); + + void retryPendingCleanup(); +} diff --git a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/DeleteTimeSeriesProcedure.java b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/DeleteTimeSeriesProcedure.java index 018b2e07730da..7df0cf22d47e5 100644 --- a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/DeleteTimeSeriesProcedure.java +++ b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/DeleteTimeSeriesProcedure.java @@ -39,6 +39,7 @@ import org.apache.iotdb.confignode.exception.DatabaseNotExistsException; import org.apache.iotdb.confignode.i18n.ProcedureMessages; import org.apache.iotdb.confignode.manager.ConfigManager; +import org.apache.iotdb.confignode.procedure.ProcedureWithPendingCleanup; import org.apache.iotdb.confignode.procedure.env.ConfigNodeProcedureEnv; import org.apache.iotdb.confignode.procedure.exception.ProcedureException; import org.apache.iotdb.confignode.procedure.impl.StateMachineProcedure; @@ -50,6 +51,7 @@ import org.apache.iotdb.mpp.rpc.thrift.TConstructSchemaBlackListReq; import org.apache.iotdb.mpp.rpc.thrift.TDeleteDataForDeleteSchemaReq; import org.apache.iotdb.mpp.rpc.thrift.TDeleteTimeSeriesReq; +import org.apache.iotdb.mpp.rpc.thrift.TDropTableModProgress; import org.apache.iotdb.mpp.rpc.thrift.TRollbackSchemaBlackListReq; import org.apache.iotdb.pipe.api.exception.PipeException; import org.apache.iotdb.rpc.RpcUtils; @@ -78,12 +80,18 @@ import static org.apache.iotdb.commons.schema.table.Audit.TREE_MODEL_AUDIT_DATABASE; public class DeleteTimeSeriesProcedure - extends StateMachineProcedure { + extends StateMachineProcedure + implements ProcedureWithPendingCleanup { private static final Logger LOGGER = LoggerFactory.getLogger(DeleteTimeSeriesProcedure.class); private String queryId; + private final ModFileDeletionProgress modProgress = + new ModFileDeletionProgress( + this::getProcId, + () -> !isFinished() && getCurrentState() == DeleteTimeSeriesState.DELETE_DATA); + private PathPatternTree patternTree; private PathPatternTree originalPatternTree; private final List deleteDatabaseSchemas = new ArrayList<>(); @@ -160,6 +168,9 @@ protected Flow executeFromState( } return Flow.NO_MORE_STATE; case DELETE_DATABASES: + if (patternTree.isEmpty()) { + modProgress.finishWithoutModFiles(); + } // This is a background task: an RPC wait timeout must not allow recreation while a // database-deletion procedure is still running. final TSStatus deleteStatus = @@ -333,20 +344,9 @@ public static void invalidateCache( } private void deleteData(final ConfigNodeProcedureEnv env) { - deleteDataWithRawPathPattern(env); - } - - private void deleteDataWithRawPathPattern(final ConfigNodeProcedureEnv env) { - executeDeleteData(env, patternTree); - if (isFailed()) { - return; - } - setNextState(DeleteTimeSeriesState.DELETE_TIMESERIES_SCHEMA); - } - - private void executeDeleteData( - final ConfigNodeProcedureEnv env, final PathPatternTree patternTree) { if (isAllLogicalView) { + modProgress.finishWithoutModFiles(); + setNextState(DeleteTimeSeriesState.DELETE_TIMESERIES_SCHEMA); return; } @@ -355,9 +355,13 @@ private void executeDeleteData( // Target timeSeries has no data if (relatedDataRegionGroup.isEmpty()) { + modProgress.finishWithoutModFiles(); + setNextState(DeleteTimeSeriesState.DELETE_TIMESERIES_SCHEMA); return; } + modProgress.setRegionCount(relatedDataRegionGroup.size()); + modProgress.trackRegionReplicas(relatedDataRegionGroup); final DeleteTimeSeriesRegionTaskExecutor deleteDataTask = new DeleteTimeSeriesRegionTaskExecutor<>( ProcedureMessages.MESSAGE_DELETE_DATA_1896591B, @@ -365,12 +369,40 @@ private void executeDeleteData( relatedDataRegionGroup, false, CnToDnAsyncRequestType.DELETE_DATA_FOR_DELETE_SCHEMA, - ((dataNodeLocation, consensusGroupIdList) -> - new TDeleteDataForDeleteSchemaReq( - new ArrayList<>(consensusGroupIdList), - preparePatternTreeBytesData(patternTree)) - .setIsGeneratedByPipe(isGeneratedByPipe))); + (dataNodeLocation, consensusGroupIdList) -> { + modProgress.trackRegions(dataNodeLocation, consensusGroupIdList); + return new TDeleteDataForDeleteSchemaReq( + new ArrayList<>(consensusGroupIdList), + preparePatternTreeBytesData(patternTree)) + .setIsGeneratedByPipe(isGeneratedByPipe) + .setProcedureId(getProcId()) + .setTrackModFileProgress(true); + }); deleteDataTask.execute(); + modProgress.finish( + () -> { + if (!isFailed()) { + setNextState(DeleteTimeSeriesState.DELETE_TIMESERIES_SCHEMA); + } + }); + } + + public TDropTableModProgress getModFileProgress() { + return modProgress.snapshot(); + } + + public void updateModFileProgress() { + modProgress.update(); + } + + @Override + public boolean hasPendingCleanup() { + return modProgress.hasPendingCleanup(); + } + + @Override + public void retryPendingCleanup() { + updateModFileProgress(); } private void deleteTimeSeriesSchema(final ConfigNodeProcedureEnv env) { @@ -524,6 +556,7 @@ public void serialize(final DataOutputStream stream) throws IOException { ThriftConfigNodeSerDeUtils.serializeTDatabaseSchema(database, stream); } ReadWriteIOUtils.write(databaseDeletionFailure, stream); + modProgress.serialize(stream); } @Override @@ -555,6 +588,7 @@ public void deserialize(final ByteBuffer byteBuffer) { databaseDeletionFailure = ReadWriteIOUtils.readString(byteBuffer); } } + modProgress.deserialize(byteBuffer); } @Override diff --git a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/ModFileDeletionProgress.java b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/ModFileDeletionProgress.java new file mode 100644 index 0000000000000..d3c7e59c6fa72 --- /dev/null +++ b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/ModFileDeletionProgress.java @@ -0,0 +1,399 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.iotdb.confignode.procedure.impl.schema; + +import org.apache.iotdb.common.rpc.thrift.TConsensusGroupId; +import org.apache.iotdb.common.rpc.thrift.TDataNodeLocation; +import org.apache.iotdb.common.rpc.thrift.TRegionReplicaSet; +import org.apache.iotdb.commons.utils.ThriftCommonsSerDeUtils; +import org.apache.iotdb.confignode.client.async.CnToDnAsyncRequestType; +import org.apache.iotdb.confignode.client.async.CnToDnInternalServiceAsyncRequestManager; +import org.apache.iotdb.confignode.client.async.handlers.DataNodeAsyncRequestContext; +import org.apache.iotdb.mpp.rpc.thrift.TDropTableModProgress; +import org.apache.iotdb.mpp.rpc.thrift.TGetDropTableModProgressReq; +import org.apache.iotdb.mpp.rpc.thrift.TGetDropTableModProgressResp; +import org.apache.iotdb.rpc.TSStatusCode; + +import java.io.DataOutputStream; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.BooleanSupplier; +import java.util.function.Consumer; +import java.util.function.LongSupplier; + +/** Tracks mod-file writes for a schema deletion using one replica per region. */ +public class ModFileDeletionProgress { + private final LongSupplier procedureId; + private final BooleanSupplier deletionRunning; + private final Consumer< + DataNodeAsyncRequestContext> + progressRequestSender; + // Track the replica actually executing each region, including changes caused by retries. + // Count each region once; followers may have different local TsFiles and apply asynchronously. + private final Map modProgressTargets = + new ConcurrentHashMap<>(); + private final Map> modProgressReplicaTargets = + new ConcurrentHashMap<>(); + private final Object modProgressRefreshMonitor = new Object(); + private CompletableFuture modProgressRefreshFuture; + private volatile int modProgressRegionCount; + private volatile TDropTableModProgress modFileProgress; + private volatile boolean modProgressFinished; + private volatile boolean modProgressCleanupPending; + + public ModFileDeletionProgress( + final LongSupplier procedureId, final BooleanSupplier deletionRunning) { + this( + procedureId, + deletionRunning, + requestContext -> + CnToDnInternalServiceAsyncRequestManager.getInstance() + .sendAsyncRequest(requestContext, 1, 2_000L, true)); + } + + ModFileDeletionProgress( + final LongSupplier procedureId, + final BooleanSupplier deletionRunning, + final Consumer< + DataNodeAsyncRequestContext< + TGetDropTableModProgressReq, TGetDropTableModProgressResp>> + progressRequestSender) { + this.procedureId = procedureId; + this.deletionRunning = deletionRunning; + this.progressRequestSender = progressRequestSender; + } + + public void setRegionCount(final int regionCount) { + modProgressRegionCount = regionCount; + } + + public void trackRegions( + final TDataNodeLocation location, final List regions) { + regions.forEach(region -> modProgressTargets.put(region, location)); + } + + public void trackRegionReplicas( + final Map regionReplicaSets) { + synchronized (modProgressRefreshMonitor) { + regionReplicaSets.forEach( + (region, replicaSet) -> + modProgressReplicaTargets.put( + region, new ArrayList<>(replicaSet.getDataNodeLocations()))); + } + } + + public void finish(final Runnable advanceState) { + // Publish the final snapshot together with the state transition, after any in-flight query. + runModProgressRefresh( + () -> { + refreshModFileProgress(true); + modProgressFinished = true; + modProgressTargets.clear(); + advanceState.run(); + }, + true); + } + + public void finishWithoutModFiles() { + synchronized (modProgressRefreshMonitor) { + modFileProgress = new TDropTableModProgress(0).setRemainingModFileCount(0); + modProgressFinished = true; + modProgressTargets.clear(); + modProgressCleanupPending = false; + modProgressReplicaTargets.clear(); + } + } + + public TDropTableModProgress snapshot() { + final TDropTableModProgress progress = modFileProgress; + return progress == null ? null : progress.deepCopy(); + } + + public boolean hasPendingCleanup() { + return modProgressCleanupPending; + } + + /** Shares an in-flight counter refresh among concurrent observability requests. */ + public void update() { + runModProgressRefresh( + () -> { + if (modProgressFinished) { + retryCleanup(); + } else { + refreshModFileProgress(false); + } + }, + false); + } + + private void runModProgressRefresh(final Runnable action, final boolean retryAfterWait) { + while (true) { + final CompletableFuture refreshFuture; + final boolean refreshOwner; + synchronized (modProgressRefreshMonitor) { + if (modProgressRefreshFuture == null) { + refreshFuture = new CompletableFuture<>(); + modProgressRefreshFuture = refreshFuture; + refreshOwner = true; + } else { + refreshFuture = modProgressRefreshFuture; + refreshOwner = false; + } + } + if (!refreshOwner) { + refreshFuture.join(); + if (retryAfterWait) { + continue; + } + return; + } + try { + action.run(); + return; + } catch (final RuntimeException | Error e) { + refreshFuture.completeExceptionally(e); + throw e; + } finally { + synchronized (modProgressRefreshMonitor) { + if (modProgressRefreshFuture == refreshFuture) { + modProgressRefreshFuture = null; + } + refreshFuture.complete(null); + } + } + } + } + + private boolean refreshModFileProgress(final boolean clearProgress) { + if (!clearProgress && (modProgressFinished || !deletionRunning.getAsBoolean())) { + return false; + } + final Map targets = new HashMap<>(modProgressTargets); + final Map> refreshTargets = + getRefreshTargets(clearProgress); + if (refreshTargets.isEmpty()) { + if (clearProgress && targets.equals(modProgressTargets)) { + modFileProgress = null; + } + return true; + } + if (!clearProgress && (targets.isEmpty() || targets.size() != modProgressRegionCount)) { + return false; + } + final DataNodeAsyncRequestContext + requestContext = sendProgressRequest(refreshTargets, clearProgress); + + // A deletion retry may have selected a different replica while these RPCs were in flight. + if (targets.equals(modProgressTargets)) { + modFileProgress = + targets.size() == modProgressRegionCount + ? aggregateModFileProgress(targets, requestContext.getResponseMap()) + : null; + } + if (clearProgress) { + final boolean cleanupPending = !allRequestsSucceeded(refreshTargets, requestContext); + synchronized (modProgressRefreshMonitor) { + modProgressCleanupPending = cleanupPending; + if (!cleanupPending) { + modProgressReplicaTargets.clear(); + } + } + return !cleanupPending; + } + return true; + } + + private DataNodeAsyncRequestContext + sendProgressRequest( + final Map> refreshTargets, + final boolean clearProgress) { + final DataNodeAsyncRequestContext + requestContext = + new DataNodeAsyncRequestContext<>(CnToDnAsyncRequestType.GET_DROP_TABLE_MOD_PROGRESS); + final Map> regionsByNode = new HashMap<>(); + refreshTargets.forEach( + (location, regions) -> { + requestContext.putNodeLocation(location.getDataNodeId(), location); + regionsByNode + .computeIfAbsent(location.getDataNodeId(), ignored -> new ArrayList<>()) + .addAll(regions); + }); + regionsByNode.forEach( + (nodeId, regions) -> + requestContext.putRequest( + nodeId, + new TGetDropTableModProgressReq(procedureId.getAsLong(), regions) + .setClearProgress(clearProgress))); + progressRequestSender.accept(requestContext); + return requestContext; + } + + private void retryCleanup() { + if (!modProgressCleanupPending) { + return; + } + final Map> refreshTargets = getRefreshTargets(true); + if (refreshTargets.isEmpty()) { + synchronized (modProgressRefreshMonitor) { + modProgressCleanupPending = false; + modProgressReplicaTargets.clear(); + } + return; + } + final DataNodeAsyncRequestContext + requestContext = sendProgressRequest(refreshTargets, true); + if (allRequestsSucceeded(refreshTargets, requestContext)) { + synchronized (modProgressRefreshMonitor) { + modProgressCleanupPending = false; + modProgressReplicaTargets.clear(); + } + } + } + + private static boolean allRequestsSucceeded( + final Map> refreshTargets, + final DataNodeAsyncRequestContext + requestContext) { + return refreshTargets.keySet().stream() + .allMatch( + location -> { + final TGetDropTableModProgressResp response = + requestContext.getResponseMap().get(location.getDataNodeId()); + return response != null + && response.getStatus() != null + && response.getStatus().getCode() == TSStatusCode.SUCCESS_STATUS.getStatusCode(); + }); + } + + Map> getRefreshTargets(final boolean clearProgress) { + final Map> refreshTargets = new HashMap<>(); + if (clearProgress && !modProgressReplicaTargets.isEmpty()) { + modProgressReplicaTargets.forEach( + (region, locations) -> + locations.forEach( + location -> + refreshTargets + .computeIfAbsent(location, ignored -> new ArrayList<>()) + .add(region))); + } else { + modProgressTargets.forEach( + (region, location) -> + refreshTargets.computeIfAbsent(location, ignored -> new ArrayList<>()).add(region)); + } + return refreshTargets; + } + + public static TDropTableModProgress aggregateModFileProgress( + final Map targets, + final Map responses) { + long written = 0; + long remaining = 0; + boolean hasUnknown = false; + for (final Map.Entry target : targets.entrySet()) { + final TGetDropTableModProgressResp response = + responses.get(target.getValue().getDataNodeId()); + if (response == null + || response.getStatus().getCode() != TSStatusCode.SUCCESS_STATUS.getStatusCode() + || !response.isSetRegionProgress() + || !response.getRegionProgress().containsKey(target.getKey().getId())) { + // Unknown is different from zero. In particular, an old DataNode does not report counts. + return null; + } + final TDropTableModProgress progress = + response.getRegionProgress().get(target.getKey().getId()); + written += progress.getWrittenModFileCount(); + if (progress.isSetRemainingModFileCount()) { + remaining += progress.getRemainingModFileCount(); + } else { + hasUnknown = true; + } + } + final TDropTableModProgress progress = new TDropTableModProgress(written); + if (!hasUnknown) { + progress.setRemainingModFileCount(remaining); + } + return progress; + } + + public void serialize(final DataOutputStream stream) throws IOException { + final TDropTableModProgress progress; + final boolean cleanupPending; + final Map> replicaTargets; + synchronized (modProgressRefreshMonitor) { + progress = modFileProgress; + cleanupPending = modProgressCleanupPending; + replicaTargets = + cleanupPending ? new HashMap<>(modProgressReplicaTargets) : Collections.emptyMap(); + } + stream.writeBoolean(progress != null); + if (progress != null) { + stream.writeLong(progress.getWrittenModFileCount()); + stream.writeLong( + progress.isSetRemainingModFileCount() ? progress.getRemainingModFileCount() : -1); + } + stream.writeBoolean(cleanupPending); + if (cleanupPending) { + stream.writeInt(replicaTargets.size()); + for (final Map.Entry> entry : + replicaTargets.entrySet()) { + ThriftCommonsSerDeUtils.serializeTConsensusGroupId(entry.getKey(), stream); + stream.writeInt(entry.getValue().size()); + for (final TDataNodeLocation location : entry.getValue()) { + ThriftCommonsSerDeUtils.serializeTDataNodeLocation(location, stream); + } + } + } + } + + public void deserialize(final ByteBuffer buffer) { + if (buffer.hasRemaining() && buffer.get() != 0) { + final TDropTableModProgress progress = new TDropTableModProgress(buffer.getLong()); + final long remaining = buffer.getLong(); + if (remaining >= 0) { + progress.setRemainingModFileCount(remaining); + } + modFileProgress = progress; + } + if (buffer.hasRemaining()) { + modProgressCleanupPending = buffer.get() != 0; + if (modProgressCleanupPending) { + modProgressFinished = true; + final int regionCount = buffer.getInt(); + for (int i = 0; i < regionCount; i++) { + final TConsensusGroupId region = + ThriftCommonsSerDeUtils.deserializeTConsensusGroupId(buffer); + final int locationCount = buffer.getInt(); + final List locations = new ArrayList<>(locationCount); + for (int j = 0; j < locationCount; j++) { + locations.add(ThriftCommonsSerDeUtils.deserializeTDataNodeLocation(buffer)); + } + modProgressReplicaTargets.put(region, locations); + } + } + } + } +} diff --git a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableColumnProcedure.java b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableColumnProcedure.java index e2db53848010e..aba6390c7bfaa 100644 --- a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableColumnProcedure.java +++ b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableColumnProcedure.java @@ -34,8 +34,10 @@ import org.apache.iotdb.confignode.consensus.request.write.table.view.PreDeleteViewColumnPlan; import org.apache.iotdb.confignode.i18n.ProcedureMessages; import org.apache.iotdb.confignode.manager.lease.ClusterCachePropagator; +import org.apache.iotdb.confignode.procedure.ProcedureWithPendingCleanup; import org.apache.iotdb.confignode.procedure.env.ConfigNodeProcedureEnv; import org.apache.iotdb.confignode.procedure.exception.ProcedureException; +import org.apache.iotdb.confignode.procedure.impl.schema.ModFileDeletionProgress; import org.apache.iotdb.confignode.procedure.impl.schema.SchemaUtils; import org.apache.iotdb.confignode.procedure.impl.schema.table.view.DropViewColumnProcedure; import org.apache.iotdb.confignode.procedure.state.schema.DropTableColumnState; @@ -57,14 +59,15 @@ import java.util.Objects; public class DropTableColumnProcedure - extends AbstractAlterOrDropTableProcedure { + extends AbstractAlterOrDropTableProcedure + implements ProcedureWithPendingCleanup { private static final Logger LOGGER = LoggerFactory.getLogger(DropTableColumnProcedure.class); private String columnName; private boolean isAttributeColumn; - private final TableDeletionModProgress modProgress = - new TableDeletionModProgress( + private final ModFileDeletionProgress modProgress = + new ModFileDeletionProgress( this::getProcId, () -> !isFinished() && getCurrentState() == DropTableColumnState.EXECUTE_ON_REGIONS); @@ -102,6 +105,16 @@ public void updateModFileProgress() { modProgress.update(); } + @Override + public boolean hasPendingCleanup() { + return modProgress.hasPendingCleanup(); + } + + @Override + public void retryPendingCleanup() { + updateModFileProgress(); + } + @Override protected String getActionMessage() { return ProcedureMessages.MESSAGE_DROP_TABLE_COLUMN_6FA1DB5F; @@ -229,6 +242,7 @@ private void executeOnRegions(final ConfigNodeProcedureEnv env) { if (!relatedRegionGroup.isEmpty()) { if (!isAttributeColumn) { modProgress.setRegionCount(relatedRegionGroup.size()); + modProgress.trackRegionReplicas(relatedRegionGroup); } new TableRegionTaskExecutor<>( ProcedureMessages.MESSAGE_DELETE_DATA_FOR_DROP_TABLE_A678391E, @@ -244,7 +258,8 @@ private void executeOnRegions(final ConfigNodeProcedureEnv env) { tableName, columnName, isAttributeColumn) - .setProcedureId(getProcId()); + .setProcedureId(getProcId()) + .setTrackModFileProgress(!isAttributeColumn); })) .execute(); } diff --git a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableProcedure.java b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableProcedure.java index a40334a9182a6..236804c0989fa 100644 --- a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableProcedure.java +++ b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableProcedure.java @@ -36,8 +36,10 @@ import org.apache.iotdb.confignode.consensus.request.write.table.view.PreDeleteViewPlan; import org.apache.iotdb.confignode.i18n.ProcedureMessages; import org.apache.iotdb.confignode.manager.lease.ClusterCachePropagator; +import org.apache.iotdb.confignode.procedure.ProcedureWithPendingCleanup; import org.apache.iotdb.confignode.procedure.env.ConfigNodeProcedureEnv; import org.apache.iotdb.confignode.procedure.exception.ProcedureException; +import org.apache.iotdb.confignode.procedure.impl.schema.ModFileDeletionProgress; import org.apache.iotdb.confignode.procedure.impl.schema.SchemaUtils; import org.apache.iotdb.confignode.procedure.impl.schema.table.view.DropViewProcedure; import org.apache.iotdb.confignode.procedure.state.schema.DropTableState; @@ -56,12 +58,13 @@ import java.util.ArrayList; import java.util.Map; -public class DropTableProcedure extends AbstractAlterOrDropTableProcedure { +public class DropTableProcedure extends AbstractAlterOrDropTableProcedure + implements ProcedureWithPendingCleanup { private static final Logger LOGGER = LoggerFactory.getLogger(DropTableProcedure.class); - private final TableDeletionModProgress modProgress = - new TableDeletionModProgress( + private final ModFileDeletionProgress modProgress = + new ModFileDeletionProgress( this::getProcId, () -> !isFinished() && getCurrentState() == DropTableState.DELETE_DATA); public DropTableProcedure(final boolean isGeneratedByPipe) { @@ -92,6 +95,16 @@ public void updateModFileProgress() { modProgress.update(); } + @Override + public boolean hasPendingCleanup() { + return modProgress.hasPendingCleanup(); + } + + @Override + public void retryPendingCleanup() { + updateModFileProgress(); + } + @Override protected String getActionMessage() { return ProcedureMessages.MESSAGE_DROP_TABLE_F5849AD7; @@ -206,6 +219,7 @@ private void deleteData(final ConfigNodeProcedureEnv env) { if (!relatedDataRegionGroup.isEmpty()) { modProgress.setRegionCount(relatedDataRegionGroup.size()); + modProgress.trackRegionReplicas(relatedDataRegionGroup); new TableRegionTaskExecutor<>( ProcedureMessages.MESSAGE_DELETE_DATA_FOR_DROP_TABLE_A678391E, env, @@ -215,7 +229,8 @@ private void deleteData(final ConfigNodeProcedureEnv env) { modProgress.trackRegions(dataNodeLocation, consensusGroupIdList); return new TDeleteDataOrDevicesForDropTableReq( new ArrayList<>(consensusGroupIdList), tableName) - .setProcedureId(getProcId()); + .setProcedureId(getProcId()) + .setTrackModFileProgress(true); })) .execute(); modProgress.finish(() -> setNextState(DropTableState.DELETE_DEVICES)); diff --git a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/TableDeletionModProgress.java b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/TableDeletionModProgress.java deleted file mode 100644 index a0a2179ea58be..0000000000000 --- a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/TableDeletionModProgress.java +++ /dev/null @@ -1,222 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ - -package org.apache.iotdb.confignode.procedure.impl.schema.table; - -import org.apache.iotdb.common.rpc.thrift.TConsensusGroupId; -import org.apache.iotdb.common.rpc.thrift.TDataNodeLocation; -import org.apache.iotdb.confignode.client.async.CnToDnAsyncRequestType; -import org.apache.iotdb.confignode.client.async.CnToDnInternalServiceAsyncRequestManager; -import org.apache.iotdb.confignode.client.async.handlers.DataNodeAsyncRequestContext; -import org.apache.iotdb.mpp.rpc.thrift.TDropTableModProgress; -import org.apache.iotdb.mpp.rpc.thrift.TGetDropTableModProgressReq; -import org.apache.iotdb.mpp.rpc.thrift.TGetDropTableModProgressResp; -import org.apache.iotdb.rpc.TSStatusCode; - -import java.io.DataOutputStream; -import java.io.IOException; -import java.nio.ByteBuffer; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ConcurrentHashMap; -import java.util.function.BooleanSupplier; -import java.util.function.LongSupplier; - -/** Tracks mod-file writes for table and field-column deletion using one replica per region. */ -class TableDeletionModProgress { - private final LongSupplier procedureId; - private final BooleanSupplier deletionRunning; - // Track the replica actually executing each region, including changes caused by retries. - // Count each region once; followers may have different local TsFiles and apply asynchronously. - private final Map modProgressTargets = - new ConcurrentHashMap<>(); - private final Object modProgressRefreshMonitor = new Object(); - private CompletableFuture modProgressRefreshFuture; - private volatile int modProgressRegionCount; - private volatile TDropTableModProgress modFileProgress; - private volatile boolean modProgressFinished; - - TableDeletionModProgress(final LongSupplier procedureId, final BooleanSupplier deletionRunning) { - this.procedureId = procedureId; - this.deletionRunning = deletionRunning; - } - - void setRegionCount(final int regionCount) { - modProgressRegionCount = regionCount; - } - - void trackRegions(final TDataNodeLocation location, final List regions) { - regions.forEach(region -> modProgressTargets.put(region, location)); - } - - void finish(final Runnable advanceState) { - // Publish the final snapshot together with the state transition, after any in-flight query. - runModProgressRefresh( - () -> { - refreshModFileProgress(); - modProgressFinished = true; - advanceState.run(); - }, - true); - } - - void finishWithoutModFiles() { - modFileProgress = new TDropTableModProgress(0).setRemainingModFileCount(0); - modProgressFinished = true; - } - - TDropTableModProgress snapshot() { - final TDropTableModProgress progress = modFileProgress; - return progress == null ? null : progress.deepCopy(); - } - - /** Shares an in-flight counter refresh among concurrent observability requests. */ - void update() { - runModProgressRefresh(this::refreshModFileProgress, false); - } - - private void runModProgressRefresh(final Runnable action, final boolean retryAfterWait) { - while (true) { - final CompletableFuture refreshFuture; - final boolean refreshOwner; - synchronized (modProgressRefreshMonitor) { - if (modProgressRefreshFuture == null) { - refreshFuture = new CompletableFuture<>(); - modProgressRefreshFuture = refreshFuture; - refreshOwner = true; - } else { - refreshFuture = modProgressRefreshFuture; - refreshOwner = false; - } - } - if (!refreshOwner) { - refreshFuture.join(); - if (retryAfterWait) { - continue; - } - return; - } - try { - action.run(); - return; - } catch (final RuntimeException | Error e) { - refreshFuture.completeExceptionally(e); - throw e; - } finally { - synchronized (modProgressRefreshMonitor) { - if (modProgressRefreshFuture == refreshFuture) { - modProgressRefreshFuture = null; - } - refreshFuture.complete(null); - } - } - } - } - - private void refreshModFileProgress() { - if (modProgressFinished - || !deletionRunning.getAsBoolean() - || modProgressTargets.isEmpty() - || modProgressTargets.size() != modProgressRegionCount) { - return; - } - final DataNodeAsyncRequestContext - requestContext = - new DataNodeAsyncRequestContext<>(CnToDnAsyncRequestType.GET_DROP_TABLE_MOD_PROGRESS); - final Map> regionsByNode = new HashMap<>(); - final Map targets = new HashMap<>(modProgressTargets); - targets.forEach( - (region, location) -> { - requestContext.putNodeLocation(location.getDataNodeId(), location); - regionsByNode - .computeIfAbsent(location.getDataNodeId(), ignored -> new ArrayList<>()) - .add(region); - }); - for (final Map.Entry> entry : regionsByNode.entrySet()) { - requestContext.putRequest( - entry.getKey(), - new TGetDropTableModProgressReq(procedureId.getAsLong(), entry.getValue())); - } - CnToDnInternalServiceAsyncRequestManager.getInstance() - .sendAsyncRequest(requestContext, 1, 2_000L, true); - - // A deletion retry may have selected a different replica while these RPCs were in flight. - if (targets.equals(modProgressTargets)) { - // A failed refresh is unknown, including the final refresh. Do not freeze stale counters - // with remaining files after deletion has finished. - modFileProgress = aggregateModFileProgress(targets, requestContext.getResponseMap()); - } - } - - static TDropTableModProgress aggregateModFileProgress( - final Map targets, - final Map responses) { - long written = 0; - long remaining = 0; - boolean hasUnknown = false; - for (final Map.Entry target : targets.entrySet()) { - final TGetDropTableModProgressResp response = - responses.get(target.getValue().getDataNodeId()); - if (response == null - || response.getStatus().getCode() != TSStatusCode.SUCCESS_STATUS.getStatusCode() - || !response.isSetRegionProgress() - || !response.getRegionProgress().containsKey(target.getKey().getId())) { - // Unknown is different from zero. In particular, an old DataNode does not report counts. - return null; - } - final TDropTableModProgress progress = - response.getRegionProgress().get(target.getKey().getId()); - written += progress.getWrittenModFileCount(); - if (progress.isSetRemainingModFileCount()) { - remaining += progress.getRemainingModFileCount(); - } else { - hasUnknown = true; - } - } - final TDropTableModProgress progress = new TDropTableModProgress(written); - if (!hasUnknown) { - progress.setRemainingModFileCount(remaining); - } - return progress; - } - - void serialize(final DataOutputStream stream) throws IOException { - final TDropTableModProgress progress = modFileProgress; - stream.writeBoolean(progress != null); - if (progress != null) { - stream.writeLong(progress.getWrittenModFileCount()); - stream.writeLong( - progress.isSetRemainingModFileCount() ? progress.getRemainingModFileCount() : -1); - } - } - - void deserialize(final ByteBuffer buffer) { - if (buffer.hasRemaining() && buffer.get() != 0) { - final TDropTableModProgress progress = new TDropTableModProgress(buffer.getLong()); - final long remaining = buffer.getLong(); - if (remaining >= 0) { - progress.setRemainingModFileCount(remaining); - } - modFileProgress = progress; - } - } -} diff --git a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/AsyncTimeSeriesDeletionTest.java b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/AsyncTimeSeriesDeletionTest.java index 562df8d4486c3..53ed3965e3879 100644 --- a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/AsyncTimeSeriesDeletionTest.java +++ b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/AsyncTimeSeriesDeletionTest.java @@ -47,6 +47,7 @@ import org.apache.iotdb.confignode.procedure.store.ProcedureType; import org.apache.iotdb.confignode.rpc.thrift.TAlterOrDropTableReq; import org.apache.iotdb.confignode.rpc.thrift.TDatabaseSchema; +import org.apache.iotdb.confignode.rpc.thrift.TDeleteTimeSeriesProcedureInfo; import org.apache.iotdb.confignode.rpc.thrift.TDropTableProcedureInfo; import org.apache.iotdb.mpp.rpc.thrift.TDropTableModProgress; import org.apache.iotdb.rpc.TSStatusCode; @@ -336,6 +337,60 @@ public void testProgressWaitsForDurableCompletion() throws Exception { assertEquals("SUCCESS", manager.getDeleteTimeSeriesProcedures().get(0).getProgress()); } + @Test + public void testSuccessfulDeletionReportsZeroRemainingWhenFinalProgressIsUnknown() + throws Exception { + final DeleteTimeSeriesProcedure procedure = mock(DeleteTimeSeriesProcedure.class); + when(procedure.getProcId()).thenReturn(1L); + when(procedure.getQueryId()).thenReturn("1"); + when(procedure.getPatternTree()).thenReturn(new PathPatternTree()); + when(procedure.isFinished()).thenReturn(true); + when(procedure.isSuccess()).thenReturn(true); + when(procedure.getState()).thenReturn(ProcedureState.SUCCESS); + when(procedure.getDeleteProgress()).thenReturn("SUCCESS"); + when(executor.isCompleted(1L)).thenReturn(true); + completed.add(procedure); + + final TDeleteTimeSeriesProcedureInfo info = manager.getDeleteTimeSeriesProcedures().get(0); + + assertFalse(info.isSetWrittenModFileCount()); + assertTrue(info.isSetRemainingModFileCount()); + assertEquals(0, info.getRemainingModFileCount()); + } + + @Test + public void testSuccessfulTableAndColumnDropsReportZeroRemainingWhenProgressIsUnknown() { + final DropTableProcedure dropTable = mock(DropTableProcedure.class); + when(dropTable.getProcId()).thenReturn(1L); + when(dropTable.getDatabase()).thenReturn("test"); + when(dropTable.getTableName()).thenReturn("t"); + when(dropTable.isSuccess()).thenReturn(true); + when(dropTable.getState()).thenReturn(ProcedureState.SUCCESS); + when(dropTable.getDropProgress()).thenReturn("SUCCESS"); + completed.add(dropTable); + + final DropTableColumnProcedure dropColumn = mock(DropTableColumnProcedure.class); + when(dropColumn.getProcId()).thenReturn(2L); + when(dropColumn.getDatabase()).thenReturn("test"); + when(dropColumn.getTableName()).thenReturn("t"); + when(dropColumn.getColumnName()).thenReturn("reading"); + when(dropColumn.isSuccess()).thenReturn(true); + when(dropColumn.getState()).thenReturn(ProcedureState.SUCCESS); + when(dropColumn.getDropProgress()).thenReturn("SUCCESS"); + when(executor.isCompleted(2L)).thenReturn(true); + completed.add(dropColumn); + + final TDropTableProcedureInfo tableInfo = manager.getDropTableProcedures().get(0); + final TDropTableProcedureInfo columnInfo = manager.getDropTableColumnProcedures().get(0); + + assertFalse(tableInfo.isSetWrittenModFileCount()); + assertTrue(tableInfo.isSetRemainingModFileCount()); + assertEquals(0, tableInfo.getRemainingModFileCount()); + assertFalse(columnInfo.isSetWrittenModFileCount()); + assertTrue(columnInfo.isSetRemainingModFileCount()); + assertEquals(0, columnInfo.getRemainingModFileCount()); + } + @Test public void testColumnCompletionDuringSnapshotDoesNotResubmit() throws Exception { final TsTable table = new TsTable("t"); diff --git a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/CompletedProcedureRecyclerTest.java b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/CompletedProcedureRecyclerTest.java index eb951641e611d..8b3f4c6d7831a 100644 --- a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/CompletedProcedureRecyclerTest.java +++ b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/CompletedProcedureRecyclerTest.java @@ -32,6 +32,21 @@ public class CompletedProcedureRecyclerTest { + private static class PendingCleanupProcedure extends NoopProcedure + implements ProcedureWithPendingCleanup { + private int cleanupAttempts; + + @Override + public boolean hasPendingCleanup() { + return cleanupAttempts < 2; + } + + @Override + public void retryPendingCleanup() { + cleanupAttempts++; + } + } + @SuppressWarnings("unchecked") private static IProcedureStore runningStore() { NoopProcedureStore store = new NoopProcedureStore(); @@ -73,4 +88,22 @@ public void freshCompletedProcedureIsRetainedWhileStaleOneIsEvicted() { "A procedure completed 300s ago must be evicted by a 100s evict TTL", completed.containsKey(2L)); } + + @Test + public void pendingCleanupIsRetriedBeforeExpiredProcedureIsEvicted() { + final PendingCleanupProcedure procedure = new PendingCleanupProcedure(); + procedure.setLastUpdate(System.currentTimeMillis() - TimeUnit.SECONDS.toMillis(300)); + final Map> completed = new ConcurrentHashMap<>(); + completed.put(1L, new CompletedProcedureContainer<>(procedure)); + final CompletedProcedureRecycler recycler = + new CompletedProcedureRecycler<>(runningStore(), completed, 30, 100); + + recycler.periodicExecute(null); + Assert.assertEquals(1, procedure.cleanupAttempts); + Assert.assertTrue(completed.containsKey(1L)); + + recycler.periodicExecute(null); + Assert.assertEquals(2, procedure.cleanupAttempts); + Assert.assertFalse(completed.containsKey(1L)); + } } diff --git a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/DeleteTimeSeriesProcedureTest.java b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/DeleteTimeSeriesProcedureTest.java index b31e6594f0d79..d45e16e295e10 100644 --- a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/DeleteTimeSeriesProcedureTest.java +++ b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/DeleteTimeSeriesProcedureTest.java @@ -20,7 +20,6 @@ package org.apache.iotdb.confignode.procedure.impl.schema; import org.apache.iotdb.common.rpc.thrift.TSStatus; -import org.apache.iotdb.commons.exception.IllegalPathException; import org.apache.iotdb.commons.path.PartialPath; import org.apache.iotdb.commons.path.PathPatternTree; import org.apache.iotdb.confignode.manager.ConfigManager; @@ -39,6 +38,7 @@ import org.apache.iotdb.confignode.procedure.store.ProcedureType; import org.apache.iotdb.confignode.procedure.util.ProcedureTestUtil; import org.apache.iotdb.confignode.rpc.thrift.TDatabaseSchema; +import org.apache.iotdb.mpp.rpc.thrift.TDropTableModProgress; import org.apache.iotdb.rpc.TSStatusCode; import org.junit.Assert; @@ -46,7 +46,7 @@ import java.io.ByteArrayOutputStream; import java.io.DataOutputStream; -import java.io.IOException; +import java.lang.reflect.Field; import java.nio.ByteBuffer; import java.util.Collections; import java.util.HashMap; @@ -498,17 +498,19 @@ public void testLegacyProcedureWithoutAsyncSuffixCanBeRecovered() throws Excepti new DeleteTimeSeriesProcedure("legacy", tree, false, false); final ByteArrayOutputStream bytes = new ByteArrayOutputStream(); procedure.serialize(new DataOutputStream(bytes)); - // Remove the original-tree flag, empty database-schema count and null deletion-failure string. - final ByteBuffer buffer = ByteBuffer.wrap(bytes.toByteArray(), 0, bytes.size() - 9); + // Keep the legacy audit flag and remove all optional fields added after it. + final ByteBuffer buffer = + ByteBuffer.wrap(bytes.toByteArray(), 0, bytes.size() - 3 * Byte.BYTES - 2 * Integer.BYTES); buffer.getShort(); final DeleteTimeSeriesProcedure restored = new DeleteTimeSeriesProcedure(false); restored.deserialize(buffer); Assert.assertEquals(tree, restored.getPatternTree()); Assert.assertEquals("legacy", restored.getQueryId()); + Assert.assertNull(restored.getModFileProgress()); } @Test - public void serializeDeserializeTest() throws IllegalPathException, IOException { + public void serializeDeserializeTest() throws Exception { String queryId = "1"; PathPatternTree patternTree = new PathPatternTree(); patternTree.appendPathPattern(new PartialPath("root.sg1.**")); @@ -516,6 +518,12 @@ public void serializeDeserializeTest() throws IllegalPathException, IOException patternTree.constructTree(); DeleteTimeSeriesProcedure deleteTimeSeriesProcedure = new DeleteTimeSeriesProcedure(queryId, patternTree, false, false); + final Field trackerField = DeleteTimeSeriesProcedure.class.getDeclaredField("modProgress"); + trackerField.setAccessible(true); + final Field progressField = ModFileDeletionProgress.class.getDeclaredField("modFileProgress"); + progressField.setAccessible(true); + final TDropTableModProgress progress = new TDropTableModProgress(4).setRemainingModFileCount(0); + progressField.set(trackerField.get(deleteTimeSeriesProcedure), progress); ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream); @@ -530,6 +538,7 @@ public void serializeDeserializeTest() throws IllegalPathException, IOException deserializedProcedure.deserialize(byteBuffer); Assert.assertEquals(queryId, deserializedProcedure.getQueryId()); + Assert.assertEquals(progress, deserializedProcedure.getModFileProgress()); List pathList = deserializedProcedure.getPatternTree().getAllPathPatterns(); pathList.sort(PartialPath::compareTo); diff --git a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/ModFileDeletionProgressTest.java b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/ModFileDeletionProgressTest.java new file mode 100644 index 0000000000000..41ff44297ef14 --- /dev/null +++ b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/ModFileDeletionProgressTest.java @@ -0,0 +1,324 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.iotdb.confignode.procedure.impl.schema; + +import org.apache.iotdb.common.rpc.thrift.TConsensusGroupId; +import org.apache.iotdb.common.rpc.thrift.TConsensusGroupType; +import org.apache.iotdb.common.rpc.thrift.TDataNodeLocation; +import org.apache.iotdb.common.rpc.thrift.TEndPoint; +import org.apache.iotdb.common.rpc.thrift.TRegionReplicaSet; +import org.apache.iotdb.common.rpc.thrift.TSStatus; +import org.apache.iotdb.mpp.rpc.thrift.TDropTableModProgress; +import org.apache.iotdb.mpp.rpc.thrift.TGetDropTableModProgressResp; +import org.apache.iotdb.rpc.TSStatusCode; + +import org.junit.Test; + +import java.io.ByteArrayOutputStream; +import java.io.DataOutputStream; +import java.io.OutputStream; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +public class ModFileDeletionProgressTest { + @Test + public void finalRefreshTargetsEveryReplicaButLiveRefreshUsesExecutorTarget() { + final TConsensusGroupId region = new TConsensusGroupId(TConsensusGroupType.DataRegion, 1); + final TDataNodeLocation firstReplica = dataNodeLocation(1); + final TDataNodeLocation secondReplica = dataNodeLocation(2); + final TRegionReplicaSet replicaSet = + new TRegionReplicaSet(region, Arrays.asList(firstReplica, secondReplica)); + final ModFileDeletionProgress progress = new ModFileDeletionProgress(() -> 1, () -> true); + progress.setRegionCount(1); + progress.trackRegionReplicas(Map.of(region, replicaSet)); + progress.trackRegions(firstReplica, Collections.singletonList(region)); + + assertEquals( + Map.of(firstReplica, Collections.singletonList(region)), progress.getRefreshTargets(false)); + assertEquals( + Map.of( + firstReplica, + Collections.singletonList(region), + secondReplica, + Collections.singletonList(region)), + progress.getRefreshTargets(true)); + } + + @Test + public void failedFinalRefreshRetainsTargetsAcrossSerializationAndRetries() throws Exception { + final TConsensusGroupId region = new TConsensusGroupId(TConsensusGroupType.DataRegion, 1); + final TDataNodeLocation firstReplica = dataNodeLocation(1); + final TDataNodeLocation secondReplica = dataNodeLocation(2); + final TRegionReplicaSet replicaSet = + new TRegionReplicaSet(region, Arrays.asList(firstReplica, secondReplica)); + final AtomicBoolean omitSecondResponse = new AtomicBoolean(true); + final List> requestNodeIds = new ArrayList<>(); + final ModFileDeletionProgress progress = + new ModFileDeletionProgress( + () -> 9, + () -> true, + requestContext -> { + final Set nodeIds = new HashSet<>(requestContext.getRequestIndices()); + requestNodeIds.add(nodeIds); + for (final int nodeId : nodeIds) { + assertTrue(requestContext.getRequest(nodeId).isClearProgress()); + if (nodeId == 2 && omitSecondResponse.get()) { + continue; + } + requestContext + .getResponseMap() + .put( + nodeId, + new TGetDropTableModProgressResp( + new TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode())) + .setRegionProgress( + Map.of( + region.getId(), + new TDropTableModProgress(5).setRemainingModFileCount(0)))); + } + }); + progress.setRegionCount(1); + progress.trackRegionReplicas(Map.of(region, replicaSet)); + progress.trackRegions(firstReplica, Collections.singletonList(region)); + + final AtomicBoolean advanced = new AtomicBoolean(); + progress.finish(() -> advanced.set(true)); + + assertTrue(advanced.get()); + assertTrue(progress.hasPendingCleanup()); + assertEquals(Collections.singletonList(Set.of(1, 2)), requestNodeIds); + assertEquals(Collections.emptyMap(), progress.getRefreshTargets(false)); + assertEquals( + Map.of( + firstReplica, + Collections.singletonList(region), + secondReplica, + Collections.singletonList(region)), + progress.getRefreshTargets(true)); + + final ByteArrayOutputStream bytes = new ByteArrayOutputStream(); + progress.serialize(new DataOutputStream(bytes)); + omitSecondResponse.set(false); + final List retryNodeIds = new ArrayList<>(); + final ModFileDeletionProgress recovered = + new ModFileDeletionProgress( + () -> 9, + () -> false, + requestContext -> { + for (final int nodeId : requestContext.getRequestIndices()) { + retryNodeIds.add(nodeId); + assertTrue(requestContext.getRequest(nodeId).isClearProgress()); + requestContext + .getResponseMap() + .put( + nodeId, + new TGetDropTableModProgressResp( + new TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode()))); + } + }); + recovered.deserialize(ByteBuffer.wrap(bytes.toByteArray())); + + assertTrue(recovered.hasPendingCleanup()); + assertEquals(new TDropTableModProgress(5).setRemainingModFileCount(0), recovered.snapshot()); + recovered.update(); + + assertFalse(recovered.hasPendingCleanup()); + assertEquals(Set.of(1, 2), new HashSet<>(retryNodeIds)); + assertEquals(Collections.emptyMap(), recovered.getRefreshTargets(true)); + } + + @Test + public void unsuccessfulFinalRefreshResponseKeepsCleanupPending() { + final TConsensusGroupId region = new TConsensusGroupId(TConsensusGroupType.DataRegion, 5); + final TDataNodeLocation firstReplica = dataNodeLocation(5); + final TDataNodeLocation secondReplica = dataNodeLocation(6); + final TRegionReplicaSet replicaSet = + new TRegionReplicaSet(region, Arrays.asList(firstReplica, secondReplica)); + final ModFileDeletionProgress progress = + new ModFileDeletionProgress( + () -> 12, + () -> true, + requestContext -> { + for (final int nodeId : requestContext.getRequestIndices()) { + requestContext + .getResponseMap() + .put( + nodeId, + new TGetDropTableModProgressResp( + new TSStatus( + nodeId == secondReplica.getDataNodeId() + ? TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode() + : TSStatusCode.SUCCESS_STATUS.getStatusCode()))); + } + }); + progress.setRegionCount(1); + progress.trackRegionReplicas(Map.of(region, replicaSet)); + progress.trackRegions(firstReplica, Collections.singletonList(region)); + final AtomicBoolean advanced = new AtomicBoolean(); + + progress.finish(() -> advanced.set(true)); + + assertTrue(advanced.get()); + assertTrue(progress.hasPendingCleanup()); + assertEquals(2, progress.getRefreshTargets(true).values().stream().mapToInt(List::size).sum()); + } + + @Test + public void serializationKeepsCleanupTargetsWhenConcurrentRetryCompletes() throws Exception { + final TConsensusGroupId region = new TConsensusGroupId(TConsensusGroupType.DataRegion, 3); + final TDataNodeLocation firstReplica = dataNodeLocation(3); + final TDataNodeLocation secondReplica = dataNodeLocation(4); + final TRegionReplicaSet replicaSet = + new TRegionReplicaSet(region, Arrays.asList(firstReplica, secondReplica)); + final AtomicBoolean omitCleanupResponse = new AtomicBoolean(true); + final ModFileDeletionProgress progress = + new ModFileDeletionProgress( + () -> 11, + () -> true, + requestContext -> { + for (final int nodeId : requestContext.getRequestIndices()) { + final boolean clearProgress = requestContext.getRequest(nodeId).isClearProgress(); + if (clearProgress + && nodeId == secondReplica.getDataNodeId() + && omitCleanupResponse.get()) { + continue; + } + final TGetDropTableModProgressResp response = + new TGetDropTableModProgressResp( + new TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode())); + if (!clearProgress) { + response.setRegionProgress( + Map.of( + region.getId(), + new TDropTableModProgress(2).setRemainingModFileCount(0))); + } + requestContext.getResponseMap().put(nodeId, response); + } + }); + progress.setRegionCount(1); + progress.trackRegionReplicas(Map.of(region, replicaSet)); + progress.trackRegions(firstReplica, Collections.singletonList(region)); + progress.update(); + progress.finish(() -> {}); + assertTrue(progress.hasPendingCleanup()); + + final ByteArrayOutputStream bytes = new ByteArrayOutputStream(); + final AtomicBoolean retryCleanup = new AtomicBoolean(); + final OutputStream outputStream = + new OutputStream() { + private int writtenBytes; + + @Override + public void write(final int value) { + bytes.write(value); + triggerCleanup(1); + } + + @Override + public void write(final byte[] buffer, final int offset, final int length) { + bytes.write(buffer, offset, length); + triggerCleanup(length); + } + + private void triggerCleanup(final int length) { + writtenBytes += length; + if (writtenBytes >= 18 && retryCleanup.compareAndSet(false, true)) { + omitCleanupResponse.set(false); + progress.update(); + } + } + }; + progress.serialize(new DataOutputStream(outputStream)); + + assertFalse(progress.hasPendingCleanup()); + final ModFileDeletionProgress recovered = + new ModFileDeletionProgress(() -> 11, () -> false, requestContext -> {}); + recovered.deserialize(ByteBuffer.wrap(bytes.toByteArray())); + + assertTrue(recovered.hasPendingCleanup()); + assertEquals( + Map.of( + firstReplica, + Collections.singletonList(region), + secondReplica, + Collections.singletonList(region)), + recovered.getRefreshTargets(true)); + } + + @Test + public void staleRefreshFromPreviousReplicaIsIgnoredAfterTargetSwitch() { + final TConsensusGroupId region = new TConsensusGroupId(TConsensusGroupType.DataRegion, 2); + final TDataNodeLocation firstReplica = dataNodeLocation(1); + final TDataNodeLocation secondReplica = dataNodeLocation(2); + final AtomicReference progressReference = new AtomicReference<>(); + final AtomicBoolean switchReplica = new AtomicBoolean(true); + final ModFileDeletionProgress progress = + new ModFileDeletionProgress( + () -> 10, + () -> true, + requestContext -> { + final int nodeId = requestContext.getRequestIndices().get(0); + if (switchReplica.getAndSet(false)) { + progressReference + .get() + .trackRegions(secondReplica, Collections.singletonList(region)); + } + requestContext + .getResponseMap() + .put( + nodeId, + new TGetDropTableModProgressResp( + new TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode())) + .setRegionProgress( + Map.of(region.getId(), new TDropTableModProgress(nodeId)))); + }); + progressReference.set(progress); + progress.setRegionCount(1); + progress.trackRegions(firstReplica, Collections.singletonList(region)); + + progress.update(); + assertNull(progress.snapshot()); + + progress.update(); + assertEquals(new TDropTableModProgress(2), progress.snapshot()); + } + + private static TDataNodeLocation dataNodeLocation(final int nodeId) { + return new TDataNodeLocation() + .setDataNodeId(nodeId) + .setClientRpcEndPoint(new TEndPoint("127.0.0.1", 6660 + nodeId)) + .setInternalEndPoint(new TEndPoint("127.0.0.1", 10730 + nodeId)) + .setMPPDataExchangeEndPoint(new TEndPoint("127.0.0.1", 10740 + nodeId)) + .setDataRegionConsensusEndPoint(new TEndPoint("127.0.0.1", 10750 + nodeId)) + .setSchemaRegionConsensusEndPoint(new TEndPoint("127.0.0.1", 10760 + nodeId)); + } +} diff --git a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableColumnProcedureTest.java b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableColumnProcedureTest.java index 844e19109db55..2a8b39842ac55 100644 --- a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableColumnProcedureTest.java +++ b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableColumnProcedureTest.java @@ -28,6 +28,7 @@ import org.apache.iotdb.confignode.procedure.ProcedureExecutor; import org.apache.iotdb.confignode.procedure.env.ConfigNodeProcedureEnv; import org.apache.iotdb.confignode.procedure.exception.ProcedureException; +import org.apache.iotdb.confignode.procedure.impl.schema.ModFileDeletionProgress; import org.apache.iotdb.confignode.procedure.state.ProcedureState; import org.apache.iotdb.confignode.procedure.state.schema.DropTableColumnState; import org.apache.iotdb.confignode.procedure.store.ProcedureType; @@ -196,7 +197,7 @@ public void modProgressSurvivesSerialization() throws Exception { final Field trackerField = DropTableColumnProcedure.class.getDeclaredField("modProgress"); trackerField.setAccessible(true); final Field progressField = - TableDeletionModProgress.class.getDeclaredField("modFileProgress"); + ModFileDeletionProgress.class.getDeclaredField("modFileProgress"); progressField.setAccessible(true); progressField.set(trackerField.get(procedure), progress); final ByteArrayOutputStream bytes = new ByteArrayOutputStream(); diff --git a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableProcedureTest.java b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableProcedureTest.java index afe15bade1e28..1812e891bd987 100644 --- a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableProcedureTest.java +++ b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/DropTableProcedureTest.java @@ -28,6 +28,7 @@ import org.apache.iotdb.confignode.procedure.Procedure; import org.apache.iotdb.confignode.procedure.ProcedureExecutor; import org.apache.iotdb.confignode.procedure.env.ConfigNodeProcedureEnv; +import org.apache.iotdb.confignode.procedure.impl.schema.ModFileDeletionProgress; import org.apache.iotdb.confignode.procedure.impl.schema.table.view.DropViewProcedure; import org.apache.iotdb.confignode.procedure.state.schema.DropTableState; import org.apache.iotdb.confignode.procedure.store.ProcedureType; @@ -261,7 +262,7 @@ firstRegion, new TDataNodeLocation().setDataNodeId(1), Assert.assertEquals( new TDropTableModProgress(7).setRemainingModFileCount(10), - TableDeletionModProgress.aggregateModFileProgress(targets, responses)); + ModFileDeletionProgress.aggregateModFileProgress(targets, responses)); } @Test @@ -284,7 +285,7 @@ public void aggregateModProgressBeforeAllRegionsStart() { new TDropTableModProgress(0)))); final TDropTableModProgress progress = - TableDeletionModProgress.aggregateModFileProgress(targets, responses); + ModFileDeletionProgress.aggregateModFileProgress(targets, responses); Assert.assertEquals(2, progress.getWrittenModFileCount()); Assert.assertFalse(progress.isSetRemainingModFileCount()); } @@ -296,12 +297,12 @@ public void aggregateUnavailableModProgressIsUnknown() { new TConsensusGroupId(TConsensusGroupType.DataRegion, 1), new TDataNodeLocation().setDataNodeId(1)); Assert.assertNull( - TableDeletionModProgress.aggregateModFileProgress(targets, Collections.emptyMap())); + ModFileDeletionProgress.aggregateModFileProgress(targets, Collections.emptyMap())); Assert.assertNull( - TableDeletionModProgress.aggregateModFileProgress( + ModFileDeletionProgress.aggregateModFileProgress( targets, Map.of(1, new TGetDropTableModProgressResp(StatusUtils.OK)))); Assert.assertNull( - TableDeletionModProgress.aggregateModFileProgress( + ModFileDeletionProgress.aggregateModFileProgress( targets, Map.of( 1, @@ -314,7 +315,7 @@ public void concurrentModProgressQueriesWaitForInFlightRefresh() throws Exceptio final DropTableProcedure procedure = new DropTableProcedure("database", "table", "query", false); final Field futureField = - TableDeletionModProgress.class.getDeclaredField("modProgressRefreshFuture"); + ModFileDeletionProgress.class.getDeclaredField("modProgressRefreshFuture"); futureField.setAccessible(true); final CountDownLatch waitingQueryStarted = new CountDownLatch(1); final CompletableFuture refreshFuture = @@ -353,7 +354,7 @@ public void modProgressSurvivesSerialization() throws Exception { final DropTableProcedure procedure = new DropTableProcedure("database", "table", "query", isGeneratedByPipe); final Field progressField = - TableDeletionModProgress.class.getDeclaredField("modFileProgress"); + ModFileDeletionProgress.class.getDeclaredField("modFileProgress"); progressField.setAccessible(true); progressField.set(modProgress(procedure), progress); final ByteArrayOutputStream bytes = new ByteArrayOutputStream(); @@ -386,10 +387,10 @@ public void deserializeProcedureWithoutModProgress() throws Exception { Assert.assertFalse(buffer.hasRemaining()); } - private static TableDeletionModProgress modProgress(final DropTableProcedure procedure) + private static ModFileDeletionProgress modProgress(final DropTableProcedure procedure) throws Exception { final Field field = DropTableProcedure.class.getDeclaredField("modProgress"); field.setAccessible(true); - return (TableDeletionModProgress) field.get(procedure); + return (ModFileDeletionProgress) field.get(procedure); } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/consensus/statemachine/dataregion/DataExecutionVisitor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/consensus/statemachine/dataregion/DataExecutionVisitor.java index 4f8eca8f27551..7b3e883bb3546 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/consensus/statemachine/dataregion/DataExecutionVisitor.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/consensus/statemachine/dataregion/DataExecutionVisitor.java @@ -52,6 +52,7 @@ import org.apache.iotdb.db.queryengine.plan.planner.plan.node.write.RelationalInsertRowsNode; import org.apache.iotdb.db.queryengine.plan.planner.plan.node.write.RelationalInsertTabletNode; import org.apache.iotdb.db.storageengine.dataregion.DataRegion; +import org.apache.iotdb.db.storageengine.dataregion.modification.SchemaDeletionModProgress; import org.apache.iotdb.rpc.RpcUtils; import org.apache.iotdb.rpc.TSStatusCode; @@ -325,7 +326,12 @@ public TSStatus visitPipeEnrichedInsertNode(PipeEnrichedInsertNode node, DataReg @Override public TSStatus visitDeleteData(DeleteDataNode node, DataRegion dataRegion) { dataRegion.writeLock("deleteData"); + SchemaDeletionModProgress modProgress = null; + boolean succeeded = false; try { + if (!node.isGeneratedByRemoteConsensusLeader()) { + modProgress = dataRegion.startTimeSeriesModProgress(node.getPlanNodeId()); + } for (MeasurementPath path : node.getPathList()) { MeasurementPath databaseToDelete = new MeasurementPath(dataRegion.getDatabaseName() + ".**"); @@ -336,12 +342,13 @@ public TSStatus visitDeleteData(DeleteDataNode node, DataRegion dataRegion) { .PIPE_LOG_NOW_TRY_TO_DELETE_DIRECTLY_DATABASEPATH_DELETEPATH_A427CD01, databaseToDelete.getFullPath(), path.getFullPath()); - dataRegion.deleteDataDirectly(databaseToDelete, node); + dataRegion.deleteDataDirectly(databaseToDelete, node, modProgress); } else { - dataRegion.deleteByDevice(path, node); + dataRegion.deleteByDevice(path, node, modProgress); } } dataRegion.insertSeparatorToWAL(node); + succeeded = true; return StatusUtils.OK; } catch (WriteProcessRejectException e) { return RpcUtils.getStatus(e.getErrorCode(), e.getMessage()); @@ -352,6 +359,9 @@ public TSStatus visitDeleteData(DeleteDataNode node, DataRegion dataRegion) { LOGGER.error(DataNodeMiscMessages.ERROR_EXECUTING_PLAN_NODE_CAUSED, node, e.getMessage()); return RpcUtils.getStatus(TSStatusCode.WRITE_PROCESS_ERROR, e.getMessage()); } finally { + if (modProgress != null) { + modProgress.finishTimeSeriesDeletion(succeeded); + } dataRegion.writeUnlock(); } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalRPCServiceImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalRPCServiceImpl.java index 43f2e412abdea..48808a23660eb 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalRPCServiceImpl.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalRPCServiceImpl.java @@ -219,7 +219,7 @@ import org.apache.iotdb.db.storageengine.dataregion.compaction.settle.SettleRequestHandler; import org.apache.iotdb.db.storageengine.dataregion.flush.CompressionRatio; import org.apache.iotdb.db.storageengine.dataregion.modification.DeletionPredicate; -import org.apache.iotdb.db.storageengine.dataregion.modification.DropTableModProgress; +import org.apache.iotdb.db.storageengine.dataregion.modification.SchemaDeletionModProgress; import org.apache.iotdb.db.storageengine.dataregion.modification.TableDeletionEntry; import org.apache.iotdb.db.storageengine.dataregion.modification.TagPredicate; import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileManager; @@ -399,7 +399,6 @@ import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Future; import java.util.concurrent.ThreadPoolExecutor; @@ -957,6 +956,10 @@ public TSStatus deleteDataForDeleteSchema(final TDeleteDataForDeleteSchemaReq re final List pathList = PathPatternTree.deserialize(ByteBuffer.wrap(req.getPathPatternTree())) .getAllPathPatterns(true); + final PlanNodeId planNodeId = + req.isSetProcedureId() && req.isSetTrackModFileProgress() && req.isTrackModFileProgress() + ? SchemaDeletionModProgress.deleteTimeSeriesPlanNodeId(req.getProcedureId()) + : new PlanNodeId(""); return executeInternalSchemaTask( req.getDataRegionIdList(), consensusGroupId -> @@ -968,9 +971,8 @@ public TSStatus deleteDataForDeleteSchema(final TDeleteDataForDeleteSchemaReq re req.isSetIsGeneratedByPipe() && req.isIsGeneratedByPipe() ? new PipeEnrichedDeleteDataNode( new DeleteDataNode( - new PlanNodeId(""), pathList, Long.MIN_VALUE, Long.MAX_VALUE)) - : new DeleteDataNode( - new PlanNodeId(""), pathList, Long.MIN_VALUE, Long.MAX_VALUE)) + planNodeId, pathList, Long.MIN_VALUE, Long.MAX_VALUE)) + : new DeleteDataNode(planNodeId, pathList, Long.MIN_VALUE, Long.MAX_VALUE)) .getStatus()); } @@ -1822,83 +1824,15 @@ public TPipeHeartbeatResp pipeHeartbeat(TPipeHeartbeatReq req) throws TException private TSStatus executeSchemaBlackListTask( final List consensusGroupIdList, final Function executeOnOneRegion) { - // Not guarantee sequence - final List statusList = Collections.synchronizedList(new ArrayList<>()); - final AtomicBoolean hasFailure = new AtomicBoolean(false); - - final Set> schemaFuture = new HashSet<>(); - - consensusGroupIdList.forEach( - consensusGroupId -> - schemaFuture.add( - schemaExecutor.submit( - () -> { - final TSStatus status = executeOnOneRegion.apply(consensusGroupId); - if (status.getCode() != TSStatusCode.SUCCESS_STATUS.getStatusCode() - && status.getCode() != TSStatusCode.ONLY_LOGICAL_VIEW.getStatusCode()) { - hasFailure.set(true); - } - statusList.add(status); - }))); - - for (final Future future : schemaFuture) { - try { - future.get(); - } catch (final ExecutionException | InterruptedException e) { - LOGGER.warn(DataNodeMiscMessages.EXCEPTION_EXECUTING_INTERNAL_SCHEMA_TASK, e); - statusList.add( - new TSStatus(TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode()) - .setMessage(e.toString())); - } - } - - if (hasFailure.get()) { - return RpcUtils.getStatus(statusList); - } else { - return statusList.stream() - .filter(tsStatus -> tsStatus.getCode() == TSStatusCode.SUCCESS_STATUS.getStatusCode()) - .findFirst() - .orElse(new TSStatus(TSStatusCode.ONLY_LOGICAL_VIEW.getStatusCode())); - } + return InternalSchemaTaskExecutor.executeSchemaBlackListTask( + consensusGroupIdList, executeOnOneRegion, schemaExecutor); } private TSStatus executeInternalSchemaTask( final List consensusGroupIdList, final Function executeOnOneRegion) { - // Not guarantee sequence - final List statusList = Collections.synchronizedList(new ArrayList<>()); - final AtomicBoolean hasFailure = new AtomicBoolean(false); - - final Set> schemaFuture = new HashSet<>(); - - consensusGroupIdList.forEach( - consensusGroupId -> - schemaFuture.add( - schemaExecutor.submit( - () -> { - final TSStatus status = executeOnOneRegion.apply(consensusGroupId); - if (status.getCode() != TSStatusCode.SUCCESS_STATUS.getStatusCode()) { - hasFailure.set(true); - } - statusList.add(status); - }))); - - for (final Future future : schemaFuture) { - try { - future.get(); - } catch (final ExecutionException | InterruptedException e) { - LOGGER.warn(DataNodeMiscMessages.EXCEPTION_EXECUTING_INTERNAL_SCHEMA_TASK, e); - statusList.add( - new TSStatus(TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode()) - .setMessage(e.toString())); - } - } - - if (hasFailure.get()) { - return RpcUtils.getStatus(statusList); - } else { - return RpcUtils.SUCCESS_STATUS; - } + return InternalSchemaTaskExecutor.executeInternalSchemaTask( + consensusGroupIdList, executeOnOneRegion, schemaExecutor); } @Override @@ -2092,7 +2026,9 @@ public TSStatus deleteDataForDropTable(final TDeleteDataOrDevicesForDropTableReq new DataRegionId(consensusGroupId.getId()), new RelationalDeleteDataNode( req.isSetProcedureId() - ? DropTableModProgress.planNodeId(req.getProcedureId()) + && req.isSetTrackModFileProgress() + && req.isTrackModFileProgress() + ? SchemaDeletionModProgress.dropTablePlanNodeId(req.getProcedureId()) : new PlanNodeId(""), new TableDeletionEntry( new DeletionPredicate(req.getTableName()), @@ -2105,18 +2041,21 @@ public TSStatus deleteDataForDropTable(final TDeleteDataOrDevicesForDropTableReq @Override public TGetDropTableModProgressResp getDropTableModProgress( final TGetDropTableModProgressReq req) { + final boolean clearProgress = req.isSetClearProgress() && req.isClearProgress(); final Map progress = new HashMap<>(); for (final TConsensusGroupId regionId : req.getRegionIdList()) { final DataRegion region = StorageEngine.getInstance().getDataRegion(new DataRegionId(regionId.getId())); if (region != null) { final TDropTableModProgress regionProgress = - region.getDropTableModProgress(req.getProcedureId()); + region.getDropTableModProgress(req.getProcedureId(), clearProgress); // Regions in the same deletion request execute sequentially. Report zero written and // an unknown total until this region starts, so other regions' live counts are visible. - progress.put( - regionId.getId(), - regionProgress == null ? new TDropTableModProgress(0) : regionProgress); + if (regionProgress != null) { + progress.put(regionId.getId(), regionProgress); + } else if (!clearProgress) { + progress.put(regionId.getId(), new TDropTableModProgress(0)); + } } } return new TGetDropTableModProgressResp(StatusUtils.OK).setRegionProgress(progress); @@ -2322,7 +2261,10 @@ public TSStatus deleteColumnData(final TDeleteColumnDataReq req) { new DataRegionId(consensusGroupId.getId()), new RelationalDeleteDataNode( req.isSetProcedureId() - ? DropTableModProgress.planNodeId(req.getProcedureId()) + && req.isSetTrackModFileProgress() + && req.isTrackModFileProgress() + ? SchemaDeletionModProgress.dropTablePlanNodeId( + req.getProcedureId()) : new PlanNodeId(""), new TableDeletionEntry( new DeletionPredicate( diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/InternalSchemaTaskExecutor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/InternalSchemaTaskExecutor.java new file mode 100644 index 0000000000000..bc8a19c29c56c --- /dev/null +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/InternalSchemaTaskExecutor.java @@ -0,0 +1,108 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.iotdb.db.protocol.thrift.impl; + +import org.apache.iotdb.common.rpc.thrift.TConsensusGroupId; +import org.apache.iotdb.common.rpc.thrift.TSStatus; +import org.apache.iotdb.db.i18n.DataNodeMiscMessages; +import org.apache.iotdb.rpc.RpcUtils; +import org.apache.iotdb.rpc.TSStatusCode; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Future; +import java.util.function.Function; + +final class InternalSchemaTaskExecutor { + private static final Logger LOGGER = LoggerFactory.getLogger(InternalSchemaTaskExecutor.class); + + private InternalSchemaTaskExecutor() {} + + static TSStatus executeSchemaBlackListTask( + final List consensusGroupIdList, + final Function executeOnOneRegion, + final ExecutorService executor) { + final List statusList = + executeTasksInOrder(consensusGroupIdList, executeOnOneRegion, executor); + if (statusList.stream() + .anyMatch( + status -> + status.getCode() != TSStatusCode.SUCCESS_STATUS.getStatusCode() + && status.getCode() != TSStatusCode.ONLY_LOGICAL_VIEW.getStatusCode())) { + return RpcUtils.getStatus(statusList); + } + return statusList.stream() + .filter(status -> status.getCode() == TSStatusCode.SUCCESS_STATUS.getStatusCode()) + .findFirst() + .orElse(new TSStatus(TSStatusCode.ONLY_LOGICAL_VIEW.getStatusCode())); + } + + static TSStatus executeInternalSchemaTask( + final List consensusGroupIdList, + final Function executeOnOneRegion, + final ExecutorService executor) { + final List statusList = + executeTasksInOrder(consensusGroupIdList, executeOnOneRegion, executor); + return statusList.stream() + .allMatch(status -> status.getCode() == TSStatusCode.SUCCESS_STATUS.getStatusCode()) + ? RpcUtils.SUCCESS_STATUS + : RpcUtils.getStatus(statusList); + } + + private static List executeTasksInOrder( + final List consensusGroupIdList, + final Function executeOnOneRegion, + final ExecutorService executor) { + final List> schemaFutures = new ArrayList<>(consensusGroupIdList.size()); + for (final TConsensusGroupId consensusGroupId : consensusGroupIdList) { + schemaFutures.add( + executor.submit( + () -> Objects.requireNonNull(executeOnOneRegion.apply(consensusGroupId)))); + } + + final List statusList = new ArrayList<>(schemaFutures.size()); + boolean interrupted = false; + for (final Future future : schemaFutures) { + while (true) { + try { + statusList.add(future.get()); + break; + } catch (final InterruptedException e) { + interrupted = true; + } catch (final ExecutionException e) { + LOGGER.warn(DataNodeMiscMessages.EXCEPTION_EXECUTING_INTERNAL_SCHEMA_TASK, e); + statusList.add( + new TSStatus(TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode()) + .setMessage(e.toString())); + break; + } + } + } + if (interrupted) { + Thread.currentThread().interrupt(); + } + return statusList; + } +} diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/sys/ShowDeleteTimeSeriesProgressTask.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/sys/ShowDeleteTimeSeriesProgressTask.java index efc6bf9ae2488..f90eb7d1b60be 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/sys/ShowDeleteTimeSeriesProgressTask.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/sys/ShowDeleteTimeSeriesProgressTask.java @@ -54,7 +54,9 @@ public static void buildTsBlock( TSDataType.TEXT, TSDataType.TEXT, TSDataType.TEXT, - TSDataType.TEXT)); + TSDataType.TEXT, + TSDataType.INT64, + TSDataType.INT64)); for (TDeleteTimeSeriesProcedureInfo info : procedures == null ? Collections.emptyList() : procedures) { builder.getTimeColumnBuilder().writeLong(0); @@ -78,6 +80,16 @@ public static void buildTsBlock( } else { builder.getColumnBuilder(5).appendNull(); } + if (info.isSetWrittenModFileCount()) { + builder.getColumnBuilder(6).writeLong(info.getWrittenModFileCount()); + } else { + builder.getColumnBuilder(6).appendNull(); + } + if (info.isSetRemainingModFileCount()) { + builder.getColumnBuilder(7).writeLong(info.getRemainingModFileCount()); + } else { + builder.getColumnBuilder(7).appendNull(); + } builder.declarePosition(); } future.set( diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/pipe/PipeEnrichedDeleteDataNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/pipe/PipeEnrichedDeleteDataNode.java index e7e38db013246..1210e5cf25c7c 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/pipe/PipeEnrichedDeleteDataNode.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/pipe/PipeEnrichedDeleteDataNode.java @@ -72,6 +72,16 @@ public void markAsGeneratedByPipe() { deleteDataNode.markAsGeneratedByPipe(); } + @Override + public boolean isGeneratedByRemoteConsensusLeader() { + return deleteDataNode.isGeneratedByRemoteConsensusLeader(); + } + + @Override + public void markAsGeneratedByRemoteConsensusLeader() { + deleteDataNode.markAsGeneratedByRemoteConsensusLeader(); + } + @Override public PlanNodeId getPlanNodeId() { return deleteDataNode.getPlanNodeId(); diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/write/AbstractDeleteDataNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/write/AbstractDeleteDataNode.java index e2d94bee22520..3b65bf83a8963 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/write/AbstractDeleteDataNode.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/write/AbstractDeleteDataNode.java @@ -34,6 +34,7 @@ public abstract class AbstractDeleteDataNode extends SearchNode implements WALEntryValue { protected TRegionReplicaSet regionReplicaSet; protected ProgressIndex progressIndex; + private boolean isGeneratedByRemoteConsensusLeader; protected AbstractDeleteDataNode(PlanNodeId id) { super(id); @@ -41,6 +42,15 @@ protected AbstractDeleteDataNode(PlanNodeId id) { public abstract ByteBuffer serializeToDAL(); + @Override + public void markAsGeneratedByRemoteConsensusLeader() { + isGeneratedByRemoteConsensusLeader = true; + } + + public boolean isGeneratedByRemoteConsensusLeader() { + return isGeneratedByRemoteConsensusLeader; + } + public static AbstractDeleteDataNode deserializeFromDAL( ByteBuffer byteBuffer, boolean isRelational) { if (isRelational) { diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java index e4bf8bddd4cac..be3ea4d6f107e 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java @@ -127,9 +127,9 @@ import org.apache.iotdb.db.storageengine.dataregion.memtable.IMemTable; import org.apache.iotdb.db.storageengine.dataregion.memtable.TsFileProcessor; import org.apache.iotdb.db.storageengine.dataregion.memtable.TsFileProcessorInfo; -import org.apache.iotdb.db.storageengine.dataregion.modification.DropTableModProgress; import org.apache.iotdb.db.storageengine.dataregion.modification.ModEntry; import org.apache.iotdb.db.storageengine.dataregion.modification.ModificationFile; +import org.apache.iotdb.db.storageengine.dataregion.modification.SchemaDeletionModProgress; import org.apache.iotdb.db.storageengine.dataregion.modification.TableDeletionEntry; import org.apache.iotdb.db.storageengine.dataregion.modification.TagPredicate; import org.apache.iotdb.db.storageengine.dataregion.modification.TreeDeletionEntry; @@ -307,9 +307,8 @@ public class DataRegion implements IDataRegionForQuery { /** Data region has been deleted or not. */ private volatile boolean deleted = false; - // Only the latest drop is retained per region. The ConfigNode captures its final counters - // before the dedicated DROP TABLE worker executes another procedure's DELETE_DATA state. - private volatile Pair dropTableModProgress; + private final Map modFileDeletionProgress = + new ConcurrentHashMap<>(); /** closeStorageGroupCondition is used to wait for all currently closing TsFiles to be done. */ private final Object closeStorageGroupCondition = new Object(); @@ -3420,6 +3419,14 @@ private void getTwoKindsOfTsFiles( public void deleteByDevice(final MeasurementPath pattern, final DeleteDataNode node) throws IOException, WriteProcessRejectException { + deleteByDevice(pattern, node, null); + } + + public void deleteByDevice( + final MeasurementPath pattern, + final DeleteDataNode node, + final SchemaDeletionModProgress progress) + throws IOException, WriteProcessRejectException { if (SettleService.getINSTANCE().getFilesToBeSettledCount().get() != 0) { throw new IOException( StorageEngineMessages @@ -3471,7 +3478,7 @@ public void deleteByDevice(final MeasurementPath pattern, final DeleteDataNode n writeUnlock(); hasReleasedLock = true; - deleteDataInSealedFiles(sealedTsFileResource, deletion); + deleteDataInSealedFiles(sealedTsFileResource, deletion, progress); } catch (WriteProcessRejectException e) { throw e; } catch (Exception e) { @@ -3484,8 +3491,26 @@ public void deleteByDevice(final MeasurementPath pattern, final DeleteDataNode n } public TDropTableModProgress getDropTableModProgress(final long procedureId) { - final Pair progress = dropTableModProgress; - return progress != null && progress.left == procedureId ? progress.right.snapshot() : null; + return getDropTableModProgress(procedureId, false); + } + + public TDropTableModProgress getDropTableModProgress( + final long procedureId, final boolean clearProgress) { + final SchemaDeletionModProgress progress = + clearProgress + ? modFileDeletionProgress.remove(procedureId) + : modFileDeletionProgress.get(procedureId); + return progress == null ? null : progress.snapshot(); + } + + public SchemaDeletionModProgress startTimeSeriesModProgress(final PlanNodeId planNodeId) { + final long procedureId = SchemaDeletionModProgress.procedureId(planNodeId); + if (procedureId < 0) { + return null; + } + final SchemaDeletionModProgress progress = SchemaDeletionModProgress.forTimeSeries(); + modFileDeletionProgress.put(procedureId, progress); + return progress; } public void deleteByTable(RelationalDeleteDataNode node) @@ -3502,9 +3527,12 @@ public void deleteByTable(RelationalDeleteDataNode node) } List modEntries = node.getModEntries(); - final long procedureId = DropTableModProgress.procedureId(node.getPlanNodeId()); - final DropTableModProgress progress = - procedureId >= 0 && modEntries.size() == 1 ? new DropTableModProgress() : null; + final long procedureId = + node.isGeneratedByRemoteConsensusLeader() + ? -1 + : SchemaDeletionModProgress.procedureId(node.getPlanNodeId()); + final SchemaDeletionModProgress progress = + procedureId >= 0 && modEntries.size() == 1 ? new SchemaDeletionModProgress() : null; logger.info(StorageEngineMessages.DELETION_EXECUTING_TABLE_DELETION, node); @@ -3518,7 +3546,7 @@ public void deleteByTable(RelationalDeleteDataNode node) ioTConsensusDeletionAdmitted = true; } if (progress != null) { - dropTableModProgress = new Pair<>(procedureId, progress); + modFileDeletionProgress.put(procedureId, progress); } if (deleted) { if (progress != null) { @@ -3632,6 +3660,12 @@ public void deleteByTable(RelationalDeleteDataNode node) public void deleteDataDirectly(MeasurementPath pathToDelete, DeleteDataNode node) throws IOException, WriteProcessRejectException { + deleteDataDirectly(pathToDelete, node, null); + } + + public void deleteDataDirectly( + MeasurementPath pathToDelete, DeleteDataNode node, SchemaDeletionModProgress progress) + throws IOException, WriteProcessRejectException { final long startTime = node.getDeleteStartTime(); final long endTime = node.getDeleteEndTime(); final long searchIndex = node.getSearchIndex(); @@ -3665,7 +3699,7 @@ public void deleteDataDirectly(MeasurementPath pathToDelete, DeleteDataNode node List sealedTsFileResource = new ArrayList<>(); List unsealedTsFileResource = new ArrayList<>(); getTwoKindsOfTsFiles(sealedTsFileResource, unsealedTsFileResource, startTime, endTime); - deleteDataDirectlyInFile(unsealedTsFileResource, deletion); + deleteDataDirectlyInFile(unsealedTsFileResource, deletion, progress); // capture deleteDataNode and wait it to be persisted to DAL. DeletionResource deletionResource = PipeInsertionDataNodeListener.getInstance() @@ -3676,7 +3710,7 @@ public void deleteDataDirectly(MeasurementPath pathToDelete, DeleteDataNode node } writeUnlock(); releasedLock = true; - deleteDataDirectlyInFile(sealedTsFileResource, deletion); + deleteDataDirectlyInFile(sealedTsFileResource, deletion, progress); } catch (WriteProcessRejectException e) { throw e; } catch (Exception e) { @@ -3946,13 +3980,10 @@ private void deleteDataInUnsealedFiles( } } - private void deleteDataInSealedFiles(Collection sealedTsFiles, ModEntry deletion) - throws IOException { - deleteDataInSealedFiles(sealedTsFiles, deletion, null); - } - private void deleteDataInSealedFiles( - Collection sealedTsFiles, ModEntry deletion, DropTableModProgress progress) + Collection sealedTsFiles, + ModEntry deletion, + SchemaDeletionModProgress progress) throws IOException { Set involvedModificationFiles = new HashSet<>(); List deletedByMods = new ArrayList<>(); @@ -4088,7 +4119,7 @@ private void deleteDataInSealedFiles( } } - if (progress != null) { + if (progress != null && deletion instanceof TableDeletionEntry) { progress.setTotalModFileCount(involvedModificationFiles.size()); } @@ -4105,7 +4136,7 @@ private void deleteDataInSealedFiles( modFile.write(deletion); modFile.close(); if (progress != null) { - progress.modFileWritten(); + progress.modFileWritten(modFile); } } catch (Exception e) { return e; @@ -4154,7 +4185,10 @@ private void deleteTsFileCompletely(List tsfileResourceList) { } } - private void deleteDataDirectlyInFile(List tsfileResourceList, ModEntry modEntry) + private void deleteDataDirectlyInFile( + List tsfileResourceList, + ModEntry modEntry, + SchemaDeletionModProgress progress) throws IOException { List deletedByMods = new ArrayList<>(); List deletedByFiles = new ArrayList<>(); @@ -4175,6 +4209,9 @@ private void deleteDataDirectlyInFile(List tsfileResourceList, M // The file size may be smaller than the original file, so the increment here may be // negative involvedModificationFile.close(); + if (progress != null) { + progress.modFileWritten(involvedModificationFile); + } logger.debug( StorageEngineMessages.STORAGE_LOG_DELETION_DELETION_WRITTEN_INTO_MODS_FILE_F5E26D2A, modEntry, diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/modification/DropTableModProgress.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/modification/SchemaDeletionModProgress.java similarity index 53% rename from iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/modification/DropTableModProgress.java rename to iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/modification/SchemaDeletionModProgress.java index edf6e850fa0fa..1159eabb9bc7c 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/modification/DropTableModProgress.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/modification/SchemaDeletionModProgress.java @@ -22,28 +22,41 @@ import org.apache.iotdb.commons.queryengine.plan.planner.plan.node.PlanNodeId; import org.apache.iotdb.mpp.rpc.thrift.TDropTableModProgress; -/** - * Counts the distinct mod files processed by one region's current table or column deletion attempt. - */ -public class DropTableModProgress { - private static final String PLAN_NODE_ID_PREFIX = "drop-table-"; +import java.io.File; +import java.util.HashSet; +import java.util.Set; + +/** Counts the distinct mod files processed by one region's schema deletion attempt. */ +public class SchemaDeletionModProgress { + private static final String DROP_TABLE_PLAN_NODE_ID_PREFIX = "drop-table-"; + private static final String DELETE_TIMESERIES_PLAN_NODE_ID_PREFIX = "delete-timeseries-"; private long totalModFileCount = -1; private long writtenModFileCount; + private Set writtenModFiles; - public static PlanNodeId planNodeId(final long procedureId) { + public static PlanNodeId dropTablePlanNodeId(final long procedureId) { // PlanNodeId already travels through consensus. Reuse it so observability does not change // the deletion plan, WAL or DAL serialization formats. - return new PlanNodeId(PLAN_NODE_ID_PREFIX + procedureId); + return new PlanNodeId(DROP_TABLE_PLAN_NODE_ID_PREFIX + procedureId); + } + + public static PlanNodeId deleteTimeSeriesPlanNodeId(final long procedureId) { + return new PlanNodeId(DELETE_TIMESERIES_PLAN_NODE_ID_PREFIX + procedureId); } public static long procedureId(final PlanNodeId planNodeId) { final String id = planNodeId.getId(); - if (!id.startsWith(PLAN_NODE_ID_PREFIX)) { + final String prefix; + if (id.startsWith(DROP_TABLE_PLAN_NODE_ID_PREFIX)) { + prefix = DROP_TABLE_PLAN_NODE_ID_PREFIX; + } else if (id.startsWith(DELETE_TIMESERIES_PLAN_NODE_ID_PREFIX)) { + prefix = DELETE_TIMESERIES_PLAN_NODE_ID_PREFIX; + } else { return -1; } try { - return Long.parseLong(id.substring(PLAN_NODE_ID_PREFIX.length())); + return Long.parseLong(id.substring(prefix.length())); } catch (final NumberFormatException e) { return -1; } @@ -53,8 +66,23 @@ public synchronized void setTotalModFileCount(final long totalModFileCount) { this.totalModFileCount = totalModFileCount; } - public synchronized void modFileWritten() { - ++writtenModFileCount; + public static SchemaDeletionModProgress forTimeSeries() { + final SchemaDeletionModProgress progress = new SchemaDeletionModProgress(); + progress.writtenModFiles = new HashSet<>(); + return progress; + } + + public synchronized void modFileWritten(final ModificationFile modFile) { + if (writtenModFiles == null || writtenModFiles.add(modFile.getFile())) { + ++writtenModFileCount; + } + } + + public synchronized void finishTimeSeriesDeletion(final boolean succeeded) { + if (succeeded) { + totalModFileCount = writtenModFileCount; + } + writtenModFiles = null; } public synchronized TDropTableModProgress snapshot() { diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/consensus/statemachine/dataregion/DataExecutionVisitorTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/consensus/statemachine/dataregion/DataExecutionVisitorTest.java index 8d754bb3d10ce..60fcf8878a4f1 100644 --- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/consensus/statemachine/dataregion/DataExecutionVisitorTest.java +++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/consensus/statemachine/dataregion/DataExecutionVisitorTest.java @@ -114,7 +114,9 @@ public void testTreeDeleteFailureReturnsMessage() throws Exception { Mockito.when(dataRegion.getDatabaseName()).thenReturn("root.sg"); final DeleteDataNode node = createDeleteDataNode("root.sg.device.s1"); final IOException failure = new IOException("injected tree delete failure"); - Mockito.doThrow(failure).when(dataRegion).deleteByDevice(any(MeasurementPath.class), any()); + Mockito.doThrow(failure) + .when(dataRegion) + .deleteByDevice(any(MeasurementPath.class), any(), any()); final TSStatus status = new DataExecutionVisitor().visitDeleteData(node, dataRegion); @@ -142,7 +144,8 @@ public void testTreeDeleteIllegalPathDoesNotLogStackTrace() throws Exception { Assert.assertTrue(appender.list.get(0).getFormattedMessage().contains(failure.getMessage())); Assert.assertNull(appender.list.get(0).getThrowableProxy()); Mockito.verify(dataRegion).writeUnlock(); - Mockito.verify(dataRegion, Mockito.never()).deleteByDevice(any(MeasurementPath.class), any()); + Mockito.verify(dataRegion, Mockito.never()) + .deleteByDevice(any(MeasurementPath.class), any(), any()); } @Test @@ -151,7 +154,9 @@ public void testDirectTreeDeleteFailureReturnsMessage() throws Exception { Mockito.when(dataRegion.getDatabaseName()).thenReturn("root.sg"); final DeleteDataNode node = createDeleteDataNode("root.sg.**"); final IOException failure = new IOException("injected direct delete failure"); - Mockito.doThrow(failure).when(dataRegion).deleteDataDirectly(any(MeasurementPath.class), any()); + Mockito.doThrow(failure) + .when(dataRegion) + .deleteDataDirectly(any(MeasurementPath.class), any(), any()); final TSStatus status = new DataExecutionVisitor().visitDeleteData(node, dataRegion); diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalSchemaTaskTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalSchemaTaskTest.java new file mode 100644 index 0000000000000..126064ff783b4 --- /dev/null +++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalSchemaTaskTest.java @@ -0,0 +1,128 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.iotdb.db.protocol.thrift.impl; + +import org.apache.iotdb.common.rpc.thrift.TConsensusGroupId; +import org.apache.iotdb.common.rpc.thrift.TConsensusGroupType; +import org.apache.iotdb.common.rpc.thrift.TSStatus; +import org.apache.iotdb.rpc.TSStatusCode; + +import org.junit.Test; + +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; + +import static org.junit.Assert.assertEquals; + +public class DataNodeInternalSchemaTaskTest { + @Test + public void preservesRegionOrderWhenTasksCompleteOutOfOrder() throws Exception { + final TConsensusGroupId firstRegion = new TConsensusGroupId(TConsensusGroupType.DataRegion, 1); + final TConsensusGroupId secondRegion = new TConsensusGroupId(TConsensusGroupType.DataRegion, 2); + final CountDownLatch secondFinished = new CountDownLatch(1); + final ExecutorService executor = Executors.newFixedThreadPool(2); + try { + final TSStatus status = + InternalSchemaTaskExecutor.executeInternalSchemaTask( + Arrays.asList(firstRegion, secondRegion), + region -> { + if (region.equals(firstRegion)) { + try { + if (!secondFinished.await(5, TimeUnit.SECONDS)) { + throw new IllegalStateException("Second region did not finish"); + } + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new IllegalStateException(e); + } + return new TSStatus(TSStatusCode.WRITE_PROCESS_ERROR.getStatusCode()); + } + secondFinished.countDown(); + return new TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode()); + }, + executor); + + assertEquals(TSStatusCode.MULTIPLE_ERROR.getStatusCode(), status.getCode()); + final List subStatus = status.getSubStatus(); + assertEquals(2, subStatus.size()); + assertEquals(TSStatusCode.WRITE_PROCESS_ERROR.getStatusCode(), subStatus.get(0).getCode()); + assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), subStatus.get(1).getCode()); + } finally { + executor.shutdownNow(); + } + } + + @Test + public void taskExceptionIsReportedAsRegionFailure() { + final TConsensusGroupId firstRegion = new TConsensusGroupId(TConsensusGroupType.DataRegion, 1); + final TConsensusGroupId secondRegion = new TConsensusGroupId(TConsensusGroupType.DataRegion, 2); + final ExecutorService executor = Executors.newFixedThreadPool(2); + try { + final TSStatus status = + InternalSchemaTaskExecutor.executeInternalSchemaTask( + Arrays.asList(firstRegion, secondRegion), + region -> { + if (region.equals(firstRegion)) { + throw new IllegalStateException("Injected region failure"); + } + return new TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode()); + }, + executor); + + assertEquals(TSStatusCode.MULTIPLE_ERROR.getStatusCode(), status.getCode()); + final List subStatus = status.getSubStatus(); + assertEquals(2, subStatus.size()); + assertEquals(TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), subStatus.get(0).getCode()); + assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), subStatus.get(1).getCode()); + } finally { + executor.shutdownNow(); + } + } + + @Test + public void schemaBlacklistTaskExceptionIsReportedAsFailure() { + final TConsensusGroupId firstRegion = new TConsensusGroupId(TConsensusGroupType.DataRegion, 1); + final TConsensusGroupId secondRegion = new TConsensusGroupId(TConsensusGroupType.DataRegion, 2); + final ExecutorService executor = Executors.newFixedThreadPool(2); + try { + final TSStatus status = + InternalSchemaTaskExecutor.executeSchemaBlackListTask( + Arrays.asList(firstRegion, secondRegion), + region -> { + if (region.equals(firstRegion)) { + throw new IllegalStateException("Injected region failure"); + } + return new TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode()); + }, + executor); + + assertEquals(TSStatusCode.MULTIPLE_ERROR.getStatusCode(), status.getCode()); + final List subStatus = status.getSubStatus(); + assertEquals(2, subStatus.size()); + assertEquals(TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), subStatus.get(0).getCode()); + assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), subStatus.get(1).getCode()); + } finally { + executor.shutdownNow(); + } + } +} diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/write/RelationalDeleteDataNodeTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/write/RelationalDeleteDataNodeTest.java index bcbc490ea2a39..e37418dec24c9 100644 --- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/write/RelationalDeleteDataNodeTest.java +++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/write/RelationalDeleteDataNodeTest.java @@ -24,7 +24,7 @@ import org.apache.iotdb.commons.queryengine.plan.planner.plan.node.PlanNodeId; import org.apache.iotdb.commons.queryengine.plan.planner.plan.node.PlanNodeType; import org.apache.iotdb.db.storageengine.dataregion.modification.DeletionPredicate; -import org.apache.iotdb.db.storageengine.dataregion.modification.DropTableModProgress; +import org.apache.iotdb.db.storageengine.dataregion.modification.SchemaDeletionModProgress; import org.apache.iotdb.db.storageengine.dataregion.modification.TableDeletionEntry; import org.apache.iotdb.db.storageengine.dataregion.modification.TagPredicate.And; import org.apache.iotdb.db.storageengine.dataregion.modification.TagPredicate.FullExactMatch; @@ -52,21 +52,21 @@ public class RelationalDeleteDataNodeTest { public void testDropTableProcedureIdSurvivesConsensusSerialization() throws IOException { final RelationalDeleteDataNode node = new RelationalDeleteDataNode( - DropTableModProgress.planNodeId(42), + SchemaDeletionModProgress.dropTablePlanNodeId(42), new TableDeletionEntry( new DeletionPredicate("table"), new TimeRange(Long.MIN_VALUE, Long.MAX_VALUE)), null); assertEquals( 42, - DropTableModProgress.procedureId( + SchemaDeletionModProgress.procedureId( PlanNodeType.deserialize(node.serializeToByteBuffer()).getPlanNodeId())); final ByteArrayOutputStream bytes = new ByteArrayOutputStream(); node.serialize(new DataOutputStream(bytes)); assertEquals( 42, - DropTableModProgress.procedureId( + SchemaDeletionModProgress.procedureId( PlanNodeType.deserialize(ByteBuffer.wrap(bytes.toByteArray())).getPlanNodeId())); - assertEquals(-1, DropTableModProgress.procedureId(new PlanNodeId("query-plan"))); + assertEquals(-1, SchemaDeletionModProgress.procedureId(new PlanNodeId("query-plan"))); } @Test diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/dataregion/DataRegionTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/dataregion/DataRegionTest.java index cc33dfd9abc9b..aeec33e56438d 100644 --- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/dataregion/DataRegionTest.java +++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/dataregion/DataRegionTest.java @@ -37,6 +37,7 @@ import org.apache.iotdb.commons.utils.TimePartitionUtils; import org.apache.iotdb.db.conf.IoTDBConfig; import org.apache.iotdb.db.conf.IoTDBDescriptor; +import org.apache.iotdb.db.consensus.statemachine.dataregion.DataExecutionVisitor; import org.apache.iotdb.db.exception.BatchProcessException; import org.apache.iotdb.db.exception.DataRegionException; import org.apache.iotdb.db.exception.DataTypeInconsistentException; @@ -75,9 +76,9 @@ import org.apache.iotdb.db.storageengine.dataregion.memtable.ReadOnlyMemChunk; import org.apache.iotdb.db.storageengine.dataregion.memtable.TsFileProcessor; import org.apache.iotdb.db.storageengine.dataregion.modification.DeletionPredicate; -import org.apache.iotdb.db.storageengine.dataregion.modification.DropTableModProgress; import org.apache.iotdb.db.storageengine.dataregion.modification.ModEntry; import org.apache.iotdb.db.storageengine.dataregion.modification.ModificationFile; +import org.apache.iotdb.db.storageengine.dataregion.modification.SchemaDeletionModProgress; import org.apache.iotdb.db.storageengine.dataregion.modification.TableDeletionEntry; import org.apache.iotdb.db.storageengine.dataregion.modification.TagPredicate.NOP; import org.apache.iotdb.db.storageengine.dataregion.modification.TreeDeletionEntry; @@ -2689,7 +2690,9 @@ public void testTableDeletionFallsBackToModsForCompactingFile() throws Exception new TimeRange(Long.MIN_VALUE, Long.MAX_VALUE)); dataRegion.deleteByTable( new RelationalDeleteDataNode( - DropTableModProgress.planNodeId(42), deletionEntry, dataRegion.getDatabaseName())); + SchemaDeletionModProgress.dropTablePlanNodeId(42), + deletionEntry, + dataRegion.getDatabaseName())); Assert.assertEquals( new TDropTableModProgress(1).setRemainingModFileCount(0), @@ -2825,6 +2828,138 @@ public void testDropTableModProgressDoesNotCountFailedClose() throws Exception { } } + @Test + public void testTimeSeriesDeletionCountsDistinctModFiles() throws Exception { + final String secondMeasurement = "s1"; + final TSRecord record = new TSRecord(deviceId, 1); + record.addTuple(DataPoint.getDataPoint(TSDataType.INT32, measurementId, "10")); + record.addTuple(DataPoint.getDataPoint(TSDataType.INT32, secondMeasurement, "20")); + dataRegion.insert(buildInsertRowNodeByTSRecord(record)); + dataRegion.syncCloseAllWorkingTsFileProcessors(); + final TsFileResource resource = dataRegion.getTsFileManager().getTsFileList(true).get(0); + final ModificationFile modFile = Mockito.spy(resource.getModFileForWrite()); + resource.setExclusiveModFile(modFile); + final long procedureId = 48; + final AtomicInteger closeCount = new AtomicInteger(); + Mockito.doAnswer( + invocation -> { + if (closeCount.incrementAndGet() == 2) { + Assert.assertEquals( + new TDropTableModProgress(1), dataRegion.getDropTableModProgress(procedureId)); + } + return invocation.callRealMethod(); + }) + .when(modFile) + .close(); + + final DeleteDataNode deletion = + new DeleteDataNode( + SchemaDeletionModProgress.deleteTimeSeriesPlanNodeId(procedureId), + Arrays.asList( + new MeasurementPath(deviceId, measurementId), + new MeasurementPath(deviceId, secondMeasurement)), + Long.MIN_VALUE, + Long.MAX_VALUE); + final TSStatus status = new DataExecutionVisitor().visitDeleteData(deletion, dataRegion); + Assert.assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), status.getCode()); + Assert.assertEquals(2, closeCount.get()); + Assert.assertEquals(2, resource.getAllModEntries().size()); + Assert.assertEquals( + new TDropTableModProgress(1).setRemainingModFileCount(0), + dataRegion.getDropTableModProgress(procedureId, true)); + Assert.assertNull(dataRegion.getDropTableModProgress(procedureId)); + } + + @Test + public void testRemoteConsensusTimeSeriesDeletionDoesNotRetainProgress() throws Exception { + final TSRecord record = new TSRecord(deviceId, 1); + record.addTuple(DataPoint.getDataPoint(TSDataType.INT32, measurementId, "10")); + dataRegion.insert(buildInsertRowNodeByTSRecord(record)); + dataRegion.syncCloseAllWorkingTsFileProcessors(); + + final long procedureId = 50; + final DeleteDataNode deletion = + new DeleteDataNode( + SchemaDeletionModProgress.deleteTimeSeriesPlanNodeId(procedureId), + Collections.singletonList(new MeasurementPath(deviceId, measurementId)), + Long.MIN_VALUE, + Long.MAX_VALUE); + deletion.markAsGeneratedByRemoteConsensusLeader(); + + final TSStatus status = new DataExecutionVisitor().visitDeleteData(deletion, dataRegion); + + Assert.assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), status.getCode()); + Assert.assertNull(dataRegion.getDropTableModProgress(procedureId)); + } + + @Test + public void testRemoteConsensusTableDeletionDoesNotRetainProgress() throws Exception { + dataRegion.insertTablet(genInsertTabletNode(10, 0)); + dataRegion.syncCloseAllWorkingTsFileProcessors(); + + final long procedureId = 51; + final RelationalDeleteDataNode deletion = dropTableNode(procedureId); + deletion.markAsGeneratedByRemoteConsensusLeader(); + + final TSStatus status = new DataExecutionVisitor().visitDeleteData(deletion, dataRegion); + + Assert.assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), status.getCode()); + Assert.assertNull(dataRegion.getDropTableModProgress(procedureId)); + } + + @Test + public void testFailedTimeSeriesDeletionKeepsRemainingCountUnknownAndCanBeCleared() + throws Exception { + final TSRecord record = new TSRecord(deviceId, 1); + record.addTuple(DataPoint.getDataPoint(TSDataType.INT32, measurementId, "10")); + dataRegion.insert(buildInsertRowNodeByTSRecord(record)); + dataRegion.syncCloseAllWorkingTsFileProcessors(); + final TsFileResource resource = dataRegion.getTsFileManager().getTsFileList(true).get(0); + final ModificationFile modFile = Mockito.spy(resource.getModFileForWrite()); + resource.setExclusiveModFile(modFile); + Mockito.doThrow(new IOException()).when(modFile).close(); + + final long procedureId = 49; + final DeleteDataNode deletion = + new DeleteDataNode( + SchemaDeletionModProgress.deleteTimeSeriesPlanNodeId(procedureId), + Collections.singletonList(new MeasurementPath(deviceId, measurementId)), + Long.MIN_VALUE, + Long.MAX_VALUE); + try { + final TSStatus status = new DataExecutionVisitor().visitDeleteData(deletion, dataRegion); + Assert.assertEquals(TSStatusCode.WRITE_PROCESS_ERROR.getStatusCode(), status.getCode()); + final TDropTableModProgress progress = dataRegion.getDropTableModProgress(procedureId); + Assert.assertEquals(0, progress.getWrittenModFileCount()); + Assert.assertFalse(progress.isSetRemainingModFileCount()); + Assert.assertEquals(progress, dataRegion.getDropTableModProgress(procedureId, true)); + Assert.assertNull(dataRegion.getDropTableModProgress(procedureId)); + } finally { + Mockito.doCallRealMethod().when(modFile).close(); + modFile.close(); + } + } + + @Test + public void testActiveTimeSeriesModProgressIsNotEvicted() { + final long firstProcedureId = 1000; + final int progressCount = 129; + for (int index = 0; index < progressCount; index++) { + final long procedureId = firstProcedureId + index; + dataRegion.startTimeSeriesModProgress( + SchemaDeletionModProgress.deleteTimeSeriesPlanNodeId(procedureId)); + } + + Assert.assertEquals( + new TDropTableModProgress(0), dataRegion.getDropTableModProgress(firstProcedureId)); + + for (int index = 0; index < progressCount; index++) { + final long procedureId = firstProcedureId + index; + Assert.assertNotNull(dataRegion.getDropTableModProgress(procedureId, true)); + Assert.assertNull(dataRegion.getDropTableModProgress(procedureId)); + } + } + @Test public void testDropTableModProgressWithoutModFiles() throws Exception { dataRegion.deleteByTable(dropTableNode(45)); @@ -2838,13 +2973,16 @@ public void testDropTableModProgressWithoutModFiles() throws Exception { Assert.assertFalse(resource.getTsFile().exists()); Assert.assertEquals( new TDropTableModProgress(0).setRemainingModFileCount(0), - dataRegion.getDropTableModProgress(46)); + dataRegion.getDropTableModProgress(45, true)); Assert.assertNull(dataRegion.getDropTableModProgress(45)); + Assert.assertEquals( + new TDropTableModProgress(0).setRemainingModFileCount(0), + dataRegion.getDropTableModProgress(46)); } private RelationalDeleteDataNode dropTableNode(final long procedureId) { return new RelationalDeleteDataNode( - DropTableModProgress.planNodeId(procedureId), + SchemaDeletionModProgress.dropTablePlanNodeId(procedureId), new TableDeletionEntry( new DeletionPredicate(StatementTestUtils.tableName()), new TimeRange(Long.MIN_VALUE, Long.MAX_VALUE)), @@ -3056,7 +3194,9 @@ public void testDropColumnModFileProgress() throws Exception { new TimeRange(Long.MIN_VALUE, Long.MAX_VALUE)); dataRegion.deleteByTable( new RelationalDeleteDataNode( - DropTableModProgress.planNodeId(47), deletion, dataRegion.getDatabaseName())); + SchemaDeletionModProgress.dropTablePlanNodeId(47), + deletion, + dataRegion.getDatabaseName())); Assert.assertEquals( new TDropTableModProgress(1).setRemainingModFileCount(0), dataRegion.getDropTableModProgress(47)); diff --git a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/schema/column/ColumnHeaderConstant.java b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/schema/column/ColumnHeaderConstant.java index 4f0c475c9c2a6..fe4e7cdd42a35 100644 --- a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/schema/column/ColumnHeaderConstant.java +++ b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/schema/column/ColumnHeaderConstant.java @@ -696,7 +696,9 @@ private ColumnHeaderConstant() { new ColumnHeader(PATHS, TSDataType.TEXT), new ColumnHeader(STATE, TSDataType.TEXT), new ColumnHeader("Progress", TSDataType.TEXT), - new ColumnHeader("ErrorMessage", TSDataType.TEXT)); + new ColumnHeader("ErrorMessage", TSDataType.TEXT), + new ColumnHeader("WrittenModFileCount", TSDataType.INT64), + new ColumnHeader("RemainingModFileCount", TSDataType.INT64)); public static final List showRepairDataPartitionTableProgressColumnHeaders = ImmutableList.of( diff --git a/iotdb-protocol/thrift-confignode/src/main/thrift/confignode.thrift b/iotdb-protocol/thrift-confignode/src/main/thrift/confignode.thrift index 0dcd274ae43e4..a34e21ac68d8d 100644 --- a/iotdb-protocol/thrift-confignode/src/main/thrift/confignode.thrift +++ b/iotdb-protocol/thrift-confignode/src/main/thrift/confignode.thrift @@ -997,6 +997,8 @@ struct TDeleteTimeSeriesProcedureInfo { 4: required string state 5: required string progress 6: optional string errorMessage + 7: optional i64 writtenModFileCount + 8: optional i64 remainingModFileCount } struct TShowDeleteTimeSeriesProceduresResp { diff --git a/iotdb-protocol/thrift-datanode/src/main/thrift/datanode.thrift b/iotdb-protocol/thrift-datanode/src/main/thrift/datanode.thrift index 8e2335fab0cf7..2fad2308cc567 100644 --- a/iotdb-protocol/thrift-datanode/src/main/thrift/datanode.thrift +++ b/iotdb-protocol/thrift-datanode/src/main/thrift/datanode.thrift @@ -397,12 +397,14 @@ struct TDeleteColumnDataReq { 3: required string columnName, 4: required bool isAttributeColumn 5: optional i64 procedureId + 6: optional bool trackModFileProgress } struct TDeleteDataOrDevicesForDropTableReq { 1: required list regionIdList 2: required string tableName 3: optional i64 procedureId + 4: optional bool trackModFileProgress } struct TDropTableModProgress { @@ -414,6 +416,7 @@ struct TDropTableModProgress { struct TGetDropTableModProgressReq { 1: required i64 procedureId 2: required list regionIdList + 3: optional bool clearProgress } struct TGetDropTableModProgressResp { @@ -515,6 +518,8 @@ struct TDeleteDataForDeleteSchemaReq { 1: required list dataRegionIdList 2: required binary pathPatternTree 3: optional bool isGeneratedByPipe + 4: optional i64 procedureId + 5: optional bool trackModFileProgress } struct TDeleteTimeSeriesReq { From 064980f9b6eec4b3f5d227547379ad9ec2fdbd81 Mon Sep 17 00:00:00 2001 From: Caideyipi <87789683+Caideyipi@users.noreply.github.com> Date: Fri, 20 Nov 2026 20:07:47 +0800 Subject: [PATCH 2/2] Fix C++ tests for asynchronous timeseries deletion --- .../client-cpp/test/cpp/sessionCIT.cpp | 120 +++++++++++++++--- .../client-cpp/test/cpp/sessionIT.cpp | 99 ++++++++++++--- 2 files changed, 183 insertions(+), 36 deletions(-) diff --git a/iotdb-client/client-cpp/test/cpp/sessionCIT.cpp b/iotdb-client/client-cpp/test/cpp/sessionCIT.cpp index 08aace0ca93ca..c7db4f641e451 100644 --- a/iotdb-client/client-cpp/test/cpp/sessionCIT.cpp +++ b/iotdb-client/client-cpp/test/cpp/sessionCIT.cpp @@ -19,14 +19,104 @@ #include "catch.hpp" #include "SessionC.h" +#include +#include #include #include #include +#include +#include #include +#include #include extern CSession* g_session; +static std::string lastErrorMessage() { + const char* message = ts_get_last_error(); + return message == nullptr ? "unknown error" : message; +} + +static int64_t latestDeleteTimeSeriesProcedureId(CSession* session) { + CSessionDataSet* rawDataSet = nullptr; + if (ts_session_execute_query(session, "SHOW DELETE TIMESERIES PROGRESS", &rawDataSet) != TS_OK) { + throw std::runtime_error(lastErrorMessage()); + } + if (rawDataSet == nullptr) { + throw std::runtime_error("SHOW DELETE TIMESERIES PROGRESS returned no dataset"); + } + std::unique_ptr dataSet(rawDataSet, + ts_dataset_destroy); + int64_t latestId = -1; + while (ts_dataset_has_next(dataSet.get())) { + std::unique_ptr record( + ts_dataset_next(dataSet.get()), ts_row_record_destroy); + if (!record) { + throw std::runtime_error(lastErrorMessage()); + } + latestId = std::max(latestId, ts_row_record_get_int64(record.get(), 0)); + } + return latestId; +} + +static void waitForDeleteTimeSeriesProcedure(CSession* session, int64_t previousId) { + const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(60); + do { + CSessionDataSet* rawDataSet = nullptr; + if (ts_session_execute_query(session, "SHOW DELETE TIMESERIES PROGRESS", &rawDataSet) != + TS_OK) { + throw std::runtime_error(lastErrorMessage()); + } + if (rawDataSet == nullptr) { + throw std::runtime_error("SHOW DELETE TIMESERIES PROGRESS returned no dataset"); + } + std::unique_ptr dataSet(rawDataSet, + ts_dataset_destroy); + while (ts_dataset_has_next(dataSet.get())) { + std::unique_ptr record( + ts_dataset_next(dataSet.get()), ts_row_record_destroy); + if (!record) { + throw std::runtime_error(lastErrorMessage()); + } + if (ts_row_record_get_int64(record.get(), 0) <= previousId) { + continue; + } + const char* stateValue = ts_row_record_get_string(record.get(), 3); + if (stateValue == nullptr) { + throw std::runtime_error("Delete timeseries progress returned a null state"); + } + const std::string state(stateValue); + if (state == "ROLLEDBACK") { + const char* errorValue = ts_row_record_get_string(record.get(), 5); + throw std::runtime_error(std::string("Asynchronous timeseries deletion rolled back: ") + + (errorValue == nullptr ? "unknown error" : errorValue)); + } + if (state == "SUCCESS") { + return; + } + } + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + } while (std::chrono::steady_clock::now() < deadline); + throw std::runtime_error("Timed out waiting for asynchronous timeseries deletion"); +} + +static void deleteTimeseriesAndWait(CSession* session, const char* path) { + const int64_t previousId = latestDeleteTimeSeriesProcedureId(session); + if (ts_session_delete_timeseries(session, path) != TS_OK) { + throw std::runtime_error(lastErrorMessage()); + } + waitForDeleteTimeSeriesProcedure(session, previousId); +} + +static void deleteTimeseriesBatchAndWait(CSession* session, int pathCount, + const char* const* paths) { + const int64_t previousId = latestDeleteTimeSeriesProcedureId(session); + if (ts_session_delete_timeseries_batch(session, paths, pathCount) != TS_OK) { + throw std::runtime_error(lastErrorMessage()); + } + waitForDeleteTimeSeriesProcedure(session, previousId); +} + static int global_test_id = 0; class CaseReporter { @@ -51,7 +141,7 @@ static void dropTimeseriesIfExists(CSession* session, const char* path) { bool exists = false; REQUIRE(ts_session_check_timeseries_exists(session, path, &exists) == TS_OK); if (exists) { - REQUIRE(ts_session_delete_timeseries(session, path) == TS_OK); + deleteTimeseriesAndWait(session, path); } } @@ -100,14 +190,14 @@ TEST_CASE("C API - Create timeseries", "[c_createTimeseries]") { bool exists = false; REQUIRE(ts_session_check_timeseries_exists(g_session, path, &exists) == TS_OK); REQUIRE(exists); - REQUIRE(ts_session_delete_timeseries(g_session, path) == TS_OK); + deleteTimeseriesAndWait(g_session, path); } TEST_CASE("C API - Delete timeseries", "[c_deleteTimeseries]") { CaseReporter cr("c_deleteTimeseries"); const char* path = "root.ctest.d1.s1"; ensureTimeseries(g_session, path, TS_TYPE_INT64, TS_ENCODING_RLE, TS_COMPRESSION_SNAPPY); - REQUIRE(ts_session_delete_timeseries(g_session, path) == TS_OK); + deleteTimeseriesAndWait(g_session, path); bool exists = true; REQUIRE(ts_session_check_timeseries_exists(g_session, path, &exists) == TS_OK); REQUIRE_FALSE(exists); @@ -384,7 +474,7 @@ TEST_CASE("C API - Multi-node session", "[c_multiNode]") { bool exists = false; REQUIRE(ts_session_check_timeseries_exists(localSession, path, &exists) == TS_OK); REQUIRE(exists); - REQUIRE(ts_session_delete_timeseries(localSession, path) == TS_OK); + deleteTimeseriesAndWait(localSession, path); ts_session_close(localSession); ts_session_destroy(localSession); @@ -478,8 +568,8 @@ TEST_CASE("C API - Database and extended timeseries APIs", "[c_dbTimeseries]") { dropTimeseriesIfExists(g_session, pathsM[i]); } REQUIRE(ts_session_create_multi_timeseries(g_session, 2, pathsM, tsM, encM, compM) == TS_OK); - REQUIRE(ts_session_delete_timeseries_batch(g_session, pathsM, 2) == TS_OK); - REQUIRE(ts_session_delete_timeseries(g_session, pathEx) == TS_OK); + deleteTimeseriesBatchAndWait(g_session, 2, pathsM); + deleteTimeseriesAndWait(g_session, pathEx); REQUIRE(ts_session_delete_database(g_session, sgEx) == TS_OK); } @@ -782,14 +872,14 @@ TEST_CASE("C API - RowRecord and delete data APIs", "[c_rowDelete]") { const char* delPaths[] = {pi, pf}; REQUIRE(ts_session_delete_data_range(g_session, 2, delPaths, 400LL, 600LL) == TS_OK); - REQUIRE(ts_session_delete_timeseries(g_session, pb) == TS_OK); - REQUIRE(ts_session_delete_timeseries(g_session, pi) == TS_OK); - REQUIRE(ts_session_delete_timeseries(g_session, pf) == TS_OK); - REQUIRE(ts_session_delete_timeseries(g_session, pd) == TS_OK); - REQUIRE(ts_session_delete_timeseries(g_session, pt) == TS_OK); - REQUIRE(ts_session_delete_timeseries(g_session, pstr) == TS_OK); - REQUIRE(ts_session_delete_timeseries(g_session, pdate) == TS_OK); - REQUIRE(ts_session_delete_timeseries(g_session, pblob) == TS_OK); + deleteTimeseriesAndWait(g_session, pb); + deleteTimeseriesAndWait(g_session, pi); + deleteTimeseriesAndWait(g_session, pf); + deleteTimeseriesAndWait(g_session, pd); + deleteTimeseriesAndWait(g_session, pt); + deleteTimeseriesAndWait(g_session, pstr); + deleteTimeseriesAndWait(g_session, pdate); + deleteTimeseriesAndWait(g_session, pblob); REQUIRE(ts_session_delete_database(g_session, sg) == TS_OK); } @@ -820,5 +910,5 @@ TEST_CASE("C API - Query DATE 1000-01-01", "[c_dateMinYear]") { ts_row_record_destroy(record); ts_dataset_destroy(dataSet); - REQUIRE(ts_session_delete_timeseries(g_session, path) == TS_OK); + deleteTimeseriesAndWait(g_session, path); } diff --git a/iotdb-client/client-cpp/test/cpp/sessionIT.cpp b/iotdb-client/client-cpp/test/cpp/sessionIT.cpp index 2a0ec6cb7f82b..d8e222092a10c 100644 --- a/iotdb-client/client-cpp/test/cpp/sessionIT.cpp +++ b/iotdb-client/client-cpp/test/cpp/sessionIT.cpp @@ -27,7 +27,9 @@ #include "TsBlock.h" #include "common_types.h" +#include #include +#include #include #include #include @@ -36,12 +38,67 @@ using namespace std; extern std::shared_ptr session; +static int64_t latestDeleteTimeSeriesProcedureId(Session* target) { + unique_ptr dataSet = + target->executeQueryStatement("SHOW DELETE TIMESERIES PROGRESS"); + int64_t latestId = -1; + while (dataSet->hasNext()) { + const auto fields = dataSet->next()->fields; + if (!fields[0].longV.is_initialized()) { + throw runtime_error("Delete timeseries progress returned a null procedure ID"); + } + latestId = max(latestId, fields[0].longV.value()); + } + return latestId; +} + +static void waitForDeleteTimeSeriesProcedure(Session* target, int64_t previousId) { + const auto deadline = chrono::steady_clock::now() + chrono::seconds(60); + do { + unique_ptr dataSet = + target->executeQueryStatement("SHOW DELETE TIMESERIES PROGRESS"); + while (dataSet->hasNext()) { + const auto fields = dataSet->next()->fields; + if (!fields[0].longV.is_initialized() || fields[0].longV.value() <= previousId) { + continue; + } + if (!fields[3].stringV.is_initialized()) { + throw runtime_error("Delete timeseries progress returned a null state"); + } + const string state = fields[3].stringV.value(); + if (state == "ROLLEDBACK") { + const string error = fields[5].stringV.is_initialized() + ? fields[5].stringV.value() + : "unknown error"; + throw runtime_error("Asynchronous timeseries deletion rolled back: " + error); + } + if (state == "SUCCESS") { + return; + } + } + this_thread::sleep_for(chrono::milliseconds(20)); + } while (chrono::steady_clock::now() < deadline); + throw runtime_error("Timed out waiting for asynchronous timeseries deletion"); +} + +static void deleteTimeseriesAndWait(Session* target, const string& path) { + const int64_t previousId = latestDeleteTimeSeriesProcedureId(target); + target->deleteTimeseries(path); + waitForDeleteTimeSeriesProcedure(target, previousId); +} + +static void executeDeleteTimeseriesAndWait(Session* target, const string& sql) { + const int64_t previousId = latestDeleteTimeSeriesProcedureId(target); + target->executeNonQueryStatement(sql); + waitForDeleteTimeSeriesProcedure(target, previousId); +} + static vector testTimeseries = {"root.test.d1.s1", "root.test.d1.s2", "root.test.d1.s3"}; void prepareTimeseries() { for (const string& timeseries : testTimeseries) { if (session->checkTimeseriesExists(timeseries)) { - session->deleteTimeseries(timeseries); + deleteTimeseriesAndWait(session.get(), timeseries); } session->createTimeseries(timeseries, TSDataType::INT64, TSEncoding::RLE, CompressionType::SNAPPY); @@ -71,7 +128,7 @@ TEST_CASE("Create timeseries success", "[createTimeseries]") { CompressionType::SNAPPY); } REQUIRE(session->checkTimeseriesExists("root.test.d1.s1") == true); - session->deleteTimeseries("root.test.d1.s1"); + deleteTimeseriesAndWait(session.get(), "root.test.d1.s1"); } TEST_CASE("Login Test - Authentication failed with error code 801", "[Authentication]") { @@ -98,7 +155,7 @@ TEST_CASE("Test Session constructor with nodeUrls", "[SessionInitAndOperate]") { CompressionType::SNAPPY); } REQUIRE(localSession->checkTimeseriesExists("root.test.d1.s1") == true); - localSession->deleteTimeseries("root.test.d1.s1"); + deleteTimeseriesAndWait(localSession.get(), "root.test.d1.s1"); localSession->close(); } @@ -115,7 +172,7 @@ TEST_CASE("Test Session builder with nodeUrls", "[SessionBuilderInit]") { CompressionType::SNAPPY); } REQUIRE(session->checkTimeseriesExists("root.test.d1.s1") == true); - session->deleteTimeseries("root.test.d1.s1"); + deleteTimeseriesAndWait(session.get(), "root.test.d1.s1"); session->close(); } @@ -126,7 +183,7 @@ TEST_CASE("Delete timeseries success", "[deleteTimeseries]") { CompressionType::SNAPPY); } REQUIRE(session->checkTimeseriesExists("root.test.d1.s1") == true); - session->deleteTimeseries("root.test.d1.s1"); + deleteTimeseriesAndWait(session.get(), "root.test.d1.s1"); REQUIRE(session->checkTimeseriesExists("root.test.d1.s1") == false); } @@ -214,7 +271,7 @@ TEST_CASE("Test insertRecord with types ", "[testTypedInsertRecord]") { for (size_t i = 0; i < timeseries.size(); i++) { if (session->checkTimeseriesExists(timeseries[i])) { - session->deleteTimeseries(timeseries[i]); + deleteTimeseriesAndWait(session.get(), timeseries[i]); } session->createTimeseries(timeseries[i], types[i], TSEncoding::RLE, CompressionType::SNAPPY); } @@ -249,7 +306,7 @@ TEST_CASE("Test insertRecord with new datatypes ", "[testTypedInsertRecordNewDat for (size_t i = 0; i < timeseries.size(); i++) { if (session->checkTimeseriesExists(timeseries[i])) { - session->deleteTimeseries(timeseries[i]); + deleteTimeseriesAndWait(session.get(), timeseries[i]); } session->createTimeseries(timeseries[i], types[i], TSEncoding::PLAIN, CompressionType::SNAPPY); } @@ -292,7 +349,7 @@ TEST_CASE("Test insertRecords with types ", "[testTypedInsertRecords]") { for (size_t i = 0; i < timeseries.size(); i++) { if (session->checkTimeseriesExists(timeseries[i])) { - session->deleteTimeseries(timeseries[i]); + deleteTimeseriesAndWait(session.get(), timeseries[i]); } session->createTimeseries(timeseries[i], types[i], TSEncoding::RLE, CompressionType::SNAPPY); } @@ -336,7 +393,7 @@ TEST_CASE("Test insertRecordsOfOneDevice", "[testInsertRecordsOfOneDevice]") { for (size_t i = 0; i < timeseries.size(); i++) { if (session->checkTimeseriesExists(timeseries[i])) { - session->deleteTimeseries(timeseries[i]); + deleteTimeseriesAndWait(session.get(), timeseries[i]); } session->createTimeseries(timeseries[i], types[i], TSEncoding::RLE, CompressionType::SNAPPY); } @@ -442,7 +499,7 @@ TEST_CASE("Test insertTablets ", "[testInsertTablets]") { "root.test.d2.s1", "root.test.d2.s2", "root.test.d2.s3"}; for (const string& timeseries : testTimeseries) { if (session->checkTimeseriesExists(timeseries)) { - session->deleteTimeseries(timeseries); + deleteTimeseriesAndWait(session.get(), timeseries); } session->createTimeseries(timeseries, TSDataType::INT64, TSEncoding::RLE, CompressionType::SNAPPY); @@ -503,7 +560,7 @@ TEST_CASE("Test insertTablet multi datatype", "[testInsertTabletMultiDatatype]") for (int i = 0; i < 4; i++) { auto timeseries = deviceId + "." + measurements[i]; if (session->checkTimeseriesExists(timeseries)) { - session->deleteTimeseries(timeseries); + deleteTimeseriesAndWait(session.get(), timeseries); } session->createTimeseries(timeseries, dataTypes[i], TSEncoding::PLAIN, CompressionType::UNCOMPRESSED); @@ -553,7 +610,7 @@ TEST_CASE("Test boolean column via DataIterator", "[testBooleanColumnDataIterato string timeseries = "root.test.d1.s1"; if (session->checkTimeseriesExists(timeseries)) { - session->deleteTimeseries(timeseries); + deleteTimeseriesAndWait(session.get(), timeseries); } session->createTimeseries(timeseries, TSDataType::BOOLEAN, TSEncoding::PLAIN, CompressionType::SNAPPY); @@ -581,7 +638,7 @@ TEST_CASE("Test boolean column via DataIterator", "[testBooleanColumnDataIterato count++; } REQUIRE(count == 10); - session->deleteTimeseries(timeseries); + deleteTimeseriesAndWait(session.get(), timeseries); } TEST_CASE("Test Last query ", "[testLastQuery]") { @@ -850,7 +907,7 @@ TEST_CASE("Fast Last Query returns all series under a tree prefix", "[fastLastQu "root.test.fast_last_cpp.d2.s1"}; for (const auto& path : paths) { if (session->checkTimeseriesExists(path)) { - session->deleteTimeseries(path); + deleteTimeseriesAndWait(session.get(), path); } session->createTimeseries(path, TSDataType::INT64, TSEncoding::RLE, CompressionType::SNAPPY); @@ -887,7 +944,7 @@ TEST_CASE("Fast Last Query returns all series under a tree prefix", "[fastLastQu std::invalid_argument); for (const auto& path : paths) { - session->deleteTimeseries(path); + deleteTimeseriesAndWait(session.get(), path); } } @@ -1005,7 +1062,7 @@ TEST_CASE("SessionPool basic borrow/insert/query via RAII lease", "[sessionPool] { PooledSession s = pool->getSession(); try { - s->executeNonQueryStatement("delete timeseries root.test.pool.d1.*"); + executeDeleteTimeseriesAndWait(&*s, "delete timeseries root.test.pool.d1.*"); } catch (const std::exception&) { // Ignore: the timeseries may not exist yet on a fresh database. } @@ -1029,7 +1086,7 @@ TEST_CASE("SessionPool basic borrow/insert/query via RAII lease", "[sessionPool] { PooledSession s = pool->getSession(); - s->executeNonQueryStatement("delete timeseries root.test.pool.d1.*"); + executeDeleteTimeseriesAndWait(&*s, "delete timeseries root.test.pool.d1.*"); } pool->close(); } @@ -1047,7 +1104,7 @@ TEST_CASE("SessionPool is safe under concurrent writers", "[sessionPool]") { { PooledSession s = pool->getSession(); try { - s->executeNonQueryStatement("delete timeseries root.test.pool.d2.*"); + executeDeleteTimeseriesAndWait(&*s, "delete timeseries root.test.pool.d2.*"); } catch (const std::exception&) { // Ignore: the timeseries may not exist yet on a fresh database. } @@ -1094,7 +1151,7 @@ TEST_CASE("SessionPool is safe under concurrent writers", "[sessionPool]") { { PooledSession s = pool->getSession(); - s->executeNonQueryStatement("delete timeseries root.test.pool.d2.*"); + executeDeleteTimeseriesAndWait(&*s, "delete timeseries root.test.pool.d2.*"); } pool->close(); } @@ -1128,7 +1185,7 @@ TEST_CASE("Query DATE 1000-01-01", "[dateMinYear]") { CaseReporter cr("dateMinYear"); const string timeseries = "root.test.d1.s_date_min"; if (session->checkTimeseriesExists(timeseries)) { - session->deleteTimeseries(timeseries); + deleteTimeseriesAndWait(session.get(), timeseries); } session->createTimeseries(timeseries, TSDataType::DATE, TSEncoding::PLAIN, CompressionType::SNAPPY); @@ -1149,5 +1206,5 @@ TEST_CASE("Query DATE 1000-01-01", "[dateMinYear]") { REQUIRE(record->fields[0].dateV.value() == dateValue); REQUIRE(record->fields[0].dateV.value().toIsoExtendedString() == "1000-01-01"); - session->deleteTimeseries(timeseries); + deleteTimeseriesAndWait(session.get(), timeseries); }