This is an automated email from the ASF dual-hosted git repository.

Caideyipi pushed a commit to branch dev/1.3
in repository https://gitbox.apache.org/repos/asf/iotdb.git


The following commit(s) were added to refs/heads/dev/1.3 by this push:
     new 0cd29819227 [To dev/1.3] Fix automatic LOAD retries during region 
recovery (#19156)
0cd29819227 is described below

commit 0cd2981922721f22cca74a951993a6ec5dea1be5
Author: Caideyipi <[email protected]>
AuthorDate: Fri Nov 6 16:58:01 2026 +0800

    [To dev/1.3] Fix automatic LOAD retries during region recovery (#19156)
    
    * Fix automatic LOAD retries during region recovery (#19098)
    
    * Fix automatic LOAD retries during region recovery
    
    * Preserve wrapped region recovery errors during LOAD
    
    * Clarify region-unavailable LOAD retry semantics
    
    (cherry picked from commit 3ffe2958758ac2a7d9c372cc5e282d264e818eb2)
    
    * Adapt LOAD recovery CP to 1.3 TsFile API
    
    * Preserve LOAD conversion priority in 1.3 backport
    
    * Avoid PowerMock reflect dependency in LOAD tests
---
 .../plan/analyze/load/LoadTsFileAnalyzer.java      |  37 +++++
 .../load/LoadTsFileAnalyzerDiagnosticsTest.java    | 163 ++++++++++++++++++++-
 2 files changed, 199 insertions(+), 1 deletion(-)

diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzer.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzer.java
index 4cdf80d5416..7dfd99ca628 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzer.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzer.java
@@ -27,6 +27,8 @@ import 
org.apache.iotdb.commons.client.exception.ClientManagerException;
 import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.consensus.ConfigRegionId;
 import org.apache.iotdb.commons.exception.IllegalPathException;
+import org.apache.iotdb.commons.exception.IoTDBException;
+import org.apache.iotdb.commons.exception.IoTDBRuntimeException;
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.commons.path.PatternTreeMap;
 import org.apache.iotdb.commons.schema.SchemaConstant;
@@ -591,6 +593,18 @@ public class LoadTsFileAnalyzer implements AutoCloseable {
 
   private boolean setTemporaryUnavailableStatusIfNecessary(
       final Analysis analysis, final Throwable throwable) {
+    // Region unavailability can persist beyond recovery. Retain the file for 
retry; permanent
+    // region loss still requires operator intervention.
+    if (throwable instanceof IoTDBRuntimeException
+        && ((IoTDBRuntimeException) throwable).getErrorCode()
+            == TSStatusCode.NO_AVAILABLE_REGION_GROUP.getStatusCode()) {
+      analysis.setFinishQueryAfterAnalyze(true);
+      analysis.setFailStatus(
+          RpcUtils.getStatus(
+              TSStatusCode.LOAD_TEMPORARY_UNAVAILABLE_EXCEPTION, 
throwable.getMessage()));
+      analysis.setStatement(loadTsFileStatement);
+      return true;
+    }
     if (isTemporaryUnavailableDueToPipeSchemaNotReady(throwable)) {
       setFailAnalysisForTemporaryUnavailablePipeSchema(analysis, throwable);
       return true;
@@ -849,6 +863,7 @@ public class LoadTsFileAnalyzer implements AutoCloseable {
         if (isTemporaryUnavailableDueToPipeSchemaNotReady(e)) {
           throw e;
         }
+        rethrowIfUnavailableRegion(e);
         LOGGER.warn("Auto create or verify schema error.", e);
         throw new SemanticException(
             String.format(
@@ -858,6 +873,7 @@ public class LoadTsFileAnalyzer implements AutoCloseable {
         if (e.getCause() instanceof LoadAnalyzeTypeMismatchException && 
isConvertOnTypeMismatch) {
           throw (LoadAnalyzeTypeMismatchException) e.getCause();
         }
+        rethrowIfUnavailableRegion(e);
         LOGGER.warn("Auto create or verify schema error.", e);
         throw new SemanticException(
             String.format(
@@ -866,6 +882,27 @@ public class LoadTsFileAnalyzer implements AutoCloseable {
       }
     }
 
+    private void rethrowIfUnavailableRegion(final Exception e) {
+      // Preserve retryable region errors through the analyzer's schema-error 
wrapper.
+      Throwable current = e;
+      while (current != null) {
+        if (current instanceof IoTDBRuntimeException
+            && ((IoTDBRuntimeException) current).getErrorCode()
+                == TSStatusCode.NO_AVAILABLE_REGION_GROUP.getStatusCode()) {
+          throw (IoTDBRuntimeException) current;
+        }
+        if (current instanceof IoTDBException
+            && ((IoTDBException) current).getErrorCode()
+                == TSStatusCode.NO_AVAILABLE_REGION_GROUP.getStatusCode()) {
+          throw new IoTDBRuntimeException(
+              current.getMessage(),
+              current,
+              TSStatusCode.NO_AVAILABLE_REGION_GROUP.getStatusCode());
+        }
+        current = current.getCause();
+      }
+    }
+
     private void makeSureNoDuplicatedMeasurementsInDevices() throws 
LoadAnalyzeException {
       for (final Map.Entry<IDeviceID, Set<MeasurementSchema>> entry :
           schemaCache.getDevice2TimeSeries().entrySet()) {
diff --git 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzerDiagnosticsTest.java
 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzerDiagnosticsTest.java
index 816b79bd013..6fe20c64bc2 100644
--- 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzerDiagnosticsTest.java
+++ 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzerDiagnosticsTest.java
@@ -21,17 +21,27 @@ package org.apache.iotdb.db.queryengine.plan.analyze.load;
 
 import org.apache.iotdb.common.rpc.thrift.TEndPoint;
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.commons.exception.IoTDBException;
+import org.apache.iotdb.commons.exception.IoTDBRuntimeException;
 import org.apache.iotdb.db.exception.LoadAnalyzeException;
+import org.apache.iotdb.db.exception.LoadAnalyzeTypeMismatchException;
+import org.apache.iotdb.db.exception.sql.SemanticException;
 import org.apache.iotdb.db.i18n.DataNodeQueryMessages;
 import org.apache.iotdb.db.queryengine.common.MPPQueryContext;
 import org.apache.iotdb.db.queryengine.common.QueryId;
 import org.apache.iotdb.db.queryengine.plan.analyze.Analysis;
 import org.apache.iotdb.db.queryengine.plan.analyze.IPartitionFetcher;
 import org.apache.iotdb.db.queryengine.plan.analyze.schema.ISchemaFetcher;
+import org.apache.iotdb.db.queryengine.plan.analyze.schema.SchemaValidator;
 import org.apache.iotdb.db.queryengine.plan.statement.crud.LoadTsFileStatement;
 import 
org.apache.iotdb.db.storageengine.load.converter.LoadTsFileDataTypeConverter;
 import org.apache.iotdb.rpc.TSStatusCode;
 
+import org.apache.tsfile.enums.TSDataType;
+import org.apache.tsfile.file.metadata.IDeviceID;
+import org.apache.tsfile.file.metadata.PlainDeviceID;
+import org.apache.tsfile.read.TsFileSequenceReader;
+import org.apache.tsfile.write.schema.MeasurementSchema;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Rule;
@@ -45,16 +55,20 @@ import 
org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.PowerMockRunner;
 
 import java.io.File;
+import java.io.FileOutputStream;
+import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Collections;
 import java.util.Optional;
 
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyList;
 import static org.mockito.Mockito.when;
 
 @RunWith(PowerMockRunner.class)
 @PowerMockIgnore({"com.sun.org.apache.xerces.*", "javax.xml.*", "org.xml.*", 
"javax.management.*"})
-@PrepareForTest(LoadTsFileAnalyzer.class)
+@PrepareForTest({LoadTsFileAnalyzer.class, SchemaValidator.class})
 public class LoadTsFileAnalyzerDiagnosticsTest {
 
   @Rule public TemporaryFolder temporaryFolder = new TemporaryFolder();
@@ -126,6 +140,153 @@ public class LoadTsFileAnalyzerDiagnosticsTest {
     Assert.assertTrue(status.getMessage().contains("missing WRITE_DATA 
privilege"));
   }
 
+  @Test
+  public void testUnavailableSchemaRegionsShouldRemainRetryable() throws 
Exception {
+    final TSStatus status = 
analyzeAfterSchemaFailure(TSStatusCode.NO_AVAILABLE_REGION_GROUP);
+
+    Assert.assertEquals(
+        TSStatusCode.LOAD_TEMPORARY_UNAVAILABLE_EXCEPTION.getStatusCode(), 
status.getCode());
+    Assert.assertTrue(status.getMessage().contains("schema request failed"));
+  }
+
+  @Test
+  public void testPermanentSchemaErrorShouldNotBecomeRetryable() throws 
Exception {
+    final TSStatus status = 
analyzeAfterSchemaFailure(TSStatusCode.METADATA_ERROR);
+
+    Assert.assertEquals(TSStatusCode.LOAD_FILE_ERROR.getStatusCode(), 
status.getCode());
+    Assert.assertTrue(status.getMessage().contains("schema request failed"));
+  }
+
+  @Test
+  public void testWrappedUnavailableSchemaRegionsShouldRemainRetryable() 
throws Exception {
+    final TSStatus status =
+        analyzeAfterSchemaFailure(
+            new SemanticException(
+                new IoTDBException(
+                    "schema request failed",
+                    TSStatusCode.NO_AVAILABLE_REGION_GROUP.getStatusCode())));
+
+    Assert.assertEquals(
+        TSStatusCode.LOAD_TEMPORARY_UNAVAILABLE_EXCEPTION.getStatusCode(), 
status.getCode());
+    Assert.assertTrue(status.getMessage().contains("schema request failed"));
+  }
+
+  @Test
+  public void testWrappedPermanentSchemaErrorShouldNotBecomeRetryable() throws 
Exception {
+    final TSStatus status =
+        analyzeAfterSchemaFailure(
+            new SemanticException(
+                new IoTDBException(
+                    "schema request failed", 
TSStatusCode.METADATA_ERROR.getStatusCode())));
+
+    Assert.assertEquals(TSStatusCode.LOAD_FILE_ERROR.getStatusCode(), 
status.getCode());
+    Assert.assertTrue(status.getMessage().contains("schema request failed"));
+  }
+
+  @Test
+  public void testWrappedTypeMismatchShouldKeepConversionPriority() throws 
Exception {
+    final LoadAnalyzeTypeMismatchException mismatch =
+        new LoadAnalyzeTypeMismatchException("schema type mismatch");
+    mismatch.initCause(
+        new IoTDBRuntimeException(
+            "schema request failed", 
TSStatusCode.NO_AVAILABLE_REGION_GROUP.getStatusCode()));
+    when(converter.convertForTreeModel(any()))
+        .thenReturn(Optional.of(new 
TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode())));
+
+    final TSStatus status = analyzeAfterSchemaFailure(new 
SemanticException(mismatch));
+
+    // Successful conversion leaves the analysis failure status unset in 1.3.
+    Assert.assertNull(status);
+    Mockito.verify(converter).convertForTreeModel(any());
+  }
+
+  @Test
+  public void testUnavailableRegionsDuringSingleFileAnalysisShouldRetry() 
throws Exception {
+    final File file = temporaryFolder.newFile("regions-recovering.tsfile");
+    try (final FileOutputStream output = new FileOutputStream(file)) {
+      output.write(1);
+    }
+    PowerMockito.whenNew(TsFileSequenceReader.class)
+        .withArguments(file.getAbsolutePath())
+        .thenThrow(
+            new IoTDBRuntimeException(
+                "region request failed", 
TSStatusCode.NO_AVAILABLE_REGION_GROUP.getStatusCode()));
+
+    try (final LoadTsFileAnalyzer analyzer =
+        new LoadTsFileAnalyzer(
+            LoadTsFileStatement.createUnchecked(file.getPath()),
+            new MPPQueryContext(new QueryId("load_region_recovery")),
+            Mockito.mock(IPartitionFetcher.class),
+            Mockito.mock(ISchemaFetcher.class))) {
+      final Analysis analysis = analyzer.analyzeFileByFile(new Analysis());
+
+      Assert.assertTrue(analysis.isFinishQueryAfterAnalyze());
+      Assert.assertEquals(
+          TSStatusCode.LOAD_TEMPORARY_UNAVAILABLE_EXCEPTION.getStatusCode(),
+          analysis.getFailStatus().getCode());
+      Assert.assertEquals("region request failed", 
analysis.getFailStatus().getMessage());
+      Assert.assertTrue(file.exists());
+    }
+  }
+
+  private TSStatus analyzeAfterSchemaFailure(final TSStatusCode code) throws 
Exception {
+    return analyzeAfterSchemaFailure(
+        new IoTDBRuntimeException("schema request failed", 
code.getStatusCode()));
+  }
+
+  private TSStatus analyzeAfterSchemaFailure(final RuntimeException exception) 
throws Exception {
+    PowerMockito.mockStatic(SchemaValidator.class);
+    when(SchemaValidator.validate(
+            any(),
+            anyList(),
+            anyList(),
+            anyList(),
+            anyList(),
+            anyList(),
+            anyList(),
+            anyBoolean(),
+            any()))
+        .thenThrow(exception);
+
+    final File file = temporaryFolder.newFile("schema-failure.tsfile");
+    final LoadTsFileStatement statement = 
LoadTsFileStatement.createUnchecked(file.getPath());
+    statement.setAutoCreateDatabase(false);
+
+    try (final LoadTsFileAnalyzer analyzer =
+        new LoadTsFileAnalyzer(
+            statement,
+            new MPPQueryContext(new QueryId("load_schema_recovery")),
+            Mockito.mock(IPartitionFetcher.class),
+            Mockito.mock(ISchemaFetcher.class))) {
+      final Field verifierField =
+          analyzer.getClass().getDeclaredField("schemaAutoCreatorAndVerifier");
+      verifierField.setAccessible(true);
+      final Object verifier = verifierField.get(analyzer);
+      final Field schemaCacheField = 
verifier.getClass().getDeclaredField("schemaCache");
+      schemaCacheField.setAccessible(true);
+      final Object schemaCache = schemaCacheField.get(verifier);
+      final IDeviceID device = new PlainDeviceID("root.sg.d");
+      final Method addTimeSeries =
+          schemaCache
+              .getClass()
+              .getDeclaredMethod("addTimeSeries", IDeviceID.class, 
MeasurementSchema.class);
+      addTimeSeries.setAccessible(true);
+      addTimeSeries.invoke(schemaCache, device, new MeasurementSchema("s", 
TSDataType.INT64));
+      final Method addIsAlignedCache =
+          schemaCache
+              .getClass()
+              .getDeclaredMethod(
+                  "addIsAlignedCache", IDeviceID.class, boolean.class, 
boolean.class);
+      addIsAlignedCache.setAccessible(true);
+      addIsAlignedCache.invoke(schemaCache, device, false, true);
+
+      final Analysis analysis = analyzer.analyzeFileByFile(new Analysis());
+      Assert.assertTrue(analysis.isFinishQueryAfterAnalyze());
+      Assert.assertTrue(file.exists());
+      return analysis.getFailStatus();
+    }
+  }
+
   private TSStatus convertAfterAnalysisFailure(final File file) throws 
Exception {
     try (final LoadTsFileAnalyzer analyzer =
         new LoadTsFileAnalyzer(

Reply via email to