Add an overlapped data case on the scene of query.

Author: zerolbsony

integration-test/src/test/java/org/apache/iotdb/relational/it/schema/IoTDBAlterColumnTypeIT.java

@@ -132,6 +132,7 @@ public void testWriteAndAlter()
           doWriteAndAlter(from, to);
           testAlignDeviceSequenceDataQuery(from, to);
           testAlignDeviceUnSequenceDataQuery(from, to);
+          testAlignDeviceUnSequenceOverlappedDataQuery(from, to);
         }
       }
     }
@@ -1490,6 +1491,113 @@ public void testAlignDeviceUnSequenceDataQuery(TSDataType from, TSDataType to)
     }
   }
 
+  public void testAlignDeviceUnSequenceOverlappedDataQuery(TSDataType from, TSDataType to)
+      throws IoTDBConnectionException,
+          StatementExecutionException,
+          IOException,
+          WriteProcessException {
+    try (ITableSession session = EnvFactory.getEnv().getTableSessionConnectionWithDB("test")) {
+      session.executeNonQueryStatement("SET CONFIGURATION enable_unseq_space_compaction='false'");
+
+      // create a table with type of "from"
+      session.executeNonQueryStatement(
+          "CREATE TABLE IF NOT EXISTS construct_and_alter_column_type (s1 "
+              + from
+              + ", s2 "
+              + from
+              + ")");
+
+      // write a sequence tsfile point of "from"
+      Tablet tablet =
+          new Tablet(
+              "construct_and_alter_column_type",
+              Arrays.asList("s1", "s2"),
+              Arrays.asList(from, from),
+              Arrays.asList(ColumnCategory.FIELD, ColumnCategory.FIELD));
+
+      System.out.println(tablet.getSchemas().toString());
+
+      for (int i = 513; i <= 1024; i++) {
+        int rowIndex = tablet.getRowSize();
+        tablet.addTimestamp(0, i);
+        tablet.addValue("s1", rowIndex, genValue(from, i));
+        tablet.addValue("s2", rowIndex, genValue(from, i * 2));
+        session.insert(tablet);
+        tablet.reset();
+      }
+
+      session.executeNonQueryStatement("FLUSH");
+
+      for (int i = 1; i <= 520; i++) {
+        int rowIndex = tablet.getRowSize();
+        tablet.addTimestamp(0, i);
+        tablet.addValue("s1", rowIndex, genValue(from, i));
+        tablet.addValue("s2", rowIndex, genValue(from, i * 2));
+        session.insert(tablet);
+        tablet.reset();
+      }
+      //        session.executeNonQueryStatement("FLUSH");
+
+      SessionDataSet dataSet =
+          session.executeQueryStatement(
+              "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
+      RowRecord rec = dataSet.next();
+      while (rec != null) {
+        System.out.println(rec.getFields().toString());
+        rec = dataSet.next();
+      }
+      dataSet.close();
+
+      try {
+        standardSelectTest(session, from, to);
+        standardAccumulatorQueryTest(session, from);
+      } catch (Exception e) {
+        log.error("{}", e.getStackTrace());
+        log.info(e.getMessage());
+      }
+
+      // alter the type to "to"
+      boolean isCompatible = MetadataUtils.canAlter(from, to);
+      if (isCompatible) {
+        session.executeNonQueryStatement(
+            "ALTER TABLE construct_and_alter_column_type ALTER COLUMN s1 SET DATA TYPE " + to);
+      } else {
+        try {
+          session.executeNonQueryStatement(
+              "ALTER TABLE construct_and_alter_column_type ALTER COLUMN s1 SET DATA TYPE " + to);
+        } catch (StatementExecutionException e) {
+          assertEquals(
+              "701: New type " + to + " is not compatible with the existing one " + from,
+              e.getMessage());
+        }
+      }
+
+      System.out.println(
+          "[testAlignDeviceUnSequenceDataQuery] AFTER ALTER COLUMN s1 SET DATA TYPE ");
+
+      // If don't execute the flush" operation, verify if result can get valid value, not be null
+      // when query memtable.
+      //      session.executeNonQueryStatement("FLUSH");
+
+      TSDataType newType = isCompatible ? to : from;
+
+      try {
+        standardSelectTestAfterAlterColumnType(from, session, newType);
+        // Accumulator query test
+        standardAccumulatorQueryTest(session, from, newType);
+      } catch (Exception e) {
+        log.error("{}", e.getStackTrace());
+        log.info(e.getMessage());
+      }
+
+      if (from == TSDataType.DATE) {
+        accumulatorQueryTestForDateType(session, to);
+      }
+
+      session.executeNonQueryStatement("DROP TABLE construct_and_alter_column_type");
+    }
+  }
+
   // Don't support for non-align device unsequence data query, because non-align timeseries is not
   // exist in the table model, only exist align timeseries.
   // Though support for non-align timeseries in the tree model, can let tree transfer to table, but