add ut

Author: shuwenwei

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/memtable/AlignedWritableMemChunk.java

@@ -352,6 +352,19 @@ private void getAnySatisfiedTimestamp(
       valueColumnsDeletionList.forEach(x -> valueColumnDeleteCursor.add(new int[] {0}));
     }
 
+    // example:
+    // globalTimeFilter:null, ignoreAllNullRows: true
+    // tvList:
+    // time s1    s2    s3
+    // 1    1     null  null
+    // 2    null  1     null
+    // 2    1     1     null
+    // 3    1     null  null
+    // 4    1     null  1
+    // timestampWithBitmap:
+    // timestamp: 1 bitmap: 011
+    // timestamp: 2 bitmap: 101
+    // timestamp: 4 bitmap: 110
     for (int row = 0; row < rowCount; row++) {
       // the row is deleted
       if (allValueColDeletedMap != null && allValueColDeletedMap.isMarked(row)) {
@@ -362,12 +375,12 @@ private void getAnySatisfiedTimestamp(
         continue;
       }
 
-      BitMap bitMap = new BitMap(schemaList.size());
+      // Note that this method will only perform bitmap unmarking on the first occurrence of a
+      // non-null value in multiple timestamps for the same column.
+      BitMap currentRowNullValueBitmap = null;
 
-      boolean foundAnyNewColumnWithNonNullValue = false;
       for (int column = 0; column < schemaList.size(); column++) {
         if (alignedTVList.isNullValue(alignedTVList.getValueIndex(row), column)) {
-          bitMap.mark(column);
           continue;
         }
 
@@ -378,33 +391,46 @@ && isPointDeleted(
                 timestamp,
                 valueColumnsDeletionList.get(column),
                 valueColumnDeleteCursor.get(column))) {
-          bitMap.mark(column);
           continue;
         }
-
         if (!columnHasNonNullValue.isMarked(column)) {
           hasNonNullValueColumnCount.incrementAndGet();
-          foundAnyNewColumnWithNonNullValue = true;
           columnHasNonNullValue.mark(column);
+          currentRowNullValueBitmap =
+              currentRowNullValueBitmap != null
+                  ? currentRowNullValueBitmap
+                  : timestampWithBitmap.computeIfAbsent(
+                      timestamp, k -> getAllMarkedBitmap(schemaList.size()));
+          currentRowNullValueBitmap.unmark(column);
         }
       }
 
       if (!ignoreAllNullRows) {
-        // count devices in table model
-        timestampWithBitmap.put(timestamp, bitMap);
+        timestampWithBitmap.put(
+            timestamp,
+            currentRowNullValueBitmap != null
+                ? currentRowNullValueBitmap
+                : getAllMarkedBitmap(schemaList.size()));
         return;
       }
-      if (!foundAnyNewColumnWithNonNullValue) {
+      if (currentRowNullValueBitmap == null) {
         continue;
       }
-      timestampWithBitmap.put(timestamp, bitMap);
+      // found new column with non-null value
+      timestampWithBitmap.put(timestamp, currentRowNullValueBitmap);
 
       if (hasNonNullValueColumnCount.get() == schemaList.size()) {
         return;
       }
     }
   }
 
+  private BitMap getAllMarkedBitmap(int size) {
+    BitMap bitMap = new BitMap(size);
+    bitMap.markAll();
+    return bitMap;
+  }
+
   @Override
   public AlignedTVList getWorkingTVList() {
     return list;

iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/dataregion/memtable/AlignedTVListIteratorTest.java

@@ -1034,7 +1034,7 @@ public void test() {
       //      }
       long start = System.currentTimeMillis();
       //      long[] filteredTimestamp = writableMemChunk.getAnySatisfiedTimestamp(null, null);
-      writableMemChunk.getAnySatisfiedTimestamp(null, null);
+      writableMemChunk.getAnySatisfiedTimestamp(null, new TimeFilterOperators.TimeGt(3000000 - 2));
       System.out.println("cost: " + (System.currentTimeMillis() - start));
     }
   }

iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/dataregion/memtable/WritableMemChunkRegionScanTest.java

@@ -101,9 +101,9 @@ public void testAlignedWritableMemChunkRegionScan() {
     Assert.assertFalse(bitMaps.get(0).isMarked(0));
     Assert.assertTrue(bitMaps.get(0).isMarked(1));
     Assert.assertFalse(bitMaps.get(0).isMarked(2));
-    Assert.assertFalse(bitMaps.get(1).isMarked(0));
+    Assert.assertTrue(bitMaps.get(1).isMarked(0));
     Assert.assertFalse(bitMaps.get(1).isMarked(1));
-    Assert.assertFalse(bitMaps.get(1).isMarked(2));
+    Assert.assertTrue(bitMaps.get(1).isMarked(2));
     Assert.assertEquals(30001, timestamps[1]);
 
     bitMaps = new ArrayList<>();
@@ -127,8 +127,35 @@ public void testAlignedWritableMemChunkRegionScan() {
     Assert.assertTrue(bitMaps.get(1).isMarked(1));
     Assert.assertTrue(bitMaps.get(1).isMarked(2));
     Assert.assertEquals(30001, timestamps[2]);
-    Assert.assertFalse(bitMaps.get(2).isMarked(0));
+    Assert.assertTrue(bitMaps.get(2).isMarked(0));
     Assert.assertFalse(bitMaps.get(2).isMarked(1));
+    Assert.assertTrue(bitMaps.get(2).isMarked(2));
+
+    writableMemChunk.writeAlignedPoints(1000001, new Object[] {1, null, null}, measurementSchemas);
+    writableMemChunk.writeAlignedPoints(1000002, new Object[] {null, 1, null}, measurementSchemas);
+    writableMemChunk.writeAlignedPoints(1000002, new Object[] {1, 1, null}, measurementSchemas);
+    writableMemChunk.writeAlignedPoints(1000003, new Object[] {1, null, null}, measurementSchemas);
+    writableMemChunk.writeAlignedPoints(1000004, new Object[] {1, null, 1}, measurementSchemas);
+    bitMaps = new ArrayList<>();
+    timestamps =
+        writableMemChunk.getAnySatisfiedTimestamp(
+            Arrays.asList(
+                Collections.emptyList(), Collections.emptyList(), Collections.emptyList()),
+            bitMaps,
+            true,
+            new TimeFilterOperators.TimeGt(1000000));
+    Assert.assertEquals(3, timestamps.length);
+    Assert.assertEquals(1000001, timestamps[0]);
+    Assert.assertFalse(bitMaps.get(0).isMarked(0));
+    Assert.assertTrue(bitMaps.get(0).isMarked(1));
+    Assert.assertTrue(bitMaps.get(0).isMarked(2));
+    Assert.assertEquals(1000002, timestamps[1]);
+    Assert.assertTrue(bitMaps.get(1).isMarked(0));
+    Assert.assertFalse(bitMaps.get(1).isMarked(1));
+    Assert.assertTrue(bitMaps.get(1).isMarked(2));
+    Assert.assertEquals(1000004, timestamps[2]);
+    Assert.assertTrue(bitMaps.get(2).isMarked(0));
+    Assert.assertTrue(bitMaps.get(2).isMarked(1));
     Assert.assertFalse(bitMaps.get(2).isMarked(2));
   }