Skip to content

Commit 92f4941

Browse files
shuwenweishuwenwei
committed
fix codecov
1 parent ab0978d commit 92f4941

File tree

2 files changed

+226
-110
lines changed

2 files changed

+226
-110
lines changed

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

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -590,6 +590,9 @@ private void getMemChunkHandleFromMemTable(
590590
WritableMemChunk memChunk =
591591
(WritableMemChunk) memTableMap.get(deviceID).getMemChunkMap().get(measurementId);
592592

593+
if (memChunk == null) {
594+
return;
595+
}
593596
Optional<Long> anySatisfiedTimestamp =
594597
memChunk.getAnySatisfiedTimestamp(deletionList, globalTimeFilter);
595598
if (!anySatisfiedTimestamp.isPresent()) {

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

Lines changed: 223 additions & 110 deletions
Original file line numberDiff line numberDiff line change
@@ -19,9 +19,13 @@
1919

2020
package org.apache.iotdb.db.storageengine.dataregion.memtable;
2121

22+
import org.apache.iotdb.commons.path.AlignedFullPath;
23+
import org.apache.iotdb.commons.path.NonAlignedFullPath;
2224
import org.apache.iotdb.db.conf.IoTDBDescriptor;
25+
import org.apache.iotdb.db.storageengine.dataregion.read.filescan.IChunkHandle;
2326

2427
import org.apache.tsfile.enums.TSDataType;
28+
import org.apache.tsfile.file.metadata.StringArrayDeviceID;
2529
import org.apache.tsfile.read.common.TimeRange;
2630
import org.apache.tsfile.read.filter.operator.TimeFilterOperators;
2731
import org.apache.tsfile.utils.BitMap;
@@ -38,7 +42,9 @@
3842
import java.util.Arrays;
3943
import java.util.Collection;
4044
import java.util.Collections;
45+
import java.util.HashMap;
4146
import java.util.List;
47+
import java.util.Map;
4248
import java.util.Optional;
4349

4450
@RunWith(Parameterized.class)
@@ -69,94 +75,167 @@ public void tearDown() {
6975

7076
@Test
7177
public void testAlignedWritableMemChunkRegionScan() {
72-
List<IMeasurementSchema> measurementSchemas =
73-
Arrays.asList(
74-
new MeasurementSchema("s1", TSDataType.INT32),
75-
new MeasurementSchema("s2", TSDataType.INT32),
76-
new MeasurementSchema("s3", TSDataType.INT32));
77-
AlignedWritableMemChunk writableMemChunk =
78-
new AlignedWritableMemChunk(measurementSchemas, false);
79-
int size = 100000;
80-
for (int i = 0; i < size; i++) {
81-
if (i <= 10000) {
82-
writableMemChunk.writeAlignedPoints(i, new Object[] {1, null, 1}, measurementSchemas);
83-
} else if (i <= 20000) {
84-
writableMemChunk.writeAlignedPoints(i, new Object[] {null, null, 2}, measurementSchemas);
85-
} else if (i <= 30000) {
86-
writableMemChunk.writeAlignedPoints(i, new Object[] {3, null, null}, measurementSchemas);
87-
} else {
88-
writableMemChunk.writeAlignedPoints(i, new Object[] {4, 4, 4}, measurementSchemas);
78+
PrimitiveMemTable memTable = new PrimitiveMemTable("root.test", "0");
79+
try {
80+
List<IMeasurementSchema> measurementSchemas =
81+
Arrays.asList(
82+
new MeasurementSchema("s1", TSDataType.INT32),
83+
new MeasurementSchema("s2", TSDataType.INT32),
84+
new MeasurementSchema("s3", TSDataType.INT32));
85+
AlignedWritableMemChunk writableMemChunk = null;
86+
int size = 100000;
87+
for (int i = 0; i < size; i++) {
88+
if (i <= 10000) {
89+
memTable.writeAlignedRow(
90+
new StringArrayDeviceID("root.test.d1"),
91+
measurementSchemas,
92+
i,
93+
new Object[] {1, null, 1});
94+
} else if (i <= 20000) {
95+
memTable.writeAlignedRow(
96+
new StringArrayDeviceID("root.test.d1"),
97+
measurementSchemas,
98+
i,
99+
new Object[] {null, null, 2});
100+
} else if (i <= 30000) {
101+
memTable.writeAlignedRow(
102+
new StringArrayDeviceID("root.test.d1"),
103+
measurementSchemas,
104+
i,
105+
new Object[] {3, null, null});
106+
} else {
107+
memTable.writeAlignedRow(
108+
new StringArrayDeviceID("root.test.d1"),
109+
measurementSchemas,
110+
i,
111+
new Object[] {4, 4, 4});
112+
}
89113
}
90-
}
91-
List<BitMap> bitMaps = new ArrayList<>();
92-
long[] timestamps =
93-
writableMemChunk.getAnySatisfiedTimestamp(
94-
Arrays.asList(
95-
Collections.emptyList(), Collections.emptyList(), Collections.emptyList()),
96-
bitMaps,
97-
true,
98-
null);
99-
Assert.assertEquals(2, timestamps.length);
100-
Assert.assertEquals(0, timestamps[0]);
101-
Assert.assertFalse(bitMaps.get(0).isMarked(0));
102-
Assert.assertTrue(bitMaps.get(0).isMarked(1));
103-
Assert.assertFalse(bitMaps.get(0).isMarked(2));
104-
Assert.assertTrue(bitMaps.get(1).isMarked(0));
105-
Assert.assertFalse(bitMaps.get(1).isMarked(1));
106-
Assert.assertTrue(bitMaps.get(1).isMarked(2));
107-
Assert.assertEquals(30001, timestamps[1]);
114+
writableMemChunk =
115+
(AlignedWritableMemChunk)
116+
memTable.getWritableMemChunk(new StringArrayDeviceID("root.test.d1"), "");
117+
List<BitMap> bitMaps = new ArrayList<>();
118+
long[] timestamps =
119+
writableMemChunk.getAnySatisfiedTimestamp(
120+
Arrays.asList(
121+
Collections.emptyList(), Collections.emptyList(), Collections.emptyList()),
122+
bitMaps,
123+
true,
124+
null);
125+
Assert.assertEquals(2, timestamps.length);
126+
Assert.assertEquals(0, timestamps[0]);
127+
Assert.assertFalse(bitMaps.get(0).isMarked(0));
128+
Assert.assertTrue(bitMaps.get(0).isMarked(1));
129+
Assert.assertFalse(bitMaps.get(0).isMarked(2));
130+
Assert.assertTrue(bitMaps.get(1).isMarked(0));
131+
Assert.assertFalse(bitMaps.get(1).isMarked(1));
132+
Assert.assertTrue(bitMaps.get(1).isMarked(2));
133+
Assert.assertEquals(30001, timestamps[1]);
108134

109-
bitMaps = new ArrayList<>();
110-
timestamps =
111-
writableMemChunk.getAnySatisfiedTimestamp(
112-
Arrays.asList(
113-
Collections.emptyList(),
114-
Collections.emptyList(),
115-
Collections.singletonList(new TimeRange(0, 12000))),
116-
bitMaps,
117-
true,
118-
new TimeFilterOperators.TimeGt(11000));
135+
bitMaps = new ArrayList<>();
136+
timestamps =
137+
writableMemChunk.getAnySatisfiedTimestamp(
138+
Arrays.asList(
139+
Collections.emptyList(),
140+
Collections.emptyList(),
141+
Collections.singletonList(new TimeRange(0, 12000))),
142+
bitMaps,
143+
true,
144+
new TimeFilterOperators.TimeGt(10000000));
145+
Assert.assertEquals(0, timestamps.length);
119146

120-
Assert.assertEquals(3, timestamps.length);
121-
Assert.assertEquals(12001, timestamps[0]);
122-
Assert.assertTrue(bitMaps.get(0).isMarked(0));
123-
Assert.assertTrue(bitMaps.get(0).isMarked(1));
124-
Assert.assertFalse(bitMaps.get(0).isMarked(2));
125-
Assert.assertEquals(20001, timestamps[1]);
126-
Assert.assertFalse(bitMaps.get(1).isMarked(0));
127-
Assert.assertTrue(bitMaps.get(1).isMarked(1));
128-
Assert.assertTrue(bitMaps.get(1).isMarked(2));
129-
Assert.assertEquals(30001, timestamps[2]);
130-
Assert.assertTrue(bitMaps.get(2).isMarked(0));
131-
Assert.assertFalse(bitMaps.get(2).isMarked(1));
132-
Assert.assertTrue(bitMaps.get(2).isMarked(2));
133-
134-
writableMemChunk.writeAlignedPoints(1000001, new Object[] {1, null, null}, measurementSchemas);
135-
writableMemChunk.writeAlignedPoints(1000002, new Object[] {null, 1, null}, measurementSchemas);
136-
writableMemChunk.writeAlignedPoints(1000002, new Object[] {1, 1, null}, measurementSchemas);
137-
writableMemChunk.writeAlignedPoints(1000003, new Object[] {1, null, null}, measurementSchemas);
138-
writableMemChunk.writeAlignedPoints(1000004, new Object[] {1, null, 1}, measurementSchemas);
139-
bitMaps = new ArrayList<>();
140-
timestamps =
141-
writableMemChunk.getAnySatisfiedTimestamp(
142-
Arrays.asList(
143-
Collections.emptyList(), Collections.emptyList(), Collections.emptyList()),
144-
bitMaps,
145-
true,
146-
new TimeFilterOperators.TimeGt(1000000));
147-
Assert.assertEquals(3, timestamps.length);
148-
Assert.assertEquals(1000001, timestamps[0]);
149-
Assert.assertFalse(bitMaps.get(0).isMarked(0));
150-
Assert.assertTrue(bitMaps.get(0).isMarked(1));
151-
Assert.assertTrue(bitMaps.get(0).isMarked(2));
152-
Assert.assertEquals(1000002, timestamps[1]);
153-
Assert.assertTrue(bitMaps.get(1).isMarked(0));
154-
Assert.assertFalse(bitMaps.get(1).isMarked(1));
155-
Assert.assertTrue(bitMaps.get(1).isMarked(2));
156-
Assert.assertEquals(1000004, timestamps[2]);
157-
Assert.assertTrue(bitMaps.get(2).isMarked(0));
158-
Assert.assertTrue(bitMaps.get(2).isMarked(1));
159-
Assert.assertFalse(bitMaps.get(2).isMarked(2));
147+
bitMaps = new ArrayList<>();
148+
timestamps =
149+
writableMemChunk.getAnySatisfiedTimestamp(
150+
Arrays.asList(
151+
Collections.emptyList(),
152+
Collections.emptyList(),
153+
Collections.singletonList(new TimeRange(0, 12000))),
154+
bitMaps,
155+
true,
156+
new TimeFilterOperators.TimeGt(11000));
157+
158+
Assert.assertEquals(3, timestamps.length);
159+
Assert.assertEquals(12001, timestamps[0]);
160+
Assert.assertTrue(bitMaps.get(0).isMarked(0));
161+
Assert.assertTrue(bitMaps.get(0).isMarked(1));
162+
Assert.assertFalse(bitMaps.get(0).isMarked(2));
163+
Assert.assertEquals(20001, timestamps[1]);
164+
Assert.assertFalse(bitMaps.get(1).isMarked(0));
165+
Assert.assertTrue(bitMaps.get(1).isMarked(1));
166+
Assert.assertTrue(bitMaps.get(1).isMarked(2));
167+
Assert.assertEquals(30001, timestamps[2]);
168+
Assert.assertTrue(bitMaps.get(2).isMarked(0));
169+
Assert.assertFalse(bitMaps.get(2).isMarked(1));
170+
Assert.assertTrue(bitMaps.get(2).isMarked(2));
171+
172+
writableMemChunk.writeAlignedPoints(
173+
1000001, new Object[] {1, null, null}, measurementSchemas);
174+
writableMemChunk.writeAlignedPoints(
175+
1000002, new Object[] {null, 1, null}, measurementSchemas);
176+
writableMemChunk.writeAlignedPoints(1000002, new Object[] {1, 1, null}, measurementSchemas);
177+
writableMemChunk.writeAlignedPoints(
178+
1000003, new Object[] {1, null, null}, measurementSchemas);
179+
writableMemChunk.writeAlignedPoints(1000004, new Object[] {1, null, 1}, measurementSchemas);
180+
bitMaps = new ArrayList<>();
181+
timestamps =
182+
writableMemChunk.getAnySatisfiedTimestamp(
183+
Arrays.asList(
184+
Collections.emptyList(), Collections.emptyList(), Collections.emptyList()),
185+
bitMaps,
186+
true,
187+
new TimeFilterOperators.TimeGt(1000000));
188+
Assert.assertEquals(3, timestamps.length);
189+
Assert.assertEquals(1000001, timestamps[0]);
190+
Assert.assertFalse(bitMaps.get(0).isMarked(0));
191+
Assert.assertTrue(bitMaps.get(0).isMarked(1));
192+
Assert.assertTrue(bitMaps.get(0).isMarked(2));
193+
Assert.assertEquals(1000002, timestamps[1]);
194+
Assert.assertTrue(bitMaps.get(1).isMarked(0));
195+
Assert.assertFalse(bitMaps.get(1).isMarked(1));
196+
Assert.assertTrue(bitMaps.get(1).isMarked(2));
197+
Assert.assertEquals(1000004, timestamps[2]);
198+
Assert.assertTrue(bitMaps.get(2).isMarked(0));
199+
Assert.assertTrue(bitMaps.get(2).isMarked(1));
200+
Assert.assertFalse(bitMaps.get(2).isMarked(2));
201+
202+
Map<String, List<IChunkHandle>> chunkHandleMap = new HashMap<>();
203+
memTable.queryForDeviceRegionScan(
204+
new StringArrayDeviceID("root.test.d1"),
205+
true,
206+
Long.MIN_VALUE,
207+
new HashMap<>(),
208+
chunkHandleMap,
209+
Collections.emptyList(),
210+
new TimeFilterOperators.TimeGt(1000000));
211+
Assert.assertEquals(3, chunkHandleMap.size());
212+
Assert.assertArrayEquals(
213+
new long[] {1000001, 1000001}, chunkHandleMap.get("s1").get(0).getPageStatisticsTime());
214+
Assert.assertArrayEquals(
215+
new long[] {1000002, 1000002}, chunkHandleMap.get("s2").get(0).getPageStatisticsTime());
216+
Assert.assertArrayEquals(
217+
new long[] {1000004, 1000004}, chunkHandleMap.get("s3").get(0).getPageStatisticsTime());
218+
219+
memTable.queryForSeriesRegionScan(
220+
new AlignedFullPath(
221+
new StringArrayDeviceID("root.test.d1"),
222+
IMeasurementSchema.getMeasurementNameList(measurementSchemas),
223+
measurementSchemas),
224+
Long.MIN_VALUE,
225+
new HashMap<>(),
226+
chunkHandleMap,
227+
Collections.emptyList(),
228+
new TimeFilterOperators.TimeGt(1000000));
229+
Assert.assertEquals(3, chunkHandleMap.size());
230+
Assert.assertArrayEquals(
231+
new long[] {1000001, 1000001}, chunkHandleMap.get("s1").get(0).getPageStatisticsTime());
232+
Assert.assertArrayEquals(
233+
new long[] {1000002, 1000002}, chunkHandleMap.get("s2").get(0).getPageStatisticsTime());
234+
Assert.assertArrayEquals(
235+
new long[] {1000004, 1000004}, chunkHandleMap.get("s3").get(0).getPageStatisticsTime());
236+
} finally {
237+
memTable.release();
238+
}
160239
}
161240

162241
@Test
@@ -214,33 +293,67 @@ public void testTableWritableMemChunkRegionScan() {
214293

215294
@Test
216295
public void testNonAlignedWritableMemChunkRegionScan() {
217-
MeasurementSchema measurementSchema = new MeasurementSchema("s1", TSDataType.INT32);
218-
WritableMemChunk writableMemChunk = new WritableMemChunk(measurementSchema);
219-
int size = 100000;
220-
for (int i = 0; i < size; i++) {
221-
writableMemChunk.writeNonAlignedPoint(i, i);
222-
}
223-
Optional<Long> timestamp = writableMemChunk.getAnySatisfiedTimestamp(null, null);
224-
Assert.assertTrue(timestamp.isPresent());
225-
Assert.assertEquals(0, timestamp.get().longValue());
296+
PrimitiveMemTable memTable = new PrimitiveMemTable("root.test", "0");
297+
try {
298+
MeasurementSchema measurementSchema = new MeasurementSchema("s1", TSDataType.INT32);
299+
int size = 100000;
300+
for (int i = 0; i < size; i++) {
301+
memTable.write(
302+
new StringArrayDeviceID("root.test.d1"),
303+
Collections.singletonList(measurementSchema),
304+
i,
305+
new Object[] {i});
306+
}
307+
WritableMemChunk writableMemChunk =
308+
(WritableMemChunk)
309+
memTable.getWritableMemChunk(new StringArrayDeviceID("root.test.d1"), "s1");
310+
Optional<Long> timestamp = writableMemChunk.getAnySatisfiedTimestamp(null, null);
311+
Assert.assertTrue(timestamp.isPresent());
312+
Assert.assertEquals(0, timestamp.get().longValue());
226313

227-
timestamp =
228-
writableMemChunk.getAnySatisfiedTimestamp(
229-
null, new TimeFilterOperators.TimeBetweenAnd(1000L, 2000L));
230-
Assert.assertTrue(timestamp.isPresent());
231-
Assert.assertEquals(1000, timestamp.get().longValue());
314+
timestamp =
315+
writableMemChunk.getAnySatisfiedTimestamp(
316+
null, new TimeFilterOperators.TimeBetweenAnd(1000L, 2000L));
317+
Assert.assertTrue(timestamp.isPresent());
318+
Assert.assertEquals(1000, timestamp.get().longValue());
232319

233-
timestamp =
234-
writableMemChunk.getAnySatisfiedTimestamp(
235-
Collections.singletonList(new TimeRange(1, 1500)),
236-
new TimeFilterOperators.TimeBetweenAnd(1000L, 2000L));
237-
Assert.assertTrue(timestamp.isPresent());
238-
Assert.assertEquals(1501, timestamp.get().longValue());
320+
timestamp =
321+
writableMemChunk.getAnySatisfiedTimestamp(
322+
Collections.singletonList(new TimeRange(1, 1500)),
323+
new TimeFilterOperators.TimeBetweenAnd(1000L, 2000L));
324+
Assert.assertTrue(timestamp.isPresent());
325+
Assert.assertEquals(1501, timestamp.get().longValue());
239326

240-
timestamp =
241-
writableMemChunk.getAnySatisfiedTimestamp(
242-
Collections.singletonList(new TimeRange(1, 1500)),
243-
new TimeFilterOperators.TimeBetweenAnd(100000L, 200000L));
244-
Assert.assertFalse(timestamp.isPresent());
327+
timestamp =
328+
writableMemChunk.getAnySatisfiedTimestamp(
329+
Collections.singletonList(new TimeRange(1, 1500)),
330+
new TimeFilterOperators.TimeBetweenAnd(100000L, 200000L));
331+
Assert.assertFalse(timestamp.isPresent());
332+
333+
Map<String, List<IChunkHandle>> chunkHandleMap = new HashMap<>();
334+
memTable.queryForDeviceRegionScan(
335+
new StringArrayDeviceID("root.test.d1"),
336+
false,
337+
Long.MIN_VALUE,
338+
new HashMap<>(),
339+
chunkHandleMap,
340+
Collections.emptyList(),
341+
new TimeFilterOperators.TimeGt(1));
342+
Assert.assertEquals(1, chunkHandleMap.size());
343+
Assert.assertArrayEquals(
344+
new long[] {2, 2}, chunkHandleMap.get("s1").get(0).getPageStatisticsTime());
345+
memTable.queryForSeriesRegionScan(
346+
new NonAlignedFullPath(new StringArrayDeviceID("root.test.d1"), measurementSchema),
347+
Long.MIN_VALUE,
348+
new HashMap<>(),
349+
chunkHandleMap,
350+
Collections.emptyList(),
351+
new TimeFilterOperators.TimeGt(1));
352+
Assert.assertEquals(1, chunkHandleMap.size());
353+
Assert.assertArrayEquals(
354+
new long[] {2, 2}, chunkHandleMap.get("s1").get(0).getPageStatisticsTime());
355+
} finally {
356+
memTable.release();
357+
}
245358
}
246359
}

0 commit comments

Comments
 (0)