diff --git a/src/impl/MilvusClientV2Impl.cpp b/src/impl/MilvusClientV2Impl.cpp
index 0e4a9a30..765ad793 100644
--- a/src/impl/MilvusClientV2Impl.cpp
+++ b/src/impl/MilvusClientV2Impl.cpp
@@ -136,7 +136,7 @@ MilvusClientV2Impl::CreateCollection(const CreateCollectionRequest& request) {
         }
 
         // properties
-        for (auto it : request.Properties()) {
+        for (const auto& it : request.Properties()) {
             auto kv = rpc_request.add_properties();
             kv->set_key(it.first);
             kv->set_value(it.second);
diff --git a/src/impl/types/FieldData.cpp b/src/impl/types/FieldData.cpp
index aef9f4c4..972e3dcf 100644
--- a/src/impl/types/FieldData.cpp
+++ b/src/impl/types/FieldData.cpp
@@ -359,14 +359,14 @@ BinaryVecFieldData::ToBinaryStrings(const std::vector<std::vector<uint8_t>>& dat
     std::vector<std::string> ret;
     ret.reserve(data.size());
     for (const auto& item : data) {
-        ret.emplace_back(std::move(ToBinaryString(item)));
+        ret.emplace_back(ToBinaryString(item));
     }
-    return std::move(ret);
+    return ret;
 }
 
 std::string
 BinaryVecFieldData::ToBinaryString(const std::vector<uint8_t>& data) {
-    return std::move(std::string{data.begin(), data.end()});
+    return std::string{data.begin(), data.end()};
 }
 
 std::vector<std::vector<uint8_t>>
@@ -376,7 +376,7 @@ BinaryVecFieldData::ToUnsignedChars(const std::vector<std::string>& data) {
     for (const auto& item : data) {
         ret.emplace_back(item.begin(), item.end());
     }
-    return std::move(ret);
+    return ret;
 }
 
 std::vector<uint8_t>
@@ -384,7 +384,7 @@ BinaryVecFieldData::ToUnsignedChars(const std::string& data) {
     std::vector<uint8_t> ret;
     ret.reserve(data.size());
     std::copy(data.begin(), data.end(), std::back_inserter(ret));
-    return std::move(ret);
+    return ret;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/impl/utils/CompareUtils.cpp b/src/impl/utils/CompareUtils.cpp
index b362c290..92e2db37 100644
--- a/src/impl/utils/CompareUtils.cpp
+++ b/src/impl/utils/CompareUtils.cpp
@@ -203,7 +203,7 @@ operator==(const proto::schema::FieldData& lhs, const JSONFieldData& rhs) {
 
     EntityRows jsons;
     for (const auto& str : scalars_data) {
-        jsons.emplace_back(std::move(nlohmann::json::parse(str)));
+        jsons.emplace_back(nlohmann::json::parse(str));
     }
     return std::equal(jsons.begin(), jsons.end(), rhs.Data().begin());
 }
diff --git a/src/impl/utils/DqlUtils.cpp b/src/impl/utils/DqlUtils.cpp
index e0c360cd..6951fcf6 100644
--- a/src/impl/utils/DqlUtils.cpp
+++ b/src/impl/utils/DqlUtils.cpp
@@ -28,7 +28,7 @@
 namespace milvus {
 
 SparseFloatVecFieldData::ElementT
-DecodeSparseFloatVector(std::string& bytes) {
+DecodeSparseFloatVector(const std::string& bytes) {
     if (bytes.size() % 8 != 0) {
         throw std::runtime_error("Unexpected binary string is received from server side!");
     }
@@ -65,8 +65,8 @@ BuildFieldDataSparseVectors(const google::protobuf::RepeatedPtrField<std::string
     auto end = cursor;
     std::advance(end, count);
     while (cursor != end) {
-        std::string bytes = *cursor;
-        data.emplace_back(std::move(DecodeSparseFloatVector(bytes)));
+        const std::string& bytes = *cursor;
+        data.emplace_back(DecodeSparseFloatVector(bytes));
         cursor++;
     }
     return data;
@@ -358,13 +358,21 @@ CreateMilvusFieldData(const proto::schema::FieldData& proto_data, size_t offset,
             return Status::OK();
         }
         case proto::schema::DataType::JSON: {
-            std::vector<nlohmann::json> objects;
+            // Don't use BuildFieldDataScalars here: JSON requires json::parse() for each element,
+            // so we parse only the [offset, end) range to avoid parsing all elements upfront.
             const auto& scalars_data = proto_scalars.json_data().data();
-            for (const auto& s : scalars_data) {
-                objects.emplace_back(std::move(nlohmann::json::parse(s)));
+            auto total = static_cast<size_t>(scalars_data.size());
+            if (offset >= total) {
+                field_data = std::make_shared<JSONFieldData>(std::move(name), std::vector<JSONFieldData::ElementT>{},
+                                                             std::move(valid_data));
+                return Status::OK();
+            }
+            size_t end = (offset + count > total) ? total : offset + count;
+            std::vector<JSONFieldData::ElementT> values;
+            values.reserve(end - offset);
+            for (size_t i = offset; i < end; ++i) {
+                values.emplace_back(nlohmann::json::parse(scalars_data[static_cast<int>(i)]));
             }
-            std::vector<JSONFieldData::ElementT> values =
-                BuildFieldDataScalars<JSONFieldData::ElementT>(objects, offset, count);
             field_data = std::make_shared<JSONFieldData>(std::move(name), std::move(values), std::move(valid_data));
             return Status::OK();
         }
@@ -498,7 +506,7 @@ FillStructValue(const FieldDataPtr& array_data, std::vector<std::vector<nlohmann
     for (auto k = 0; k < actual_count; k++) {
         const auto& arr = actual_ptr->Value(k);
         if (structs.size() <= k) {
-            structs.emplace_back(std::move(std::vector<nlohmann::json>()));
+            structs.emplace_back();
             structs[k].resize(arr.size());
         }
         for (auto j = 0; j < arr.size(); j++) {
@@ -593,7 +601,7 @@ ConvertStructFieldData(const proto::schema::FieldData& proto_data, size_t offset
                         vector_field.dim() * 4, floats.data(), floats.size(), 0, floats.size());
                     auto num = k - offset;
                     if (structs.size() <= num) {
-                        structs.emplace_back(std::move(std::vector<nlohmann::json>()));
+                        structs.emplace_back();
                         structs[num].resize(vectors.size());
                     }
                     for (auto j = 0; j < vectors.size(); j++) {
@@ -746,8 +754,7 @@ SetEmbeddingLists(const std::vector<EmbeddingList>& emb_lists, proto::milvus::Se
             std::string content;
             content.reserve(emb_list.Count() * emb_list.Dim() * 4);
             for (const auto& vector : vectors.Data()) {
-                std::string single_content(reinterpret_cast<const char*>(vector.data()), vector.size() * sizeof(float));
-                content += single_content;
+                content.append(reinterpret_cast<const char*>(vector.data()), vector.size() * sizeof(float));
             }
             rpc_request->set_nq(static_cast<int64_t>(emb_list.Count()));
             placeholder_value.add_values(std::move(content));
@@ -798,8 +805,8 @@ GenGetter(const FieldDataPtr& field) {
         // special process float16/bfloat16 vector to float arrays
         if (field->Type() == DataType::FLOAT16_VECTOR || field->Type() == DataType::BFLOAT16_VECTOR) {
             bool is_fp16 = (field->Type() == DataType::FLOAT16_VECTOR);
-            std::vector<uint16_t> f16_vec = is_fp16 ? std::static_pointer_cast<Float16VecFieldData>(field)->Value(i)
-                                                    : std::static_pointer_cast<BFloat16VecFieldData>(field)->Value(i);
+            const auto& f16_vec = is_fp16 ? std::static_pointer_cast<Float16VecFieldData>(field)->Data()[i]
+                                          : std::static_pointer_cast<BFloat16VecFieldData>(field)->Data()[i];
             std::vector<float> f32_vec;
             f32_vec.reserve(f16_vec.size());
             std::transform(f16_vec.begin(), f16_vec.end(), std::back_inserter(f32_vec),
@@ -938,7 +945,7 @@ GenGetters(const std::vector<FieldDataPtr>& fields) {
                 break;
         }
     }
-    return std::move(getters);
+    return getters;
 }
 
 Status
diff --git a/src/impl/utils/FP16.cpp b/src/impl/utils/FP16.cpp
index d6a25b94..70e9f693 100644
--- a/src/impl/utils/FP16.cpp
+++ b/src/impl/utils/FP16.cpp
@@ -100,43 +100,43 @@ BF16toF32(uint16_t val) {
 }
 
 std::vector<uint16_t>
-ArrayF32toF16(std::vector<float> array) {
+ArrayF32toF16(const std::vector<float>& array) {
     std::vector<uint16_t> result;
     result.reserve(array.size());
     for (float v : array) {
         result.push_back(F32toF16(v));
     }
-    return std::move(result);
+    return result;
 }
 
 std::vector<float>
-ArrayF16toF32(std::vector<uint16_t> array) {
+ArrayF16toF32(const std::vector<uint16_t>& array) {
     std::vector<float> result;
     result.reserve(array.size());
     for (uint16_t v : array) {
         result.push_back(F16toF32(v));
     }
-    return std::move(result);
+    return result;
 }
 
 std::vector<uint16_t>
-ArrayF32toBF16(std::vector<float> array) {
+ArrayF32toBF16(const std::vector<float>& array) {
     std::vector<uint16_t> result;
     result.reserve(array.size());
     for (float v : array) {
         result.push_back(F32toBF16(v));
     }
-    return std::move(result);
+    return result;
 }
 
 std::vector<float>
-ArrayBF16toF32(std::vector<uint16_t> array) {
+ArrayBF16toF32(const std::vector<uint16_t>& array) {
     std::vector<float> result;
     result.reserve(array.size());
     for (uint16_t v : array) {
         result.push_back(BF16toF32(v));
     }
-    return std::move(result);
+    return result;
 }
 
 }  // namespace milvus
diff --git a/src/include/milvus/types/ConnectParam.h b/src/include/milvus/types/ConnectParam.h
index e7c8827d..918d627b 100644
--- a/src/include/milvus/types/ConnectParam.h
+++ b/src/include/milvus/types/ConnectParam.h
@@ -339,11 +339,11 @@ class ConnectParam {
  private:
     std::string uri_ = "http://localhost:19530";
 
-    uint64_t connect_timeout_ms_ = 10000;    // the same with pymilvus
-    uint64_t keepalive_time_ms_ = 10000;     // Send keepalive pings every 10 seconds
-    uint64_t keepalive_timeout_ms_ = 5000;   // Keepalive ping timeout after 5 seconds
-    bool keepalive_without_calls_ = true;    // Allow keepalive pings when there are no gRPC calls
-    uint64_t rpc_deadline_ms_ = 0;           // the same with java sdk
+    uint64_t connect_timeout_ms_ = 10000;   // the same with pymilvus
+    uint64_t keepalive_time_ms_ = 10000;    // Send keepalive pings every 10 seconds
+    uint64_t keepalive_timeout_ms_ = 5000;  // Keepalive ping timeout after 5 seconds
+    bool keepalive_without_calls_ = true;   // Allow keepalive pings when there are no gRPC calls
+    uint64_t rpc_deadline_ms_ = 0;          // the same with java sdk
 
     bool tls_{false};
     std::string server_name_;
diff --git a/src/include/milvus/utils/FP16.h b/src/include/milvus/utils/FP16.h
index 17cadbe7..7bc052b0 100644
--- a/src/include/milvus/utils/FP16.h
+++ b/src/include/milvus/utils/FP16.h
@@ -49,24 +49,24 @@ BF16toF32(uint16_t val);
  * @brief Convert a float32 array to a float16 array represented by uint16_t.
  */
 std::vector<uint16_t>
-ArrayF32toF16(std::vector<float> array);
+ArrayF32toF16(const std::vector<float>& array);
 
 /**
  * @brief Convert a float16 array to a float32 array.
  */
 std::vector<float>
-ArrayF16toF32(std::vector<uint16_t> array);
+ArrayF16toF32(const std::vector<uint16_t>& array);
 
 /**
  * @brief Convert a float32 array to a bfloat16 array represented by uint16_t.
  */
 std::vector<uint16_t>
-ArrayF32toBF16(std::vector<float> array);
+ArrayF32toBF16(const std::vector<float>& array);
 
 /**
  * @brief Convert a bfloat16 array to a float32 array.
  */
 std::vector<float>
-ArrayBF16toF32(std::vector<uint16_t> array);
+ArrayBF16toF32(const std::vector<uint16_t>& array);
 
 }  // namespace milvus