Implement tree-model interface and table-model tagfilter

java/pom.xml

@@ -56,7 +56,7 @@
             <dependency>
                 <groupId>org.apache.commons</groupId>
                 <artifactId>commons-lang3</artifactId>
-                <version>3.15.0</version>
+                <version>3.18.0</version>
             </dependency>
             <dependency>
                 <groupId>org.lz4</groupId>

java/tsfile/src/main/java/org/apache/tsfile/file/metadata/IDeviceID.java

@@ -47,6 +47,8 @@ public interface IDeviceID extends Comparable<IDeviceID>, Accountable, Serializa
 
   boolean isTableModel();
 
+  String getDeviceID();
+
   /**
    * @return the table name associated with the device. For a path-DeviceId, like "root.a.b.c.d", it
    *     is converted according to a fixed rule, like assuming the first three levels ("root.a.b")

java/tsfile/src/main/java/org/apache/tsfile/file/metadata/PlainDeviceID.java

@@ -115,6 +115,11 @@ public boolean isTableModel() {
     return false;
   }
 
+  @Override
+  public String getDeviceID() {
+    return deviceID;
+  }
+
   @Override
   public long ramBytesUsed() {
     long size = INSTANCE_SIZE;

java/tsfile/src/main/java/org/apache/tsfile/file/metadata/StringArrayDeviceID.java

@@ -226,6 +226,11 @@ public boolean isTableModel() {
     return !segments[0].startsWith(PATH_ROOT + PATH_SEPARATOR);
   }
 
+  @Override
+  public String getDeviceID() {
+    return String.join(PATH_SEPARATOR, segments);
+  }
+
   @Override
   public String getTableName() {
     return segments[0];

java/tsfile/src/main/java/org/apache/tsfile/read/TsFileReader.java

@@ -20,16 +20,23 @@
 package org.apache.tsfile.read;
 
 import org.apache.tsfile.annotations.TsFileApi;
+import org.apache.tsfile.enums.TSDataType;
+import org.apache.tsfile.file.metadata.IDeviceID;
 import org.apache.tsfile.read.controller.CachedChunkLoaderImpl;
 import org.apache.tsfile.read.controller.IChunkLoader;
 import org.apache.tsfile.read.controller.IMetadataQuerier;
 import org.apache.tsfile.read.controller.MetadataQuerierByFileImpl;
 import org.apache.tsfile.read.expression.QueryExpression;
 import org.apache.tsfile.read.query.dataset.QueryDataSet;
 import org.apache.tsfile.read.query.executor.TsFileExecutor;
+import org.apache.tsfile.write.schema.MeasurementSchema;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 public class TsFileReader implements AutoCloseable {
 
@@ -61,6 +68,22 @@ public QueryDataSet query(
     return tsfileExecutor.execute(queryExpression, partitionStartOffset, partitionEndOffset);
   }
 
+  public List<String> getAllDeviceIds() throws IOException {
+    List<IDeviceID> deviceIDList = fileReader.getAllDevices();
+    List<String> deviceIds = new ArrayList<>(deviceIDList.size());
+    for (IDeviceID deviceID : deviceIDList) {
+      deviceIds.add(deviceID.getDeviceID());
+    }
+    return deviceIds;
+  }
+
+  public List<MeasurementSchema> getMeasurement(IDeviceID deviceID) throws IOException {
+    Map<String, TSDataType> measurementMap = fileReader.getMeasurement(deviceID);
+    return measurementMap.entrySet().stream()
+        .map(entry -> new MeasurementSchema(entry.getKey(), entry.getValue()))
+        .collect(Collectors.toList());
+  }
+
   @Override
   @TsFileApi
   public void close() throws IOException {

java/tsfile/src/main/java/org/apache/tsfile/read/TsFileSequenceReader.java

@@ -2717,6 +2717,20 @@ public Map<String, TSDataType> getAllMeasurements() throws IOException {
     return result;
   }
 
+  /**
+   * get measurements for deviceID
+   *
+   * @return measurementSchema
+   */
+  public Map<String, TSDataType> getMeasurement(IDeviceID deviceID) throws IOException {
+    Map<String, TSDataType> result = new HashMap<>();
+    Map<String, TimeseriesMetadata> timeseriesMetadataMap = readDeviceMetadata(deviceID);
+    for (TimeseriesMetadata timeseriesMetadata : timeseriesMetadataMap.values()) {
+      result.put(timeseriesMetadata.getMeasurementId(), timeseriesMetadata.getTsDataType());
+    }
+    return result;
+  }
+
   /**
    * get all types of measurements in this file
    *

java/tsfile/src/main/java/org/apache/tsfile/read/filter/factory/TagFilterBuilder.java

@@ -20,27 +20,112 @@
 package org.apache.tsfile.read.filter.factory;
 
 import org.apache.tsfile.annotations.TsFileApi;
+import org.apache.tsfile.common.regexp.LikePattern;
 import org.apache.tsfile.file.metadata.TableSchema;
 import org.apache.tsfile.read.filter.basic.Filter;
+import org.apache.tsfile.read.filter.operator.And;
+import org.apache.tsfile.read.filter.operator.Not;
+import org.apache.tsfile.read.filter.operator.Or;
+import org.apache.tsfile.read.filter.operator.TagFilterOperators;
 import org.apache.tsfile.read.filter.operator.TagFilterOperators.ValueEq;
-import org.apache.tsfile.write.schema.IMeasurementSchema;
+import org.apache.tsfile.read.filter.operator.TagFilterOperators.ValueNotEq;
+
+import java.util.Optional;
+import java.util.regex.Pattern;
 
 public class TagFilterBuilder {
-  private TableSchema tableSchema;
+  private final TableSchema tableSchema;
 
   public TagFilterBuilder(TableSchema tableSchema) {
     this.tableSchema = tableSchema;
   }
 
-  @TsFileApi
-  public Filter eq(String columnName, Object value) {
+  private int getIdColumnIndex(String columnName) {
     int idColumnOrder = tableSchema.findIdColumnOrder(columnName);
     if (idColumnOrder == -1) {
       throw new IllegalArgumentException("Column '" + columnName + "' is not a tag column");
     }
-    IMeasurementSchema columnSchema = tableSchema.findColumnSchema(columnName);
+    return idColumnOrder + 1;
+  }
+
+  @TsFileApi
+  public Filter eq(String columnName, Object value) {
+    return new ValueEq(getIdColumnIndex(columnName), (String) value);
+  }
+
+  @TsFileApi
+  public Filter neq(String columnName, Object value) {
+    return new ValueNotEq(getIdColumnIndex(columnName), (String) value);
+  }
+
+  @TsFileApi
+  public Filter lt(String columnName, Object value) {
+    return new TagFilterOperators.ValueLt(getIdColumnIndex(columnName), (String) value);
+  }
+
+  @TsFileApi
+  public Filter lteq(String columnName, Object value) {
+    return new TagFilterOperators.ValueLtEq(getIdColumnIndex(columnName), (String) value);
+  }
+
+  @TsFileApi
+  public Filter gt(String columnName, Object value) {
+    return new TagFilterOperators.ValueGt(getIdColumnIndex(columnName), (String) value);
+  }
+
+  @TsFileApi
+  public Filter gteq(String columnName, Object value) {
+    return new TagFilterOperators.ValueGtEq(getIdColumnIndex(columnName), (String) value);
+  }
+
+  @TsFileApi
+  public Filter betweenAnd(String columnName, Object value1, Object value2) {
+    return new TagFilterOperators.ValueBetweenAnd(
+        getIdColumnIndex(columnName), (String) value1, (String) value2);
+  }
+
+  @TsFileApi
+  public Filter notBetweenAnd(String columnName, Object value1, Object value2) {
+    return new TagFilterOperators.ValueNotBetweenAnd(
+        getIdColumnIndex(columnName), (String) value1, (String) value2);
+  }
+
+  @TsFileApi
+  public Filter regExp(String columnName, String pattern) {
+    return new TagFilterOperators.ValueRegexp(
+        getIdColumnIndex(columnName), Pattern.compile(pattern));
+  }
+
+  @TsFileApi
+  public Filter notRegExp(String columnName, String pattern) {
+    return new TagFilterOperators.ValueNotRegexp(
+        getIdColumnIndex(columnName), Pattern.compile(pattern));
+  }
+
+  @TsFileApi
+  public Filter like(String columnName, String pattern) {
+    return new TagFilterOperators.ValueLike(
+        getIdColumnIndex(columnName), LikePattern.compile(pattern, Optional.empty()));
+  }
+
+  @TsFileApi
+  public Filter notLike(String columnName, String pattern) {
+    return new TagFilterOperators.ValueNotLike(
+        getIdColumnIndex(columnName), LikePattern.compile(pattern, Optional.empty()));
+  }
+
+  @TsFileApi
+  public Filter and(Filter left, Filter right) {
+    return new And(left, right);
+  }
+
+  @TsFileApi
+  public Filter or(Filter left, Filter right) {
+    return new Or(left, right);
+  }
 
-    // +1 for table name
-    return new ValueEq(idColumnOrder + 1, (String) value);
+  @TsFileApi
+  public Filter not(Filter value) {
+    return new Not(value);
   }
 }

java/tsfile/src/main/java/org/apache/tsfile/read/query/dataset/TreeResultSet.java

@@ -20,21 +20,37 @@
 package org.apache.tsfile.read.query.dataset;
 
 import org.apache.tsfile.annotations.TsFileApi;
+import org.apache.tsfile.file.metadata.StringArrayDeviceID;
+import org.apache.tsfile.read.common.Field;
 import org.apache.tsfile.read.common.Path;
 import org.apache.tsfile.write.record.TSRecord;
 
 import java.io.IOException;
 import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 public class TreeResultSet extends AbstractResultSet {
   private QueryDataSet queryDataSet;
+  private List<String> deviceList;
+  private List<String> measurementList;
+  private Map<Path, Integer> pathIndexMap;
 
-  public TreeResultSet(QueryDataSet queryDataSet) {
+  public TreeResultSet(
+      QueryDataSet queryDataSet, List<String> deviceIds, List<String> measurementNames) {
     super(
         queryDataSet.getPaths().stream().map(Path::toString).collect(Collectors.toList()),
         queryDataSet.getDataTypes());
     this.queryDataSet = queryDataSet;
+    this.deviceList = deviceIds;
+    this.measurementList = measurementNames;
+    List<Path> paths = queryDataSet.getPaths();
+    this.pathIndexMap =
+        IntStream.range(0, paths.size()).boxed().collect(Collectors.toMap(paths::get, i -> i));
   }
 
   @TsFileApi
@@ -56,6 +72,92 @@ public void close() {
 
   @Override
   public Iterator<TSRecord> recordIterator() {
-    return null;
+    return new TreeResultSet.RecordIterator();
+  }
+
+  private class RecordIterator implements Iterator<TSRecord> {
+    private final LinkedList<TSRecord> recordBuffer = new LinkedList<>();
+    private boolean exhausted = false;
+
+    @Override
+    public boolean hasNext() {
+      if (!recordBuffer.isEmpty()) {
+        return true;
+      }
+      if (exhausted) {
+        return false;
+      }
+
+      try {
+        return fetchRecords();
+      } catch (IOException e) {
+        throw new NoSuchElementException(e.toString());
+      }
+    }
+
+    private boolean fetchRecords() throws IOException {
+      boolean hasNewRecords = false;
+      while (TreeResultSet.this.next()) {
+        for (String device : deviceList) {
+          TSRecord record = new TSRecord(device, getLong("Time"));
+          record.addPoint("id", device);
+
+          for (String measurement : measurementList) {
+            Integer pathIdx =
+                pathIndexMap.get(new Path(new StringArrayDeviceID(device), measurement, false));
+            if (pathIdx != null) {
+              Field field = currentRow.getField(pathIdx);
+              switch (field.getDataType()) {
+                case INT32:
+                case DATE:
+                  record.addPoint(measurement, field.getIntV());
+                  break;
+                case INT64:
+                case TIMESTAMP:
+                  record.addPoint(measurement, field.getLongV());
+                  break;
+                case FLOAT:
+                  record.addPoint(measurement, field.getFloatV());
+                  break;
+                case DOUBLE:
+                  record.addPoint(measurement, field.getDoubleV());
+                  break;
+                case STRING:
+                case TEXT:
+                  record.addPoint(measurement, field.getStringValue());
+                  break;
+                case BLOB:
+                  record.addPoint(measurement, field.getBinaryV().getValues());
+                  break;
+                case BOOLEAN:
+                  record.addPoint(measurement, field.getBoolV());
+                  break;
+                case VECTOR:
+                case UNKNOWN:
+                default:
+                  break;
+              }
+            } else {
+              record.dataPointList.add(null);
+            }
+          }
+          recordBuffer.add(record);
+          hasNewRecords = true;
+        }
+      }
+      if (!hasNewRecords) {
+        exhausted = true;
+        return false;
+      }
+      return true;
+    }
+
+    @Override
+    public TSRecord next() {
+      if (!hasNext()) {
+        throw new NoSuchElementException();
+      }
+      return recordBuffer.poll();
+    }
   }
 }