You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ro...@apache.org on 2024/08/19 09:59:25 UTC

(iotdb) branch tsfile-tablet-converter updated (67642d6dd37 -> cee7d7af04e)

This is an automated email from the ASF dual-hosted git repository.

rong pushed a change to branch tsfile-tablet-converter
in repository https://gitbox.apache.org/repos/asf/iotdb.git


    from 67642d6dd37 Added check for table TTL to ensure that it's equal to or greater than 0
     new 4c6bcc1d8a9 stash
     new cee7d7af04e Revert "stash"

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.


Summary of changes:

(iotdb) 01/02: stash

Posted by ro...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

rong pushed a commit to branch tsfile-tablet-converter
in repository https://gitbox.apache.org/repos/asf/iotdb.git

commit 4c6bcc1d8a9b3c90f1d77bf90f5d8e98c8d3df50
Author: Steve Yurong Su <ro...@apache.org>
AuthorDate: Mon Aug 19 16:44:21 2024 +0800

    stash
---
 .../converter/TsFileToTabletConverter.java         | 940 +++++++++++++++++++++
 ...peStatementDataTypeConvertExecutionVisitor.java |  10 +
 2 files changed, 950 insertions(+)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/transform/converter/TsFileToTabletConverter.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/transform/converter/TsFileToTabletConverter.java
