This is an automated email from the ASF dual-hosted git repository. sunzesong pushed a commit to branch CreateAlignedTimeseriesPlan in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 3f6b91559bfc93e73aa8738d7da5a93ce47a6759 Author: samperson1997 <[email protected]> AuthorDate: Sat Mar 13 23:24:40 2021 +0800 [IOTDB-1225] Support CreateAlignedTimeseriesPlan in MManager --- .../metadata/AlignedTimeseriesException.java | 31 ++++ .../org/apache/iotdb/db/metadata/MManager.java | 79 +++++++++- .../java/org/apache/iotdb/db/metadata/MTree.java | 167 ++++++++++++++++++--- .../iotdb/db/metadata/MManagerBasicTest.java | 67 ++++++++- .../db/qp/physical/PhysicalPlanSerializeTest.java | 20 +-- .../java/org/apache/iotdb/rpc/TSStatusCode.java | 1 + .../write/writer/VectorChunkWriterImplTest.java | 8 - 7 files changed, 317 insertions(+), 56 deletions(-) diff --git a/server/src/main/java/org/apache/iotdb/db/exception/metadata/AlignedTimeseriesException.java b/server/src/main/java/org/apache/iotdb/db/exception/metadata/AlignedTimeseriesException.java new file mode 100644 index 0000000..ac95856 --- /dev/null +++ b/server/src/main/java/org/apache/iotdb/db/exception/metadata/AlignedTimeseriesException.java @@ -0,0 +1,31 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.iotdb.db.exception.metadata; + +import org.apache.iotdb.rpc.TSStatusCode; + +public class AlignedTimeseriesException extends MetadataException { + + public AlignedTimeseriesException(String message, String path) { + super(String.format("%s (Timeseries: %s)", message, path)); + errorCode = TSStatusCode.ALIGNED_TIMESERIES_ERROR.getStatusCode(); + this.isUserException = true; + } +} diff --git a/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java b/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java index 76703a8..60819b3 100644 --- a/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java +++ b/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java @@ -73,6 +73,7 @@ import org.apache.iotdb.tsfile.utils.Pair; import org.apache.iotdb.tsfile.write.schema.IMeasurementSchema; import org.apache.iotdb.tsfile.write.schema.MeasurementSchema; import org.apache.iotdb.tsfile.write.schema.TimeseriesSchema; +import org.apache.iotdb.tsfile.write.schema.VectorMeasurementSchema; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -485,8 +486,63 @@ public class MManager { } } - // TODO - public void createAlignedTimeSeries(CreateAlignedTimeSeriesPlan plan) throws MetadataException {} + public void createAlignedTimeSeries( + PartialPath devicePath, + List<String> measurements, + List<TSDataType> dataTypes, + List<TSEncoding> encodings, + CompressionType compressor) + throws MetadataException { + createAlignedTimeSeries( + new CreateAlignedTimeSeriesPlan( + devicePath, measurements, dataTypes, encodings, compressor, null)); + } + + /** + * create aligned timeseries + * + * @param plan CreateAlignedTimeSeriesPlan + */ + public void createAlignedTimeSeries(CreateAlignedTimeSeriesPlan plan) throws MetadataException { + if (!allowToCreateNewSeries) { + throw new MetadataException( + "IoTDB system load is too large to create timeseries, " + + "please increase MAX_HEAP_SIZE in iotdb-env.sh/bat and restart"); + } + try { + PartialPath devicePath = plan.getDevicePath(); + List<String> measurements = plan.getMeasurements(); + int alignedSize = measurements.size(); + List<TSDataType> dataTypes = plan.getDataTypes(); + List<TSEncoding> encodings = plan.getEncodings(); + + for (int i = 0; i < alignedSize; i++) { + SchemaUtils.checkDataTypeWithEncoding(dataTypes.get(i), encodings.get(i)); + } + + ensureStorageGroup(devicePath); + + // create time series in MTree + mtree.createAlignedTimeseries( + devicePath, measurements, plan.getDataTypes(), plan.getEncodings(), plan.getCompressor()); + + // update statistics and schemaDataTypeNumMap + totalSeriesNumber.addAndGet(measurements.size()); + if (totalSeriesNumber.get() * ESTIMATED_SERIES_SIZE >= MTREE_SIZE_THRESHOLD) { + logger.warn("Current series number {} is too large...", totalSeriesNumber); + allowToCreateNewSeries = false; + } + for (TSDataType type : dataTypes) { + updateSchemaDataTypeNumMap(type, 1); + } + // write log + if (!isRecovering) { + logWriter.createAlignedTimeseries(plan); + } + } catch (IOException e) { + throw new MetadataException(e); + } + } /** * Delete all timeseries under the given path, may cross different storage group @@ -586,15 +642,24 @@ public class MManager { throws MetadataException, IOException { Pair<PartialPath, MeasurementMNode> pair = mtree.deleteTimeseriesAndReturnEmptyStorageGroup(path); - removeFromTagInvertedIndex(pair.right); + // if one of the aligned timeseries is deleted, pair.right could be null + IMeasurementSchema schema = pair.right.getSchema(); + int timeseriesNum = 0; + if (schema instanceof MeasurementSchema) { + removeFromTagInvertedIndex(pair.right); + updateSchemaDataTypeNumMap(schema.getType(), -1); + timeseriesNum = 1; + } else if (schema instanceof VectorMeasurementSchema) { + for (TSDataType dataType : schema.getValueTSDataTypeList()) { + updateSchemaDataTypeNumMap(dataType, -1); + timeseriesNum++; + } + } PartialPath storageGroupPath = pair.left; - // update statistics in schemaDataTypeNumMap - updateSchemaDataTypeNumMap(pair.right.getSchema().getType(), -1); - // TODO: delete the path node and all its ancestors mNodeCache.clear(); - totalSeriesNumber.addAndGet(-1); + totalSeriesNumber.addAndGet(-timeseriesNum); if (!allowToCreateNewSeries && totalSeriesNumber.get() * ESTIMATED_SERIES_SIZE < MTREE_SIZE_THRESHOLD) { logger.info("Current series number {} come back to normal level", totalSeriesNumber); diff --git a/server/src/main/java/org/apache/iotdb/db/metadata/MTree.java b/server/src/main/java/org/apache/iotdb/db/metadata/MTree.java index 762e2a8..7b4110e 100644 --- a/server/src/main/java/org/apache/iotdb/db/metadata/MTree.java +++ b/server/src/main/java/org/apache/iotdb/db/metadata/MTree.java @@ -22,7 +22,14 @@ import org.apache.iotdb.db.conf.IoTDBConfig; import org.apache.iotdb.db.conf.IoTDBConstant; import org.apache.iotdb.db.conf.IoTDBDescriptor; import org.apache.iotdb.db.engine.querycontext.QueryDataSource; -import org.apache.iotdb.db.exception.metadata.*; +import org.apache.iotdb.db.exception.metadata.AliasAlreadyExistException; +import org.apache.iotdb.db.exception.metadata.IllegalParameterOfPathException; +import org.apache.iotdb.db.exception.metadata.IllegalPathException; +import org.apache.iotdb.db.exception.metadata.MetadataException; +import org.apache.iotdb.db.exception.metadata.PathAlreadyExistException; +import org.apache.iotdb.db.exception.metadata.PathNotExistException; +import org.apache.iotdb.db.exception.metadata.StorageGroupAlreadySetException; +import org.apache.iotdb.db.exception.metadata.StorageGroupNotSetException; import org.apache.iotdb.db.metadata.MManager.StorageGroupFilter; import org.apache.iotdb.db.metadata.logfile.MLogReader; import org.apache.iotdb.db.metadata.logfile.MLogWriter; @@ -30,7 +37,11 @@ import org.apache.iotdb.db.metadata.mnode.MNode; import org.apache.iotdb.db.metadata.mnode.MeasurementMNode; import org.apache.iotdb.db.metadata.mnode.StorageGroupMNode; import org.apache.iotdb.db.qp.physical.PhysicalPlan; -import org.apache.iotdb.db.qp.physical.sys.*; +import org.apache.iotdb.db.qp.physical.sys.MNodePlan; +import org.apache.iotdb.db.qp.physical.sys.MeasurementMNodePlan; +import org.apache.iotdb.db.qp.physical.sys.ShowDevicesPlan; +import org.apache.iotdb.db.qp.physical.sys.ShowTimeSeriesPlan; +import org.apache.iotdb.db.qp.physical.sys.StorageGroupMNodePlan; import org.apache.iotdb.db.query.context.QueryContext; import org.apache.iotdb.db.query.control.QueryResourceManager; import org.apache.iotdb.db.query.dataset.ShowDevicesResult; @@ -42,6 +53,8 @@ import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding; import org.apache.iotdb.tsfile.read.TimeValuePair; import org.apache.iotdb.tsfile.utils.Pair; import org.apache.iotdb.tsfile.write.schema.IMeasurementSchema; +import org.apache.iotdb.tsfile.write.schema.MeasurementSchema; +import org.apache.iotdb.tsfile.write.schema.VectorMeasurementSchema; import com.google.gson.Gson; import com.google.gson.GsonBuilder; @@ -53,14 +66,31 @@ import org.slf4j.LoggerFactory; import java.io.File; import java.io.IOException; import java.io.Serializable; -import java.util.*; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.Deque; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; import java.util.Map.Entry; +import java.util.Queue; +import java.util.Set; +import java.util.TreeSet; import java.util.concurrent.ConcurrentHashMap; import java.util.regex.Pattern; import java.util.stream.Stream; import static java.util.stream.Collectors.toList; -import static org.apache.iotdb.db.conf.IoTDBConstant.*; +import static org.apache.iotdb.db.conf.IoTDBConstant.LOSS; +import static org.apache.iotdb.db.conf.IoTDBConstant.PATH_SEPARATOR; +import static org.apache.iotdb.db.conf.IoTDBConstant.PATH_WILDCARD; +import static org.apache.iotdb.db.conf.IoTDBConstant.SDT; +import static org.apache.iotdb.db.conf.IoTDBConstant.SDT_COMP_DEV; +import static org.apache.iotdb.db.conf.IoTDBConstant.SDT_COMP_MAX_TIME; +import static org.apache.iotdb.db.conf.IoTDBConstant.SDT_COMP_MIN_TIME; /** The hierarchical struct of the Metadata Tree is implemented in this class. */ public class MTree implements Serializable { @@ -165,7 +195,7 @@ public class MTree implements Serializable { } /** - * Create a timeseries with a full path from root to leaf node Before creating a timeseries, the + * Create a timeseries with a full path from root to leaf node. Before creating a timeseries, the * storage group should be set first, throw exception otherwise * * @param path timeseries path @@ -244,6 +274,81 @@ public class MTree implements Serializable { } } + /** + * Create aligned timeseries with full paths from root to one leaf node. Before creating + * timeseries, the * storage group should be set first, throw exception otherwise + * + * @param devicePath device path + * @param measurements measurements list + * @param dataTypes data types list + * @param encodings encodings list + * @param compressor compressor + */ + void createAlignedTimeseries( + PartialPath devicePath, + List<String> measurements, + List<TSDataType> dataTypes, + List<TSEncoding> encodings, + CompressionType compressor) + throws MetadataException { + String[] deviceNodeNames = devicePath.getNodes(); + if (deviceNodeNames.length <= 1 || !deviceNodeNames[0].equals(root.getName())) { + throw new IllegalPathException(devicePath.getFullPath()); + } + checkTimeseries(devicePath.getFullPath()); + for (String measurement : measurements) { + checkTimeseries(measurement); + } + MNode cur = root; + boolean hasSetStorageGroup = false; + // e.g, devicePath = root.sg.d1, create internal nodes and set cur to d1 node + for (int i = 1; i < deviceNodeNames.length; i++) { + String nodeName = deviceNodeNames[i]; + if (cur instanceof StorageGroupMNode) { + hasSetStorageGroup = true; + } + if (!cur.hasChild(nodeName)) { + if (!hasSetStorageGroup) { + throw new StorageGroupNotSetException("Storage group should be created first"); + } + cur.addChild(nodeName, new MNode(cur, nodeName)); + } + cur = cur.getChild(nodeName); + } + + String leafName = measurements.get(0) + ".align"; + + // synchronize check and add, we need addChild and add Alias become atomic operation + // only write on mtree will be synchronized + synchronized (this) { + MNode child = cur.getChild(leafName); + if (child instanceof MeasurementMNode || child instanceof StorageGroupMNode) { + throw new PathAlreadyExistException(devicePath.getFullPath() + "." + leafName); + } + + int measurementsSize = measurements.size(); + + // this measurementMNode could be a leaf or not. + MeasurementMNode measurementMNode = + new MeasurementMNode( + cur, + leafName, + new VectorMeasurementSchema( + measurements.toArray(new String[measurementsSize]), + dataTypes.toArray(new TSDataType[measurementsSize]), + encodings.toArray(new TSEncoding[measurementsSize]), + compressor), + null); + for (String measurement : measurements) { + if (child != null) { + cur.replaceChild(measurementMNode.getName(), measurementMNode); + } else { + cur.addChild(measurement, measurementMNode); + } + } + } + } + private void checkTimeseries(String timeseries) throws IllegalPathException { if (!IoTDBConfig.NODE_PATTERN.matcher(timeseries).matches()) { throw new IllegalPathException( @@ -473,7 +578,7 @@ public class MTree implements Serializable { throw new IllegalPathException(path.getFullPath()); } // delete the last node of path - curNode.getParent().deleteChild(curNode.getName()); + curNode.getParent().deleteChild(path.getMeasurement()); MeasurementMNode deletedNode = (MeasurementMNode) curNode; if (deletedNode.getAlias() != null) { curNode.getParent().deleteAliasChild(((MeasurementMNode) curNode).getAlias()); @@ -1078,21 +1183,43 @@ public class MTree implements Serializable { return; } } - - PartialPath nodePath = node.getPartialPath(); - String[] tsRow = new String[7]; - tsRow[0] = ((MeasurementMNode) node).getAlias(); IMeasurementSchema measurementSchema = ((MeasurementMNode) node).getSchema(); - tsRow[1] = getStorageGroupPath(nodePath).getFullPath(); - tsRow[2] = measurementSchema.getType().toString(); - tsRow[3] = measurementSchema.getEncodingType().toString(); - tsRow[4] = measurementSchema.getCompressor().toString(); - tsRow[5] = String.valueOf(((MeasurementMNode) node).getOffset()); - tsRow[6] = - needLast ? String.valueOf(getLastTimeStamp((MeasurementMNode) node, queryContext)) : null; - Pair<PartialPath, String[]> temp = new Pair<>(nodePath, tsRow); - timeseriesSchemaList.add(temp); - + if (measurementSchema instanceof MeasurementSchema) { + PartialPath nodePath = node.getPartialPath(); + String[] tsRow = new String[7]; + tsRow[0] = ((MeasurementMNode) node).getAlias(); + tsRow[1] = getStorageGroupPath(nodePath).getFullPath(); + tsRow[2] = measurementSchema.getType().toString(); + tsRow[3] = measurementSchema.getEncodingType().toString(); + tsRow[4] = measurementSchema.getCompressor().toString(); + tsRow[5] = String.valueOf(((MeasurementMNode) node).getOffset()); + tsRow[6] = + needLast + ? String.valueOf(getLastTimeStamp((MeasurementMNode) node, queryContext)) + : null; + Pair<PartialPath, String[]> temp = new Pair<>(nodePath, tsRow); + timeseriesSchemaList.add(temp); + } else if (measurementSchema instanceof VectorMeasurementSchema) { + List<String> measurements = measurementSchema.getValueMeasurementIdList(); + int measurementSize = measurements.size(); + for (int i = 0; i < measurementSize; i++) { + PartialPath devicePath = node.getPartialPath().getDevicePath(); + String[] tsRow = new String[7]; + tsRow[0] = null; + tsRow[1] = getStorageGroupPath(devicePath).getFullPath(); + tsRow[2] = measurementSchema.getValueTSDataTypeList().get(i).toString(); + tsRow[3] = measurementSchema.getValueTSEncodingList().get(i).toString(); + tsRow[4] = measurementSchema.getCompressor().toString(); + tsRow[5] = "0"; + tsRow[6] = + needLast + ? String.valueOf(getLastTimeStamp((MeasurementMNode) node, queryContext)) + : null; + Pair<PartialPath, String[]> temp = + new Pair<>(new PartialPath(devicePath.getFullPath(), measurements.get(i)), tsRow); + timeseriesSchemaList.add(temp); + } + } if (hasLimit) { count.set(count.get() + 1); } diff --git a/server/src/test/java/org/apache/iotdb/db/metadata/MManagerBasicTest.java b/server/src/test/java/org/apache/iotdb/db/metadata/MManagerBasicTest.java index 624f441..1f4bbe4 100644 --- a/server/src/test/java/org/apache/iotdb/db/metadata/MManagerBasicTest.java +++ b/server/src/test/java/org/apache/iotdb/db/metadata/MManagerBasicTest.java @@ -64,7 +64,6 @@ public class MManagerBasicTest { @Test public void testAddPathAndExist() throws IllegalPathException { - MManager manager = IoTDB.metaManager; assertTrue(manager.isPathExist(new PartialPath("root"))); @@ -114,19 +113,19 @@ public class MManagerBasicTest { TSDataType.INT32, TSEncoding.RLE, TSFileDescriptor.getInstance().getConfig().getCompressor(), - Collections.EMPTY_MAP); + Collections.emptyMap()); manager.createTimeseries( new PartialPath("root.laptop.d1.\"1.2.3\""), TSDataType.INT32, TSEncoding.RLE, TSFileDescriptor.getInstance().getConfig().getCompressor(), - Collections.EMPTY_MAP); + Collections.emptyMap()); manager.createTimeseries( new PartialPath("root.1.2.3"), TSDataType.INT32, TSEncoding.RLE, TSFileDescriptor.getInstance().getConfig().getCompressor(), - Collections.EMPTY_MAP); + Collections.emptyMap()); assertTrue(manager.isPathExist(new PartialPath("root.laptop.d1.s1"))); assertTrue(manager.isPathExist(new PartialPath("root.laptop.d1.1_2"))); @@ -231,6 +230,66 @@ public class MManagerBasicTest { } @Test + public void testCreateAlignedTimeseries() throws IllegalPathException { + MManager manager = IoTDB.metaManager; + try { + manager.setStorageGroup(new PartialPath("root.laptop")); + } catch (MetadataException e) { + e.printStackTrace(); + fail(e.getMessage()); + } + + try { + manager.createTimeseries( + new PartialPath("root.laptop.d1.s0"), + TSDataType.valueOf("INT32"), + TSEncoding.valueOf("RLE"), + compressionType, + Collections.emptyMap()); + manager.createAlignedTimeSeries( + new PartialPath("root.laptop.d1"), + Arrays.asList("s1", "s2", "s3"), + Arrays.asList( + TSDataType.valueOf("INT32"), + TSDataType.valueOf("FLOAT"), + TSDataType.valueOf("INT32")), + Arrays.asList( + TSEncoding.valueOf("RLE"), TSEncoding.valueOf("RLE"), TSEncoding.valueOf("RLE")), + compressionType); + } catch (MetadataException e) { + e.printStackTrace(); + fail(e.getMessage()); + } + + assertTrue(manager.isPathExist(new PartialPath("root.laptop"))); + assertTrue(manager.isPathExist(new PartialPath("root.laptop.d1"))); + assertTrue(manager.isPathExist(new PartialPath("root.laptop.d1.s0"))); + assertTrue(manager.isPathExist(new PartialPath("root.laptop.d1.s1"))); + assertTrue(manager.isPathExist(new PartialPath("root.laptop.d1.s2"))); + assertTrue(manager.isPathExist(new PartialPath("root.laptop.d1.s3"))); + + try { + manager.deleteTimeseries(new PartialPath("root.laptop.d1.s2")); + } catch (MetadataException e) { + e.printStackTrace(); + } + + assertTrue(manager.isPathExist(new PartialPath("root.laptop.d1"))); + assertTrue(manager.isPathExist(new PartialPath("root.laptop.d1.s0"))); + assertFalse(manager.isPathExist(new PartialPath("root.laptop.d1.s1"))); + assertFalse(manager.isPathExist(new PartialPath("root.laptop.d1.s2"))); + assertFalse(manager.isPathExist(new PartialPath("root.laptop.d1.s3"))); + + try { + manager.deleteTimeseries(new PartialPath("root.laptop.d1.s0")); + } catch (MetadataException e) { + e.printStackTrace(); + } + assertFalse(manager.isPathExist(new PartialPath("root.laptop.d1"))); + assertFalse(manager.isPathExist(new PartialPath("root.laptop.d1.s0"))); + } + + @Test public void testGetAllTimeseriesCount() { MManager manager = IoTDB.metaManager; diff --git a/server/src/test/java/org/apache/iotdb/db/qp/physical/PhysicalPlanSerializeTest.java b/server/src/test/java/org/apache/iotdb/db/qp/physical/PhysicalPlanSerializeTest.java index e7d1b25..9a3eee3 100644 --- a/server/src/test/java/org/apache/iotdb/db/qp/physical/PhysicalPlanSerializeTest.java +++ b/server/src/test/java/org/apache/iotdb/db/qp/physical/PhysicalPlanSerializeTest.java @@ -51,10 +51,8 @@ import java.io.ByteArrayOutputStream; import java.io.DataOutputStream; import java.io.IOException; import java.nio.ByteBuffer; -import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; -import java.util.List; import java.util.Properties; public class PhysicalPlanSerializeTest { @@ -194,24 +192,12 @@ public class PhysicalPlanSerializeTest { @Test public void createAlignedTimeSeriesPlanSerializeTest() throws IOException, IllegalPathException { - List<String> measurements = new ArrayList<>(); - measurements.add("s1"); - measurements.add("s2"); - - List<TSDataType> dataTypes = new ArrayList<>(); - dataTypes.add(TSDataType.DOUBLE); - dataTypes.add(TSDataType.INT32); - - List<TSEncoding> encodings = new ArrayList<>(); - encodings.add(TSEncoding.RLE); - encodings.add(TSEncoding.RLE); - CreateAlignedTimeSeriesPlan createAlignedTimeSeriesPlan = new CreateAlignedTimeSeriesPlan( new PartialPath("root.sg.d1"), - measurements, - dataTypes, - encodings, + Arrays.asList("s1", "s2"), + Arrays.asList(TSDataType.DOUBLE, TSDataType.INT32), + Arrays.asList(TSEncoding.RLE, TSEncoding.RLE), CompressionType.SNAPPY, null); diff --git a/service-rpc/src/main/java/org/apache/iotdb/rpc/TSStatusCode.java b/service-rpc/src/main/java/org/apache/iotdb/rpc/TSStatusCode.java index f2fd3c1..fd76bfc 100644 --- a/service-rpc/src/main/java/org/apache/iotdb/rpc/TSStatusCode.java +++ b/service-rpc/src/main/java/org/apache/iotdb/rpc/TSStatusCode.java @@ -46,6 +46,7 @@ public enum TSStatusCode { LOAD_FILE_ERROR(316), STORAGE_GROUP_NOT_READY(317), ILLEGAL_PARAMETER(318), + ALIGNED_TIMESERIES_ERROR(319), EXECUTE_STATEMENT_ERROR(400), SQL_PARSE_ERROR(401), diff --git a/tsfile/src/test/java/org/apache/iotdb/tsfile/write/writer/VectorChunkWriterImplTest.java b/tsfile/src/test/java/org/apache/iotdb/tsfile/write/writer/VectorChunkWriterImplTest.java index 7866f48..3ca81b1 100644 --- a/tsfile/src/test/java/org/apache/iotdb/tsfile/write/writer/VectorChunkWriterImplTest.java +++ b/tsfile/src/test/java/org/apache/iotdb/tsfile/write/writer/VectorChunkWriterImplTest.java @@ -65,11 +65,7 @@ public class VectorChunkWriterImplTest { (byte) (0x80 | MetaMarker.ONLY_ONE_PAGE_CHUNK_HEADER), ReadWriteIOUtils.readByte(buffer)); assertEquals("s1.time", ReadWriteIOUtils.readVarIntString(buffer)); assertEquals(164, ReadWriteForEncodingUtils.readUnsignedVarInt(buffer)); -<<<<<<< HEAD assertEquals(TSDataType.VECTOR.serialize(), ReadWriteIOUtils.readByte(buffer)); -======= - assertEquals(TSDataType.Vector.serialize(), ReadWriteIOUtils.readByte(buffer)); ->>>>>>> origin/Vector assertEquals(CompressionType.UNCOMPRESSED.serialize(), ReadWriteIOUtils.readByte(buffer)); assertEquals(TSEncoding.PLAIN.serialize(), ReadWriteIOUtils.readByte(buffer)); buffer.position(buffer.position() + 164); @@ -142,11 +138,7 @@ public class VectorChunkWriterImplTest { assertEquals((byte) (0x80 | MetaMarker.CHUNK_HEADER), ReadWriteIOUtils.readByte(buffer)); assertEquals("s1.time", ReadWriteIOUtils.readVarIntString(buffer)); assertEquals(362, ReadWriteForEncodingUtils.readUnsignedVarInt(buffer)); -<<<<<<< HEAD assertEquals(TSDataType.VECTOR.serialize(), ReadWriteIOUtils.readByte(buffer)); -======= - assertEquals(TSDataType.Vector.serialize(), ReadWriteIOUtils.readByte(buffer)); ->>>>>>> origin/Vector assertEquals(CompressionType.UNCOMPRESSED.serialize(), ReadWriteIOUtils.readByte(buffer)); assertEquals(TSEncoding.PLAIN.serialize(), ReadWriteIOUtils.readByte(buffer)); buffer.position(buffer.position() + 362);
