You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by su...@apache.org on 2021/03/13 15:38:16 UTC
[iotdb] branch CreateAlignedTimeseriesPlan created (now 567491f)
This is an automated email from the ASF dual-hosted git repository.
sunzesong pushed a change to branch CreateAlignedTimeseriesPlan
in repository https://gitbox.apache.org/repos/asf/iotdb.git.
at 567491f Merge remote-tracking branch 'origin/Vector' into Vector
This branch includes the following new commits:
new 3f6b915 [IOTDB-1225] Support CreateAlignedTimeseriesPlan in MManager
new 567491f Merge remote-tracking branch 'origin/Vector' into Vector
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[iotdb] 01/02: [IOTDB-1225] Support CreateAlignedTimeseriesPlan in
MManager
Posted by su...@apache.org.
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 <sz...@mails.tsinghua.edu.cn>
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);
[iotdb] 02/02: Merge remote-tracking branch 'origin/Vector' into
Vector
Posted by su...@apache.org.
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 567491f8ba2a74ac2d1d4345c1a339e51a500d93
Merge: 3f6b915 b2ee6ca
Author: samperson1997 <sz...@mails.tsinghua.edu.cn>
AuthorDate: Sat Mar 13 23:25:32 2021 +0800
Merge remote-tracking branch 'origin/Vector' into Vector
.../iotdb/db/engine/flush/MemTableFlushTask.java | 69 +++-
.../iotdb/db/engine/memtable/AbstractMemTable.java | 44 ++-
.../apache/iotdb/db/engine/memtable/IMemTable.java | 2 +
.../db/engine/memtable/IWritableMemChunk.java | 4 +
.../iotdb/db/engine/memtable/WritableMemChunk.java | 13 +
.../db/engine/querycontext/ReadOnlyMemChunk.java | 3 +
.../org/apache/iotdb/db/metadata/PartialPath.java | 6 +-
.../iotdb/db/metadata/VectorPartialPath.java | 58 +++
.../iotdb/db/rescon/PrimitiveArrayManager.java | 8 +
.../iotdb/db/utils/datastructure/TVList.java | 16 +
.../iotdb/db/utils/datastructure/VectorTVList.java | 419 +++++++++++++++++++++
.../db/engine/memtable/PrimitiveMemTableTest.java | 60 +++
.../db/utils/datastructure/VectorTVListTest.java | 105 ++++++
.../writelog/recover/UnseqTsFileRecoverTest.java | 18 +-
.../tsfile/file/metadata/enums/TSDataType.java | 3 +-
.../apache/iotdb/tsfile/utils/TsPrimitiveType.java | 4 +-
.../tsfile/write/schema/IMeasurementSchema.java | 1 -
.../write/writer/VectorMeasurementSchemaStub.java | 8 +-
18 files changed, 816 insertions(+), 25 deletions(-)