jt2594838 commented on code in PR #18821:
URL: https://github.com/apache/iotdb/pull/18821#discussion_r4244266243
##########
iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/executor/RegionWriteExecutorTest.java:
##########
@@ -22,32 +22,299 @@
import org.apache.iotdb.common.rpc.thrift.TSStatus;
import org.apache.iotdb.commons.consensus.ConsensusGroupId;
import org.apache.iotdb.commons.consensus.DataRegionId;
+import org.apache.iotdb.commons.consensus.SchemaRegionId;
import org.apache.iotdb.commons.exception.IllegalPathException;
+import org.apache.iotdb.commons.path.MeasurementPath;
import org.apache.iotdb.commons.path.PartialPath;
import org.apache.iotdb.commons.queryengine.plan.planner.plan.node.PlanNodeId;
+import
org.apache.iotdb.commons.schema.view.viewExpression.leaf.TimeSeriesViewOperand;
+import org.apache.iotdb.consensus.ConsensusFactory;
import org.apache.iotdb.consensus.IConsensus;
import org.apache.iotdb.consensus.exception.ConsensusException;
+import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.protocol.thrift.impl.DataNodeRegionManager;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.node.WritePlanNode;
+import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.metadata.write.AlterTimeSeriesNode;
+import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.metadata.write.InternalCreateMultiTimeSeriesNode;
+import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.metadata.write.InternalCreateTimeSeriesNode;
+import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.metadata.write.MeasurementGroup;
+import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.metadata.write.view.CreateLogicalViewNode;
+import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.pipe.PipeEnrichedWritePlanNode;
import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.write.InsertRowNode;
+import
org.apache.iotdb.db.queryengine.plan.relational.planner.node.schema.CreateOrUpdateTableDeviceNode;
+import
org.apache.iotdb.db.queryengine.plan.statement.metadata.AlterTimeSeriesStatement.AlterType;
import org.apache.iotdb.db.schemaengine.SchemaEngine;
+import org.apache.iotdb.db.schemaengine.schemaregion.ISchemaRegion;
import org.apache.iotdb.db.schemaengine.template.ClusterTemplateManager;
import org.apache.iotdb.db.trigger.executor.TriggerFireResult;
import org.apache.iotdb.db.trigger.executor.TriggerFireVisitor;
import org.apache.iotdb.rpc.TSStatusCode;
import org.apache.iotdb.trigger.api.enums.TriggerEvent;
import org.apache.tsfile.enums.TSDataType;
+import org.apache.tsfile.file.metadata.enums.CompressionType;
+import org.apache.tsfile.file.metadata.enums.TSEncoding;
+import org.apache.tsfile.utils.Pair;
import org.junit.Test;
import org.mockito.Mockito;
+import java.util.Collections;
+import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantReadWriteLock;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
public class RegionWriteExecutorTest {
+ @Test
+ public void testAlterTimeSeriesRegionAvailability() throws Exception {
+ // Alter validation fetches the measurement before consensus; a missing
region must be
+ // retryable.
+ checkSchemaWriteWithRegionAvailability(
+ new AlterTimeSeriesNode(
+ new PlanNodeId("alter"),
+ new MeasurementPath("root.sg.d.s"),
+ AlterType.ADD_TAGS,
+ Collections.singletonMap("tag", "value"),
+ null,
+ null,
+ null,
+ false));
+ }
+
+ @Test
+ public void testCreateLogicalViewRegionAvailability() throws Exception {
+ // Ratis checks target existence locally. SimpleConsensus must retain its
direct write path.
+ checkSchemaWriteWithRegionAvailability(
+ new CreateLogicalViewNode(
+ new PlanNodeId("view"),
+ Collections.singletonMap(
+ new MeasurementPath("root.sg.d.v"), new
TimeSeriesViewOperand("root.sg.d.s"))));
+ }
+
+ @Test
+ public void testCreateOrUpdateTableDeviceRegionAvailability() throws
Exception {
+ // Table-device quota validation has the same missing-region window as
tree auto-creation.
+ checkSchemaWriteWithRegionAvailability(
+ new CreateOrUpdateTableDeviceNode(
+ new PlanNodeId("table"),
+ "db",
+ "table1",
+ Collections.singletonList(new Object[] {"device1"}),
+ Collections.emptyList(),
+ Collections.singletonList(new Object[0])));
+ }
+
+ private void checkSchemaWriteWithRegionAvailability(final WritePlanNode
node) throws Exception {
+ final String originalProtocol =
+
IoTDBDescriptor.getInstance().getConfig().getSchemaRegionConsensusProtocolClass();
+ try {
+ for (String protocol :
+ new String[] {ConsensusFactory.RATIS_CONSENSUS,
ConsensusFactory.SIMPLE_CONSENSUS}) {
+
IoTDBDescriptor.getInstance().getConfig().setSchemaRegionConsensusProtocolClass(protocol);
+ for (boolean available : new boolean[] {false, true}) {
+ for (boolean fromPipe : new boolean[] {false, true}) {
+ final IConsensus consensus = Mockito.mock(IConsensus.class);
+ final DataNodeRegionManager regionManager =
Mockito.mock(DataNodeRegionManager.class);
+ final SchemaEngine schemaEngine = Mockito.mock(SchemaEngine.class);
+ final SchemaRegionId regionId = new SchemaRegionId(1);
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ // Retain the lock even when the region has already been cleared
during shutdown.
+
Mockito.when(regionManager.getRegionLock(regionId)).thenReturn(lock);
+ final ISchemaRegion region = Mockito.mock(ISchemaRegion.class);
+ Mockito.when(schemaEngine.getSchemaRegion(regionId))
+ .thenReturn(available ? region : null);
+ if (node instanceof AlterTimeSeriesNode alterNode) {
+ Mockito.when(region.fetchMeasurementPath(alterNode.getPath()))
+ .thenReturn(new MeasurementPath("root.sg.d.s",
TSDataType.INT64));
+ }
+ final RegionWriteExecutor executor =
+ new RegionWriteExecutor(
+ Mockito.mock(IConsensus.class),
+ consensus,
+ regionManager,
+ schemaEngine,
+ Mockito.mock(ClusterTemplateManager.class),
+ Mockito.mock(TriggerFireVisitor.class));
+ final WritePlanNode request = fromPipe ? new
PipeEnrichedWritePlanNode(node) : node;
+ Mockito.when(consensus.write(regionId, request))
+ .thenReturn(new
TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode()));
+
+ final boolean validatesRegion =
+ !(node instanceof CreateLogicalViewNode)
+ || ConsensusFactory.RATIS_CONSENSUS.equals(protocol);
+ final boolean accepted = available || !validatesRegion;
+ final RegionExecutionResult result = executor.execute(regionId,
request);
+ assertEquals(accepted, result.isAccepted());
+ assertEquals(
+ (accepted ? TSStatusCode.SUCCESS_STATUS :
TSStatusCode.NO_AVAILABLE_REGION_GROUP)
+ .getStatusCode(),
+ result.getStatus().getCode());
+ assertFalse(lock.isWriteLocked());
+ assertEquals(0, lock.getReadLockCount());
+ if (accepted) {
+ Mockito.verify(consensus).write(regionId, request);
+ if (node instanceof AlterTimeSeriesNode alterNode) {
+
Mockito.verify(region).fetchMeasurementPath(alterNode.getPath());
+ } else if (node instanceof CreateOrUpdateTableDeviceNode
tableNode) {
+ Mockito.verify(region)
+ .checkSchemaQuota(tableNode.getTableName(),
tableNode.getDeviceIdList());
+ } else if (validatesRegion) {
+ Mockito.verify(region)
+ .checkMeasurementExistence(
+ new PartialPath("root.sg.d"),
Collections.singletonList("v"), null);
+ }
+ } else {
+ Mockito.verifyZeroInteractions(consensus);
+ assertEquals(result.getMessage(),
result.getStatus().getMessage());
+ }
+ }
+ }
+ }
+ } finally {
+ IoTDBDescriptor.getInstance()
+ .getConfig()
+ .setSchemaRegionConsensusProtocolClass(originalProtocol);
+ }
+ }
+
+ @Test
+ public void testInternalCreateTimeSeriesAfterSchemaRegionCleared() throws
Exception {
+ // A shutdown can clear the region while its validation lock remains
registered.
+ checkInternalCreateWithRegionAvailability(false, false);
+ }
+
+ @Test
+ public void testInternalCreateMultiTimeSeriesAfterSchemaRegionCleared()
throws Exception {
+ // Batch and Pipe auto-creation must return a retryable status for the
same shutdown window.
+ checkInternalCreateWithRegionAvailability(true, false);
+ }
+
+ @Test
+ public void testInternalCreateWithAvailableSchemaRegion() throws Exception {
+ // The guard must preserve quota checks and consensus writes for both
live-region requests.
+ checkInternalCreateWithRegionAvailability(false, true);
+ checkInternalCreateWithRegionAvailability(true, true);
+ }
+
+ @Test
+ public void testSchemaWriteWhenRegionIsClearedAfterLookup() throws Exception
{
Review Comment:
Covers the previously missing interleaving: lookup returns a region, its
MTree is cleared, and local validation then throws while the lock still exists.
The test checks that execution returns retryable 906 and never enters consensus.
##########
iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/executor/RegionWriteExecutor.java:
##########
@@ -933,6 +938,9 @@ private RegionExecutionResult executeAlterTimeSeries(
AlterTimeSeriesNode node, WritePlanNodeExecutionContext context,
boolean receivedFromPipe) {
ISchemaRegion schemaRegion =
schemaEngine.getSchemaRegion((SchemaRegionId) context.getRegionId());
+ if (schemaRegion == null) {
+ return createSchemaRegionUnavailableResult();
+ }
Review Comment:
Addressed in 705d388aa9b. SchemaEngine now publishes its teardown state
before clearing regions, RegionWriteExecutor returns retryable
NO_AVAILABLE_REGION_GROUP for in-flight schema-write failures during teardown,
and RegionWriteExecutorTest covers the after-lookup/clear interleaving.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]