This is an automated email from the ASF dual-hosted git repository.
jiangtian pushed a commit to branch tsFile_v4
in repository https://gitbox.apache.org/repos/asf/tsfile.git
The following commit(s) were added to refs/heads/tsFile_v4 by this push:
new 3286aa7b Factorize IDeviceId
3286aa7b is described below
commit 3286aa7b38514d466db7859a110a83e0657cad27
Author: jt2594838 <[email protected]>
AuthorDate: Fri Apr 12 10:44:05 2024 +0800
Factorize IDeviceId
---
.../CompatibilityUtils.java | 43 ++++++-
.../tsfile/file/header/ChunkGroupHeader.java | 20 +--
.../file/metadata/DeviceMetadataIndexEntry.java | 25 +++-
.../org/apache/tsfile/file/metadata/IDeviceID.java | 31 ++++-
.../apache/tsfile/file/metadata/PlainDeviceID.java | 30 ++++-
.../tsfile/file/metadata/StringArrayDeviceID.java | 68 +++++++++-
.../apache/tsfile/file/metadata/TableSchema.java | 4 +
.../java/org/apache/tsfile/read/common/Path.java | 3 +-
.../org/apache/tsfile/utils/ReadWriteIOUtils.java | 4 +-
.../java/org/apache/tsfile/write/TsFileWriter.java | 140 ++++++++------------
.../org/apache/tsfile/write/schema/Schema.java | 33 +++--
.../apache/tsfile/file/metadata/utils/Utils.java | 8 +-
.../tsfile/write/MetadataIndexConstructorTest.java | 2 +-
.../apache/tsfile/write/TableViewWriteTest.java | 141 +++++++++++++++++++++
.../apache/tsfile/write/TsFileIOWriterTest.java | 2 +-
15 files changed, 422 insertions(+), 132 deletions(-)
diff --git
a/tsfile/src/main/java/org/apache/tsfile/utils/CompatibilityUtils.java
b/tsfile/src/main/java/org/apache/tsfile/compatibility/CompatibilityUtils.java
similarity index 54%
rename from tsfile/src/main/java/org/apache/tsfile/utils/CompatibilityUtils.java
rename to
tsfile/src/main/java/org/apache/tsfile/compatibility/CompatibilityUtils.java
index 4f8bcb99..0933c1ec 100644
--- a/tsfile/src/main/java/org/apache/tsfile/utils/CompatibilityUtils.java
+++
b/tsfile/src/main/java/org/apache/tsfile/compatibility/CompatibilityUtils.java
@@ -17,15 +17,29 @@
* under the License.
*/
-package org.apache.tsfile.utils;
+package org.apache.tsfile.compatibility;
+import org.apache.tsfile.file.metadata.DeviceMetadataIndexEntry;
+import org.apache.tsfile.file.metadata.DeviceMetadataIndexEntry.Deserializer;
+import org.apache.tsfile.file.metadata.IDeviceID;
import org.apache.tsfile.file.metadata.MetadataIndexNode;
+import org.apache.tsfile.file.metadata.PlainDeviceID;
import org.apache.tsfile.file.metadata.TsFileMetadata;
+import org.apache.tsfile.utils.BloomFilter;
+import org.apache.tsfile.utils.ReadWriteForEncodingUtils;
+import org.apache.tsfile.utils.ReadWriteIOUtils;
+import java.io.IOException;
+import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.Collections;
public class CompatibilityUtils {
+
+ private CompatibilityUtils() {
+ // util class
+ }
+
public static TsFileMetadata deserializeTsFileMetadataFromV3(ByteBuffer
buffer) {
TsFileMetadata fileMetaData = new TsFileMetadata();
@@ -48,4 +62,31 @@ public class CompatibilityUtils {
return fileMetaData;
}
+
+ public static DeviceMetadataIndexEntry.Deserializer
v3DeviceMetadataIndexEntryDeserializer =
+ new Deserializer() {
+ @Override
+ public DeviceMetadataIndexEntry deserializeFrom(ByteBuffer buffer) {
+ return deserializeFromV3(buffer);
+ }
+
+ @Override
+ public DeviceMetadataIndexEntry deserializeFrom(InputStream
inputStream)
+ throws IOException {
+ return deserializeFromV3(inputStream);
+ }
+ };
+
+ public static DeviceMetadataIndexEntry deserializeFromV3(ByteBuffer buffer) {
+ IDeviceID device = PlainDeviceID.DESERIALIZER.deserializeFrom(buffer);
+ long offset = ReadWriteIOUtils.readLong(buffer);
+ return new DeviceMetadataIndexEntry(device, offset);
+ }
+
+ public static DeviceMetadataIndexEntry deserializeFromV3(InputStream
inputStream)
+ throws IOException {
+ IDeviceID device = PlainDeviceID.DESERIALIZER.deserializeFrom(inputStream);
+ long offset = ReadWriteIOUtils.readLong(inputStream);
+ return new DeviceMetadataIndexEntry(device, offset);
+ }
}
diff --git
a/tsfile/src/main/java/org/apache/tsfile/file/header/ChunkGroupHeader.java
b/tsfile/src/main/java/org/apache/tsfile/file/header/ChunkGroupHeader.java
index 8e327af6..05c98a26 100644
--- a/tsfile/src/main/java/org/apache/tsfile/file/header/ChunkGroupHeader.java
+++ b/tsfile/src/main/java/org/apache/tsfile/file/header/ChunkGroupHeader.java
@@ -19,7 +19,6 @@
package org.apache.tsfile.file.header;
-import org.apache.tsfile.common.conf.TSFileConfig;
import org.apache.tsfile.file.MetaMarker;
import org.apache.tsfile.file.metadata.IDeviceID;
import org.apache.tsfile.file.metadata.PlainDeviceID;
@@ -56,8 +55,7 @@ public class ChunkGroupHeader {
private int getSerializedSize(IDeviceID deviceID) {
// TODO: add an interface in IDeviceID
- int length =
- ((PlainDeviceID)
deviceID).toStringID().getBytes(TSFileConfig.STRING_CHARSET).length;
+ int length = deviceID.serializedSize();
return Byte.BYTES + ReadWriteForEncodingUtils.varIntSize(length) + length;
}
@@ -77,11 +75,8 @@ public class ChunkGroupHeader {
}
// TODO: add an interface in IDeviceID
- String deviceID = ReadWriteIOUtils.readVarIntString(inputStream);
- if (deviceID == null || deviceID.isEmpty()) {
- throw new IOException("DeviceId is empty");
- }
- return new ChunkGroupHeader(new PlainDeviceID(deviceID));
+ final IDeviceID deviceID =
IDeviceID.DEFAULT_DESERIALIZER.deserializeFrom(inputStream);
+ return new ChunkGroupHeader(deviceID);
}
/**
@@ -97,8 +92,13 @@ public class ChunkGroupHeader {
offsetVar++;
}
// TODO: add an interface in IDeviceID
- String deviceID = input.readVarIntString(offsetVar);
- return new ChunkGroupHeader(new PlainDeviceID(deviceID));
+ final InputStream inputStream = input.wrapAsInputStream();
+ final long skipped = inputStream.skip(offsetVar);
+ if (skipped != offsetVar) {
+ throw new IOException("Skipped " + skipped + " of " + offsetVar);
+ }
+ final IDeviceID deviceID =
IDeviceID.DEFAULT_DESERIALIZER.deserializeFrom(inputStream);
+ return new ChunkGroupHeader(deviceID);
}
public IDeviceID getDeviceID() {
diff --git
a/tsfile/src/main/java/org/apache/tsfile/file/metadata/DeviceMetadataIndexEntry.java
b/tsfile/src/main/java/org/apache/tsfile/file/metadata/DeviceMetadataIndexEntry.java
index 9993cb7a..7d572d6a 100644
---
a/tsfile/src/main/java/org/apache/tsfile/file/metadata/DeviceMetadataIndexEntry.java
+++
b/tsfile/src/main/java/org/apache/tsfile/file/metadata/DeviceMetadataIndexEntry.java
@@ -28,6 +28,21 @@ import java.io.OutputStream;
import java.nio.ByteBuffer;
public class DeviceMetadataIndexEntry implements IMetadataIndexEntry {
+
+ public static final Deserializer DESERIALIZER =
+ new Deserializer() {
+ @Override
+ public DeviceMetadataIndexEntry deserializeFrom(ByteBuffer buffer) {
+ return DeviceMetadataIndexEntry.deserializeFrom(buffer);
+ }
+
+ @Override
+ public DeviceMetadataIndexEntry deserializeFrom(InputStream
inputStream)
+ throws IOException {
+ return DeviceMetadataIndexEntry.deserializeFrom(inputStream);
+ }
+ };
+
private IDeviceID deviceID;
private long offset;
@@ -73,14 +88,14 @@ public class DeviceMetadataIndexEntry implements
IMetadataIndexEntry {
}
public static DeviceMetadataIndexEntry deserializeFrom(ByteBuffer buffer) {
- IDeviceID device = IDeviceID.deserializeFrom(buffer);
+ IDeviceID device = IDeviceID.DEFAULT_DESERIALIZER.deserializeFrom(buffer);
long offset = ReadWriteIOUtils.readLong(buffer);
return new DeviceMetadataIndexEntry(device, offset);
}
public static DeviceMetadataIndexEntry deserializeFrom(InputStream
inputStream)
throws IOException {
- IDeviceID device = IDeviceID.deserializeFrom(inputStream);
+ IDeviceID device =
IDeviceID.DEFAULT_DESERIALIZER.deserializeFrom(inputStream);
long offset = ReadWriteIOUtils.readLong(inputStream);
return new DeviceMetadataIndexEntry(device, offset);
}
@@ -89,4 +104,10 @@ public class DeviceMetadataIndexEntry implements
IMetadataIndexEntry {
public String toString() {
return "<" + deviceID + "," + offset + ">";
}
+
+ public interface Deserializer {
+ DeviceMetadataIndexEntry deserializeFrom(ByteBuffer buffer);
+
+ DeviceMetadataIndexEntry deserializeFrom(InputStream inputStream) throws
IOException;
+ }
}
diff --git
a/tsfile/src/main/java/org/apache/tsfile/file/metadata/IDeviceID.java
b/tsfile/src/main/java/org/apache/tsfile/file/metadata/IDeviceID.java
index 5fadc0ab..9e13b6da 100644
--- a/tsfile/src/main/java/org/apache/tsfile/file/metadata/IDeviceID.java
+++ b/tsfile/src/main/java/org/apache/tsfile/file/metadata/IDeviceID.java
@@ -20,8 +20,11 @@
package org.apache.tsfile.file.metadata;
import org.apache.tsfile.utils.Accountable;
-import org.apache.tsfile.utils.ReadWriteIOUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
@@ -30,6 +33,10 @@ import java.nio.ByteBuffer;
/** Device id interface. */
public interface IDeviceID extends Comparable<IDeviceID>, Accountable {
+ Logger LOGGER = LoggerFactory.getLogger(IDeviceID.class);
+ Deserializer DEFAULT_DESERIALIZER = StringArrayDeviceID.DESERIALIZER;
+ Factory DEFAULT_FACTORY = StringArrayDeviceID.FACTORY;
+
int serialize(ByteBuffer byteBuffer);
int serialize(OutputStream outputStream) throws IOException;
@@ -59,11 +66,25 @@ public interface IDeviceID extends Comparable<IDeviceID>,
Accountable {
*/
Object segment(int i);
- static IDeviceID deserializeFrom(ByteBuffer byteBuffer) {
- return new PlainDeviceID(ReadWriteIOUtils.readVarIntString(byteBuffer));
+ default int serializedSize() {
+ LOGGER.debug(
+ "Using default inefficient implementation of serialized size by {}",
this.getClass());
+ try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
+ serialize(baos);
+ return baos.size();
+ } catch (IOException e) {
+ LOGGER.error("Failed to serialize device ID: {}", this, e);
+ return -1;
+ }
+ }
+
+ interface Deserializer {
+ IDeviceID deserializeFrom(ByteBuffer byteBuffer);
+
+ IDeviceID deserializeFrom(InputStream inputStream) throws IOException;
}
- static IDeviceID deserializeFrom(InputStream inputStream) throws IOException
{
- return new PlainDeviceID(ReadWriteIOUtils.readVarIntString(inputStream));
+ interface Factory {
+ IDeviceID create(String deviceIdString);
}
}
diff --git
a/tsfile/src/main/java/org/apache/tsfile/file/metadata/PlainDeviceID.java
b/tsfile/src/main/java/org/apache/tsfile/file/metadata/PlainDeviceID.java
index f7bb0b84..a983b2f0 100644
--- a/tsfile/src/main/java/org/apache/tsfile/file/metadata/PlainDeviceID.java
+++ b/tsfile/src/main/java/org/apache/tsfile/file/metadata/PlainDeviceID.java
@@ -24,6 +24,7 @@ import org.apache.tsfile.utils.RamUsageEstimator;
import org.apache.tsfile.utils.ReadWriteIOUtils;
import java.io.IOException;
+import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.Objects;
@@ -34,6 +35,27 @@ import static
org.apache.tsfile.utils.RamUsageEstimator.sizeOfCharArray;
/** Using device id path as id. */
public class PlainDeviceID implements IDeviceID {
+ public static final Deserializer DESERIALIZER =
+ new Deserializer() {
+ @Override
+ public IDeviceID deserializeFrom(ByteBuffer byteBuffer) {
+ return deserialize(byteBuffer);
+ }
+
+ @Override
+ public IDeviceID deserializeFrom(InputStream inputStream) throws
IOException {
+ return deserialize(inputStream);
+ }
+ };
+
+ public static final Factory FACTORY =
+ new Factory() {
+ @Override
+ public IDeviceID create(String deviceIdString) {
+ return new PlainDeviceID(deviceIdString);
+ }
+ };
+
// TODO: configurable but unchangeable
private static final int DEFAULT_SEGMENT_NUM_FOR_TABLE_NAME = 3;
private static final long INSTANCE_SIZE =
@@ -106,8 +128,12 @@ public class PlainDeviceID implements IDeviceID {
return size;
}
- public static PlainDeviceID deserialize(ByteBuffer byteBuffer) {
- return new PlainDeviceID(ReadWriteIOUtils.readString(byteBuffer));
+ public static IDeviceID deserialize(ByteBuffer byteBuffer) {
+ return new PlainDeviceID(ReadWriteIOUtils.readVarIntString(byteBuffer));
+ }
+
+ public static IDeviceID deserialize(InputStream inputStream) throws
IOException {
+ return new PlainDeviceID(ReadWriteIOUtils.readVarIntString(inputStream));
}
@Override
diff --git
a/tsfile/src/main/java/org/apache/tsfile/file/metadata/StringArrayDeviceID.java
b/tsfile/src/main/java/org/apache/tsfile/file/metadata/StringArrayDeviceID.java
index 45b10610..40f16aff 100644
---
a/tsfile/src/main/java/org/apache/tsfile/file/metadata/StringArrayDeviceID.java
+++
b/tsfile/src/main/java/org/apache/tsfile/file/metadata/StringArrayDeviceID.java
@@ -19,6 +19,8 @@
package org.apache.tsfile.file.metadata;
+import org.apache.tsfile.common.conf.TSFileConfig;
+import org.apache.tsfile.common.constant.TsFileConstant;
import org.apache.tsfile.exception.TsFileRuntimeException;
import org.apache.tsfile.utils.RamUsageEstimator;
import org.apache.tsfile.utils.ReadWriteIOUtils;
@@ -26,13 +28,34 @@ import org.apache.tsfile.utils.WriteUtils;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
+import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
import java.util.Objects;
public class StringArrayDeviceID implements IDeviceID {
+ public static final Deserializer DESERIALIZER =
+ new Deserializer() {
+ @Override
+ public IDeviceID deserializeFrom(ByteBuffer byteBuffer) {
+ return deserialize(byteBuffer);
+ }
+
+ @Override
+ public IDeviceID deserializeFrom(InputStream inputStream) throws
IOException {
+ return deserialize(inputStream);
+ }
+ };
+
+ public static final Factory FACTORY =
+ new Factory() {
+ @Override
+ public IDeviceID create(String deviceIdString) {
+ return new StringArrayDeviceID(deviceIdString);
+ }
+ };
+
private static final long INSTANCE_SIZE =
RamUsageEstimator.shallowSizeOfInstance(StringArrayDeviceID.class);
@@ -44,6 +67,10 @@ public class StringArrayDeviceID implements IDeviceID {
this.segments = segments;
}
+ public StringArrayDeviceID(String deviceIdString) {
+ this.segments =
deviceIdString.split(TsFileConstant.PATH_SEPARATER_NO_REGEX);
+ }
+
@Override
public int serialize(ByteBuffer byteBuffer) {
int cnt = 0;
@@ -64,12 +91,39 @@ public class StringArrayDeviceID implements IDeviceID {
return cnt;
}
+ public static StringArrayDeviceID deserialize(ByteBuffer byteBuffer) {
+ final int cnt = byteBuffer.getInt();
+ String[] segments = new String[cnt];
+ for (int i = 0; i < cnt; i++) {
+ final int stringSize = byteBuffer.getInt();
+ byte[] stringBytes = new byte[stringSize];
+ byteBuffer.get(stringBytes);
+ segments[i] = new String(stringBytes, TSFileConfig.STRING_CHARSET);
+ }
+ return new StringArrayDeviceID(segments);
+ }
+
+ public static StringArrayDeviceID deserialize(InputStream stream) throws
IOException {
+ final int cnt = ReadWriteIOUtils.readInt(stream);
+ String[] segments = new String[cnt];
+ for (int i = 0; i < cnt; i++) {
+ final int stringSize = ReadWriteIOUtils.readInt(stream);
+ byte[] stringBytes = new byte[stringSize];
+ final int readCnt = stream.read(stringBytes);
+ if (readCnt != stringSize) {
+ throw new IOException(String.format("Expected %d bytes but read %d",
stringSize, readCnt));
+ }
+ segments[i] = new String(stringBytes, TSFileConfig.STRING_CHARSET);
+ }
+ return new StringArrayDeviceID(segments);
+ }
+
@Override
public byte[] getBytes() {
ByteArrayOutputStream publicBAOS = new ByteArrayOutputStream(256);
for (String segment : segments) {
try {
- publicBAOS.write(segment.getBytes(StandardCharsets.UTF_8));
+ publicBAOS.write(segment.getBytes(TSFileConfig.STRING_CHARSET));
} catch (IOException e) {
throw new TsFileRuntimeException(e);
}
@@ -127,4 +181,14 @@ public class StringArrayDeviceID implements IDeviceID {
public long ramBytesUsed() {
return INSTANCE_SIZE + RamUsageEstimator.sizeOf(segments);
}
+
+ @Override
+ public int serializedSize() {
+ int cnt = Integer.BYTES;
+ for (String segment : segments) {
+ cnt += Integer.BYTES;
+ cnt += segment.getBytes(TSFileConfig.STRING_CHARSET).length;
+ }
+ return cnt;
+ }
}
diff --git
a/tsfile/src/main/java/org/apache/tsfile/file/metadata/TableSchema.java
b/tsfile/src/main/java/org/apache/tsfile/file/metadata/TableSchema.java
index 1a391d0a..c5625ecc 100644
--- a/tsfile/src/main/java/org/apache/tsfile/file/metadata/TableSchema.java
+++ b/tsfile/src/main/java/org/apache/tsfile/file/metadata/TableSchema.java
@@ -134,4 +134,8 @@ public class TableSchema {
}
return new TableSchema(tableName, measurementSchemas, columnTypes);
}
+
+ public String getTableName() {
+ return tableName;
+ }
}
diff --git a/tsfile/src/main/java/org/apache/tsfile/read/common/Path.java
b/tsfile/src/main/java/org/apache/tsfile/read/common/Path.java
index 3a682bf1..b89866b3 100644
--- a/tsfile/src/main/java/org/apache/tsfile/read/common/Path.java
+++ b/tsfile/src/main/java/org/apache/tsfile/read/common/Path.java
@@ -23,6 +23,7 @@ import org.apache.tsfile.common.constant.TsFileConstant;
import org.apache.tsfile.exception.PathParseException;
import org.apache.tsfile.file.metadata.IDeviceID;
import org.apache.tsfile.file.metadata.PlainDeviceID;
+import org.apache.tsfile.file.metadata.StringArrayDeviceID;
import org.apache.tsfile.read.common.parser.PathNodesGenerator;
import org.apache.tsfile.utils.PublicBAOS;
import org.apache.tsfile.utils.ReadWriteIOUtils;
@@ -151,7 +152,7 @@ public class Path implements Serializable, Comparable<Path>
{
}
public IDeviceID getIDeviceID() {
- return new PlainDeviceID(getDevice());
+ return new
StringArrayDeviceID(getDevice().split(TsFileConstant.PATH_SEPARATER_NO_REGEX));
}
public String getMeasurement() {
diff --git a/tsfile/src/main/java/org/apache/tsfile/utils/ReadWriteIOUtils.java
b/tsfile/src/main/java/org/apache/tsfile/utils/ReadWriteIOUtils.java
index 6e55e760..84175bcb 100644
--- a/tsfile/src/main/java/org/apache/tsfile/utils/ReadWriteIOUtils.java
+++ b/tsfile/src/main/java/org/apache/tsfile/utils/ReadWriteIOUtils.java
@@ -378,7 +378,7 @@ public class ReadWriteIOUtils {
return len;
}
- byte[] bytes = s.getBytes();
+ byte[] bytes = s.getBytes(TSFileConfig.STRING_CHARSET);
len += write(bytes.length, outputStream);
outputStream.write(bytes);
len += bytes.length;
@@ -414,7 +414,7 @@ public class ReadWriteIOUtils {
return write(NO_BYTE_TO_READ, buffer);
}
int len = 0;
- byte[] bytes = s.getBytes();
+ byte[] bytes = s.getBytes(TSFileConfig.STRING_CHARSET);
len += write(bytes.length, buffer);
buffer.put(bytes);
len += bytes.length;
diff --git a/tsfile/src/main/java/org/apache/tsfile/write/TsFileWriter.java
b/tsfile/src/main/java/org/apache/tsfile/write/TsFileWriter.java
index b4d282d3..b9c5d0f3 100644
--- a/tsfile/src/main/java/org/apache/tsfile/write/TsFileWriter.java
+++ b/tsfile/src/main/java/org/apache/tsfile/write/TsFileWriter.java
@@ -129,7 +129,6 @@ public class TsFileWriter implements AutoCloseable {
*
* @param output the TsFileOutput of the file to be written by this
TsFileWriter
* @param schema the schema of this TsFile
- * @throws IOException
*/
public TsFileWriter(TsFileOutput output, Schema schema) throws IOException {
this(new TsFileIOWriter(output), schema,
TSFileDescriptor.getInstance().getConfig());
@@ -164,13 +163,13 @@ public class TsFileWriter implements AutoCloseable {
if (fileWriter instanceof RestorableTsFileIOWriter) {
Map<Path, IMeasurementSchema> schemaMap =
((RestorableTsFileIOWriter) fileWriter).getKnownSchema();
- Map<Path, MeasurementGroup> measurementGroupMap = new HashMap<>();
+ Map<IDeviceID, MeasurementGroup> measurementGroupMap = new HashMap<>();
for (Map.Entry<Path, IMeasurementSchema> entry : schemaMap.entrySet()) {
IMeasurementSchema measurementSchema = entry.getValue();
if (measurementSchema instanceof VectorMeasurementSchema) {
+ final IDeviceID deviceID =
IDeviceID.DEFAULT_FACTORY.create(entry.getKey().getDevice());
MeasurementGroup group =
- measurementGroupMap.getOrDefault(
- new Path(entry.getKey().getDevice()), new
MeasurementGroup(true));
+ measurementGroupMap.getOrDefault(deviceID, new
MeasurementGroup(true));
List<String> measurementList =
measurementSchema.getSubMeasurementsList();
for (int i = 0; i < measurementList.size(); i++) {
group
@@ -182,15 +181,15 @@ public class TsFileWriter implements AutoCloseable {
measurementSchema.getSubMeasurementsTSDataTypeList().get(i),
measurementSchema.getSubMeasurementsTSEncodingList().get(i)));
}
- measurementGroupMap.put(new Path(entry.getKey().getDevice()), group);
+ measurementGroupMap.put(deviceID, group);
} else {
+ final IDeviceID deviceID =
IDeviceID.DEFAULT_FACTORY.create(entry.getKey().getDevice());
MeasurementGroup group =
- measurementGroupMap.getOrDefault(
- new Path(entry.getKey().getDevice()), new
MeasurementGroup(false));
+ measurementGroupMap.getOrDefault(deviceID, new
MeasurementGroup(false));
group
.getMeasurementSchemaMap()
.put(measurementSchema.getMeasurementId(), (MeasurementSchema)
measurementSchema);
- measurementGroupMap.put(new Path(entry.getKey().getDevice()), group);
+ measurementGroupMap.put(deviceID, group);
}
}
getSchema().setRegisteredTimeseries(measurementGroupMap);
@@ -217,45 +216,37 @@ public class TsFileWriter implements AutoCloseable {
/**
* This method is used to register all timeseries in the specified template
under the specified
* device.
- *
- * @param deviceId
- * @param templateName
- * @throws WriteProcessException
*/
- public void registerDevice(String deviceId, String templateName) throws
WriteProcessException {
+ public void registerDevice(String deviceIdString, String templateName)
+ throws WriteProcessException {
+ IDeviceID deviceID = IDeviceID.DEFAULT_FACTORY.create(deviceIdString);
if (!getSchema().getSchemaTemplates().containsKey(templateName)) {
throw new WriteProcessException("given template is not existed! " +
templateName);
}
- if (getSchema().getRegisteredTimeseriesMap().containsKey(new
Path(deviceId))) {
+ if (getSchema().getRegisteredTimeseriesMap().containsKey(deviceID)) {
throw new WriteProcessException(
"this device "
- + deviceId
+ + deviceIdString
+ " has been registered, you can only use registerDevice method
to register empty device.");
}
- getSchema().registerDevice(deviceId, templateName);
+ getSchema().registerDevice(deviceID, templateName);
}
- /**
- * Register nonAligned timeseries by single.
- *
- * @param devicePath
- * @param measurementSchema
- * @throws WriteProcessException
- */
- public void registerTimeseries(Path devicePath, MeasurementSchema
measurementSchema)
+ /** Register nonAligned timeseries by single. */
+ public void registerTimeseries(IDeviceID deviceID, MeasurementSchema
measurementSchema)
throws WriteProcessException {
MeasurementGroup measurementGroup;
- if (getSchema().containsDevice(devicePath)) {
- measurementGroup = getSchema().getSeriesSchema(devicePath);
+ if (getSchema().containsDevice(deviceID)) {
+ measurementGroup = getSchema().getSeriesSchema(deviceID);
if (measurementGroup.isAligned()) {
throw new WriteProcessException(
- "given device " + devicePath + " has been registered for aligned
timeseries.");
+ "given device " + deviceID + " has been registered for aligned
timeseries.");
} else if (measurementGroup
.getMeasurementSchemaMap()
.containsKey(measurementSchema.getMeasurementId())) {
throw new WriteProcessException(
"given nonAligned timeseries "
- + (devicePath + "." + measurementSchema.getMeasurementId())
+ + (deviceID + "." + measurementSchema.getMeasurementId())
+ " has been registered.");
}
} else {
@@ -264,44 +255,40 @@ public class TsFileWriter implements AutoCloseable {
measurementGroup
.getMeasurementSchemaMap()
.put(measurementSchema.getMeasurementId(), measurementSchema);
- getSchema().registerMeasurementGroup(devicePath, measurementGroup);
+ getSchema().registerMeasurementGroup(deviceID, measurementGroup);
}
- /**
- * Register nonAligned timeseries by groups.
- *
- * @param devicePath
- * @param measurementSchemas
- */
+ /** Register nonAligned timeseries by groups. */
public void registerTimeseries(Path devicePath, List<MeasurementSchema>
measurementSchemas) {
for (MeasurementSchema schema : measurementSchemas) {
try {
- registerTimeseries(devicePath, schema);
+
registerTimeseries(IDeviceID.DEFAULT_FACTORY.create(devicePath.getDevice()),
schema);
} catch (WriteProcessException e) {
LOG.warn(e.getMessage());
}
}
}
+ public void registerAlignedTimeseries(Path devicePath,
List<MeasurementSchema> measurementSchemas)
+ throws WriteProcessException {
+ registerAlignedTimeseries(
+ IDeviceID.DEFAULT_FACTORY.create(devicePath.getDevice()),
measurementSchemas);
+ }
/**
* Register aligned timeseries. Once the device is registered for aligned
timeseries, it cannot be
* expanded.
- *
- * @param devicePath
- * @param measurementSchemas
- * @throws WriteProcessException
*/
- public void registerAlignedTimeseries(Path devicePath,
List<MeasurementSchema> measurementSchemas)
- throws WriteProcessException {
- if (getSchema().containsDevice(devicePath)) {
- if (getSchema().getSeriesSchema(devicePath).isAligned()) {
+ public void registerAlignedTimeseries(
+ IDeviceID deviceID, List<MeasurementSchema> measurementSchemas) throws
WriteProcessException {
+ if (getSchema().containsDevice(deviceID)) {
+ if (getSchema().getSeriesSchema(deviceID).isAligned()) {
throw new WriteProcessException(
"given device "
- + devicePath
+ + deviceID
+ " has been registered for aligned timeseries and should not
be expanded.");
} else {
throw new WriteProcessException(
- "given device " + devicePath + " has been registered for
nonAligned timeseries.");
+ "given device " + deviceID + " has been registered for nonAligned
timeseries.");
}
}
MeasurementGroup measurementGroup = new MeasurementGroup(true);
@@ -311,34 +298,30 @@ public class TsFileWriter implements AutoCloseable {
.getMeasurementSchemaMap()
.put(measurementSchema.getMeasurementId(), measurementSchema);
});
- getSchema().registerMeasurementGroup(devicePath, measurementGroup);
+ getSchema().registerMeasurementGroup(deviceID, measurementGroup);
}
private boolean checkIsTimeseriesExist(TSRecord record, boolean isAligned)
throws WriteProcessException, IOException {
// initial ChunkGroupWriter of this device in the TSRecord
- IChunkGroupWriter groupWriter =
- tryToInitialGroupWriter(new PlainDeviceID(record.deviceId), isAligned);
+ final IDeviceID deviceID =
IDeviceID.DEFAULT_FACTORY.create(record.deviceId);
+ IChunkGroupWriter groupWriter = tryToInitialGroupWriter(deviceID,
isAligned);
// initial all SeriesWriters of measurements in this TSRecord
- Path devicePath = new Path(record.deviceId);
List<MeasurementSchema> measurementSchemas;
- if (getSchema().containsDevice(devicePath)) {
+ if (getSchema().containsDevice(deviceID)) {
measurementSchemas =
checkIsAllMeasurementsInGroup(
- record.dataPointList, getSchema().getSeriesSchema(devicePath),
isAligned);
+ record.dataPointList, getSchema().getSeriesSchema(deviceID),
isAligned);
if (isAligned) {
for (IMeasurementSchema s : measurementSchemas) {
- if (flushedMeasurementsInDeviceMap.containsKey(
- new PlainDeviceID(devicePath.getFullPath()))
- && !flushedMeasurementsInDeviceMap
- .get(new PlainDeviceID(devicePath.getFullPath()))
- .contains(s.getMeasurementId())) {
+ if (flushedMeasurementsInDeviceMap.containsKey(deviceID)
+ &&
!flushedMeasurementsInDeviceMap.get(deviceID).contains(s.getMeasurementId())) {
throw new WriteProcessException(
"TsFile has flushed chunk group and should not add new
measurement "
+ s.getMeasurementId()
+ " in device "
- + devicePath.getFullPath());
+ + deviceID);
}
}
}
@@ -352,7 +335,7 @@ public class TsFileWriter implements AutoCloseable {
checkIsAllMeasurementsInGroup(record.dataPointList,
measurementGroup, isAligned);
groupWriter.tryToAddSeriesWriter(measurementSchemas);
} else {
- throw new NoMeasurementException("input devicePath is invalid: " +
devicePath);
+ throw new NoMeasurementException("input devicePath is invalid: " +
deviceID);
}
return true;
}
@@ -380,25 +363,21 @@ public class TsFileWriter implements AutoCloseable {
private void checkIsTimeseriesExist(Tablet tablet, boolean isAligned)
throws WriteProcessException, IOException {
- IChunkGroupWriter groupWriter =
- tryToInitialGroupWriter(new PlainDeviceID(tablet.insertTargetName),
isAligned);
+ final IDeviceID deviceID =
IDeviceID.DEFAULT_FACTORY.create(tablet.insertTargetName);
+ IChunkGroupWriter groupWriter = tryToInitialGroupWriter(deviceID,
isAligned);
- Path devicePath = new Path(tablet.insertTargetName);
List<MeasurementSchema> schemas = tablet.getSchemas();
- if (getSchema().containsDevice(devicePath)) {
- checkIsAllMeasurementsInGroup(getSchema().getSeriesSchema(devicePath),
schemas, isAligned);
+ if (getSchema().containsDevice(deviceID)) {
+ checkIsAllMeasurementsInGroup(getSchema().getSeriesSchema(deviceID),
schemas, isAligned);
if (isAligned) {
for (IMeasurementSchema s : schemas) {
- if (flushedMeasurementsInDeviceMap.containsKey(
- new PlainDeviceID(devicePath.getFullPath()))
- && !flushedMeasurementsInDeviceMap
- .get(new PlainDeviceID(devicePath.getFullPath()))
- .contains(s.getMeasurementId())) {
+ if (flushedMeasurementsInDeviceMap.containsKey(deviceID)
+ &&
!flushedMeasurementsInDeviceMap.get(deviceID).contains(s.getMeasurementId())) {
throw new WriteProcessException(
"TsFile has flushed chunk group and should not add new
measurement "
+ s.getMeasurementId()
+ " in device "
- + devicePath.getFullPath());
+ + deviceID);
}
}
}
@@ -410,7 +389,7 @@ public class TsFileWriter implements AutoCloseable {
checkIsAllMeasurementsInGroup(measurementGroup, schemas, isAligned);
groupWriter.tryToAddSeriesWriter(schemas);
} else {
- throw new NoMeasurementException("input devicePath is invalid: " +
devicePath);
+ throw new NoMeasurementException("input devicePath is invalid: " +
deviceID);
}
}
@@ -418,11 +397,6 @@ public class TsFileWriter implements AutoCloseable {
* If it's aligned, then all measurementSchemas should be contained in the
measurementGroup, or it
* will throw exception. If it's nonAligned, then remove the
measurementSchema that is not
* contained in the measurementGroup.
- *
- * @param measurementGroup
- * @param measurementSchemas
- * @param isAligned
- * @throws NoMeasurementException
*/
private void checkIsAllMeasurementsInGroup(
MeasurementGroup measurementGroup,
@@ -450,15 +424,7 @@ public class TsFileWriter implements AutoCloseable {
}
}
- /**
- * Check whether all measurements of dataPoints list are in the
measurementGroup.
- *
- * @param dataPoints
- * @param measurementGroup
- * @param isAligned
- * @return
- * @throws NoMeasurementException
- */
+ /** Check whether all measurements of dataPoints list are in the
measurementGroup. */
private List<MeasurementSchema> checkIsAllMeasurementsInGroup(
List<DataPoint> dataPoints, MeasurementGroup measurementGroup, boolean
isAligned)
throws NoMeasurementException {
@@ -709,4 +675,8 @@ public class TsFileWriter implements AutoCloseable {
public void setTableWriteAligned(boolean tableWriteAligned) {
isTableWriteAligned = tableWriteAligned;
}
+
+ public void registerTableSchema(TableSchema tableSchema) {
+ getSchema().registerTableSchema(tableSchema);
+ }
}
diff --git a/tsfile/src/main/java/org/apache/tsfile/write/schema/Schema.java
b/tsfile/src/main/java/org/apache/tsfile/write/schema/Schema.java
index 091d14b4..9a4689b6 100644
--- a/tsfile/src/main/java/org/apache/tsfile/write/schema/Schema.java
+++ b/tsfile/src/main/java/org/apache/tsfile/write/schema/Schema.java
@@ -22,7 +22,6 @@ import org.apache.tsfile.file.metadata.ChunkGroupMetadata;
import org.apache.tsfile.file.metadata.IDeviceID;
import org.apache.tsfile.file.metadata.LogicalTableSchema;
import org.apache.tsfile.file.metadata.TableSchema;
-import org.apache.tsfile.read.common.Path;
import org.apache.tsfile.utils.MeasurementGroup;
import java.io.Serializable;
@@ -37,10 +36,10 @@ import java.util.Map;
public class Schema implements Serializable {
/**
- * Path (devicePath) -> measurementSchema By default, use the LinkedHashMap
to store the order of
+ * IDeviceID -> measurementSchema By default, use the LinkedHashMap to store
the order of
* insertion
*/
- private Map<Path, MeasurementGroup> registeredTimeseries;
+ private Map<IDeviceID, MeasurementGroup> registeredTimeseries;
/** template name -> (measurement -> MeasurementSchema) */
private Map<String, MeasurementGroup> schemaTemplates;
@@ -51,20 +50,20 @@ public class Schema implements Serializable {
this.registeredTimeseries = new LinkedHashMap<>();
}
- public Schema(Map<Path, MeasurementGroup> knownSchema) {
+ public Schema(Map<IDeviceID, MeasurementGroup> knownSchema) {
this.registeredTimeseries = knownSchema;
}
// This method can only register nonAligned timeseries.
- public void registerTimeseries(Path devicePath, MeasurementSchema
measurementSchema) {
+ public void registerTimeseries(IDeviceID deviceID, MeasurementSchema
measurementSchema) {
MeasurementGroup group =
- registeredTimeseries.getOrDefault(devicePath, new
MeasurementGroup(false));
+ registeredTimeseries.getOrDefault(deviceID, new
MeasurementGroup(false));
group.getMeasurementSchemaMap().put(measurementSchema.getMeasurementId(),
measurementSchema);
- this.registeredTimeseries.put(devicePath, group);
+ this.registeredTimeseries.put(deviceID, group);
}
- public void registerMeasurementGroup(Path devicePath, MeasurementGroup
measurementGroup) {
- this.registeredTimeseries.put(devicePath, measurementGroup);
+ public void registerMeasurementGroup(IDeviceID deviceID, MeasurementGroup
measurementGroup) {
+ this.registeredTimeseries.put(deviceID, measurementGroup);
}
public void registerSchemaTemplate(String templateName, MeasurementGroup
measurementGroup) {
@@ -74,8 +73,8 @@ public class Schema implements Serializable {
this.schemaTemplates.put(templateName, measurementGroup);
}
- public void registerTableSchema(String tableName, TableSchema tableSchema) {
- tableSchemaMap.put(tableName, tableSchema);
+ public void registerTableSchema(TableSchema tableSchema) {
+ tableSchemaMap.put(tableSchema.getTableName(), tableSchema);
}
/** If template does not exist, an nonAligned timeseries is created by
default */
@@ -90,17 +89,17 @@ public class Schema implements Serializable {
this.schemaTemplates.put(templateName, measurementGroup);
}
- public void registerDevice(String deviceId, String templateName) {
+ public void registerDevice(IDeviceID deviceId, String templateName) {
if (!schemaTemplates.containsKey(templateName)) {
return;
}
Map<String, MeasurementSchema> template =
schemaTemplates.get(templateName).getMeasurementSchemaMap();
boolean isAligned = schemaTemplates.get(templateName).isAligned();
- registerMeasurementGroup(new Path(deviceId), new
MeasurementGroup(isAligned, template));
+ registerMeasurementGroup(deviceId, new MeasurementGroup(isAligned,
template));
}
- public MeasurementGroup getSeriesSchema(Path devicePath) {
+ public MeasurementGroup getSeriesSchema(IDeviceID devicePath) {
return registeredTimeseries.get(devicePath);
}
@@ -109,16 +108,16 @@ public class Schema implements Serializable {
}
/** check if this schema contains a measurement named measurementId. */
- public boolean containsDevice(Path devicePath) {
+ public boolean containsDevice(IDeviceID devicePath) {
return registeredTimeseries.containsKey(devicePath);
}
- public void setRegisteredTimeseries(Map<Path, MeasurementGroup>
registeredTimeseries) {
+ public void setRegisteredTimeseries(Map<IDeviceID, MeasurementGroup>
registeredTimeseries) {
this.registeredTimeseries = registeredTimeseries;
}
// for test
- public Map<Path, MeasurementGroup> getRegisteredTimeseriesMap() {
+ public Map<IDeviceID, MeasurementGroup> getRegisteredTimeseriesMap() {
return registeredTimeseries;
}
diff --git
a/tsfile/src/test/java/org/apache/tsfile/file/metadata/utils/Utils.java
b/tsfile/src/test/java/org/apache/tsfile/file/metadata/utils/Utils.java
index 103a84c8..60761199 100644
--- a/tsfile/src/test/java/org/apache/tsfile/file/metadata/utils/Utils.java
+++ b/tsfile/src/test/java/org/apache/tsfile/file/metadata/utils/Utils.java
@@ -51,9 +51,11 @@ public class Utils {
public static boolean isFileMetaDataEqual(TsFileMetadata metadata1,
TsFileMetadata metadata2) {
if (Utils.isTwoObjectsNotNULL(metadata1, metadata2, "File MetaData")) {
if (Utils.isTwoObjectsNotNULL(
- metadata1.getMetadataIndex(), metadata2.getMetadataIndex(),
"Metadata Index")) {
- MetadataIndexNode metaDataIndex1 = metadata1.getMetadataIndex();
- MetadataIndexNode metaDataIndex2 = metadata2.getMetadataIndex();
+ metadata1.getTableMetadataIndexNodeMap().get(""),
+ metadata2.getTableMetadataIndexNodeMap().get(""),
+ "Metadata " + "Index")) {
+ MetadataIndexNode metaDataIndex1 =
metadata1.getTableMetadataIndexNodeMap().get("");
+ MetadataIndexNode metaDataIndex2 =
metadata2.getTableMetadataIndexNodeMap().get("");
return metaDataIndex1.getChildren().size() ==
metaDataIndex2.getChildren().size();
}
}
diff --git
a/tsfile/src/test/java/org/apache/tsfile/write/MetadataIndexConstructorTest.java
b/tsfile/src/test/java/org/apache/tsfile/write/MetadataIndexConstructorTest.java
index 41f1ada7..c286c73e 100644
---
a/tsfile/src/test/java/org/apache/tsfile/write/MetadataIndexConstructorTest.java
+++
b/tsfile/src/test/java/org/apache/tsfile/write/MetadataIndexConstructorTest.java
@@ -284,7 +284,7 @@ public class MetadataIndexConstructorTest {
private void readMetaDataDFS(List<IDeviceID> devices, List<List<String>>
measurements) {
try (TsFileSequenceReader reader = new TsFileSequenceReader(FILE_PATH)) {
TsFileMetadata tsFileMetaData = reader.readFileMetadata();
- MetadataIndexNode metadataIndexNode = tsFileMetaData.getMetadataIndex();
+ MetadataIndexNode metadataIndexNode =
tsFileMetaData.getTableMetadataIndexNodeMap().get("");
deviceDFS(devices, measurements, reader, metadataIndexNode);
} catch (IOException e) {
e.printStackTrace();
diff --git
a/tsfile/src/test/java/org/apache/tsfile/write/TableViewWriteTest.java
b/tsfile/src/test/java/org/apache/tsfile/write/TableViewWriteTest.java
new file mode 100644
index 00000000..fb2db4bc
--- /dev/null
+++ b/tsfile/src/test/java/org/apache/tsfile/write/TableViewWriteTest.java
@@ -0,0 +1,141 @@
+/*
+ * 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.tsfile.write;
+
+import org.apache.tsfile.enums.TSDataType;
+import org.apache.tsfile.exception.read.ReadProcessException;
+import org.apache.tsfile.exception.write.WriteProcessException;
+import org.apache.tsfile.file.metadata.TableSchema;
+import org.apache.tsfile.file.metadata.enums.CompressionType;
+import org.apache.tsfile.file.metadata.enums.TSEncoding;
+import org.apache.tsfile.read.TsFileSequenceReader;
+import org.apache.tsfile.read.common.block.TsBlock;
+import org.apache.tsfile.read.controller.CachedChunkLoaderImpl;
+import org.apache.tsfile.read.controller.MetadataQuerierByFileImpl;
+import org.apache.tsfile.read.query.executor.TableQueryExecutor;
+import
org.apache.tsfile.read.query.executor.TableQueryExecutor.TableQueryOrdering;
+import org.apache.tsfile.read.reader.block.TsBlockReader;
+import org.apache.tsfile.utils.Binary;
+import org.apache.tsfile.write.record.Tablet;
+import org.apache.tsfile.write.record.Tablet.ColumnType;
+import org.apache.tsfile.write.schema.MeasurementSchema;
+
+import org.apache.commons.io.FileUtils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class TableViewWriteTest {
+
+ private final String testDir = "target" + File.separator + "tableViewTest";
+ private final int idSchemaNum = 5;
+ private final int measurementSchemaNum = 5;
+ private TableSchema testTableSchema;
+
+ @Before
+ public void setUp() throws Exception {
+ new File(testDir).mkdirs();
+ testTableSchema = genTableSchema(0);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ FileUtils.deleteDirectory(new File(testDir));
+ }
+
+ @Test
+ public void testWriteOneTable() throws IOException, WriteProcessException,
ReadProcessException {
+ final File testFile = new File(testDir, "testFile");
+ TsFileWriter writer = new TsFileWriter(testFile);
+ writer.registerTableSchema(testTableSchema);
+
+ writer.writeTable(genTablet(testTableSchema, 0, 100));
+ writer.close();
+
+ TsFileSequenceReader sequenceReader = new
TsFileSequenceReader(testFile.getAbsolutePath());
+ TableQueryExecutor tableQueryExecutor =
+ new TableQueryExecutor(
+ new MetadataQuerierByFileImpl(sequenceReader),
+ new CachedChunkLoaderImpl(sequenceReader),
+ TableQueryOrdering.DEVICE);
+
+ final List<String> columns =
+ testTableSchema.getColumnSchemas().stream()
+ .map(MeasurementSchema::getMeasurementId)
+ .collect(Collectors.toList());
+ final TsBlockReader reader =
+ tableQueryExecutor.query(testTableSchema.getTableName(), columns,
null, null, null);
+ assertTrue(reader.hasNext());
+ final TsBlock result = reader.next();
+ assertEquals(100, result.getPositionCount());
+ }
+
+ private Tablet genTablet(TableSchema tableSchema, int offset, int num) {
+ Tablet tablet = new Tablet(tableSchema.getTableName(),
tableSchema.getColumnSchemas());
+ for (int i = 0; i < num; i++) {
+ tablet.addTimestamp(i, offset + i);
+ for (MeasurementSchema columnSchema : tableSchema.getColumnSchemas()) {
+ tablet.addValue(columnSchema.getMeasurementId(), i,
getValue(columnSchema.getType(), i));
+ }
+ }
+ tablet.rowSize = num;
+ return tablet;
+ }
+
+ public Object getValue(TSDataType dataType, int i) {
+ switch (dataType) {
+ case INT64:
+ return (long) i;
+ case TEXT:
+ return new Binary(String.valueOf(i), StandardCharsets.UTF_8);
+ default:
+ return i;
+ }
+ }
+
+ private TableSchema genTableSchema(int tableNum) {
+ List<MeasurementSchema> measurementSchemas = new ArrayList<>();
+ List<ColumnType> columnTypes = new ArrayList<>();
+
+ for (int i = 0; i < idSchemaNum; i++) {
+ measurementSchemas.add(
+ new MeasurementSchema(
+ "id" + i, TSDataType.TEXT, TSEncoding.PLAIN,
CompressionType.UNCOMPRESSED));
+ columnTypes.add(ColumnType.ID);
+ }
+ for (int i = 0; i < measurementSchemaNum; i++) {
+ measurementSchemas.add(
+ new MeasurementSchema(
+ "s" + i, TSDataType.INT64, TSEncoding.PLAIN,
CompressionType.UNCOMPRESSED));
+ columnTypes.add(ColumnType.MEASUREMENT);
+ }
+ return new TableSchema("testTable" + tableNum, measurementSchemas,
columnTypes);
+ }
+}
diff --git
a/tsfile/src/test/java/org/apache/tsfile/write/TsFileIOWriterTest.java
b/tsfile/src/test/java/org/apache/tsfile/write/TsFileIOWriterTest.java
index dbda5319..e43839eb 100644
--- a/tsfile/src/test/java/org/apache/tsfile/write/TsFileIOWriterTest.java
+++ b/tsfile/src/test/java/org/apache/tsfile/write/TsFileIOWriterTest.java
@@ -165,7 +165,7 @@ public class TsFileIOWriterTest {
// FileMetaData
TsFileMetadata metaData = reader.readFileMetadata();
- Assert.assertEquals(2, metaData.getMetadataIndex().getChildren().size());
+ Assert.assertEquals(2,
metaData.getTableMetadataIndexNodeMap().get("").getChildren().size());
}
private void writeChunkGroup(TsFileIOWriter writer, MeasurementSchema
measurementSchema)