new file mode 100644
index 00000000000..d2dcf5a61b9
--- /dev/null
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/transform/converter/TsFileToTabletConverter.java
@@ -0,0 +1,940 @@
+/*
+ * 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.pipe.receiver.transform.converter;
+
+import org.apache.tsfile.enums.TSDataType;
+import org.apache.tsfile.utils.Binary;
+
+public class TsFileToTabletConverter {
+
+  @FunctionalInterface
+  private interface Converter {
+    Object convert(
+        final TSDataType sourceDataType,
+        final TSDataType targetDataType,
+        final Object sourceValues);
+  }
+
+  private static final Converter[][] CONVERTER =
+      new Converter[TSDataType.values().length][TSDataType.values().length];
+
+  private static final Converter DO_NOTHING_CONVERTER =
+      (sourceDataType, targetDataType, sourceValues) -> sourceValues;
+
+  static {
+    for (final TSDataType sourceDataType : TSDataType.values()) {
+      for (final TSDataType targetDataType : TSDataType.values()) {
+        CONVERTER[sourceDataType.ordinal()][targetDataType.ordinal()] = DO_NOTHING_CONVERTER;
+      }
+    }
+
+    // BOOLEAN
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.BOOLEAN.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.INT32.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final boolean[] boolValues = (boolean[]) sourceValues;
+          final int[] intValues = new int[boolValues.length];
+          for (int i = 0; i < boolValues.length; i++) {
+            intValues[i] = ValueConverter.convertBooleanToInt32(boolValues[i]);
+          }
+          return intValues;
+        };
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.INT64.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final boolean[] boolValues = (boolean[]) sourceValues;
+          final long[] longValues = new long[boolValues.length];
+          for (int i = 0; i < boolValues.length; i++) {
+            longValues[i] = ValueConverter.convertBooleanToInt64(boolValues[i]);
+          }
+          return longValues;
+        };
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.FLOAT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final boolean[] boolValues = (boolean[]) sourceValues;
+          final float[] floatValues = new float[boolValues.length];
+          for (int i = 0; i < boolValues.length; i++) {
+            floatValues[i] = ValueConverter.convertBooleanToFloat(boolValues[i]);
+          }
+          return floatValues;
+        };
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.DOUBLE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final boolean[] boolValues = (boolean[]) sourceValues;
+          final double[] doubleValues = new double[boolValues.length];
+          for (int i = 0; i < boolValues.length; i++) {
+            doubleValues[i] = ValueConverter.convertBooleanToDouble(boolValues[i]);
+          }
+          return doubleValues;
+        };
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.TEXT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final boolean[] boolValues = (boolean[]) sourceValues;
+          final Binary[] textValues = new Binary[boolValues.length];
+          for (int i = 0; i < boolValues.length; i++) {
+            textValues[i] = ValueConverter.convertBooleanToText(boolValues[i]);
+          }
+          return textValues;
+        };
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final boolean[] boolValues = (boolean[]) sourceValues;
+          final long[] timestampValues = new long[boolValues.length];
+          for (int i = 0; i < boolValues.length; i++) {
+            timestampValues[i] = ValueConverter.convertBooleanToTimestamp(boolValues[i]);
+          }
+          return timestampValues;
+        };
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.DATE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final boolean[] boolValues = (boolean[]) sourceValues;
+          final int[] dateValues = new int[boolValues.length];
+          for (int i = 0; i < boolValues.length; i++) {
+            dateValues[i] = ValueConverter.convertBooleanToDate(boolValues[i]);
+          }
+          return dateValues;
+        };
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.BLOB.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final boolean[] boolValues = (boolean[]) sourceValues;
+          final Binary[] blobValues = new Binary[boolValues.length];
+          for (int i = 0; i < boolValues.length; i++) {
+            blobValues[i] = ValueConverter.convertBooleanToBlob(boolValues[i]);
+          }
+          return blobValues;
+        };
+    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.STRING.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final boolean[] boolValues = (boolean[]) sourceValues;
+          final Binary[] stringValues = new Binary[boolValues.length];
+          for (int i = 0; i < boolValues.length; i++) {
+            stringValues[i] = ValueConverter.convertBooleanToString(boolValues[i]);
+          }
+          return stringValues;
+        };
+
+    // INT32
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.BOOLEAN.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] intValues = (int[]) sourceValues;
+          final boolean[] boolValues = new boolean[intValues.length];
+          for (int i = 0; i < intValues.length; i++) {
+            boolValues[i] = ValueConverter.convertInt32ToBoolean(intValues[i]);
+          }
+          return boolValues;
+        };
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.INT32.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.INT64.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] intValues = (int[]) sourceValues;
+          final long[] longValues = new long[intValues.length];
+          for (int i = 0; i < intValues.length; i++) {
+            longValues[i] = ValueConverter.convertInt32ToInt64(intValues[i]);
+          }
+          return longValues;
+        };
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.FLOAT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] intValues = (int[]) sourceValues;
+          final float[] floatValues = new float[intValues.length];
+          for (int i = 0; i < intValues.length; i++) {
+            floatValues[i] = ValueConverter.convertInt32ToFloat(intValues[i]);
+          }
+          return floatValues;
+        };
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.DOUBLE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] intValues = (int[]) sourceValues;
+          final double[] doubleValues = new double[intValues.length];
+          for (int i = 0; i < intValues.length; i++) {
+            doubleValues[i] = ValueConverter.convertInt32ToDouble(intValues[i]);
+          }
+          return doubleValues;
+        };
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.TEXT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] intValues = (int[]) sourceValues;
+          final Binary[] textValues = new Binary[intValues.length];
+          for (int i = 0; i < intValues.length; i++) {
+            textValues[i] = ValueConverter.convertInt32ToText(intValues[i]);
+          }
+          return textValues;
+        };
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] intValues = (int[]) sourceValues;
+          final long[] timestampValues = new long[intValues.length];
+          for (int i = 0; i < intValues.length; i++) {
+            timestampValues[i] = ValueConverter.convertInt32ToTimestamp(intValues[i]);
+          }
+          return timestampValues;
+        };
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.DATE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] intValues = (int[]) sourceValues;
+          final int[] dateValues = new int[intValues.length];
+          for (int i = 0; i < intValues.length; i++) {
+            dateValues[i] = ValueConverter.convertInt32ToDate(intValues[i]);
+          }
+          return dateValues;
+        };
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.BLOB.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] intValues = (int[]) sourceValues;
+          final Binary[] blobValues = new Binary[intValues.length];
+          for (int i = 0; i < intValues.length; i++) {
+            blobValues[i] = ValueConverter.convertInt32ToBlob(intValues[i]);
+          }
+          return blobValues;
+        };
+    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.STRING.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] intValues = (int[]) sourceValues;
+          final Binary[] stringValues = new Binary[intValues.length];
+          for (int i = 0; i < intValues.length; i++) {
+            stringValues[i] = ValueConverter.convertInt32ToString(intValues[i]);
+          }
+          return stringValues;
+        };
+
+    // INT64
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.BOOLEAN.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] longValues = (long[]) sourceValues;
+          final boolean[] boolValues = new boolean[longValues.length];
+          for (int i = 0; i < longValues.length; i++) {
+            boolValues[i] = ValueConverter.convertInt64ToBoolean(longValues[i]);
+          }
+          return boolValues;
+        };
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.INT32.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] longValues = (long[]) sourceValues;
+          final int[] intValues = new int[longValues.length];
+          for (int i = 0; i < longValues.length; i++) {
+            intValues[i] = ValueConverter.convertInt64ToInt32(longValues[i]);
+          }
+          return intValues;
+        };
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.INT64.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.FLOAT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] longValues = (long[]) sourceValues;
+          final float[] floatValues = new float[longValues.length];
+          for (int i = 0; i < longValues.length; i++) {
+            floatValues[i] = ValueConverter.convertInt64ToFloat(longValues[i]);
+          }
+          return floatValues;
+        };
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.DOUBLE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] longValues = (long[]) sourceValues;
+          final double[] doubleValues = new double[longValues.length];
+          for (int i = 0; i < longValues.length; i++) {
+            doubleValues[i] = ValueConverter.convertInt64ToDouble(longValues[i]);
+          }
+          return doubleValues;
+        };
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.TEXT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] longValues = (long[]) sourceValues;
+          final Binary[] textValues = new Binary[longValues.length];
+          for (int i = 0; i < longValues.length; i++) {
+            textValues[i] = ValueConverter.convertInt64ToText(longValues[i]);
+          }
+          return textValues;
+        };
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] longValues = (long[]) sourceValues;
+          final long[] timestampValues = new long[longValues.length];
+          for (int i = 0; i < longValues.length; i++) {
+            timestampValues[i] = ValueConverter.convertInt64ToTimestamp(longValues[i]);
+          }
+          return timestampValues;
+        };
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.DATE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] longValues = (long[]) sourceValues;
+          final int[] dateValues = new int[longValues.length];
+          for (int i = 0; i < longValues.length; i++) {
+            dateValues[i] = ValueConverter.convertInt64ToDate(longValues[i]);
+          }
+          return dateValues;
+        };
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.BLOB.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] longValues = (long[]) sourceValues;
+          final Binary[] blobValues = new Binary[longValues.length];
+          for (int i = 0; i < longValues.length; i++) {
+            blobValues[i] = ValueConverter.convertInt64ToBlob(longValues[i]);
+          }
+          return blobValues;
+        };
+    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.STRING.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] longValues = (long[]) sourceValues;
+          final Binary[] stringValues = new Binary[longValues.length];
+          for (int i = 0; i < longValues.length; i++) {
+            stringValues[i] = ValueConverter.convertInt64ToString(longValues[i]);
+          }
+          return stringValues;
+        };
+
+    // FLOAT
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.BOOLEAN.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final float[] floatValues = (float[]) sourceValues;
+          final boolean[] boolValues = new boolean[floatValues.length];
+          for (int i = 0; i < floatValues.length; i++) {
+            boolValues[i] = ValueConverter.convertFloatToBoolean(floatValues[i]);
+          }
+          return boolValues;
+        };
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.INT32.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final float[] floatValues = (float[]) sourceValues;
+          final int[] intValues = new int[floatValues.length];
+          for (int i = 0; i < floatValues.length; i++) {
+            intValues[i] = ValueConverter.convertFloatToInt32(floatValues[i]);
+          }
+          return intValues;
+        };
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.INT64.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final float[] floatValues = (float[]) sourceValues;
+          final long[] longValues = new long[floatValues.length];
+          for (int i = 0; i < floatValues.length; i++) {
+            longValues[i] = ValueConverter.convertFloatToInt64(floatValues[i]);
+          }
+          return longValues;
+        };
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.FLOAT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.DOUBLE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final float[] floatValues = (float[]) sourceValues;
+          final double[] doubleValues = new double[floatValues.length];
+          for (int i = 0; i < floatValues.length; i++) {
+            doubleValues[i] = ValueConverter.convertFloatToDouble(floatValues[i]);
+          }
+          return doubleValues;
+        };
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.TEXT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final float[] floatValues = (float[]) sourceValues;
+          final Binary[] textValues = new Binary[floatValues.length];
+          for (int i = 0; i < floatValues.length; i++) {
+            textValues[i] = ValueConverter.convertFloatToText(floatValues[i]);
+          }
+          return textValues;
+        };
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final float[] floatValues = (float[]) sourceValues;
+          final long[] timestampValues = new long[floatValues.length];
+          for (int i = 0; i < floatValues.length; i++) {
+            timestampValues[i] = ValueConverter.convertFloatToTimestamp(floatValues[i]);
+          }
+          return timestampValues;
+        };
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.DATE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final float[] floatValues = (float[]) sourceValues;
+          final int[] dateValues = new int[floatValues.length];
+          for (int i = 0; i < floatValues.length; i++) {
+            dateValues[i] = ValueConverter.convertFloatToDate(floatValues[i]);
+          }
+          return dateValues;
+        };
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.BLOB.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final float[] floatValues = (float[]) sourceValues;
+          final Binary[] blobValues = new Binary[floatValues.length];
+          for (int i = 0; i < floatValues.length; i++) {
+            blobValues[i] = ValueConverter.convertFloatToBlob(floatValues[i]);
+          }
+          return blobValues;
+        };
+    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.STRING.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final float[] floatValues = (float[]) sourceValues;
+          final Binary[] stringValues = new Binary[floatValues.length];
+          for (int i = 0; i < floatValues.length; i++) {
+            stringValues[i] = ValueConverter.convertFloatToString(floatValues[i]);
+          }
+          return stringValues;
+        };
+
+    // DOUBLE
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.BOOLEAN.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final double[] doubleValues = (double[]) sourceValues;
+          final boolean[] boolValues = new boolean[doubleValues.length];
+          for (int i = 0; i < doubleValues.length; i++) {
+            boolValues[i] = ValueConverter.convertDoubleToBoolean(doubleValues[i]);
+          }
+          return boolValues;
+        };
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.INT32.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final double[] doubleValues = (double[]) sourceValues;
+          final int[] intValues = new int[doubleValues.length];
+          for (int i = 0; i < doubleValues.length; i++) {
+            intValues[i] = ValueConverter.convertDoubleToInt32(doubleValues[i]);
+          }
+          return intValues;
+        };
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.INT64.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final double[] doubleValues = (double[]) sourceValues;
+          final long[] longValues = new long[doubleValues.length];
+          for (int i = 0; i < doubleValues.length; i++) {
+            longValues[i] = ValueConverter.convertDoubleToInt64(doubleValues[i]);
+          }
+          return longValues;
+        };
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.FLOAT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final double[] doubleValues = (double[]) sourceValues;
+          final float[] floatValues = new float[doubleValues.length];
+          for (int i = 0; i < doubleValues.length; i++) {
+            floatValues[i] = ValueConverter.convertDoubleToFloat(doubleValues[i]);
+          }
+          return floatValues;
+        };
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.DOUBLE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.TEXT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final double[] doubleValues = (double[]) sourceValues;
+          final Binary[] textValues = new Binary[doubleValues.length];
+          for (int i = 0; i < doubleValues.length; i++) {
+            textValues[i] = ValueConverter.convertDoubleToText(doubleValues[i]);
+          }
+          return textValues;
+        };
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final double[] doubleValues = (double[]) sourceValues;
+          final long[] timestampValues = new long[doubleValues.length];
+          for (int i = 0; i < doubleValues.length; i++) {
+            timestampValues[i] = ValueConverter.convertDoubleToTimestamp(doubleValues[i]);
+          }
+          return timestampValues;
+        };
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.DATE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final double[] doubleValues = (double[]) sourceValues;
+          final int[] dateValues = new int[doubleValues.length];
+          for (int i = 0; i < doubleValues.length; i++) {
+            dateValues[i] = ValueConverter.convertDoubleToDate(doubleValues[i]);
+          }
+          return dateValues;
+        };
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.BLOB.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final double[] doubleValues = (double[]) sourceValues;
+          final Binary[] blobValues = new Binary[doubleValues.length];
+          for (int i = 0; i < doubleValues.length; i++) {
+            blobValues[i] = ValueConverter.convertDoubleToBlob(doubleValues[i]);
+          }
+          return blobValues;
+        };
+    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.STRING.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final double[] doubleValues = (double[]) sourceValues;
+          final Binary[] stringValues = new Binary[doubleValues.length];
+          for (int i = 0; i < doubleValues.length; i++) {
+            stringValues[i] = ValueConverter.convertDoubleToString(doubleValues[i]);
+          }
+          return stringValues;
+        };
+
+    // TEXT
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.BOOLEAN.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] textValues = (Binary[]) sourceValues;
+          final boolean[] boolValues = new boolean[textValues.length];
+          for (int i = 0; i < textValues.length; i++) {
+            boolValues[i] = ValueConverter.convertTextToBoolean(textValues[i]);
+          }
+          return boolValues;
+        };
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.INT32.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] textValues = (Binary[]) sourceValues;
+          final int[] intValues = new int[textValues.length];
+          for (int i = 0; i < textValues.length; i++) {
+            intValues[i] = ValueConverter.convertTextToInt32(textValues[i]);
+          }
+          return intValues;
+        };
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.INT64.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] textValues = (Binary[]) sourceValues;
+          final long[] longValues = new long[textValues.length];
+          for (int i = 0; i < textValues.length; i++) {
+            longValues[i] = ValueConverter.convertTextToInt64(textValues[i]);
+          }
+          return longValues;
+        };
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.FLOAT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] textValues = (Binary[]) sourceValues;
+          final float[] floatValues = new float[textValues.length];
+          for (int i = 0; i < textValues.length; i++) {
+            floatValues[i] = ValueConverter.convertTextToFloat(textValues[i]);
+          }
+          return floatValues;
+        };
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.DOUBLE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] textValues = (Binary[]) sourceValues;
+          final double[] doubleValues = new double[textValues.length];
+          for (int i = 0; i < textValues.length; i++) {
+            doubleValues[i] = ValueConverter.convertTextToDouble(textValues[i]);
+          }
+          return doubleValues;
+        };
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.TEXT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] textValues = (Binary[]) sourceValues;
+          final long[] timestampValues = new long[textValues.length];
+          for (int i = 0; i < textValues.length; i++) {
+            timestampValues[i] = ValueConverter.convertTextToTimestamp(textValues[i]);
+          }
+          return timestampValues;
+        };
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.DATE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] textValues = (Binary[]) sourceValues;
+          final int[] dateValues = new int[textValues.length];
+          for (int i = 0; i < textValues.length; i++) {
+            dateValues[i] = ValueConverter.convertTextToDate(textValues[i]);
+          }
+          return dateValues;
+        };
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.BLOB.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] textValues = (Binary[]) sourceValues;
+          final Binary[] blobValues = new Binary[textValues.length];
+          for (int i = 0; i < textValues.length; i++) {
+            blobValues[i] = ValueConverter.convertTextToBlob(textValues[i]);
+          }
+          return blobValues;
+        };
+    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.STRING.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] textValues = (Binary[]) sourceValues;
+          final Binary[] stringValues = new Binary[textValues.length];
+          for (int i = 0; i < textValues.length; i++) {
+            stringValues[i] = ValueConverter.convertTextToString(textValues[i]);
+          }
+          return stringValues;
+        };
+
+    // VECTOR
+    for (int i = 0; i < TSDataType.values().length; i++) {
+      CONVERTER[TSDataType.VECTOR.ordinal()][i] = DO_NOTHING_CONVERTER;
+    }
+
+    // UNKNOWN
+    for (int i = 0; i < TSDataType.values().length; i++) {
+      CONVERTER[TSDataType.UNKNOWN.ordinal()][i] = DO_NOTHING_CONVERTER;
+    }
+
+    // TIMESTAMP
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.BOOLEAN.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] timestampValues = (long[]) sourceValues;
+          final boolean[] boolValues = new boolean[timestampValues.length];
+          for (int i = 0; i < timestampValues.length; i++) {
+            boolValues[i] = ValueConverter.convertTimestampToBoolean(timestampValues[i]);
+          }
+          return boolValues;
+        };
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.INT32.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] timestampValues = (long[]) sourceValues;
+          final int[] intValues = new int[timestampValues.length];
+          for (int i = 0; i < timestampValues.length; i++) {
+            intValues[i] = ValueConverter.convertTimestampToInt32(timestampValues[i]);
+          }
+          return intValues;
+        };
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.INT64.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] timestampValues = (long[]) sourceValues;
+          final long[] longValues = new long[timestampValues.length];
+          for (int i = 0; i < timestampValues.length; i++) {
+            longValues[i] = ValueConverter.convertTimestampToInt64(timestampValues[i]);
+          }
+          return longValues;
+        };
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.FLOAT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] timestampValues = (long[]) sourceValues;
+          final float[] floatValues = new float[timestampValues.length];
+          for (int i = 0; i < timestampValues.length; i++) {
+            floatValues[i] = ValueConverter.convertTimestampToFloat(timestampValues[i]);
+          }
+          return floatValues;
+        };
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.DOUBLE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] timestampValues = (long[]) sourceValues;
+          final double[] doubleValues = new double[timestampValues.length];
+          for (int i = 0; i < timestampValues.length; i++) {
+            doubleValues[i] = ValueConverter.convertTimestampToDouble(timestampValues[i]);
+          }
+          return doubleValues;
+        };
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.TEXT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] timestampValues = (long[]) sourceValues;
+          final Binary[] textValues = new Binary[timestampValues.length];
+          for (int i = 0; i < timestampValues.length; i++) {
+            textValues[i] = ValueConverter.convertTimestampToText(timestampValues[i]);
+          }
+          return textValues;
+        };
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.DATE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] timestampValues = (long[]) sourceValues;
+          final int[] dateValues = new int[timestampValues.length];
+          for (int i = 0; i < timestampValues.length; i++) {
+            dateValues[i] = ValueConverter.convertTimestampToDate(timestampValues[i]);
+          }
+          return dateValues;
+        };
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.BLOB.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] timestampValues = (long[]) sourceValues;
+          final Binary[] blobValues = new Binary[timestampValues.length];
+          for (int i = 0; i < timestampValues.length; i++) {
+            blobValues[i] = ValueConverter.convertTimestampToBlob(timestampValues[i]);
+          }
+          return blobValues;
+        };
+    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.STRING.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final long[] timestampValues = (long[]) sourceValues;
+          final Binary[] stringValues = new Binary[timestampValues.length];
+          for (int i = 0; i < timestampValues.length; i++) {
+            stringValues[i] = ValueConverter.convertTimestampToString(timestampValues[i]);
+          }
+          return stringValues;
+        };
+
+    // DATE
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.BOOLEAN.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] dateValues = (int[]) sourceValues;
+          final boolean[] boolValues = new boolean[dateValues.length];
+          for (int i = 0; i < dateValues.length; i++) {
+            boolValues[i] = ValueConverter.convertDateToBoolean(dateValues[i]);
+          }
+          return boolValues;
+        };
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.INT32.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] dateValues = (int[]) sourceValues;
+          final int[] intValues = new int[dateValues.length];
+          for (int i = 0; i < dateValues.length; i++) {
+            intValues[i] = ValueConverter.convertDateToInt32(dateValues[i]);
+          }
+          return intValues;
+        };
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.INT64.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] dateValues = (int[]) sourceValues;
+          final long[] longValues = new long[dateValues.length];
+          for (int i = 0; i < dateValues.length; i++) {
+            longValues[i] = ValueConverter.convertDateToInt64(dateValues[i]);
+          }
+          return longValues;
+        };
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.FLOAT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] dateValues = (int[]) sourceValues;
+          final float[] floatValues = new float[dateValues.length];
+          for (int i = 0; i < dateValues.length; i++) {
+            floatValues[i] = ValueConverter.convertDateToFloat(dateValues[i]);
+          }
+          return floatValues;
+        };
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.DOUBLE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] dateValues = (int[]) sourceValues;
+          final double[] doubleValues = new double[dateValues.length];
+          for (int i = 0; i < dateValues.length; i++) {
+            doubleValues[i] = ValueConverter.convertDateToDouble(dateValues[i]);
+          }
+          return doubleValues;
+        };
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.TEXT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] dateValues = (int[]) sourceValues;
+          final Binary[] textValues = new Binary[dateValues.length];
+          for (int i = 0; i < dateValues.length; i++) {
+            textValues[i] = ValueConverter.convertDateToText(dateValues[i]);
+          }
+          return textValues;
+        };
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] dateValues = (int[]) sourceValues;
+          final long[] timestampValues = new long[dateValues.length];
+          for (int i = 0; i < dateValues.length; i++) {
+            timestampValues[i] = ValueConverter.convertDateToTimestamp(dateValues[i]);
+          }
+          return timestampValues;
+        };
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.DATE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.BLOB.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] dateValues = (int[]) sourceValues;
+          final Binary[] blobValues = new Binary[dateValues.length];
+          for (int i = 0; i < dateValues.length; i++) {
+            blobValues[i] = ValueConverter.convertDateToBlob(dateValues[i]);
+          }
+          return blobValues;
+        };
+    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.STRING.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final int[] dateValues = (int[]) sourceValues;
+          final Binary[] stringValues = new Binary[dateValues.length];
+          for (int i = 0; i < dateValues.length; i++) {
+            stringValues[i] = ValueConverter.convertDateToString(dateValues[i]);
+          }
+          return stringValues;
+        };
+
+    // BLOB
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.BOOLEAN.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] blobValues = (Binary[]) sourceValues;
+          final boolean[] boolValues = new boolean[blobValues.length];
+          for (int i = 0; i < blobValues.length; i++) {
+            boolValues[i] = ValueConverter.convertBlobToBoolean(blobValues[i]);
+          }
+          return boolValues;
+        };
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.INT32.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] blobValues = (Binary[]) sourceValues;
+          final int[] intValues = new int[blobValues.length];
+          for (int i = 0; i < blobValues.length; i++) {
+            intValues[i] = ValueConverter.convertBlobToInt32(blobValues[i]);
+          }
+          return intValues;
+        };
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.INT64.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] blobValues = (Binary[]) sourceValues;
+          final long[] longValues = new long[blobValues.length];
+          for (int i = 0; i < blobValues.length; i++) {
+            longValues[i] = ValueConverter.convertBlobToInt64(blobValues[i]);
+          }
+          return longValues;
+        };
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.FLOAT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] blobValues = (Binary[]) sourceValues;
+          final float[] floatValues = new float[blobValues.length];
+          for (int i = 0; i < blobValues.length; i++) {
+            floatValues[i] = ValueConverter.convertBlobToFloat(blobValues[i]);
+          }
+          return floatValues;
+        };
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.DOUBLE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] blobValues = (Binary[]) sourceValues;
+          final double[] doubleValues = new double[blobValues.length];
+          for (int i = 0; i < blobValues.length; i++) {
+            doubleValues[i] = ValueConverter.convertBlobToDouble(blobValues[i]);
+          }
+          return doubleValues;
+        };
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.TEXT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] blobValues = (Binary[]) sourceValues;
+          final Binary[] textValues = new Binary[blobValues.length];
+          for (int i = 0; i < blobValues.length; i++) {
+            textValues[i] = ValueConverter.convertBlobToText(blobValues[i]);
+          }
+          return textValues;
+        };
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] blobValues = (Binary[]) sourceValues;
+          final long[] timestampValues = new long[blobValues.length];
+          for (int i = 0; i < blobValues.length; i++) {
+            timestampValues[i] = ValueConverter.convertBlobToTimestamp(blobValues[i]);
+          }
+          return timestampValues;
+        };
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.DATE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] blobValues = (Binary[]) sourceValues;
+          final int[] dateValues = new int[blobValues.length];
+          for (int i = 0; i < blobValues.length; i++) {
+            dateValues[i] = ValueConverter.convertBlobToDate(blobValues[i]);
+          }
+          return dateValues;
+        };
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.BLOB.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
+    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.STRING.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] blobValues = (Binary[]) sourceValues;
+          final Binary[] stringValues = new Binary[blobValues.length];
+          for (int i = 0; i < blobValues.length; i++) {
+            stringValues[i] = ValueConverter.convertBlobToString(blobValues[i]);
+          }
+          return stringValues;
+        };
+
+    // STRING
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.BOOLEAN.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] stringValues = (Binary[]) sourceValues;
+          final boolean[] boolValues = new boolean[stringValues.length];
+          for (int i = 0; i < stringValues.length; i++) {
+            boolValues[i] = ValueConverter.convertStringToBoolean(stringValues[i]);
+          }
+          return boolValues;
+        };
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.INT32.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] stringValues = (Binary[]) sourceValues;
+          final int[] intValues = new int[stringValues.length];
+          for (int i = 0; i < stringValues.length; i++) {
+            intValues[i] = ValueConverter.convertStringToInt32(stringValues[i]);
+          }
+          return intValues;
+        };
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.INT64.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] stringValues = (Binary[]) sourceValues;
+          final long[] longValues = new long[stringValues.length];
+          for (int i = 0; i < stringValues.length; i++) {
+            longValues[i] = ValueConverter.convertStringToInt64(stringValues[i]);
+          }
+          return longValues;
+        };
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.FLOAT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] stringValues = (Binary[]) sourceValues;
+          final float[] floatValues = new float[stringValues.length];
+          for (int i = 0; i < stringValues.length; i++) {
+            floatValues[i] = ValueConverter.convertStringToFloat(stringValues[i]);
+          }
+          return floatValues;
+        };
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.DOUBLE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] stringValues = (Binary[]) sourceValues;
+          final double[] doubleValues = new double[stringValues.length];
+          for (int i = 0; i < stringValues.length; i++) {
+            doubleValues[i] = ValueConverter.convertStringToDouble(stringValues[i]);
+          }
+          return doubleValues;
+        };
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.TEXT.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] stringValues = (Binary[]) sourceValues;
+          final Binary[] textValues = new Binary[stringValues.length];
+          for (int i = 0; i < stringValues.length; i++) {
+            textValues[i] = ValueConverter.convertStringToText(stringValues[i]);
+          }
+          return textValues;
+        };
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] stringValues = (Binary[]) sourceValues;
+          final long[] timestampValues = new long[stringValues.length];
+          for (int i = 0; i < stringValues.length; i++) {
+            timestampValues[i] = ValueConverter.convertStringToTimestamp(stringValues[i]);
+          }
+          return timestampValues;
+        };
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.DATE.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] stringValues = (Binary[]) sourceValues;
+          final int[] dateValues = new int[stringValues.length];
+          for (int i = 0; i < stringValues.length; i++) {
+            dateValues[i] = ValueConverter.convertStringToDate(stringValues[i]);
+          }
+          return dateValues;
+        };
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.BLOB.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> {
+          final Binary[] stringValues = (Binary[]) sourceValues;
+          final Binary[] blobValues = new Binary[stringValues.length];
+          for (int i = 0; i < stringValues.length; i++) {
+            blobValues[i] = ValueConverter.convertStringToBlob(stringValues[i]);
+          }
+          return blobValues;
+        };
+    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.STRING.ordinal()] =
+        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
+  }
+
+  public static Object convert(
+      final TSDataType sourceDataType, final TSDataType targetDataType, final Object sourceValues) {
+    return sourceValues == null
+        ? null
+        : CONVERTER[sourceDataType.ordinal()][targetDataType.ordinal()].convert(
+            sourceDataType, targetDataType, sourceValues);
+  }
+
+  private TsFileToTabletConverter() {
+    // forbidden to construct
+  }
+}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/visitor/PipeStatementDataTypeConvertExecutionVisitor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/visitor/PipeStatementDataTypeConvertExecutionVisitor.java
index 69f456552f7..3d94941b326 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/visitor/PipeStatementDataTypeConvertExecutionVisitor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/visitor/PipeStatementDataTypeConvertExecutionVisitor.java
@@ -19,8 +19,10 @@
 
 package org.apache.iotdb.db.pipe.receiver.visitor;
 
+import org.apache.commons.io.FileUtils;
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
 import org.apache.iotdb.db.exception.metadata.DataTypeMismatchException;
+import org.apache.iotdb.db.pipe.event.common.tsfile.container.TsFileInsertionDataContainer;
 import org.apache.iotdb.db.pipe.receiver.transform.statement.PipeConvertedInsertRowStatement;
 import org.apache.iotdb.db.pipe.receiver.transform.statement.PipeConvertedInsertTabletStatement;
 import org.apache.iotdb.db.queryengine.plan.statement.Statement;
@@ -80,6 +82,14 @@ public class PipeStatementDataTypeConvertExecutionVisitor
       final LoadTsFileStatement loadTsFileStatement, final TSStatus status) {
     // TODO: judge if the exception is caused by data type mismatch
     // TODO: convert the data type of the statement
+    // Pipe enriched / paras in loadTsFileStatement
+
+    if (loadTsFileStatement.isDeleteAfterLoad()) {
+      loadTsFileStatement.getTsFiles().forEach(FileUtils::deleteQuietly);
+    }
+
+    TsFileInsertionDataContainer
+
     return visitStatement(loadTsFileStatement, status);
   }

(iotdb) 02/02: Revert "stash"

Posted by ro...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

rong pushed a commit to branch tsfile-tablet-converter
in repository https://gitbox.apache.org/repos/asf/iotdb.git

commit cee7d7af04e6656b01167f84799f7eba954a547f
Author: Steve Yurong Su <ro...@apache.org>
AuthorDate: Mon Aug 19 17:59:13 2024 +0800

    Revert "stash"
    
    This reverts commit 4c6bcc1d8a9b3c90f1d77bf90f5d8e98c8d3df50.
---
 .../converter/TsFileToTabletConverter.java         | 940 ---------------------
 ...peStatementDataTypeConvertExecutionVisitor.java |  10 -
 2 files changed, 950 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/transform/converter/TsFileToTabletConverter.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/transform/converter/TsFileToTabletConverter.java
deleted file mode 100644
index d2dcf5a61b9..00000000000
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/transform/converter/TsFileToTabletConverter.java
+++ /dev/null
@@ -1,940 +0,0 @@
-/*
- * 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.pipe.receiver.transform.converter;
-
-import org.apache.tsfile.enums.TSDataType;
-import org.apache.tsfile.utils.Binary;
-
-public class TsFileToTabletConverter {
-
-  @FunctionalInterface
-  private interface Converter {
-    Object convert(
-        final TSDataType sourceDataType,
-        final TSDataType targetDataType,
-        final Object sourceValues);
-  }
-
-  private static final Converter[][] CONVERTER =
-      new Converter[TSDataType.values().length][TSDataType.values().length];
-
-  private static final Converter DO_NOTHING_CONVERTER =
-      (sourceDataType, targetDataType, sourceValues) -> sourceValues;
-
-  static {
-    for (final TSDataType sourceDataType : TSDataType.values()) {
-      for (final TSDataType targetDataType : TSDataType.values()) {
-        CONVERTER[sourceDataType.ordinal()][targetDataType.ordinal()] = DO_NOTHING_CONVERTER;
-      }
-    }
-
-    // BOOLEAN
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.BOOLEAN.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.INT32.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final boolean[] boolValues = (boolean[]) sourceValues;
-          final int[] intValues = new int[boolValues.length];
-          for (int i = 0; i < boolValues.length; i++) {
-            intValues[i] = ValueConverter.convertBooleanToInt32(boolValues[i]);
-          }
-          return intValues;
-        };
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.INT64.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final boolean[] boolValues = (boolean[]) sourceValues;
-          final long[] longValues = new long[boolValues.length];
-          for (int i = 0; i < boolValues.length; i++) {
-            longValues[i] = ValueConverter.convertBooleanToInt64(boolValues[i]);
-          }
-          return longValues;
-        };
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.FLOAT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final boolean[] boolValues = (boolean[]) sourceValues;
-          final float[] floatValues = new float[boolValues.length];
-          for (int i = 0; i < boolValues.length; i++) {
-            floatValues[i] = ValueConverter.convertBooleanToFloat(boolValues[i]);
-          }
-          return floatValues;
-        };
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.DOUBLE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final boolean[] boolValues = (boolean[]) sourceValues;
-          final double[] doubleValues = new double[boolValues.length];
-          for (int i = 0; i < boolValues.length; i++) {
-            doubleValues[i] = ValueConverter.convertBooleanToDouble(boolValues[i]);
-          }
-          return doubleValues;
-        };
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.TEXT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final boolean[] boolValues = (boolean[]) sourceValues;
-          final Binary[] textValues = new Binary[boolValues.length];
-          for (int i = 0; i < boolValues.length; i++) {
-            textValues[i] = ValueConverter.convertBooleanToText(boolValues[i]);
-          }
-          return textValues;
-        };
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final boolean[] boolValues = (boolean[]) sourceValues;
-          final long[] timestampValues = new long[boolValues.length];
-          for (int i = 0; i < boolValues.length; i++) {
-            timestampValues[i] = ValueConverter.convertBooleanToTimestamp(boolValues[i]);
-          }
-          return timestampValues;
-        };
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.DATE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final boolean[] boolValues = (boolean[]) sourceValues;
-          final int[] dateValues = new int[boolValues.length];
-          for (int i = 0; i < boolValues.length; i++) {
-            dateValues[i] = ValueConverter.convertBooleanToDate(boolValues[i]);
-          }
-          return dateValues;
-        };
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.BLOB.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final boolean[] boolValues = (boolean[]) sourceValues;
-          final Binary[] blobValues = new Binary[boolValues.length];
-          for (int i = 0; i < boolValues.length; i++) {
-            blobValues[i] = ValueConverter.convertBooleanToBlob(boolValues[i]);
-          }
-          return blobValues;
-        };
-    CONVERTER[TSDataType.BOOLEAN.ordinal()][TSDataType.STRING.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final boolean[] boolValues = (boolean[]) sourceValues;
-          final Binary[] stringValues = new Binary[boolValues.length];
-          for (int i = 0; i < boolValues.length; i++) {
-            stringValues[i] = ValueConverter.convertBooleanToString(boolValues[i]);
-          }
-          return stringValues;
-        };
-
-    // INT32
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.BOOLEAN.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] intValues = (int[]) sourceValues;
-          final boolean[] boolValues = new boolean[intValues.length];
-          for (int i = 0; i < intValues.length; i++) {
-            boolValues[i] = ValueConverter.convertInt32ToBoolean(intValues[i]);
-          }
-          return boolValues;
-        };
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.INT32.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.INT64.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] intValues = (int[]) sourceValues;
-          final long[] longValues = new long[intValues.length];
-          for (int i = 0; i < intValues.length; i++) {
-            longValues[i] = ValueConverter.convertInt32ToInt64(intValues[i]);
-          }
-          return longValues;
-        };
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.FLOAT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] intValues = (int[]) sourceValues;
-          final float[] floatValues = new float[intValues.length];
-          for (int i = 0; i < intValues.length; i++) {
-            floatValues[i] = ValueConverter.convertInt32ToFloat(intValues[i]);
-          }
-          return floatValues;
-        };
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.DOUBLE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] intValues = (int[]) sourceValues;
-          final double[] doubleValues = new double[intValues.length];
-          for (int i = 0; i < intValues.length; i++) {
-            doubleValues[i] = ValueConverter.convertInt32ToDouble(intValues[i]);
-          }
-          return doubleValues;
-        };
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.TEXT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] intValues = (int[]) sourceValues;
-          final Binary[] textValues = new Binary[intValues.length];
-          for (int i = 0; i < intValues.length; i++) {
-            textValues[i] = ValueConverter.convertInt32ToText(intValues[i]);
-          }
-          return textValues;
-        };
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] intValues = (int[]) sourceValues;
-          final long[] timestampValues = new long[intValues.length];
-          for (int i = 0; i < intValues.length; i++) {
-            timestampValues[i] = ValueConverter.convertInt32ToTimestamp(intValues[i]);
-          }
-          return timestampValues;
-        };
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.DATE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] intValues = (int[]) sourceValues;
-          final int[] dateValues = new int[intValues.length];
-          for (int i = 0; i < intValues.length; i++) {
-            dateValues[i] = ValueConverter.convertInt32ToDate(intValues[i]);
-          }
-          return dateValues;
-        };
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.BLOB.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] intValues = (int[]) sourceValues;
-          final Binary[] blobValues = new Binary[intValues.length];
-          for (int i = 0; i < intValues.length; i++) {
-            blobValues[i] = ValueConverter.convertInt32ToBlob(intValues[i]);
-          }
-          return blobValues;
-        };
-    CONVERTER[TSDataType.INT32.ordinal()][TSDataType.STRING.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] intValues = (int[]) sourceValues;
-          final Binary[] stringValues = new Binary[intValues.length];
-          for (int i = 0; i < intValues.length; i++) {
-            stringValues[i] = ValueConverter.convertInt32ToString(intValues[i]);
-          }
-          return stringValues;
-        };
-
-    // INT64
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.BOOLEAN.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] longValues = (long[]) sourceValues;
-          final boolean[] boolValues = new boolean[longValues.length];
-          for (int i = 0; i < longValues.length; i++) {
-            boolValues[i] = ValueConverter.convertInt64ToBoolean(longValues[i]);
-          }
-          return boolValues;
-        };
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.INT32.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] longValues = (long[]) sourceValues;
-          final int[] intValues = new int[longValues.length];
-          for (int i = 0; i < longValues.length; i++) {
-            intValues[i] = ValueConverter.convertInt64ToInt32(longValues[i]);
-          }
-          return intValues;
-        };
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.INT64.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.FLOAT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] longValues = (long[]) sourceValues;
-          final float[] floatValues = new float[longValues.length];
-          for (int i = 0; i < longValues.length; i++) {
-            floatValues[i] = ValueConverter.convertInt64ToFloat(longValues[i]);
-          }
-          return floatValues;
-        };
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.DOUBLE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] longValues = (long[]) sourceValues;
-          final double[] doubleValues = new double[longValues.length];
-          for (int i = 0; i < longValues.length; i++) {
-            doubleValues[i] = ValueConverter.convertInt64ToDouble(longValues[i]);
-          }
-          return doubleValues;
-        };
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.TEXT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] longValues = (long[]) sourceValues;
-          final Binary[] textValues = new Binary[longValues.length];
-          for (int i = 0; i < longValues.length; i++) {
-            textValues[i] = ValueConverter.convertInt64ToText(longValues[i]);
-          }
-          return textValues;
-        };
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] longValues = (long[]) sourceValues;
-          final long[] timestampValues = new long[longValues.length];
-          for (int i = 0; i < longValues.length; i++) {
-            timestampValues[i] = ValueConverter.convertInt64ToTimestamp(longValues[i]);
-          }
-          return timestampValues;
-        };
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.DATE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] longValues = (long[]) sourceValues;
-          final int[] dateValues = new int[longValues.length];
-          for (int i = 0; i < longValues.length; i++) {
-            dateValues[i] = ValueConverter.convertInt64ToDate(longValues[i]);
-          }
-          return dateValues;
-        };
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.BLOB.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] longValues = (long[]) sourceValues;
-          final Binary[] blobValues = new Binary[longValues.length];
-          for (int i = 0; i < longValues.length; i++) {
-            blobValues[i] = ValueConverter.convertInt64ToBlob(longValues[i]);
-          }
-          return blobValues;
-        };
-    CONVERTER[TSDataType.INT64.ordinal()][TSDataType.STRING.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] longValues = (long[]) sourceValues;
-          final Binary[] stringValues = new Binary[longValues.length];
-          for (int i = 0; i < longValues.length; i++) {
-            stringValues[i] = ValueConverter.convertInt64ToString(longValues[i]);
-          }
-          return stringValues;
-        };
-
-    // FLOAT
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.BOOLEAN.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final float[] floatValues = (float[]) sourceValues;
-          final boolean[] boolValues = new boolean[floatValues.length];
-          for (int i = 0; i < floatValues.length; i++) {
-            boolValues[i] = ValueConverter.convertFloatToBoolean(floatValues[i]);
-          }
-          return boolValues;
-        };
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.INT32.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final float[] floatValues = (float[]) sourceValues;
-          final int[] intValues = new int[floatValues.length];
-          for (int i = 0; i < floatValues.length; i++) {
-            intValues[i] = ValueConverter.convertFloatToInt32(floatValues[i]);
-          }
-          return intValues;
-        };
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.INT64.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final float[] floatValues = (float[]) sourceValues;
-          final long[] longValues = new long[floatValues.length];
-          for (int i = 0; i < floatValues.length; i++) {
-            longValues[i] = ValueConverter.convertFloatToInt64(floatValues[i]);
-          }
-          return longValues;
-        };
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.FLOAT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.DOUBLE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final float[] floatValues = (float[]) sourceValues;
-          final double[] doubleValues = new double[floatValues.length];
-          for (int i = 0; i < floatValues.length; i++) {
-            doubleValues[i] = ValueConverter.convertFloatToDouble(floatValues[i]);
-          }
-          return doubleValues;
-        };
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.TEXT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final float[] floatValues = (float[]) sourceValues;
-          final Binary[] textValues = new Binary[floatValues.length];
-          for (int i = 0; i < floatValues.length; i++) {
-            textValues[i] = ValueConverter.convertFloatToText(floatValues[i]);
-          }
-          return textValues;
-        };
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final float[] floatValues = (float[]) sourceValues;
-          final long[] timestampValues = new long[floatValues.length];
-          for (int i = 0; i < floatValues.length; i++) {
-            timestampValues[i] = ValueConverter.convertFloatToTimestamp(floatValues[i]);
-          }
-          return timestampValues;
-        };
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.DATE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final float[] floatValues = (float[]) sourceValues;
-          final int[] dateValues = new int[floatValues.length];
-          for (int i = 0; i < floatValues.length; i++) {
-            dateValues[i] = ValueConverter.convertFloatToDate(floatValues[i]);
-          }
-          return dateValues;
-        };
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.BLOB.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final float[] floatValues = (float[]) sourceValues;
-          final Binary[] blobValues = new Binary[floatValues.length];
-          for (int i = 0; i < floatValues.length; i++) {
-            blobValues[i] = ValueConverter.convertFloatToBlob(floatValues[i]);
-          }
-          return blobValues;
-        };
-    CONVERTER[TSDataType.FLOAT.ordinal()][TSDataType.STRING.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final float[] floatValues = (float[]) sourceValues;
-          final Binary[] stringValues = new Binary[floatValues.length];
-          for (int i = 0; i < floatValues.length; i++) {
-            stringValues[i] = ValueConverter.convertFloatToString(floatValues[i]);
-          }
-          return stringValues;
-        };
-
-    // DOUBLE
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.BOOLEAN.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final double[] doubleValues = (double[]) sourceValues;
-          final boolean[] boolValues = new boolean[doubleValues.length];
-          for (int i = 0; i < doubleValues.length; i++) {
-            boolValues[i] = ValueConverter.convertDoubleToBoolean(doubleValues[i]);
-          }
-          return boolValues;
-        };
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.INT32.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final double[] doubleValues = (double[]) sourceValues;
-          final int[] intValues = new int[doubleValues.length];
-          for (int i = 0; i < doubleValues.length; i++) {
-            intValues[i] = ValueConverter.convertDoubleToInt32(doubleValues[i]);
-          }
-          return intValues;
-        };
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.INT64.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final double[] doubleValues = (double[]) sourceValues;
-          final long[] longValues = new long[doubleValues.length];
-          for (int i = 0; i < doubleValues.length; i++) {
-            longValues[i] = ValueConverter.convertDoubleToInt64(doubleValues[i]);
-          }
-          return longValues;
-        };
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.FLOAT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final double[] doubleValues = (double[]) sourceValues;
-          final float[] floatValues = new float[doubleValues.length];
-          for (int i = 0; i < doubleValues.length; i++) {
-            floatValues[i] = ValueConverter.convertDoubleToFloat(doubleValues[i]);
-          }
-          return floatValues;
-        };
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.DOUBLE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.TEXT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final double[] doubleValues = (double[]) sourceValues;
-          final Binary[] textValues = new Binary[doubleValues.length];
-          for (int i = 0; i < doubleValues.length; i++) {
-            textValues[i] = ValueConverter.convertDoubleToText(doubleValues[i]);
-          }
-          return textValues;
-        };
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final double[] doubleValues = (double[]) sourceValues;
-          final long[] timestampValues = new long[doubleValues.length];
-          for (int i = 0; i < doubleValues.length; i++) {
-            timestampValues[i] = ValueConverter.convertDoubleToTimestamp(doubleValues[i]);
-          }
-          return timestampValues;
-        };
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.DATE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final double[] doubleValues = (double[]) sourceValues;
-          final int[] dateValues = new int[doubleValues.length];
-          for (int i = 0; i < doubleValues.length; i++) {
-            dateValues[i] = ValueConverter.convertDoubleToDate(doubleValues[i]);
-          }
-          return dateValues;
-        };
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.BLOB.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final double[] doubleValues = (double[]) sourceValues;
-          final Binary[] blobValues = new Binary[doubleValues.length];
-          for (int i = 0; i < doubleValues.length; i++) {
-            blobValues[i] = ValueConverter.convertDoubleToBlob(doubleValues[i]);
-          }
-          return blobValues;
-        };
-    CONVERTER[TSDataType.DOUBLE.ordinal()][TSDataType.STRING.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final double[] doubleValues = (double[]) sourceValues;
-          final Binary[] stringValues = new Binary[doubleValues.length];
-          for (int i = 0; i < doubleValues.length; i++) {
-            stringValues[i] = ValueConverter.convertDoubleToString(doubleValues[i]);
-          }
-          return stringValues;
-        };
-
-    // TEXT
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.BOOLEAN.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] textValues = (Binary[]) sourceValues;
-          final boolean[] boolValues = new boolean[textValues.length];
-          for (int i = 0; i < textValues.length; i++) {
-            boolValues[i] = ValueConverter.convertTextToBoolean(textValues[i]);
-          }
-          return boolValues;
-        };
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.INT32.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] textValues = (Binary[]) sourceValues;
-          final int[] intValues = new int[textValues.length];
-          for (int i = 0; i < textValues.length; i++) {
-            intValues[i] = ValueConverter.convertTextToInt32(textValues[i]);
-          }
-          return intValues;
-        };
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.INT64.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] textValues = (Binary[]) sourceValues;
-          final long[] longValues = new long[textValues.length];
-          for (int i = 0; i < textValues.length; i++) {
-            longValues[i] = ValueConverter.convertTextToInt64(textValues[i]);
-          }
-          return longValues;
-        };
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.FLOAT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] textValues = (Binary[]) sourceValues;
-          final float[] floatValues = new float[textValues.length];
-          for (int i = 0; i < textValues.length; i++) {
-            floatValues[i] = ValueConverter.convertTextToFloat(textValues[i]);
-          }
-          return floatValues;
-        };
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.DOUBLE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] textValues = (Binary[]) sourceValues;
-          final double[] doubleValues = new double[textValues.length];
-          for (int i = 0; i < textValues.length; i++) {
-            doubleValues[i] = ValueConverter.convertTextToDouble(textValues[i]);
-          }
-          return doubleValues;
-        };
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.TEXT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] textValues = (Binary[]) sourceValues;
-          final long[] timestampValues = new long[textValues.length];
-          for (int i = 0; i < textValues.length; i++) {
-            timestampValues[i] = ValueConverter.convertTextToTimestamp(textValues[i]);
-          }
-          return timestampValues;
-        };
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.DATE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] textValues = (Binary[]) sourceValues;
-          final int[] dateValues = new int[textValues.length];
-          for (int i = 0; i < textValues.length; i++) {
-            dateValues[i] = ValueConverter.convertTextToDate(textValues[i]);
-          }
-          return dateValues;
-        };
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.BLOB.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] textValues = (Binary[]) sourceValues;
-          final Binary[] blobValues = new Binary[textValues.length];
-          for (int i = 0; i < textValues.length; i++) {
-            blobValues[i] = ValueConverter.convertTextToBlob(textValues[i]);
-          }
-          return blobValues;
-        };
-    CONVERTER[TSDataType.TEXT.ordinal()][TSDataType.STRING.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] textValues = (Binary[]) sourceValues;
-          final Binary[] stringValues = new Binary[textValues.length];
-          for (int i = 0; i < textValues.length; i++) {
-            stringValues[i] = ValueConverter.convertTextToString(textValues[i]);
-          }
-          return stringValues;
-        };
-
-    // VECTOR
-    for (int i = 0; i < TSDataType.values().length; i++) {
-      CONVERTER[TSDataType.VECTOR.ordinal()][i] = DO_NOTHING_CONVERTER;
-    }
-
-    // UNKNOWN
-    for (int i = 0; i < TSDataType.values().length; i++) {
-      CONVERTER[TSDataType.UNKNOWN.ordinal()][i] = DO_NOTHING_CONVERTER;
-    }
-
-    // TIMESTAMP
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.BOOLEAN.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] timestampValues = (long[]) sourceValues;
-          final boolean[] boolValues = new boolean[timestampValues.length];
-          for (int i = 0; i < timestampValues.length; i++) {
-            boolValues[i] = ValueConverter.convertTimestampToBoolean(timestampValues[i]);
-          }
-          return boolValues;
-        };
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.INT32.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] timestampValues = (long[]) sourceValues;
-          final int[] intValues = new int[timestampValues.length];
-          for (int i = 0; i < timestampValues.length; i++) {
-            intValues[i] = ValueConverter.convertTimestampToInt32(timestampValues[i]);
-          }
-          return intValues;
-        };
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.INT64.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] timestampValues = (long[]) sourceValues;
-          final long[] longValues = new long[timestampValues.length];
-          for (int i = 0; i < timestampValues.length; i++) {
-            longValues[i] = ValueConverter.convertTimestampToInt64(timestampValues[i]);
-          }
-          return longValues;
-        };
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.FLOAT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] timestampValues = (long[]) sourceValues;
-          final float[] floatValues = new float[timestampValues.length];
-          for (int i = 0; i < timestampValues.length; i++) {
-            floatValues[i] = ValueConverter.convertTimestampToFloat(timestampValues[i]);
-          }
-          return floatValues;
-        };
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.DOUBLE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] timestampValues = (long[]) sourceValues;
-          final double[] doubleValues = new double[timestampValues.length];
-          for (int i = 0; i < timestampValues.length; i++) {
-            doubleValues[i] = ValueConverter.convertTimestampToDouble(timestampValues[i]);
-          }
-          return doubleValues;
-        };
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.TEXT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] timestampValues = (long[]) sourceValues;
-          final Binary[] textValues = new Binary[timestampValues.length];
-          for (int i = 0; i < timestampValues.length; i++) {
-            textValues[i] = ValueConverter.convertTimestampToText(timestampValues[i]);
-          }
-          return textValues;
-        };
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.DATE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] timestampValues = (long[]) sourceValues;
-          final int[] dateValues = new int[timestampValues.length];
-          for (int i = 0; i < timestampValues.length; i++) {
-            dateValues[i] = ValueConverter.convertTimestampToDate(timestampValues[i]);
-          }
-          return dateValues;
-        };
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.BLOB.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] timestampValues = (long[]) sourceValues;
-          final Binary[] blobValues = new Binary[timestampValues.length];
-          for (int i = 0; i < timestampValues.length; i++) {
-            blobValues[i] = ValueConverter.convertTimestampToBlob(timestampValues[i]);
-          }
-          return blobValues;
-        };
-    CONVERTER[TSDataType.TIMESTAMP.ordinal()][TSDataType.STRING.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final long[] timestampValues = (long[]) sourceValues;
-          final Binary[] stringValues = new Binary[timestampValues.length];
-          for (int i = 0; i < timestampValues.length; i++) {
-            stringValues[i] = ValueConverter.convertTimestampToString(timestampValues[i]);
-          }
-          return stringValues;
-        };
-
-    // DATE
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.BOOLEAN.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] dateValues = (int[]) sourceValues;
-          final boolean[] boolValues = new boolean[dateValues.length];
-          for (int i = 0; i < dateValues.length; i++) {
-            boolValues[i] = ValueConverter.convertDateToBoolean(dateValues[i]);
-          }
-          return boolValues;
-        };
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.INT32.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] dateValues = (int[]) sourceValues;
-          final int[] intValues = new int[dateValues.length];
-          for (int i = 0; i < dateValues.length; i++) {
-            intValues[i] = ValueConverter.convertDateToInt32(dateValues[i]);
-          }
-          return intValues;
-        };
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.INT64.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] dateValues = (int[]) sourceValues;
-          final long[] longValues = new long[dateValues.length];
-          for (int i = 0; i < dateValues.length; i++) {
-            longValues[i] = ValueConverter.convertDateToInt64(dateValues[i]);
-          }
-          return longValues;
-        };
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.FLOAT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] dateValues = (int[]) sourceValues;
-          final float[] floatValues = new float[dateValues.length];
-          for (int i = 0; i < dateValues.length; i++) {
-            floatValues[i] = ValueConverter.convertDateToFloat(dateValues[i]);
-          }
-          return floatValues;
-        };
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.DOUBLE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] dateValues = (int[]) sourceValues;
-          final double[] doubleValues = new double[dateValues.length];
-          for (int i = 0; i < dateValues.length; i++) {
-            doubleValues[i] = ValueConverter.convertDateToDouble(dateValues[i]);
-          }
-          return doubleValues;
-        };
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.TEXT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] dateValues = (int[]) sourceValues;
-          final Binary[] textValues = new Binary[dateValues.length];
-          for (int i = 0; i < dateValues.length; i++) {
-            textValues[i] = ValueConverter.convertDateToText(dateValues[i]);
-          }
-          return textValues;
-        };
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] dateValues = (int[]) sourceValues;
-          final long[] timestampValues = new long[dateValues.length];
-          for (int i = 0; i < dateValues.length; i++) {
-            timestampValues[i] = ValueConverter.convertDateToTimestamp(dateValues[i]);
-          }
-          return timestampValues;
-        };
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.DATE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.BLOB.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] dateValues = (int[]) sourceValues;
-          final Binary[] blobValues = new Binary[dateValues.length];
-          for (int i = 0; i < dateValues.length; i++) {
-            blobValues[i] = ValueConverter.convertDateToBlob(dateValues[i]);
-          }
-          return blobValues;
-        };
-    CONVERTER[TSDataType.DATE.ordinal()][TSDataType.STRING.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final int[] dateValues = (int[]) sourceValues;
-          final Binary[] stringValues = new Binary[dateValues.length];
-          for (int i = 0; i < dateValues.length; i++) {
-            stringValues[i] = ValueConverter.convertDateToString(dateValues[i]);
-          }
-          return stringValues;
-        };
-
-    // BLOB
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.BOOLEAN.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] blobValues = (Binary[]) sourceValues;
-          final boolean[] boolValues = new boolean[blobValues.length];
-          for (int i = 0; i < blobValues.length; i++) {
-            boolValues[i] = ValueConverter.convertBlobToBoolean(blobValues[i]);
-          }
-          return boolValues;
-        };
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.INT32.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] blobValues = (Binary[]) sourceValues;
-          final int[] intValues = new int[blobValues.length];
-          for (int i = 0; i < blobValues.length; i++) {
-            intValues[i] = ValueConverter.convertBlobToInt32(blobValues[i]);
-          }
-          return intValues;
-        };
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.INT64.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] blobValues = (Binary[]) sourceValues;
-          final long[] longValues = new long[blobValues.length];
-          for (int i = 0; i < blobValues.length; i++) {
-            longValues[i] = ValueConverter.convertBlobToInt64(blobValues[i]);
-          }
-          return longValues;
-        };
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.FLOAT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] blobValues = (Binary[]) sourceValues;
-          final float[] floatValues = new float[blobValues.length];
-          for (int i = 0; i < blobValues.length; i++) {
-            floatValues[i] = ValueConverter.convertBlobToFloat(blobValues[i]);
-          }
-          return floatValues;
-        };
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.DOUBLE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] blobValues = (Binary[]) sourceValues;
-          final double[] doubleValues = new double[blobValues.length];
-          for (int i = 0; i < blobValues.length; i++) {
-            doubleValues[i] = ValueConverter.convertBlobToDouble(blobValues[i]);
-          }
-          return doubleValues;
-        };
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.TEXT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] blobValues = (Binary[]) sourceValues;
-          final Binary[] textValues = new Binary[blobValues.length];
-          for (int i = 0; i < blobValues.length; i++) {
-            textValues[i] = ValueConverter.convertBlobToText(blobValues[i]);
-          }
-          return textValues;
-        };
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] blobValues = (Binary[]) sourceValues;
-          final long[] timestampValues = new long[blobValues.length];
-          for (int i = 0; i < blobValues.length; i++) {
-            timestampValues[i] = ValueConverter.convertBlobToTimestamp(blobValues[i]);
-          }
-          return timestampValues;
-        };
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.DATE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] blobValues = (Binary[]) sourceValues;
-          final int[] dateValues = new int[blobValues.length];
-          for (int i = 0; i < blobValues.length; i++) {
-            dateValues[i] = ValueConverter.convertBlobToDate(blobValues[i]);
-          }
-          return dateValues;
-        };
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.BLOB.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
-    CONVERTER[TSDataType.BLOB.ordinal()][TSDataType.STRING.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] blobValues = (Binary[]) sourceValues;
-          final Binary[] stringValues = new Binary[blobValues.length];
-          for (int i = 0; i < blobValues.length; i++) {
-            stringValues[i] = ValueConverter.convertBlobToString(blobValues[i]);
-          }
-          return stringValues;
-        };
-
-    // STRING
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.BOOLEAN.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] stringValues = (Binary[]) sourceValues;
-          final boolean[] boolValues = new boolean[stringValues.length];
-          for (int i = 0; i < stringValues.length; i++) {
-            boolValues[i] = ValueConverter.convertStringToBoolean(stringValues[i]);
-          }
-          return boolValues;
-        };
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.INT32.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] stringValues = (Binary[]) sourceValues;
-          final int[] intValues = new int[stringValues.length];
-          for (int i = 0; i < stringValues.length; i++) {
-            intValues[i] = ValueConverter.convertStringToInt32(stringValues[i]);
-          }
-          return intValues;
-        };
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.INT64.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] stringValues = (Binary[]) sourceValues;
-          final long[] longValues = new long[stringValues.length];
-          for (int i = 0; i < stringValues.length; i++) {
-            longValues[i] = ValueConverter.convertStringToInt64(stringValues[i]);
-          }
-          return longValues;
-        };
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.FLOAT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] stringValues = (Binary[]) sourceValues;
-          final float[] floatValues = new float[stringValues.length];
-          for (int i = 0; i < stringValues.length; i++) {
-            floatValues[i] = ValueConverter.convertStringToFloat(stringValues[i]);
-          }
-          return floatValues;
-        };
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.DOUBLE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] stringValues = (Binary[]) sourceValues;
-          final double[] doubleValues = new double[stringValues.length];
-          for (int i = 0; i < stringValues.length; i++) {
-            doubleValues[i] = ValueConverter.convertStringToDouble(stringValues[i]);
-          }
-          return doubleValues;
-        };
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.TEXT.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] stringValues = (Binary[]) sourceValues;
-          final Binary[] textValues = new Binary[stringValues.length];
-          for (int i = 0; i < stringValues.length; i++) {
-            textValues[i] = ValueConverter.convertStringToText(stringValues[i]);
-          }
-          return textValues;
-        };
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.VECTOR.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.UNKNOWN.ordinal()] = DO_NOTHING_CONVERTER;
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.TIMESTAMP.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] stringValues = (Binary[]) sourceValues;
-          final long[] timestampValues = new long[stringValues.length];
-          for (int i = 0; i < stringValues.length; i++) {
-            timestampValues[i] = ValueConverter.convertStringToTimestamp(stringValues[i]);
-          }
-          return timestampValues;
-        };
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.DATE.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] stringValues = (Binary[]) sourceValues;
-          final int[] dateValues = new int[stringValues.length];
-          for (int i = 0; i < stringValues.length; i++) {
-            dateValues[i] = ValueConverter.convertStringToDate(stringValues[i]);
-          }
-          return dateValues;
-        };
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.BLOB.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> {
-          final Binary[] stringValues = (Binary[]) sourceValues;
-          final Binary[] blobValues = new Binary[stringValues.length];
-          for (int i = 0; i < stringValues.length; i++) {
-            blobValues[i] = ValueConverter.convertStringToBlob(stringValues[i]);
-          }
-          return blobValues;
-        };
-    CONVERTER[TSDataType.STRING.ordinal()][TSDataType.STRING.ordinal()] =
-        (sourceDataType, targetDataType, sourceValues) -> sourceValues;
-  }
-
-  public static Object convert(
-      final TSDataType sourceDataType, final TSDataType targetDataType, final Object sourceValues) {
-    return sourceValues == null
-        ? null
-        : CONVERTER[sourceDataType.ordinal()][targetDataType.ordinal()].convert(
-            sourceDataType, targetDataType, sourceValues);
-  }
-
-  private TsFileToTabletConverter() {
-    // forbidden to construct
-  }
-}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/visitor/PipeStatementDataTypeConvertExecutionVisitor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/visitor/PipeStatementDataTypeConvertExecutionVisitor.java
index 3d94941b326..69f456552f7 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/visitor/PipeStatementDataTypeConvertExecutionVisitor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/receiver/visitor/PipeStatementDataTypeConvertExecutionVisitor.java
@@ -19,10 +19,8 @@
 
 package org.apache.iotdb.db.pipe.receiver.visitor;
 
-import org.apache.commons.io.FileUtils;
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
 import org.apache.iotdb.db.exception.metadata.DataTypeMismatchException;
-import org.apache.iotdb.db.pipe.event.common.tsfile.container.TsFileInsertionDataContainer;
 import org.apache.iotdb.db.pipe.receiver.transform.statement.PipeConvertedInsertRowStatement;
 import org.apache.iotdb.db.pipe.receiver.transform.statement.PipeConvertedInsertTabletStatement;
 import org.apache.iotdb.db.queryengine.plan.statement.Statement;
@@ -82,14 +80,6 @@ public class PipeStatementDataTypeConvertExecutionVisitor
       final LoadTsFileStatement loadTsFileStatement, final TSStatus status) {
     // TODO: judge if the exception is caused by data type mismatch
     // TODO: convert the data type of the statement
-    // Pipe enriched / paras in loadTsFileStatement
-
-    if (loadTsFileStatement.isDeleteAfterLoad()) {
-      loadTsFileStatement.getTsFiles().forEach(FileUtils::deleteQuietly);
-    }
-
-    TsFileInsertionDataContainer
-
     return visitStatement(loadTsFileStatement, status);
   }