Optimized the overall performance of IoTDB & Fixed the NPE in LimitOperatorTest

iotdb-client/client-cpp/src/main/SessionDataSet.cpp

@@ -246,38 +246,39 @@ const std::vector<std::string>& SessionDataSet::DataIterator::getColumnTypeList(
 
 shared_ptr<RowRecord> SessionDataSet::constructRowRecordFromValueArray() {
   std::vector<Field> outFields;
-  for (int i = iotdbRpcDataSet_->getValueColumnStartIndex(); i < iotdbRpcDataSet_->getColumnSize();
-       i++) {
+  const int32_t valueColumnStartIndex = iotdbRpcDataSet_->getValueColumnStartIndex();
+  const int32_t columnSize = iotdbRpcDataSet_->getColumnSize();
+  outFields.reserve(columnSize - valueColumnStartIndex);
+  for (int32_t columnIndex = valueColumnStartIndex + 1; columnIndex <= columnSize; ++columnIndex) {
     Field field;
-    std::string columnName = iotdbRpcDataSet_->getColumnNameList().at(i);
-    if (!iotdbRpcDataSet_->isNullByColumnName(columnName)) {
-      TSDataType::TSDataType dataType = iotdbRpcDataSet_->getDataType(columnName);
+    if (!iotdbRpcDataSet_->isNullByIndex(columnIndex)) {
+      TSDataType::TSDataType dataType = iotdbRpcDataSet_->getDataTypeByIndex(columnIndex);
       field.dataType = dataType;
       switch (dataType) {
       case TSDataType::BOOLEAN:
-        field.boolV = iotdbRpcDataSet_->getBoolean(columnName);
+        field.boolV = iotdbRpcDataSet_->getBooleanByIndex(columnIndex).value();
         break;
       case TSDataType::INT32:
-        field.intV = iotdbRpcDataSet_->getInt(columnName);
+        field.intV = iotdbRpcDataSet_->getIntByIndex(columnIndex).value();
         break;
       case TSDataType::DATE:
-        field.dateV = iotdbRpcDataSet_->getDate(columnName);
+        field.dateV = iotdbRpcDataSet_->getDateByIndex(columnIndex).value();
         break;
       case TSDataType::INT64:
       case TSDataType::TIMESTAMP:
-        field.longV = iotdbRpcDataSet_->getLong(columnName);
+        field.longV = iotdbRpcDataSet_->getLongByIndex(columnIndex).value();
         break;
       case TSDataType::FLOAT:
-        field.floatV = iotdbRpcDataSet_->getFloat(columnName);
+        field.floatV = iotdbRpcDataSet_->getFloatByIndex(columnIndex).value();
         break;
       case TSDataType::DOUBLE:
-        field.doubleV = iotdbRpcDataSet_->getDouble(columnName);
+        field.doubleV = iotdbRpcDataSet_->getDoubleByIndex(columnIndex).value();
         break;
       case TSDataType::TEXT:
       case TSDataType::BLOB:
       case TSDataType::STRING:
       case TSDataType::OBJECT:
-        field.stringV = iotdbRpcDataSet_->getBinary(columnName)->getStringValue();
+        field.stringV = iotdbRpcDataSet_->getBinaryByIndex(columnIndex)->getStringValue();
         break;
       default:
         throw UnSupportedDataTypeException("Data type %s is not supported." + dataType);

iotdb-client/isession/src/main/java/org/apache/iotdb/isession/SessionDataSet.java

@@ -153,45 +153,42 @@ public boolean hasNext() throws StatementExecutionException, IoTDBConnectionExce
   }
 
   private RowRecord constructRowRecordFromValueArray() throws StatementExecutionException {
-    List<Field> outFields = new ArrayList<>();
-    for (int i = ioTDBRpcDataSet.getValueColumnStartIndex();
-        i < ioTDBRpcDataSet.getColumnSize();
-        i++) {
+    int valueColumnStartIndex = ioTDBRpcDataSet.getValueColumnStartIndex();
+    int columnSize = ioTDBRpcDataSet.getColumnSize();
+    List<Field> outFields = new ArrayList<>(columnSize - valueColumnStartIndex);
+    for (int columnIndex = valueColumnStartIndex + 1; columnIndex <= columnSize; columnIndex++) {
       Field field;
-
-      String columnName = ioTDBRpcDataSet.getColumnNameList().get(i);
-
-      if (!ioTDBRpcDataSet.isNull(columnName)) {
-        TSDataType dataType = ioTDBRpcDataSet.getDataType(columnName);
+      if (!ioTDBRpcDataSet.isNull(columnIndex)) {
+        TSDataType dataType = ioTDBRpcDataSet.getDataType(columnIndex);
         field = new Field(dataType);
         switch (dataType) {
           case BOOLEAN:
-            boolean booleanValue = ioTDBRpcDataSet.getBoolean(columnName);
+            boolean booleanValue = ioTDBRpcDataSet.getBoolean(columnIndex);
             field.setBoolV(booleanValue);
             break;
           case INT32:
           case DATE:
-            int intValue = ioTDBRpcDataSet.getInt(columnName);
+            int intValue = ioTDBRpcDataSet.getInt(columnIndex);
             field.setIntV(intValue);
             break;
           case INT64:
           case TIMESTAMP:
-            long longValue = ioTDBRpcDataSet.getLong(columnName);
+            long longValue = ioTDBRpcDataSet.getLong(columnIndex);
             field.setLongV(longValue);
             break;
           case FLOAT:
-            float floatValue = ioTDBRpcDataSet.getFloat(columnName);
+            float floatValue = ioTDBRpcDataSet.getFloat(columnIndex);
             field.setFloatV(floatValue);
             break;
           case DOUBLE:
-            double doubleValue = ioTDBRpcDataSet.getDouble(columnName);
+            double doubleValue = ioTDBRpcDataSet.getDouble(columnIndex);
             field.setDoubleV(doubleValue);
             break;
           case TEXT:
           case BLOB:
           case STRING:
           case OBJECT:
-            field.setBinaryV(ioTDBRpcDataSet.getBinary(columnName));
+            field.setBinaryV(ioTDBRpcDataSet.getBinary(columnIndex));
             break;
           default:
             throw new UnSupportedDataTypeException(

iotdb-client/service-rpc/src/main/java/org/apache/iotdb/rpc/IoTDBJDBCDataSet.java

@@ -128,20 +128,15 @@ public IoTDBJDBCDataSet(
 
     // deduplicate and map
     if (columnNameIndex != null) {
-      int deduplicatedColumnSize = (int) columnNameIndex.values().stream().distinct().count();
-      this.columnTypeDeduplicatedList = new ArrayList<>(deduplicatedColumnSize);
-      for (int i = 0; i < deduplicatedColumnSize; i++) {
-        columnTypeDeduplicatedList.add(null);
-      }
+      this.columnTypeDeduplicatedList =
+          initDeduplicatedColumnTypes(getDeduplicatedColumnSize(columnNameIndex));
       for (int i = 0; i < columnNameList.size(); i++) {
         String name = columnNameList.get(i);
         this.columnNameList.add(name);
         this.columnTypeList.add(columnTypeList.get(i));
         if (!columnOrdinalMap.containsKey(name)) {
           int index = columnNameIndex.get(name);
-          if (!columnOrdinalMap.containsValue(index + START_INDEX)) {
-            columnTypeDeduplicatedList.set(index, TSDataType.valueOf(columnTypeList.get(i)));
-          }
+          setColumnTypeIfAbsent(columnTypeDeduplicatedList, index, columnTypeList.get(i));
           columnOrdinalMap.put(name, index + START_INDEX);
         }
       }
@@ -243,11 +238,8 @@ public IoTDBJDBCDataSet(
 
     // deduplicate and map
     if (columnNameIndex != null) {
-      int deduplicatedColumnSize = (int) columnNameIndex.values().stream().distinct().count();
-      this.columnTypeDeduplicatedList = new ArrayList<>(deduplicatedColumnSize);
-      for (int i = 0; i < deduplicatedColumnSize; i++) {
-        columnTypeDeduplicatedList.add(null);
-      }
+      this.columnTypeDeduplicatedList =
+          initDeduplicatedColumnTypes(getDeduplicatedColumnSize(columnNameIndex));
       for (int i = 0; i < columnNameList.size(); i++) {
         String name = "";
         if (sgList != null
@@ -263,9 +255,7 @@ public IoTDBJDBCDataSet(
         // "Time".equals(name) -> to allow the Time column appear in value columns
         if (!columnOrdinalMap.containsKey(name) || "Time".equals(name)) {
           int index = columnNameIndex.get(name);
-          if (!columnOrdinalMap.containsValue(index + START_INDEX)) {
-            columnTypeDeduplicatedList.set(index, TSDataType.valueOf(columnTypeList.get(i)));
-          }
+          setColumnTypeIfAbsent(columnTypeDeduplicatedList, index, columnTypeList.get(i));
           columnOrdinalMap.put(name, index + START_INDEX);
         }
       }
@@ -321,6 +311,31 @@ public IoTDBJDBCDataSet(
     this.emptyResultSet = (queryDataSet == null || !queryDataSet.time.hasRemaining());
   }
 
+  private static int getDeduplicatedColumnSize(Map<String, Integer> columnNameIndex) {
+    int deduplicatedColumnSize = 0;
+    for (Integer index : columnNameIndex.values()) {
+      if (index != null && index + 1 > deduplicatedColumnSize) {
+        deduplicatedColumnSize = index + 1;
+      }
+    }
+    return deduplicatedColumnSize;
+  }
+
+  private static List<TSDataType> initDeduplicatedColumnTypes(int deduplicatedColumnSize) {
+    List<TSDataType> columnTypes = new ArrayList<>(deduplicatedColumnSize);
+    for (int i = 0; i < deduplicatedColumnSize; i++) {
+      columnTypes.add(null);
+    }
+    return columnTypes;
+  }
+
+  private static void setColumnTypeIfAbsent(
+      List<TSDataType> columnTypeDeduplicatedList, int index, String columnType) {
+    if (columnTypeDeduplicatedList.get(index) == null) {
+      columnTypeDeduplicatedList.set(index, TSDataType.valueOf(columnType));
+    }
+  }
+
   public void close() throws StatementExecutionException, TException {
     if (isClosed) {
       return;

iotdb-client/service-rpc/src/main/java/org/apache/iotdb/rpc/stmt/PreparedParameterSerde.java

@@ -36,6 +36,8 @@
 /** Serializer for PreparedStatement parameters. */
 public class PreparedParameterSerde {
 
+  private static final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray();
+
   public static class DeserializedParam {
     public final TSDataType type;
     public final Object value;
@@ -168,10 +170,13 @@ private static Object deserializeValue(ByteBuffer buffer, TSDataType type) {
 
   /** Convert byte array to hexadecimal string representation. */
   public static String bytesToHex(byte[] bytes) {
-    StringBuilder sb = new StringBuilder(bytes.length * 2);
-    for (byte b : bytes) {
-      sb.append(String.format("%02X", b));
+    char[] chars = new char[bytes.length * 2];
+    for (int i = 0; i < bytes.length; i++) {
+      int value = bytes[i] & 0xFF;
+      int index = i * 2;
+      chars[index] = HEX_DIGITS[value >>> 4];
+      chars[index + 1] = HEX_DIGITS[value & 0x0F];
     }
-    return sb.toString();
+    return new String(chars);
   }
 }