diff --git a/.clang-tidy b/.clang-tidy
index ad50f503d..43e3130a9 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -7,7 +7,54 @@ Checks: >
   modernize-use-equals-default,
   modernize-use-equals-delete,
   modernize-redundant-void-arg,
+  readability-identifier-naming,
 WarningsAsErrors: "*"
-HeaderFilterRegex: "^(src|tests|tools)/(?!db/sqlengine/antlr/gen/|db/index/column/fts_column/gen/|include/zvec/ailego/encoding/json/mod_json\\.h).*"
+HeaderFilterRegex: "(^|/)(src|tests|tools)/"
 FormatStyle: none
 SystemHeaders: false
+CheckOptions:
+  # Type-like identifiers use CamelCase (Google style). STL-compatible
+  # container aliases (iterator, value_type, *_t ...) are exempted.
+  readability-identifier-naming.NamespaceCase: lower_case
+  readability-identifier-naming.ClassCase: CamelCase
+  readability-identifier-naming.ClassIgnoredRegexp: '(const_)?(iterator|reverse_iterator)'
+  readability-identifier-naming.StructCase: CamelCase
+  readability-identifier-naming.StructIgnoredRegexp: '(const_)?(iterator|reverse_iterator)'
+  readability-identifier-naming.UnionCase: CamelCase
+  readability-identifier-naming.EnumCase: CamelCase
+  readability-identifier-naming.TypedefCase: CamelCase
+  readability-identifier-naming.TypedefIgnoredRegexp: '(_.*|[a-z][a-z0-9_]*|.*_t|.*_type|(const_)?(iterator|reverse_iterator|pointer|reference))'
+  readability-identifier-naming.TypeAliasCase: CamelCase
+  readability-identifier-naming.TypeAliasIgnoredRegexp: '(_.*|[a-z][a-z0-9_]*|.*_t|.*_type|(const_)?(iterator|reverse_iterator|pointer|reference))'
+  # Member functions use snake_case. Static/free/global functions may use
+  # snake_case or CamelCase. A leading underscore (private-method convention)
+  # or trailing underscore (keyword avoidance, e.g. delete_) is allowed.
+  readability-identifier-naming.MethodCase: lower_case
+  readability-identifier-naming.MethodIgnoredRegexp: '_*[a-z][a-z0-9_]*'
+  readability-identifier-naming.ClassMethodCase: lower_case
+  readability-identifier-naming.ClassMethodIgnoredRegexp: '(_*[a-z][a-z0-9_]*|[A-Z][A-Za-z0-9]*)'
+  readability-identifier-naming.FunctionCase: lower_case
+  readability-identifier-naming.FunctionIgnoredRegexp: '(_*[a-z][a-z0-9_]*|[A-Z][A-Za-z0-9]*)'
+  readability-identifier-naming.GlobalFunctionCase: lower_case
+  readability-identifier-naming.GlobalFunctionIgnoredRegexp: '(_*[a-z][a-z0-9_]*|[A-Z][A-Za-z0-9]*)'
+  # Data members use snake_case; a trailing underscore is allowed but not required.
+  readability-identifier-naming.MemberCase: lower_case
+  readability-identifier-naming.MemberIgnoredRegexp: '_*[a-z][a-z0-9]*(_[a-z0-9]+)*_*'
+  readability-identifier-naming.ConstantMemberCase: lower_case
+  readability-identifier-naming.ConstantMemberIgnoredRegexp: '_*[a-z][a-z0-9]*(_[a-z0-9]+)*_*'
+  # Static data members follow the same snake_case rule as non-static members.
+  readability-identifier-naming.ClassMemberCase: lower_case
+  readability-identifier-naming.ClassMemberIgnoredRegexp: '_*[a-z][a-z0-9]*(_[a-z0-9]+)*_*'
+  # Local variables and parameters use snake_case.
+  readability-identifier-naming.LocalVariableCase: lower_case
+  readability-identifier-naming.ParameterCase: lower_case
+  # Constants keep the existing mixed conventions (kCamelCase / UPPER_CASE /
+  # snake_case) and are intentionally not enforced.
+  readability-identifier-naming.ConstantCase: aNy_CasE
+  readability-identifier-naming.LocalConstantCase: aNy_CasE
+  readability-identifier-naming.StaticConstantCase: aNy_CasE
+  readability-identifier-naming.ClassConstantCase: aNy_CasE
+  readability-identifier-naming.GlobalConstantCase: aNy_CasE
+  readability-identifier-naming.ConstexprVariableCase: aNy_CasE
+  readability-identifier-naming.GlobalVariableCase: aNy_CasE
+  readability-identifier-naming.StaticVariableCase: aNy_CasE
diff --git a/.github/workflows/clang_tidy.yml b/.github/workflows/clang_tidy.yml
index 161188d82..190802198 100644
--- a/.github/workflows/clang_tidy.yml
+++ b/.github/workflows/clang_tidy.yml
@@ -91,7 +91,17 @@ jobs:
           selected = []
           skipped = []
 
+          # Auto-generated code is exempt from clang-tidy and must not be edited.
+          generated_dir_markers = (
+              "src/db/sqlengine/antlr/gen/",
+              "src/db/index/column/fts_column/gen/",
+          )
+
           for rel_path in changed:
+              norm_rel = rel_path.replace(os.sep, "/")
+              if any(marker in norm_rel for marker in generated_dir_markers):
+                  skipped.append(f"{rel_path} (generated file, exempt from clang-tidy)")
+                  continue
               abs_path = os.path.normpath(str((cwd / rel_path).resolve()))
               if abs_path in compile_entries:
                   selected.append(rel_path)
@@ -176,12 +186,26 @@ jobs:
           failed=0
           for f in "$log_dir"/*.log; do
             [ -e "$f" ] || break
-            failed=1
             src=$(head -1 "$f")
-            echo ""
-            echo "::group::clang-tidy errors: $src"
-            tail -n +2 "$f"
-            echo "::endgroup::"
+            # Diagnostics originating in generated headers (antlr/gen,
+            # fts_column/gen) can leak in via #include from non-generated main
+            # files. Those files are exempt and must not be edited, so drop such
+            # blocks; a log only counts as a failure if real diagnostics remain.
+            body=$(tail -n +2 "$f" | awk '
+              /^[^[:space:]].*:[0-9]+:[0-9]+: (warning|error|note):/ {
+                path = $0
+                sub(/:[0-9]+:[0-9]+:.*/, "", path)
+                skip = (path ~ /(antlr\/gen\/|fts_column\/gen\/)/) ? 1 : 0
+              }
+              { if (!skip) print }
+            ')
+            if printf '%s\n' "$body" | grep -qE ': (warning|error):'; then
+              failed=1
+              echo ""
+              echo "::group::clang-tidy errors: $src"
+              printf '%s\n' "$body"
+              echo "::endgroup::"
+            fi
           done
 
           rm -rf "$log_dir"
diff --git a/src/ailego/algorithm/integer_quantizer.cc b/src/ailego/algorithm/integer_quantizer.cc
index a3b61b74c..8cfa72fa4 100644
--- a/src/ailego/algorithm/integer_quantizer.cc
+++ b/src/ailego/algorithm/integer_quantizer.cc
@@ -129,7 +129,7 @@ static inline void ExpandCandidateDistribution(
  */
 static inline size_t ComputeThreshold(const std::vector<uint32_t> &hist,
                                       const size_t target_bins) {
-  std::vector<float> P_distribution(hist.size());
+  std::vector<float> p_distribution(hist.size());
   size_t zero_point_index = hist.size() / 2;
 
   size_t start_bin = target_bins / 2;
@@ -147,19 +147,19 @@ static inline size_t ComputeThreshold(const std::vector<uint32_t> &hist,
   //! for each zero-axised quantization range: [-threshold, threshold], search
   //! the best solution
   for (size_t threshold = start_bin; threshold <= end_bin; ++threshold) {
-    P_distribution.resize(threshold * 2);
+    p_distribution.resize(threshold * 2);
     auto p_hist = &hist[zero_point_index - threshold];
-    for (size_t i = 0; i != P_distribution.size(); ++i) {
-      P_distribution[i] = static_cast<float>(p_hist[i]);
+    for (size_t i = 0; i != p_distribution.size(); ++i) {
+      p_distribution[i] = static_cast<float>(p_hist[i]);
     }
 
     negative_outliers_count -= hist[zero_point_index - threshold];
     positive_outliers_count -= hist[zero_point_index + threshold - 1];
-    P_distribution[0] += negative_outliers_count;
-    P_distribution[P_distribution.size() - 1] += positive_outliers_count;
+    p_distribution[0] += negative_outliers_count;
+    p_distribution[p_distribution.size() - 1] += positive_outliers_count;
 
     //! Quantize the bins in range [-threshold, threshold] to target_bins
-    std::vector<float> Q_distribution(target_bins, 0);
+    std::vector<float> q_distribution(target_bins, 0);
     float merged_cnt = static_cast<float>(threshold * 2) / target_bins;
     size_t left_boundary = zero_point_index - threshold;
     for (size_t i = 0; i < target_bins; ++i) {
@@ -168,28 +168,28 @@ static inline size_t ComputeThreshold(const std::vector<uint32_t> &hist,
       const size_t start_ceil = static_cast<size_t>(std::ceil(start));
       const size_t end_floor = static_cast<size_t>(std::floor(end));
       if (left_boundary + start_ceil > 0) {
-        Q_distribution[i] +=
+        q_distribution[i] +=
             ((float)start_ceil - start) * hist[left_boundary + start_ceil - 1];
       }
       if (left_boundary + end_floor < hist.size()) {
-        Q_distribution[i] +=
+        q_distribution[i] +=
             (end - (float)end_floor) * hist[left_boundary + end_floor];
       }
 
       for (size_t j = start_ceil; j < end_floor; j++) {
-        Q_distribution[i] += hist[left_boundary + j];
+        q_distribution[i] += hist[left_boundary + j];
       }
     }
-    std::vector<float> Q_expand_distribution;
-    ExpandCandidateDistribution(hist, Q_distribution, threshold,
-                                &Q_expand_distribution);
+    std::vector<float> q_expand_distribution;
+    ExpandCandidateDistribution(hist, q_distribution, threshold,
+                                &q_expand_distribution);
 
     //! Compute Kullback-Leibler Divergence, normalize the smooth the data
     //! first. Ref: http://hanj.cs.illinois.edu/cs412/bk3/KL-divergence.pdf
-    MakeSmooth(P_distribution);
-    MakeSmooth(Q_expand_distribution);
+    MakeSmooth(p_distribution);
+    MakeSmooth(q_expand_distribution);
     double divergence =
-        ComputeKlDivergence(P_distribution, Q_expand_distribution);
+        ComputeKlDivergence(p_distribution, q_expand_distribution);
 
     if (divergence < min_divergence) {
       min_divergence = divergence;
diff --git a/src/ailego/encoding/json/mod_json.c b/src/ailego/encoding/json/mod_json.c
index ea6a1103c..a8f220f8a 100644
--- a/src/ailego/encoding/json/mod_json.c
+++ b/src/ailego/encoding/json/mod_json.c
@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// NOLINTBEGIN
+
 #include <float.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -3589,3 +3591,5 @@ mod_json_string_t *mod_json_dump(mod_json_value_t *val) {
   }
   return str;
 }
+
+// NOLINTEND
diff --git a/src/ailego/internal/cpu_features.h b/src/ailego/internal/cpu_features.h
index ac065aa1e..2ad814368 100644
--- a/src/ailego/internal/cpu_features.h
+++ b/src/ailego/internal/cpu_features.h
@@ -21,6 +21,8 @@ namespace internal {
 
 /*! Cpu Features
  */
+// NOLINTBEGIN(readability-identifier-naming): identifiers mirror CPUID feature
+// mnemonics (SSE4_1, AVX512_VNNI, L1_ECX ...) and stay in hardware casing.
 class CpuFeatures {
  public:
   //! 16-bit FP conversions
@@ -376,6 +378,7 @@ class CpuFeatures {
   };
   static StaticFlags static_flags_;
 };
+// NOLINTEND(readability-identifier-naming)
 
 }  // namespace internal
 }  // namespace ailego
diff --git a/src/ailego/io/iouring_def.h b/src/ailego/io/iouring_def.h
index e8e4076e8..42d910971 100644
--- a/src/ailego/io/iouring_def.h
+++ b/src/ailego/io/iouring_def.h
@@ -99,6 +99,9 @@
 // Struct definitions (copied verbatim from <linux/io_uring.h>)
 // ---------------------------------------------------------------------------
 
+// NOLINTBEGIN(readability-identifier-naming): types below are copied verbatim
+// from the Linux kernel ABI (<linux/io_uring.h>) and must keep their names.
+
 // Submission queue entry — 64 bytes.
 struct io_uring_sqe {
   uint8_t opcode;   // type of operation for this sqe
@@ -219,4 +222,6 @@ static inline void io_uring_prep_write(struct io_uring_sqe *sqe, int fd,
 // End: struct and constant definitions from <linux/io_uring.h>
 // ---------------------------------------------------------------------------
 
+// NOLINTEND(readability-identifier-naming)
+
 #endif  // __linux__
diff --git a/src/ailego/io/libaio_def.h b/src/ailego/io/libaio_def.h
index 6ab08f225..6b0b17556 100644
--- a/src/ailego/io/libaio_def.h
+++ b/src/ailego/io/libaio_def.h
@@ -34,6 +34,9 @@
 
 #if (defined(__linux) || defined(__linux__)) && !defined(__ANDROID__)
 
+// NOLINTBEGIN(readability-identifier-naming): types below are copied verbatim
+// from the Linux kernel ABI (<libaio.h>) and must keep their upstream names.
+
 struct sockaddr;
 struct iovec;
 
@@ -187,4 +190,6 @@ static inline void io_prep_pread(struct iocb *iocb, int fd, void *buf,
 // End: type and struct definitions from <libaio.h>
 // ---------------------------------------------------------------------------
 
+// NOLINTEND(readability-identifier-naming)
+
 #endif  // __linux__
diff --git a/src/ailego/io/libaio_loader.h b/src/ailego/io/libaio_loader.h
index 3e2fbf7b3..8bdd415f8 100644
--- a/src/ailego/io/libaio_loader.h
+++ b/src/ailego/io/libaio_loader.h
@@ -78,6 +78,9 @@ class LibAioLoader {
   aio_submit_fn io_submit;
   aio_getevents_fn io_getevents;
 
+  LibAioLoader(const LibAioLoader &) = delete;
+  LibAioLoader &operator=(const LibAioLoader &) = delete;
+
  private:
   LibAioLoader()
       : io_setup(nullptr),
@@ -91,9 +94,6 @@ class LibAioLoader {
     }
   }
 
-  LibAioLoader(const LibAioLoader &) = delete;
-  LibAioLoader &operator=(const LibAioLoader &) = delete;
-
   void try_load() {
     // On Ubuntu 24.04 the libaio package was renamed with the t64 suffix
     // (64-bit time_t transition), so probe both spellings.
diff --git a/src/ailego/math/cosine_distance_matrix.h b/src/ailego/math/cosine_distance_matrix.h
index 2f5ab51fd..4d0bb477f 100644
--- a/src/ailego/math/cosine_distance_matrix.h
+++ b/src/ailego/math/cosine_distance_matrix.h
@@ -39,6 +39,7 @@ struct CosineDistanceMatrix<
                              float *out) {
     ailego_assert(m && q && dim && out);
 
+    // NOLINTNEXTLINE(bugprone-sizeof-expression): intentional byte-width ratio
     constexpr size_t extra_dim = sizeof(float) / sizeof(ValueType);
     size_t d = dim - extra_dim;
 
diff --git a/src/ailego/math/matrix_utility.i b/src/ailego/math/matrix_utility.i
index 7716a494d..15ea7aea0 100644
--- a/src/ailego/math/matrix_utility.i
+++ b/src/ailego/math/matrix_utility.i
@@ -16,6 +16,8 @@
 
 #include <zvec/ailego/internal/platform.h>
 
+// NOLINTBEGIN(readability-identifier-naming): SIMD intrinsic helpers use the
+// deliberate Operation_TYPE_WIDTH convention (e.g. HorizontalMax_FP32_V128).
 namespace zvec {
 namespace ailego {
 
@@ -263,3 +265,4 @@ static inline float HorizontalAdd_FP16_V512(__m512h v) {
 
 } // namespace ailego
 } // namespace zvec
+// NOLINTEND(readability-identifier-naming)
diff --git a/src/ailego/math_batch/cosine_distance_batch.h b/src/ailego/math_batch/cosine_distance_batch.h
index b8a8309a9..bf44ab65e 100644
--- a/src/ailego/math_batch/cosine_distance_batch.h
+++ b/src/ailego/math_batch/cosine_distance_batch.h
@@ -21,7 +21,7 @@
 #include <zvec/ailego/utility/type_helper.h>
 #include "inner_product_distance_batch.h"
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 
 template <typename T, size_t BatchSize, size_t PrefetchStep, typename = void>
@@ -34,11 +34,12 @@ struct CosineDistanceBatch {
   static inline void ComputeBatch(const ValueType **vecs,
                                   const ValueType *query, size_t num_vecs,
                                   size_t dim, float *results) {
+    // NOLINTNEXTLINE(bugprone-sizeof-expression): intentional byte-width ratio
     constexpr size_t extra_dim = sizeof(float) / sizeof(ValueType);
-    size_t _dim = dim - extra_dim;
+    size_t data_dim = dim - extra_dim;
 
     InnerProductDistanceBatch<ValueType, BatchSize, PrefetchStep>::ComputeBatch(
-        vecs, query, num_vecs, _dim, results);
+        vecs, query, num_vecs, data_dim, results);
 
     for (size_t i = 0; i < num_vecs; ++i) {
       results[i] = 1 - results[i];
@@ -55,4 +56,4 @@ struct CosineDistanceBatch {
 };
 
 
-}  // namespace zvec::ailego::DistanceBatch
\ No newline at end of file
+}  // namespace zvec::ailego::distance_batch
\ No newline at end of file
diff --git a/src/ailego/math_batch/distance_batch.h b/src/ailego/math_batch/distance_batch.h
index 6fcc987cb..c186cef9d 100644
--- a/src/ailego/math_batch/distance_batch.h
+++ b/src/ailego/math_batch/distance_batch.h
@@ -26,7 +26,7 @@ template <
     template <typename, size_t, size_t, typename = void> class DistanceType,
     typename ValueType, size_t BatchSize, size_t PrefetchStep, typename = void>
 struct BaseDistance {
-  static inline void _ComputeBatch(const ValueType **m, const ValueType *q,
+  static inline void compute_batch(const ValueType **m, const ValueType *q,
                                    size_t num, size_t dim, float *out) {
     for (size_t i = 0; i < num; ++i) {
       DistanceType<ValueType, 1, 1>::Compute(m[i], q, dim, out + i);
@@ -39,14 +39,14 @@ struct BaseDistance {
                                   const void ** /*extra_values*/) {
     if constexpr (std::is_same_v<DistanceType<ValueType, 1, 1>,
                                  CosineDistanceMatrix<ValueType, 1, 1>>) {
-      return DistanceBatch::CosineDistanceBatch<
+      return distance_batch::CosineDistanceBatch<
           ValueType, BatchSize, PrefetchStep>::ComputeBatch(m, q, num, dim,
                                                             out);
     }
 
     if constexpr (std::is_same_v<DistanceType<ValueType, 1, 1>,
                                  EuclideanDistanceMatrix<ValueType, 1, 1>>) {
-      return DistanceBatch::EuclideanDistanceBatch<
+      return distance_batch::EuclideanDistanceBatch<
           ValueType, BatchSize, PrefetchStep>::ComputeBatch(m, q, num, dim,
                                                             out);
     }
@@ -54,12 +54,12 @@ struct BaseDistance {
     if constexpr (std::is_same_v<
                       DistanceType<ValueType, 1, 1>,
                       SquaredEuclideanDistanceMatrix<ValueType, 1, 1>>) {
-      return DistanceBatch::SquaredEuclideanDistanceBatch<
+      return distance_batch::SquaredEuclideanDistanceBatch<
           ValueType, BatchSize, PrefetchStep>::ComputeBatch(m, q, num, dim, out,
                                                             nullptr);
     }
 
-    _ComputeBatch(m, q, num, dim, out);
+    compute_batch(m, q, num, dim, out);
   }
 };
 
diff --git a/src/ailego/math_batch/euclidean_distance_batch.h b/src/ailego/math_batch/euclidean_distance_batch.h
index 60e020f9e..5fe309f94 100644
--- a/src/ailego/math_batch/euclidean_distance_batch.h
+++ b/src/ailego/math_batch/euclidean_distance_batch.h
@@ -22,7 +22,7 @@
 #include <zvec/ailego/math_batch/utils.h>
 #include <zvec/ailego/utility/type_helper.h>
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 // SquaredEuclideanDistanceBatch
 template <typename T, size_t BatchSize, size_t PrefetchStep, typename = void>
@@ -141,4 +141,4 @@ struct SquaredEuclideanDistanceBatchImpl<float, 12> {
                                   size_t dim, float *sums);
 };
 
-}  // namespace zvec::ailego::DistanceBatch
+}  // namespace zvec::ailego::distance_batch
diff --git a/src/ailego/math_batch/euclidean_distance_batch_dispatch.cc b/src/ailego/math_batch/euclidean_distance_batch_dispatch.cc
index 5c8ffb254..68f473978 100644
--- a/src/ailego/math_batch/euclidean_distance_batch_dispatch.cc
+++ b/src/ailego/math_batch/euclidean_distance_batch_dispatch.cc
@@ -19,7 +19,7 @@
 #include <zvec/ailego/utility/type_helper.h>
 #include "euclidean_distance_batch.h"
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX512FP16__)
 void compute_one_to_many_squared_euclidean_avx512fp16_fp16_1(
@@ -188,4 +188,4 @@ void SquaredEuclideanDistanceBatchImpl<ailego::Float16, 12>::
 //                                                     dim, sums);
 // }
 
-}  // namespace zvec::ailego::DistanceBatch
+}  // namespace zvec::ailego::distance_batch
diff --git a/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx2.cc b/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx2.cc
index e6d793da0..1e321e735 100644
--- a/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx2.cc
+++ b/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx2.cc
@@ -17,7 +17,7 @@
 #include <zvec/ailego/internal/platform.h>
 #include <zvec/ailego/utility/type_helper.h>
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX2__)
 
@@ -111,4 +111,4 @@ void compute_one_to_many_squared_euclidean_avx2_fp16_12(
 }
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
+}  // namespace zvec::ailego::distance_batch
diff --git a/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx512.cc b/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx512.cc
index 1d4750eff..d1caaa3bf 100644
--- a/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx512.cc
+++ b/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx512.cc
@@ -17,7 +17,7 @@
 #include <zvec/ailego/internal/platform.h>
 #include <zvec/ailego/utility/type_helper.h>
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX512F__)
 
@@ -134,4 +134,4 @@ void compute_one_to_many_squared_euclidean_avx512f_fp16_12(
 
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
+}  // namespace zvec::ailego::distance_batch
diff --git a/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx512fp16.cc b/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx512fp16.cc
index 70e024039..03eac5dcd 100644
--- a/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx512fp16.cc
+++ b/src/ailego/math_batch/euclidean_distance_batch_impl_fp16_avx512fp16.cc
@@ -17,7 +17,7 @@
 #include <zvec/ailego/internal/platform.h>
 #include <zvec/ailego/utility/type_helper.h>
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX512FP16__)
 
@@ -96,4 +96,4 @@ void compute_one_to_many_squared_euclidean_avx512fp16_fp16_12(
 
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
+}  // namespace zvec::ailego::distance_batch
diff --git a/src/ailego/math_batch/euclidean_distance_batch_impl_fp32_avx2.cc b/src/ailego/math_batch/euclidean_distance_batch_impl_fp32_avx2.cc
index ce27e92a0..8246556d4 100644
--- a/src/ailego/math_batch/euclidean_distance_batch_impl_fp32_avx2.cc
+++ b/src/ailego/math_batch/euclidean_distance_batch_impl_fp32_avx2.cc
@@ -25,7 +25,7 @@
     sum += (x * x);                 \
   }
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX2__)
 
@@ -101,4 +101,4 @@ void compute_one_to_many_squared_euclidean_avx2_fp32_12(
 
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
+}  // namespace zvec::ailego::distance_batch
diff --git a/src/ailego/math_batch/euclidean_distance_batch_impl_fp32_avx512.cc b/src/ailego/math_batch/euclidean_distance_batch_impl_fp32_avx512.cc
index d7e58478c..701bc565e 100644
--- a/src/ailego/math_batch/euclidean_distance_batch_impl_fp32_avx512.cc
+++ b/src/ailego/math_batch/euclidean_distance_batch_impl_fp32_avx512.cc
@@ -25,7 +25,7 @@
     sum += (x * x);                 \
   }
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX512F__)
 
@@ -92,4 +92,4 @@ void compute_one_to_many_squared_euclidean_avx512f_fp32_12(
 
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
+}  // namespace zvec::ailego::distance_batch
diff --git a/src/ailego/math_batch/inner_product_distance_batch.h b/src/ailego/math_batch/inner_product_distance_batch.h
index 6375482a2..568cc6c22 100644
--- a/src/ailego/math_batch/inner_product_distance_batch.h
+++ b/src/ailego/math_batch/inner_product_distance_batch.h
@@ -21,7 +21,7 @@
 #include <zvec/ailego/math_batch/utils.h>
 #include <zvec/ailego/utility/type_helper.h>
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 template <typename T, size_t BatchSize, size_t PrefetchStep, typename = void>
 struct InnerProductDistanceBatch;
@@ -140,4 +140,4 @@ struct InnerProductDistanceBatchImpl<int8_t, 12> {
                                   size_t dim, float *sums);
 };
 
-}  // namespace zvec::ailego::DistanceBatch
+}  // namespace zvec::ailego::distance_batch
diff --git a/src/ailego/math_batch/inner_product_distance_batch_dispatch.cc b/src/ailego/math_batch/inner_product_distance_batch_dispatch.cc
index 78376626a..adbd2952e 100644
--- a/src/ailego/math_batch/inner_product_distance_batch_dispatch.cc
+++ b/src/ailego/math_batch/inner_product_distance_batch_dispatch.cc
@@ -20,7 +20,7 @@
 #include <zvec/ailego/utility/type_helper.h>
 #include "inner_product_distance_batch.h"
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX512VNNI__)
 void compute_one_to_many_inner_product_avx512_vnni_int8_query_preprocess(
@@ -225,4 +225,4 @@ void InnerProductDistanceBatchImpl<int8_t, 12>::compute_one_to_many(
                                                     dim, sums);
 }
 
-}  // namespace zvec::ailego::DistanceBatch
+}  // namespace zvec::ailego::distance_batch
diff --git a/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx2.cc b/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx2.cc
index d6fe475f2..43d719180 100644
--- a/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx2.cc
+++ b/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx2.cc
@@ -18,7 +18,7 @@
 #include <zvec/ailego/internal/platform.h>
 #include <zvec/ailego/utility/type_helper.h>
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX2__)
 
@@ -106,4 +106,4 @@ void compute_one_to_many_inner_product_avx2_fp16_12(
 
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
\ No newline at end of file
+}  // namespace zvec::ailego::distance_batch
\ No newline at end of file
diff --git a/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx512.cc b/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx512.cc
index 805da8dae..c9df60988 100644
--- a/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx512.cc
+++ b/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx512.cc
@@ -18,7 +18,7 @@
 #include <zvec/ailego/internal/platform.h>
 #include <zvec/ailego/utility/type_helper.h>
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX512F__)
 
@@ -125,4 +125,4 @@ void compute_one_to_many_inner_product_avx512f_fp16_12(
 }
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
+}  // namespace zvec::ailego::distance_batch
diff --git a/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx512fp16.cc b/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx512fp16.cc
index b69e60b57..7b3fc037b 100644
--- a/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx512fp16.cc
+++ b/src/ailego/math_batch/inner_product_distance_batch_impl_fp16_avx512fp16.cc
@@ -18,7 +18,7 @@
 #include <zvec/ailego/internal/platform.h>
 #include <zvec/ailego/utility/type_helper.h>
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX512FP16__)
 template <typename ValueType, size_t dp_batch>
@@ -89,4 +89,4 @@ void compute_one_to_many_inner_product_avx512fp16_fp16_12(
 }
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
+}  // namespace zvec::ailego::distance_batch
diff --git a/src/ailego/math_batch/inner_product_distance_batch_impl_fp32_avx2.cc b/src/ailego/math_batch/inner_product_distance_batch_impl_fp32_avx2.cc
index bead50745..74cffc365 100644
--- a/src/ailego/math_batch/inner_product_distance_batch_impl_fp32_avx2.cc
+++ b/src/ailego/math_batch/inner_product_distance_batch_impl_fp32_avx2.cc
@@ -18,7 +18,7 @@
 #include <zvec/ailego/internal/platform.h>
 #include <zvec/ailego/utility/type_helper.h>
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX2__)
 
@@ -131,4 +131,4 @@ void compute_one_to_many_inner_product_avx2_fp32_12(
 
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
\ No newline at end of file
+}  // namespace zvec::ailego::distance_batch
\ No newline at end of file
diff --git a/src/ailego/math_batch/inner_product_distance_batch_impl_int8_avx2.cc b/src/ailego/math_batch/inner_product_distance_batch_impl_int8_avx2.cc
index 66d7e1543..3bab06694 100644
--- a/src/ailego/math_batch/inner_product_distance_batch_impl_int8_avx2.cc
+++ b/src/ailego/math_batch/inner_product_distance_batch_impl_int8_avx2.cc
@@ -17,7 +17,7 @@
 #include <zvec/ailego/internal/platform.h>
 #include <zvec/ailego/utility/type_helper.h>
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX2__)
 
@@ -101,4 +101,4 @@ void compute_one_to_many_inner_product_avx2_int8_12(
 
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
\ No newline at end of file
+}  // namespace zvec::ailego::distance_batch
\ No newline at end of file
diff --git a/src/ailego/math_batch/inner_product_distance_batch_impl_int8_avx512fp16.cc b/src/ailego/math_batch/inner_product_distance_batch_impl_int8_avx512fp16.cc
index 96c68dc6b..249cb7a2c 100644
--- a/src/ailego/math_batch/inner_product_distance_batch_impl_int8_avx512fp16.cc
+++ b/src/ailego/math_batch/inner_product_distance_batch_impl_int8_avx512fp16.cc
@@ -17,7 +17,7 @@
 #include <zvec/ailego/internal/platform.h>
 #include <zvec/ailego/utility/type_helper.h>
 
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 #if defined(__AVX512VNNI__)
 
@@ -170,4 +170,4 @@ void compute_one_to_many_inner_product_avx512_vnni_int8_12(
 
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
\ No newline at end of file
+}  // namespace zvec::ailego::distance_batch
\ No newline at end of file
diff --git a/src/ailego/utility/bitset_helper.h b/src/ailego/utility/bitset_helper.h
index 20af020e4..83541c2a8 100644
--- a/src/ailego/utility/bitset_helper.h
+++ b/src/ailego/utility/bitset_helper.h
@@ -112,8 +112,8 @@ class BitsetHelper {
   size_t cardinality() const;
 
   //! Calculate the size of buffer if it contains N bits
-  static size_t BufferSize(size_t N) {
-    return (((N + 0x1f) >> 5) << 2);
+  static size_t BufferSize(size_t n) {
+    return (((n + 0x1f) >> 5) << 2);
   }
 
   //! Calculate the count of bits can be contained
diff --git a/src/ailego/utility/matrix_helper.h b/src/ailego/utility/matrix_helper.h
index 1a05ad5fb..b7a136396 100644
--- a/src/ailego/utility/matrix_helper.h
+++ b/src/ailego/utility/matrix_helper.h
@@ -22,21 +22,21 @@ namespace ailego {
 struct MatrixHelper {
   //! Transpose a matrix
   template <typename T, size_t M>
-  static inline void Transpose(const void *src, size_t N, void *dst) {
+  static inline void Transpose(const void *src, size_t n, void *dst) {
     for (size_t i = 0; i < M; ++i) {
-      for (size_t j = 0; j < N; ++j) {
+      for (size_t j = 0; j < n; ++j) {
         *(reinterpret_cast<T *>(dst) + (j * M + i)) =
-            *(reinterpret_cast<const T *>(src) + (i * N + j));
+            *(reinterpret_cast<const T *>(src) + (i * n + j));
       }
     }
   }
 
   //! Reverse transpose a matrix
   template <typename T, size_t M>
-  static inline void ReverseTranspose(const void *src, size_t N, void *dst) {
-    for (size_t i = 0; i < N; ++i) {
+  static inline void ReverseTranspose(const void *src, size_t n, void *dst) {
+    for (size_t i = 0; i < n; ++i) {
       for (size_t j = 0; j < M; ++j) {
-        *(reinterpret_cast<T *>(dst) + (j * N + i)) =
+        *(reinterpret_cast<T *>(dst) + (j * n + i)) =
             *(reinterpret_cast<const T *>(src) + (i * M + j));
       }
     }
@@ -44,23 +44,23 @@ struct MatrixHelper {
 
   //! Transpose a matrix
   template <typename T>
-  static inline void Transpose(const void *src, size_t M, size_t N, void *dst) {
-    for (size_t i = 0; i < M; ++i) {
-      for (size_t j = 0; j < N; ++j) {
-        *(reinterpret_cast<T *>(dst) + (j * M + i)) =
-            *(reinterpret_cast<const T *>(src) + (i * N + j));
+  static inline void Transpose(const void *src, size_t m, size_t n, void *dst) {
+    for (size_t i = 0; i < m; ++i) {
+      for (size_t j = 0; j < n; ++j) {
+        *(reinterpret_cast<T *>(dst) + (j * m + i)) =
+            *(reinterpret_cast<const T *>(src) + (i * n + j));
       }
     }
   }
 
   //! Reverse transpose a matrix
   template <typename T>
-  static inline void ReverseTranspose(const void *src, size_t M, size_t N,
+  static inline void ReverseTranspose(const void *src, size_t m, size_t n,
                                       void *dst) {
-    for (size_t i = 0; i < N; ++i) {
-      for (size_t j = 0; j < M; ++j) {
-        *(reinterpret_cast<T *>(dst) + (j * N + i)) =
-            *(reinterpret_cast<const T *>(src) + (i * M + j));
+    for (size_t i = 0; i < n; ++i) {
+      for (size_t j = 0; j < m; ++j) {
+        *(reinterpret_cast<T *>(dst) + (j * n + i)) =
+            *(reinterpret_cast<const T *>(src) + (i * m + j));
       }
     }
   }
diff --git a/src/core/algorithm/cluster/linear_seeker.h b/src/core/algorithm/cluster/linear_seeker.h
index 022d8c194..d95c85320 100644
--- a/src/core/algorithm/cluster/linear_seeker.h
+++ b/src/core/algorithm/cluster/linear_seeker.h
@@ -28,7 +28,7 @@ class LinearSeeker : public Seeker {
   LinearSeeker() : meta_(), metric_(), features_() {}
 
   //! Destructor
-  ~LinearSeeker() = default;
+  ~LinearSeeker() override = default;
 
   //! Initialize Seeker
   int init(const IndexMeta &meta) override {
diff --git a/src/core/algorithm/cluster/multi_chunk_cluster.cc b/src/core/algorithm/cluster/multi_chunk_cluster.cc
index 8b842819f..118dfc31e 100644
--- a/src/core/algorithm/cluster/multi_chunk_cluster.cc
+++ b/src/core/algorithm/cluster/multi_chunk_cluster.cc
@@ -70,20 +70,20 @@ int MultiChunkClusterAlgorithm::update_params(const ailego::Params &params) {
 }
 
 int MultiChunkClusterAlgorithm::init_distance_func() {
-  IndexMetric::Pointer metric_{};
-  metric_ = IndexFactory::CreateMetric(meta_.metric_name());
-  if (!metric_) {
+  IndexMetric::Pointer metric{};
+  metric = IndexFactory::CreateMetric(meta_.metric_name());
+  if (!metric) {
     LOG_ERROR("Create metric %s failed.", meta_.metric_name().c_str());
     return IndexError_Unsupported;
   }
 
-  int ret = metric_->init(meta_, meta_.metric_params());
+  int ret = metric->init(meta_, meta_.metric_params());
   if (ret != 0) {
     LOG_ERROR("IndexMetric init failed wit ret %d.", ret);
     return ret;
   }
 
-  distance_func_ = metric_->distance_matrix(1, 1);
+  distance_func_ = metric->distance_matrix(1, 1);
   if (!distance_func_) {
     LOG_ERROR("DistanceMatrix function is nullptr.");
     return IndexError_Unsupported;
@@ -98,15 +98,15 @@ int MultiChunkClusterAlgorithm::do_chunk() {
   }
 
   size_t large_chunk_count = meta_.dimension() % chunk_count_;
-  size_t base_chunk_dim_ = meta_.dimension() / chunk_count_;
+  size_t base_chunk_dim = meta_.dimension() / chunk_count_;
 
   chunk_dims_.clear();
 
   for (size_t i = 0; i < chunk_count_; ++i) {
     if (i < large_chunk_count) {
-      chunk_dims_.push_back(base_chunk_dim_ + 1);
+      chunk_dims_.push_back(base_chunk_dim + 1);
     } else {
-      chunk_dims_.push_back(base_chunk_dim_);
+      chunk_dims_.push_back(base_chunk_dim);
     }
   }
 
diff --git a/src/core/algorithm/cluster/multi_chunk_cluster.h b/src/core/algorithm/cluster/multi_chunk_cluster.h
index 19096d761..d61d02d68 100644
--- a/src/core/algorithm/cluster/multi_chunk_cluster.h
+++ b/src/core/algorithm/cluster/multi_chunk_cluster.h
@@ -146,18 +146,19 @@ class MultiChunkNumericalAlgorithm : public MultiChunkClusterAlgorithm {
   MultiChunkNumericalAlgorithm() = default;
 
   //! Destructor
-  ~MultiChunkNumericalAlgorithm() = default;
+  ~MultiChunkNumericalAlgorithm() override = default;
 
  protected:
   //! cluster thread
   void do_cluster(size_t idx, size_t chunk_step,
                   IndexCluster::CentroidList *cents,
-                  std::atomic<size_t> *finished);
+                  std::atomic<size_t> *finished) override;
 
   //! label thread
   void do_label(size_t idx, size_t step,
                 const IndexCluster::CentroidList &cents,
-                std::vector<uint32_t> *out, std::atomic<size_t> *finished);
+                std::vector<uint32_t> *out,
+                std::atomic<size_t> *finished) override;
 };
 
 //! cluster thread
@@ -295,18 +296,19 @@ class MultiChunkNumericalInnerProductAlgorithm
   MultiChunkNumericalInnerProductAlgorithm() = default;
 
   //! Destructor
-  ~MultiChunkNumericalInnerProductAlgorithm() = default;
+  ~MultiChunkNumericalInnerProductAlgorithm() override = default;
 
  protected:
   //! cluster thread
   void do_cluster(size_t idx, size_t chunk_step,
                   IndexCluster::CentroidList *cents,
-                  std::atomic<size_t> *finished);
+                  std::atomic<size_t> *finished) override;
 
   //! label thread
   void do_label(size_t idx, size_t chunk_step,
                 const IndexCluster::CentroidList &cents,
-                std::vector<uint32_t> *out, std::atomic<size_t> *finished);
+                std::vector<uint32_t> *out,
+                std::atomic<size_t> *finished) override;
 };
 
 //! cluster thread
@@ -428,7 +430,7 @@ void MultiChunkNumericalInnerProductAlgorithm<T>::do_label(
 //! MultiChunkCluster
 class MultiChunkCluster {
  public:
-  std::shared_ptr<MultiChunkCluster> Pointer;
+  std::shared_ptr<MultiChunkCluster> pointer;
 
   //! Constructor
   MultiChunkCluster() = default;
diff --git a/src/core/algorithm/cluster/opt_kmeans_cluster.cc b/src/core/algorithm/cluster/opt_kmeans_cluster.cc
index 5da838628..39299f89f 100644
--- a/src/core/algorithm/cluster/opt_kmeans_cluster.cc
+++ b/src/core/algorithm/cluster/opt_kmeans_cluster.cc
@@ -222,18 +222,18 @@ void OptKmeansAlgorithm::update_params(const ailego::Params &params) {
 }
 
 int OptKmeansAlgorithm::init_distance_func() {
-  IndexMetric::Pointer metric_{};
-  metric_ = IndexFactory::CreateMetric(meta_.metric_name());
-  if (!metric_) {
+  IndexMetric::Pointer metric{};
+  metric = IndexFactory::CreateMetric(meta_.metric_name());
+  if (!metric) {
     LOG_ERROR("Create Metric %s failed.", meta_.metric_name().c_str());
     return IndexError_Unsupported;
   }
-  int ret = metric_->init(meta_, meta_.metric_params());
+  int ret = metric->init(meta_, meta_.metric_params());
   if (ret != 0) {
     LOG_ERROR("IndexMetric init failed wit ret %d.", ret);
     return ret;
   }
-  distance_func_ = metric_->distance_matrix(1, 1);
+  distance_func_ = metric->distance_matrix(1, 1);
   if (!distance_func_) {
     LOG_ERROR("DistanceMatrix function is nullptr.");
     return IndexError_Unsupported;
@@ -449,8 +449,8 @@ int OptKmeansAlgorithm::mount(IndexFeatures::Pointer feats) {
 }
 
 int OptKmeansAlgorithm::check_dimension() const {
-  auto type_ = meta_.data_type();
-  switch (type_) {
+  auto type = meta_.data_type();
+  switch (type) {
     case IndexMeta::DataType::DT_INT4:
       if (meta_.dimension() % 8 != 0) {
         LOG_ERROR(
@@ -1204,10 +1204,10 @@ int OptKmeansCluster::mount(IndexFeatures::Pointer feats) {
 
 int OptKmeansCluster::init(const IndexMeta &meta,
                            const ailego::Params &params) {
-  auto type_ = meta.data_type();
+  auto type = meta.data_type();
 
   if (meta.metric_name() == "InnerProduct") {
-    switch (type_) {
+    switch (type) {
       case IndexMeta::DataType::DT_FP16: {
         algorithm_.reset(
             new (std::nothrow)
@@ -1240,12 +1240,12 @@ int OptKmeansCluster::init(const IndexMeta &meta,
         break;
       }
       default: {
-        LOG_ERROR("Unsupported feature types %d.", type_);
+        LOG_ERROR("Unsupported feature types %d.", type);
         return IndexError_Mismatch;
       }
     }
   } else {
-    switch (type_) {
+    switch (type) {
       case IndexMeta::DataType::DT_FP16: {
         algorithm_.reset(new (std::nothrow)
                              NumericalKmeansAlgorithm<ailego::Float16>);
@@ -1272,7 +1272,7 @@ int OptKmeansCluster::init(const IndexMeta &meta,
         break;
       }
       default: {
-        LOG_ERROR("Unsupported feature types %d.", type_);
+        LOG_ERROR("Unsupported feature types %d.", type);
         return IndexError_Mismatch;
       }
     }
diff --git a/src/core/algorithm/cluster/stratified_cluster_trainer.h b/src/core/algorithm/cluster/stratified_cluster_trainer.h
index 2f48e4662..4e9dc4e8b 100644
--- a/src/core/algorithm/cluster/stratified_cluster_trainer.h
+++ b/src/core/algorithm/cluster/stratified_cluster_trainer.h
@@ -29,32 +29,33 @@ class StratifiedClusterTrainer : public IndexTrainer {
   StratifiedClusterTrainer() = default;
 
   //! Destructor
-  ~StratifiedClusterTrainer() = default;
+  ~StratifiedClusterTrainer() override = default;
 
  protected:
   //! Initialize Trainer
-  virtual int init(const IndexMeta &meta, const ailego::Params &params);
+  int init(const IndexMeta &meta, const ailego::Params &params) override;
 
   //! Cleanup Trainer
-  virtual int cleanup();
+  int cleanup() override;
 
   //! Train the data
-  virtual int train(IndexThreads::Pointer threads, IndexHolder::Pointer holder);
+  int train(IndexThreads::Pointer threads,
+            IndexHolder::Pointer holder) override;
 
   //! Load index from file path or dir
-  virtual int load(IndexStorage::Pointer cntr);
+  int load(IndexStorage::Pointer cntr) override;
 
   //! Dump index into file path or dir
-  virtual int dump(const IndexDumper::Pointer &dumper);
+  int dump(const IndexDumper::Pointer &dumper) override;
 
   //! Retrieve Index Meta
-  virtual const IndexMeta &meta() const;
+  const IndexMeta &meta() const override;
 
   //! Retrieve statistics
-  virtual const IndexTrainer::Stats &stats() const;
+  const IndexTrainer::Stats &stats() const override;
 
   //! Retrieve the output indexes
-  virtual IndexBundle::Pointer indexes() const;
+  IndexBundle::Pointer indexes() const override;
 
  private:
   int init_params(const ailego::Params &params);
diff --git a/src/core/algorithm/cluster/vector_mean.h b/src/core/algorithm/cluster/vector_mean.h
index 34024048c..44f81fe33 100644
--- a/src/core/algorithm/cluster/vector_mean.h
+++ b/src/core/algorithm/cluster/vector_mean.h
@@ -115,7 +115,7 @@ class GeneralVectorMeanArray : public VectorMeanArray {
   }
 
   //! Resize accumulators
-  virtual void resize(size_t cnt) {
+  void resize(size_t cnt) override {
     if (array_.size() < cnt) {
       for (size_t i = array_.size(); i < cnt; ++i) {
         array_.emplace_back(dimension_);
@@ -126,27 +126,27 @@ class GeneralVectorMeanArray : public VectorMeanArray {
   }
 
   //! Clear accumulators
-  virtual void clear() {
+  void clear() override {
     array_.clear();
   }
 
   //! Retrieve an accumulator
-  virtual VectorMean &at(size_t i) {
+  VectorMean &at(size_t i) override {
     return array_[i];
   }
 
   //! Retrieve an accumulator
-  virtual const VectorMean &at(size_t i) const {
+  const VectorMean &at(size_t i) const override {
     return array_[i];
   }
 
   //! Retrieve the count of accumulators
-  virtual size_t count() const {
+  size_t count() const override {
     return array_.size();
   }
 
   //! Retrieve the dimension of accumulators
-  virtual size_t dimension() const {
+  size_t dimension() const override {
     return dimension_;
   }
 
@@ -196,12 +196,12 @@ class NumericalVectorMean : public VectorMean {
   }
 
   //! Reset accumulator
-  virtual void reset() {
+  void reset() override {
     this->reset(accums_.size());
   }
 
   //! Plus a vector
-  virtual bool plus(const void *vec, size_t len) {
+  bool plus(const void *vec, size_t len) override {
     size_t dim = accums_.size();
     if (dim * sizeof(T) != len) {
       return false;
@@ -214,7 +214,7 @@ class NumericalVectorMean : public VectorMean {
   }
 
   //! Retrieve the mean of vectors
-  virtual bool mean(void *out, size_t len) const {
+  bool mean(void *out, size_t len) const override {
     size_t dim = accums_.size();
     if (dim * sizeof(T) != len) {
       return false;
@@ -226,7 +226,7 @@ class NumericalVectorMean : public VectorMean {
   }
 
   //! Retrieve the mean of vectors
-  virtual void mean(std::string *out) const {
+  void mean(std::string *out) const override {
     ailego::NumericalVector<T> &vec =
         *static_cast<ailego::NumericalVector<T> *>(out);
 
@@ -238,7 +238,7 @@ class NumericalVectorMean : public VectorMean {
   }
 
   //! Merge another vector mean
-  virtual bool merge(const VectorMean &rhs) {
+  bool merge(const VectorMean &rhs) override {
     const NumericalVectorMean<T> &src =
         dynamic_cast<const NumericalVectorMean<T> &>(rhs);
 
@@ -254,12 +254,12 @@ class NumericalVectorMean : public VectorMean {
   }
 
   //! Retrieve the count of vectors
-  virtual size_t count() const {
+  size_t count() const override {
     return count_;
   }
 
   //! Retrieve dimension of accumulator
-  virtual size_t dimension() const {
+  size_t dimension() const override {
     return accums_.size();
   }
 
@@ -321,12 +321,12 @@ class NumericalVectorHarmonicMean : public VectorMean {
   }
 
   //! Reset accumulator
-  virtual void reset() {
+  void reset() override {
     this->reset(accums_.size());
   }
 
   //! Plus a vector (harmonic)
-  virtual bool plus(const void *vec, size_t len) {
+  bool plus(const void *vec, size_t len) override {
     size_t dim = accums_.size();
     if (dim * sizeof(T) != len) {
       return false;
@@ -339,7 +339,7 @@ class NumericalVectorHarmonicMean : public VectorMean {
   }
 
   //! Retrieve the mean of vectors (harmonic)
-  virtual bool mean(void *out, size_t len) const {
+  bool mean(void *out, size_t len) const override {
     size_t dim = accums_.size();
     if (dim * sizeof(T) != len) {
       return false;
@@ -351,7 +351,7 @@ class NumericalVectorHarmonicMean : public VectorMean {
   }
 
   //! Retrieve the mean of vectors
-  virtual void mean(std::string *out) const {
+  void mean(std::string *out) const override {
     ailego::NumericalVector<T> &vec =
         *static_cast<ailego::NumericalVector<T> *>(out);
 
@@ -363,7 +363,7 @@ class NumericalVectorHarmonicMean : public VectorMean {
   }
 
   //! Merge another vector mean
-  virtual bool merge(const VectorMean &rhs) {
+  bool merge(const VectorMean &rhs) override {
     const NumericalVectorHarmonicMean<T> &src =
         dynamic_cast<const NumericalVectorHarmonicMean<T> &>(rhs);
 
@@ -379,12 +379,12 @@ class NumericalVectorHarmonicMean : public VectorMean {
   }
 
   //! Retrieve the count of vectors
-  virtual size_t count() const {
+  size_t count() const override {
     return count_;
   }
 
   //! Retrieve dimension of accumulator
-  virtual size_t dimension() const {
+  size_t dimension() const override {
     return accums_.size();
   }
 
@@ -446,12 +446,12 @@ class NumericalVectorGeometricMean : public VectorMean {
   }
 
   //! Reset accumulator
-  virtual void reset() {
+  void reset() override {
     this->reset(accums_.size());
   }
 
   //! Plus a vector (geometric)
-  virtual bool plus(const void *vec, size_t len) {
+  bool plus(const void *vec, size_t len) override {
     size_t dim = accums_.size();
     if (dim * sizeof(T) != len) {
       return false;
@@ -464,7 +464,7 @@ class NumericalVectorGeometricMean : public VectorMean {
   }
 
   //! Retrieve the mean of vectors (geometric)
-  virtual bool mean(void *out, size_t len) const {
+  bool mean(void *out, size_t len) const override {
     size_t dim = accums_.size();
     if (dim * sizeof(T) != len) {
       return false;
@@ -477,7 +477,7 @@ class NumericalVectorGeometricMean : public VectorMean {
   }
 
   //! Retrieve the mean of vectors
-  virtual void mean(std::string *out) const {
+  void mean(std::string *out) const override {
     ailego::NumericalVector<T> &vec =
         *static_cast<ailego::NumericalVector<T> *>(out);
 
@@ -489,7 +489,7 @@ class NumericalVectorGeometricMean : public VectorMean {
   }
 
   //! Merge another vector mean
-  virtual bool merge(const VectorMean &rhs) {
+  bool merge(const VectorMean &rhs) override {
     const NumericalVectorGeometricMean<T> &src =
         dynamic_cast<const NumericalVectorGeometricMean<T> &>(rhs);
 
@@ -505,12 +505,12 @@ class NumericalVectorGeometricMean : public VectorMean {
   }
 
   //! Retrieve the count of vectors
-  virtual size_t count() const {
+  size_t count() const override {
     return count_;
   }
 
   //! Retrieve dimension of accumulator
-  virtual size_t dimension() const {
+  size_t dimension() const override {
     return accums_.size();
   }
 
@@ -574,12 +574,12 @@ class BinaryVectorMean : public VectorMean {
   }
 
   //! Reset accumulator
-  virtual void reset() {
+  void reset() override {
     this->reset(accums_.size());
   }
 
   //! Plus a vector
-  virtual bool plus(const void *vec, size_t len) {
+  bool plus(const void *vec, size_t len) override {
     size_t dim = accums_.size();
     if (dim != (len << 3)) {
       return false;
@@ -596,7 +596,7 @@ class BinaryVectorMean : public VectorMean {
   }
 
   //! Retrieve the mean of vectors
-  virtual bool mean(void *out, size_t len) const {
+  bool mean(void *out, size_t len) const override {
     size_t dim = accums_.size();
     if (dim != (len << 3)) {
       return false;
@@ -614,7 +614,7 @@ class BinaryVectorMean : public VectorMean {
   }
 
   //! Retrieve the mean of vectors
-  virtual void mean(std::string *out) const {
+  void mean(std::string *out) const override {
     size_t dim = accums_.size();
     out->clear();
     out->resize((dim + 7) / 8);
@@ -630,7 +630,7 @@ class BinaryVectorMean : public VectorMean {
   }
 
   //! Merge another vector mean
-  virtual bool merge(const VectorMean &rhs) {
+  bool merge(const VectorMean &rhs) override {
     const BinaryVectorMean &src = dynamic_cast<const BinaryVectorMean &>(rhs);
 
     size_t dim = accums_.size();
@@ -645,12 +645,12 @@ class BinaryVectorMean : public VectorMean {
   }
 
   //! Retrieve the count of vectors
-  virtual size_t count() const {
+  size_t count() const override {
     return count_;
   }
 
   //! Retrieve dimension of accumulator
-  virtual size_t dimension() const {
+  size_t dimension() const override {
     return accums_.size();
   }
 
@@ -701,12 +701,12 @@ class NibbleVectorMean : public VectorMean {
   }
 
   //! Reset accumulator
-  virtual void reset() {
+  void reset() override {
     this->reset(accums_.size());
   }
 
   //! Plus a vector
-  virtual bool plus(const void *vec, size_t len) {
+  bool plus(const void *vec, size_t len) override {
     size_t dim = accums_.size();
     if (dim != (len << 1)) {
       return false;
@@ -723,7 +723,7 @@ class NibbleVectorMean : public VectorMean {
   }
 
   //! Retrieve the mean of vectors
-  virtual bool mean(void *out, size_t len) const {
+  bool mean(void *out, size_t len) const override {
     size_t dim = accums_.size();
     if (dim != (len << 1)) {
       return false;
@@ -742,7 +742,7 @@ class NibbleVectorMean : public VectorMean {
   }
 
   //! Retrieve the mean of vectors
-  virtual void mean(std::string *out) const {
+  void mean(std::string *out) const override {
     size_t dim = accums_.size();
     out->clear();
     out->resize(dim >> 1);
@@ -757,7 +757,7 @@ class NibbleVectorMean : public VectorMean {
   }
 
   //! Merge another vector mean
-  virtual bool merge(const VectorMean &rhs) {
+  bool merge(const VectorMean &rhs) override {
     const NibbleVectorMean &src = dynamic_cast<const NibbleVectorMean &>(rhs);
 
     size_t dim = accums_.size();
@@ -772,12 +772,12 @@ class NibbleVectorMean : public VectorMean {
   }
 
   //! Retrieve the count of vectors
-  virtual size_t count() const {
+  size_t count() const override {
     return count_;
   }
 
   //! Retrieve dimension of accumulator
-  virtual size_t dimension() const {
+  size_t dimension() const override {
     return accums_.size();
   }
 
diff --git a/src/core/algorithm/diskann/diskann_builder.h b/src/core/algorithm/diskann/diskann_builder.h
index dd8477e75..ec026d8d6 100644
--- a/src/core/algorithm/diskann/diskann_builder.h
+++ b/src/core/algorithm/diskann/diskann_builder.h
@@ -86,7 +86,7 @@ class DiskAnnBuilder : public IndexBuilder {
   }
 
  private:
-  enum BUILD_STATE {
+  enum BuildState {
     BUILD_STATE_INIT = 0,
     BUILD_STATE_INITED = 1,
     BUILD_STATE_TRAINED = 2,
@@ -115,7 +115,7 @@ class DiskAnnBuilder : public IndexBuilder {
   std::string codebook_prefix_{""};
   std::string index_path_prefix_{"./diskann"};
 
-  BUILD_STATE state_{BUILD_STATE_INIT};
+  BuildState state_{BUILD_STATE_INIT};
   Stats stats_;
 
   int errcode_{0};
diff --git a/src/core/algorithm/diskann/diskann_builder_entity.h b/src/core/algorithm/diskann/diskann_builder_entity.h
index ce097b3a3..75522e454 100644
--- a/src/core/algorithm/diskann/diskann_builder_entity.h
+++ b/src/core/algorithm/diskann/diskann_builder_entity.h
@@ -26,7 +26,7 @@ class DiskAnnBuilderEntity : public DiskAnnEntity {
   using Pointer = std::shared_ptr<DiskAnnBuilderEntity>;
 
   DiskAnnBuilderEntity() = default;
-  virtual ~DiskAnnBuilderEntity() = default;
+  ~DiskAnnBuilderEntity() override = default;
 
  public:
   void clear();
diff --git a/src/core/algorithm/diskann/diskann_context.h b/src/core/algorithm/diskann/diskann_context.h
index 514d36590..2d2107da8 100644
--- a/src/core/algorithm/diskann/diskann_context.h
+++ b/src/core/algorithm/diskann/diskann_context.h
@@ -57,7 +57,7 @@ class DiskAnnContext : public IndexContext,
                  const turbo::Quantizer::Pointer &data_quantizer = nullptr);
 
   //! Destructor
-  virtual ~DiskAnnContext();
+  ~DiskAnnContext() override;
 
   //! Create a lightweight context for reading vectors by id.
   static Pointer create_fetch_context(const IndexMeta &meta,
diff --git a/src/core/algorithm/diskann/diskann_holder.h b/src/core/algorithm/diskann/diskann_holder.h
index 874b862c3..f9d0f2d30 100644
--- a/src/core/algorithm/diskann/diskann_holder.h
+++ b/src/core/algorithm/diskann/diskann_holder.h
@@ -73,7 +73,7 @@ class DiskAnnIndexHolder : public IndexHolder {
     }
 
     //! Destructor
-    virtual ~Iterator() {
+    ~Iterator() override {
       if (file_.is_open()) {
         file_.close();
       }
diff --git a/src/core/algorithm/diskann/diskann_reducer.cc b/src/core/algorithm/diskann/diskann_reducer.cc
index 250ec3667..fa2c4bbf9 100644
--- a/src/core/algorithm/diskann/diskann_reducer.cc
+++ b/src/core/algorithm/diskann/diskann_reducer.cc
@@ -38,10 +38,10 @@ int DiskAnnReducer::init(const ailego::Params &params) {
   }
 
   reducer_file_path_ = ailego::StringHelper::Concat(
-      working_path_, "/", kReducerFileName, index_name);
+      working_path_, "/", k_reducer_file_name, index_name);
 
-  holder_file_path_ = ailego::StringHelper::Concat(working_path_, "/",
-                                                   kHolderFileName, index_name);
+  holder_file_path_ = ailego::StringHelper::Concat(
+      working_path_, "/", k_holder_file_name, index_name);
 
   state_ = STATE_INITED;
   return 0;
@@ -100,9 +100,10 @@ int DiskAnnReducer::reduce(const IndexFilter &filter) {
     disk_holder_->close();
   }
 
-  builder_ = IndexFactory::CreateBuilder(kDiskAnnBuilderName);
+  builder_ = IndexFactory::CreateBuilder(k_disk_ann_builder_name);
   if (!builder_) {
-    LOG_ERROR("Create builder failed. name[%s]", kDiskAnnBuilderName.c_str());
+    LOG_ERROR("Create builder failed. name[%s]",
+              k_disk_ann_builder_name.c_str());
     return IndexError_Runtime;
   }
 
diff --git a/src/core/algorithm/diskann/diskann_reducer.h b/src/core/algorithm/diskann/diskann_reducer.h
index 4d78c05ad..f1cde740d 100644
--- a/src/core/algorithm/diskann/diskann_reducer.h
+++ b/src/core/algorithm/diskann/diskann_reducer.h
@@ -76,9 +76,9 @@ class DiskAnnReducer : public IndexReducer {
   Stats stats_{};
   State state_{STATE_UNINITED};
 
-  const std::string kDiskAnnBuilderName{"DiskAnnBuilder"};
-  const std::string kReducerFileName{"diskann.reducer.builder."};
-  const std::string kHolderFileName{"diskann.reducer.holder."};
+  const std::string k_disk_ann_builder_name{"DiskAnnBuilder"};
+  const std::string k_reducer_file_name{"diskann.reducer.builder."};
+  const std::string k_holder_file_name{"diskann.reducer.holder."};
 };
 
 }  // namespace core
diff --git a/src/core/algorithm/diskann/diskann_reducer_entity.h b/src/core/algorithm/diskann/diskann_reducer_entity.h
index e653d08d0..d3fd1975d 100644
--- a/src/core/algorithm/diskann/diskann_reducer_entity.h
+++ b/src/core/algorithm/diskann/diskann_reducer_entity.h
@@ -31,7 +31,7 @@ class DiskAnnReducerEntity : public DiskAnnEntity {
 
  public:
   DiskAnnReducerEntity() = default;
-  virtual ~DiskAnnReducerEntity() = default;
+  ~DiskAnnReducerEntity() override = default;
 
   int load(const IndexStorage::Pointer &container, bool check_crc);
   int load_segments(bool check_crc);
diff --git a/src/core/algorithm/diskann/diskann_searcher.h b/src/core/algorithm/diskann/diskann_searcher.h
index 0416ea4f1..a0f73850b 100644
--- a/src/core/algorithm/diskann/diskann_searcher.h
+++ b/src/core/algorithm/diskann/diskann_searcher.h
@@ -28,7 +28,7 @@ class DiskAnnSearcher : public IndexSearcher {
 
  public:
   DiskAnnSearcher();
-  ~DiskAnnSearcher();
+  ~DiskAnnSearcher() override;
 
   DiskAnnSearcher(const DiskAnnSearcher &) = delete;
   DiskAnnSearcher &operator=(const DiskAnnSearcher &) = delete;
diff --git a/src/core/algorithm/diskann/diskann_searcher_entity.h b/src/core/algorithm/diskann/diskann_searcher_entity.h
index 38d35ee14..b2a7bb81b 100644
--- a/src/core/algorithm/diskann/diskann_searcher_entity.h
+++ b/src/core/algorithm/diskann/diskann_searcher_entity.h
@@ -30,7 +30,7 @@ class DiskAnnSearcherEntity : public DiskAnnEntity {
 
  public:
   DiskAnnSearcherEntity() = default;
-  virtual ~DiskAnnSearcherEntity() = default;
+  ~DiskAnnSearcherEntity() override = default;
 
  public:
   const DiskAnnEntity::Pointer clone() const override;
diff --git a/src/core/algorithm/diskann/diskann_streamer.h b/src/core/algorithm/diskann/diskann_streamer.h
index 983e5235b..321992cf6 100644
--- a/src/core/algorithm/diskann/diskann_streamer.h
+++ b/src/core/algorithm/diskann/diskann_streamer.h
@@ -27,7 +27,7 @@ class DiskAnnStreamer : public IndexStreamer {
 
  public:
   DiskAnnStreamer();
-  ~DiskAnnStreamer();
+  ~DiskAnnStreamer() override;
 
   DiskAnnStreamer(const DiskAnnStreamer &) = delete;
   DiskAnnStreamer &operator=(const DiskAnnStreamer &) = delete;
diff --git a/src/core/algorithm/diskann/diskann_util.h b/src/core/algorithm/diskann/diskann_util.h
index a7ff1cad5..d6b5bc952 100644
--- a/src/core/algorithm/diskann/diskann_util.h
+++ b/src/core/algorithm/diskann/diskann_util.h
@@ -79,10 +79,10 @@ class DiskAnnUtil {
   }
 
   template <typename T>
-  static inline void convert_vector_to_residual(T *data, uint32_t blocksize_,
+  static inline void convert_vector_to_residual(T *data, uint32_t blocksize,
                                                 size_t dim, void *centroid) {
     const T *centroid_ptr = reinterpret_cast<const T *>(centroid);
-    for (size_t i = 0; i < blocksize_; i++) {
+    for (size_t i = 0; i < blocksize; i++) {
       for (uint64_t d = 0; d < dim; d++) {
         float data_float = data[i * dim + d];
         data_float -= centroid_ptr[d];
@@ -102,35 +102,35 @@ class DiskAnnUtil {
   }
 
   static inline uint64_t get_node_sector(uint32_t node_per_sector,
-                                         uint32_t max_nodesize_,
-                                         uint32_t sectorsize_,
+                                         uint32_t max_nodesize,
+                                         uint32_t sectorsize,
                                          diskann_id_t node_id) {
     return (node_per_sector > 0
                 ? node_id / node_per_sector
-                : node_id * div_round_up(max_nodesize_, sectorsize_));
+                : node_id * div_round_up(max_nodesize, sectorsize));
   }
 
   static inline uint32_t *offset_to_node_neighbor(uint8_t *node_buf,
-                                                  uint32_t elementsize_) {
-    return (uint32_t *)(node_buf + elementsize_);
+                                                  uint32_t elementsize) {
+    return (uint32_t *)(node_buf + elementsize);
   }
 
   static inline uint8_t *offset_to_node(uint32_t node_per_sector,
-                                        uint32_t max_nodesize_,
+                                        uint32_t max_nodesize,
                                         uint8_t *sector_buf,
                                         diskann_id_t node_id) {
     return sector_buf + (node_per_sector == 0
                              ? 0
-                             : (node_id % node_per_sector) * max_nodesize_);
+                             : (node_id % node_per_sector) * max_nodesize);
   }
 
   static inline const uint8_t *offset_to_node_const(uint32_t node_per_sector,
-                                                    uint32_t max_nodesize_,
+                                                    uint32_t max_nodesize,
                                                     const uint8_t *sector_buf,
                                                     diskann_id_t node_id) {
     return sector_buf + (node_per_sector == 0
                              ? 0
-                             : (node_id % node_per_sector) * max_nodesize_);
+                             : (node_id % node_per_sector) * max_nodesize);
   }
 
   //! Resolve the quantizer implementation name from a serialized quantizer
diff --git a/src/core/algorithm/flat/flat_streamer_entity.cc b/src/core/algorithm/flat/flat_streamer_entity.cc
index 6f0e5ac86..a85299bcd 100644
--- a/src/core/algorithm/flat/flat_streamer_entity.cc
+++ b/src/core/algorithm/flat/flat_streamer_entity.cc
@@ -840,7 +840,7 @@ int FlatStreamerEntity::init_storage(IndexStorage::Pointer storage) {
   meta_.header.index_meta_size = str.size();
   meta_.header.linear_list_count = 1;
 
-  AdjustSegmentSize(&meta_);
+  adjust_segment_size(&meta_);
 
   LOG_DEBUG(
       "Create Streamer Index, VecSize=%u, BlockSize=%u SegmentSize=%u "
@@ -906,7 +906,7 @@ int FlatStreamerEntity::init_storage(IndexStorage::Pointer storage) {
 }
 
 int FlatStreamerEntity::load_linear_meta(IndexStorage::Pointer storage) {
-  AdjustSegmentSize(&meta_);
+  adjust_segment_size(&meta_);
 
   // Load Meta Segment
   auto segment = storage->get(FLAT_LINEAR_META_SEG_ID);
diff --git a/src/core/algorithm/flat/flat_streamer_entity.h b/src/core/algorithm/flat/flat_streamer_entity.h
index 80f4e01ac..79880d34d 100644
--- a/src/core/algorithm/flat/flat_streamer_entity.h
+++ b/src/core/algorithm/flat/flat_streamer_entity.h
@@ -313,7 +313,7 @@ class FlatStreamerEntity {
   }
 
   //! Rejust the segment size as to aligned by page size
-  void AdjustSegmentSize(StreamerLinearMeta *mt) {
+  void adjust_segment_size(StreamerLinearMeta *mt) {
     if (mt->segment_size < mt->header.block_size) {
       mt->segment_size = mt->header.block_size;
     }
diff --git a/src/core/algorithm/flat/flat_utility.h b/src/core/algorithm/flat/flat_utility.h
index e6f18b3cc..4020c8c9a 100644
--- a/src/core/algorithm/flat/flat_utility.h
+++ b/src/core/algorithm/flat/flat_utility.h
@@ -81,10 +81,10 @@ static inline void ReverseTranspose(size_t align_size, const void *src,
 }
 
 template <typename T>
-static inline void TransposeOne(const void *src, size_t M, size_t N,
+static inline void TransposeOne(const void *src, size_t m, size_t n,
                                 void *dst) {
-  for (size_t i = 0; i < N; ++i) {
-    reinterpret_cast<T *>(dst)[i] = reinterpret_cast<const T *>(src)[i * M];
+  for (size_t i = 0; i < n; ++i) {
+    reinterpret_cast<T *>(dst)[i] = reinterpret_cast<const T *>(src)[i * m];
   }
 }
 
diff --git a/src/core/algorithm/flat_sparse/flat_sparse_builder.h b/src/core/algorithm/flat_sparse/flat_sparse_builder.h
index 58a102772..ded9d9f96 100644
--- a/src/core/algorithm/flat_sparse/flat_sparse_builder.h
+++ b/src/core/algorithm/flat_sparse/flat_sparse_builder.h
@@ -81,7 +81,7 @@ class FlatSparseBuilder : public IndexBuilder {
                         IndexDumper *dumper, uint32_t *length);
 
  private:
-  enum BUILD_STATE {
+  enum BuildState {
     BUILD_STATE_INIT = 0,
     BUILD_STATE_INITED = 1,
     BUILD_STATE_TRAINED = 2,
@@ -97,7 +97,7 @@ class FlatSparseBuilder : public IndexBuilder {
   std::condition_variable cond_{};
   Stats stats_{};
 
-  BUILD_STATE state_{BUILD_STATE_INIT};
+  BuildState state_{BUILD_STATE_INIT};
 };
 
 
diff --git a/src/core/algorithm/hnsw/hnsw_algorithm.cc b/src/core/algorithm/hnsw/hnsw_algorithm.cc
index 319be5ed2..bf47fcc2b 100644
--- a/src/core/algorithm/hnsw/hnsw_algorithm.cc
+++ b/src/core/algorithm/hnsw/hnsw_algorithm.cc
@@ -71,7 +71,7 @@ int HnswAlgorithm<EntityType>::add_node(node_id_t id, level_t level,
 template <typename EntityType>
 int HnswAlgorithm<EntityType>::search(HnswContext *ctx) const {
   spin_lock_.lock();
-  auto maxLevel = entity_.cur_max_level();
+  auto max_level = entity_.cur_max_level();
   auto entry_point = entity_.entry_point();
   spin_lock_.unlock();
 
@@ -80,7 +80,7 @@ int HnswAlgorithm<EntityType>::search(HnswContext *ctx) const {
   }
 
   dist_t dist = ctx->dist_calculator().dist(entry_point);
-  for (level_t cur_level = maxLevel; cur_level >= 1; --cur_level) {
+  for (level_t cur_level = max_level; cur_level >= 1; --cur_level) {
     select_entry_point(cur_level, &entry_point, &dist, ctx);
   }
 
diff --git a/src/core/algorithm/hnsw/hnsw_chunk.cc b/src/core/algorithm/hnsw/hnsw_chunk.cc
index a9cf52578..e283bdd6f 100644
--- a/src/core/algorithm/hnsw/hnsw_chunk.cc
+++ b/src/core/algorithm/hnsw/hnsw_chunk.cc
@@ -109,7 +109,7 @@ int ChunkBroker::open(IndexStorage::Pointer stg, uint32_t &chunk_size,
     return IndexError_Duplicate;
   }
   stg_ = std::move(stg);
-  if (stg_->isHugePage()) {
+  if (stg_->is_huge_page()) {
     page_mask_ = ailego::MemoryHelper::HugePageSize() - 1;
   } else {
     page_mask_ = ailego::MemoryHelper::PageSize() - 1;
diff --git a/src/core/algorithm/hnsw/hnsw_chunk.h b/src/core/algorithm/hnsw/hnsw_chunk.h
index c58f6baf9..d4a5e9c5c 100644
--- a/src/core/algorithm/hnsw/hnsw_chunk.h
+++ b/src/core/algorithm/hnsw/hnsw_chunk.h
@@ -35,7 +35,7 @@ class ChunkBroker {
  public:
   typedef std::shared_ptr<ChunkBroker> Pointer;
 
-  enum CHUNK_TYPE {
+  enum ChunkType {
     CHUNK_TYPE_HEADER = 1,
     CHUNK_TYPE_META = 2,
     CHUNK_TYPE_NODE = 3,
diff --git a/src/core/algorithm/hnsw/hnsw_streamer_entity.cc b/src/core/algorithm/hnsw/hnsw_streamer_entity.cc
index a7757d636..9a8b072a7 100644
--- a/src/core/algorithm/hnsw/hnsw_streamer_entity.cc
+++ b/src/core/algorithm/hnsw/hnsw_streamer_entity.cc
@@ -456,7 +456,7 @@ void HnswStreamerEntity::protect_search_hotset() {
 int HnswStreamerEntity::open(IndexStorage::Pointer stg, uint64_t max_index_size,
                              bool check_crc) {
   std::lock_guard<std::mutex> lock(mutex_);
-  bool huge_page = stg->isHugePage();
+  bool huge_page = stg->is_huge_page();
   LOG_DEBUG("huge_page: %d", (int)huge_page);
   int ret = broker_->open(std::move(stg), chunk_size_, check_crc);
   if (ailego_unlikely(ret != 0)) {
diff --git a/src/core/algorithm/hnsw/hnsw_streamer_entity.h b/src/core/algorithm/hnsw/hnsw_streamer_entity.h
index 0bef67805..4ba1b84a9 100644
--- a/src/core/algorithm/hnsw/hnsw_streamer_entity.h
+++ b/src/core/algorithm/hnsw/hnsw_streamer_entity.h
@@ -302,7 +302,7 @@ class HnswStreamerEntity : public HnswEntity {
   }
 
   //! Called only in searching procedure per context, so no need to lock
-  void sync_chunks(ChunkBroker::CHUNK_TYPE type, size_t idx,
+  void sync_chunks(ChunkBroker::ChunkType type, size_t idx,
                    std::vector<Chunk::Pointer> *chunks) const {
     if (ailego_likely(idx < chunks->size())) {
       return;
diff --git a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_algorithm.h b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_algorithm.h
index 861ca467f..3a570ee17 100644
--- a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_algorithm.h
+++ b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_algorithm.h
@@ -102,7 +102,7 @@ class HnswRabitqAlgorithm {
                                 level_t level, node_id_t link_id,
                                 ResultRecord dist, TopkHeap &update_heap);
 
- private:
+ public:
   HnswRabitqAlgorithm(const HnswRabitqAlgorithm &) = delete;
   HnswRabitqAlgorithm &operator=(const HnswRabitqAlgorithm &) = delete;
 
diff --git a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_chunk.cc b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_chunk.cc
index e0ff7e7a2..0f55c9710 100644
--- a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_chunk.cc
+++ b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_chunk.cc
@@ -110,7 +110,7 @@ int HnswRabitqChunkBroker::open(IndexStorage::Pointer stg,
     return IndexError_Duplicate;
   }
   stg_ = std::move(stg);
-  if (stg_->isHugePage()) {
+  if (stg_->is_huge_page()) {
     page_mask_ = ailego::MemoryHelper::HugePageSize() - 1;
   } else {
     page_mask_ = ailego::MemoryHelper::PageSize() - 1;
diff --git a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_chunk.h b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_chunk.h
index f3929983c..a5dfd6ee8 100644
--- a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_chunk.h
+++ b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_chunk.h
@@ -36,7 +36,7 @@ class HnswRabitqChunkBroker {
  public:
   typedef std::shared_ptr<HnswRabitqChunkBroker> Pointer;
 
-  enum CHUNK_TYPE {
+  enum CHUNK_TYPE {  // NOLINT(readability-identifier-naming): on-disk chunk tag
     CHUNK_TYPE_HEADER = 1,
     CHUNK_TYPE_META = 2,
     CHUNK_TYPE_NODE = 3,
@@ -89,10 +89,10 @@ class HnswRabitqChunkBroker {
     return stg_;
   }
 
- private:
   HnswRabitqChunkBroker(const HnswRabitqChunkBroker &) = delete;
   HnswRabitqChunkBroker &operator=(const HnswRabitqChunkBroker &) = delete;
 
+ private:
   struct HnswChunkMeta {
     HnswChunkMeta() {
       memset(static_cast<void *>(this), 0, sizeof(HnswChunkMeta));
diff --git a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_dist_calculator.h b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_dist_calculator.h
index 51e8d48a8..adb87629f 100644
--- a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_dist_calculator.h
+++ b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_dist_calculator.h
@@ -218,7 +218,7 @@ class HnswRabitqAddDistCalculator {
     return provider_->get_vector(key);
   }
 
- private:
+ public:
   HnswRabitqAddDistCalculator(const HnswRabitqAddDistCalculator &) = delete;
   HnswRabitqAddDistCalculator &operator=(const HnswRabitqAddDistCalculator &) =
       delete;
diff --git a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_entity.h b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_entity.h
index 3c38b18a8..dda22f78e 100644
--- a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_entity.h
+++ b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_entity.h
@@ -229,7 +229,7 @@ struct HnswNeighborMeta {
 class HnswRabitqEntity {
  public:
   //! Constructor
-  HnswRabitqEntity() {}
+  HnswRabitqEntity() = default;
 
   //! Constructor
   HnswRabitqEntity(const HNSWHeader &hd) {
@@ -237,7 +237,7 @@ class HnswRabitqEntity {
   }
 
   //! Destructor
-  virtual ~HnswRabitqEntity() {}
+  virtual ~HnswRabitqEntity() = default;
 
   //! HnswRabitqEntity Pointerd;
   typedef std::shared_ptr<HnswRabitqEntity> Pointer;
diff --git a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_query_algorithm.h b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_query_algorithm.h
index bcf6e42c9..9d6409a52 100644
--- a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_query_algorithm.h
+++ b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_query_algorithm.h
@@ -107,7 +107,7 @@ class HnswRabitqQueryAlgorithm {
   void get_bin_est(const void *vector, EstimateRecord &res,
                    HnswRabitqQueryEntity &entity) const;
 
- private:
+ public:
   HnswRabitqQueryAlgorithm(const HnswRabitqQueryAlgorithm &) = delete;
   HnswRabitqQueryAlgorithm &operator=(const HnswRabitqQueryAlgorithm &) =
       delete;
diff --git a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_streamer_entity.cc b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_streamer_entity.cc
index 27643aac7..906dfeef9 100644
--- a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_streamer_entity.cc
+++ b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_streamer_entity.cc
@@ -23,7 +23,7 @@ namespace core {
 HnswRabitqStreamerEntity::HnswRabitqStreamerEntity(IndexStreamer::Stats &stats)
     : stats_(stats) {}
 
-HnswRabitqStreamerEntity::~HnswRabitqStreamerEntity() {}
+HnswRabitqStreamerEntity::~HnswRabitqStreamerEntity() = default;
 
 int HnswRabitqStreamerEntity::init(size_t max_doc_cnt) {
   if (std::pow(scaling_factor(), kMaxGraphLayers) < max_doc_cnt) {
@@ -305,7 +305,7 @@ int HnswRabitqStreamerEntity::init_chunks(const Chunk::Pointer &header_chunk) {
 int HnswRabitqStreamerEntity::open(IndexStorage::Pointer stg,
                                    uint64_t max_index_size, bool check_crc) {
   std::lock_guard<std::mutex> lock(mutex_);
-  bool huge_page = stg->isHugePage();
+  bool huge_page = stg->is_huge_page();
   LOG_DEBUG("huge_page: %d", (int)huge_page);
   int ret = init_chunk_params(max_index_size, huge_page);
   if (ailego_unlikely(ret != 0)) {
diff --git a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_streamer_entity.h b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_streamer_entity.h
index e0b51ee72..cf4db0120 100644
--- a/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_streamer_entity.h
+++ b/src/core/algorithm/hnsw_rabitq/hnsw_rabitq_streamer_entity.h
@@ -93,7 +93,7 @@ class HnswRabitqStreamerEntity : public HnswRabitqEntity {
   HnswRabitqStreamerEntity(IndexStreamer::Stats &stats);
 
   //! Destructor
-  ~HnswRabitqStreamerEntity();
+  ~HnswRabitqStreamerEntity() override;
 
   //! Get vector feature data by key
   const void *get_vector_by_key(key_t key) const override {
@@ -509,13 +509,13 @@ class HnswRabitqStreamerEntity : public HnswRabitqEntity {
     return 0;
   }
 
- private:
+ public:
   HnswRabitqStreamerEntity(const HnswRabitqStreamerEntity &) = delete;
   HnswRabitqStreamerEntity &operator=(const HnswRabitqStreamerEntity &) =
       delete;
-  static constexpr uint64_t kUpperHashMemoryInflateRatio = 2.0f;
 
  private:
+  static constexpr uint64_t kUpperHashMemoryInflateRatio = 2.0f;
   IndexStreamer::Stats &stats_;
   HNSWHeader header_{};
   std::mutex mutex_{};
diff --git a/src/core/algorithm/hnsw_sparse/hnsw_sparse_algorithm.cc b/src/core/algorithm/hnsw_sparse/hnsw_sparse_algorithm.cc
index a8e20ac3f..13671d12e 100644
--- a/src/core/algorithm/hnsw_sparse/hnsw_sparse_algorithm.cc
+++ b/src/core/algorithm/hnsw_sparse/hnsw_sparse_algorithm.cc
@@ -85,7 +85,7 @@ int HnswSparseAlgorithm::add_node(node_id_t id, level_t level,
 
 int HnswSparseAlgorithm::search(HnswSparseContext *ctx) const {
   spin_lock_.lock();
-  auto maxLevel = entity_.cur_max_level();
+  auto max_level = entity_.cur_max_level();
   auto entry_point = entity_.entry_point();
   spin_lock_.unlock();
 
@@ -94,7 +94,7 @@ int HnswSparseAlgorithm::search(HnswSparseContext *ctx) const {
   }
 
   dist_t dist = ctx->dist_calculator().dist(entry_point);
-  for (level_t cur_level = maxLevel; cur_level >= 1; --cur_level) {
+  for (level_t cur_level = max_level; cur_level >= 1; --cur_level) {
     select_entry_point(cur_level, &entry_point, &dist, ctx);
   }
 
diff --git a/src/core/algorithm/hnsw_sparse/hnsw_sparse_builder.h b/src/core/algorithm/hnsw_sparse/hnsw_sparse_builder.h
index b16ec4dd2..a69cb8c07 100644
--- a/src/core/algorithm/hnsw_sparse/hnsw_sparse_builder.h
+++ b/src/core/algorithm/hnsw_sparse/hnsw_sparse_builder.h
@@ -70,7 +70,7 @@ class HnswSparseBuilder : public IndexBuilder {
   constexpr static uint32_t kMaxNeighborCnt = 65535;
 
  private:
-  enum BUILD_STATE {
+  enum BuildState {
     BUILD_STATE_INIT = 0,
     BUILD_STATE_INITED = 1,
     BUILD_STATE_TRAINED = 2,
@@ -96,7 +96,7 @@ class HnswSparseBuilder : public IndexBuilder {
   std::condition_variable cond_{};
   Stats stats_{};
 
-  BUILD_STATE state_{BUILD_STATE_INIT};
+  BuildState state_{BUILD_STATE_INIT};
 };
 
 }  // namespace core
diff --git a/src/core/algorithm/hnsw_sparse/hnsw_sparse_chunk.h b/src/core/algorithm/hnsw_sparse/hnsw_sparse_chunk.h
index dda1b9849..dc1f1b079 100644
--- a/src/core/algorithm/hnsw_sparse/hnsw_sparse_chunk.h
+++ b/src/core/algorithm/hnsw_sparse/hnsw_sparse_chunk.h
@@ -35,7 +35,7 @@ class SparseChunkBroker {
  public:
   typedef std::shared_ptr<SparseChunkBroker> Pointer;
 
-  enum CHUNK_TYPE {
+  enum ChunkType {
     CHUNK_TYPE_HEADER = 1,
     CHUNK_TYPE_META = 2,
     CHUNK_TYPE_NODE = 3,
diff --git a/src/core/algorithm/hnsw_sparse/hnsw_sparse_streamer_entity.h b/src/core/algorithm/hnsw_sparse/hnsw_sparse_streamer_entity.h
index eaa1085e3..35e16c35f 100644
--- a/src/core/algorithm/hnsw_sparse/hnsw_sparse_streamer_entity.h
+++ b/src/core/algorithm/hnsw_sparse/hnsw_sparse_streamer_entity.h
@@ -126,7 +126,7 @@ class HnswSparseStreamerEntity : public HnswSparseEntity {
   HnswSparseStreamerEntity(IndexStreamer::Stats &stats);
 
   //! Destructor
-  ~HnswSparseStreamerEntity();
+  ~HnswSparseStreamerEntity() override;
 
   //! Init entity
   int init(uint64_t max_index_size, size_t max_doc_cnt);
@@ -263,7 +263,7 @@ class HnswSparseStreamerEntity : public HnswSparseEntity {
   }
 
   //! Called only in searching procedure per context, so no need to lock
-  void sync_chunks(SparseChunkBroker::CHUNK_TYPE type, size_t idx,
+  void sync_chunks(SparseChunkBroker::ChunkType type, size_t idx,
                    std::vector<SparseChunk::Pointer> *chunks) const {
     if (ailego_likely(idx < chunks->size())) {
       return;
diff --git a/src/core/algorithm/ivf/ivf_builder.cc b/src/core/algorithm/ivf/ivf_builder.cc
index 6d2352669..90c0ba995 100644
--- a/src/core/algorithm/ivf/ivf_builder.cc
+++ b/src/core/algorithm/ivf/ivf_builder.cc
@@ -479,7 +479,7 @@ int IVFBuilder::dump(const IndexDumper::Pointer &dumper) {
   return 0;
 }
 
-int IVFBuilder::CheckAndUpdateMajorOrder(IndexMeta &meta) {
+int IVFBuilder::check_and_update_major_order(IndexMeta &meta) {
   const std::string &metric_name = meta.metric_name();
   auto metric = IndexFactory::CreateMetric(metric_name);
   if (!metric) {
@@ -729,7 +729,7 @@ int IVFBuilder::dump_index(const IndexDumper::Pointer &dumper) {
       source_reader_->reset();
     }
   });
-  int ret = CheckAndUpdateMajorOrder(quantized_meta_);
+  int ret = check_and_update_major_order(quantized_meta_);
   ivf_check_error_code(ret);
 
   IVFDumper::Pointer ivf_dumper = std::make_shared<IVFDumper>(
diff --git a/src/core/algorithm/ivf/ivf_builder.h b/src/core/algorithm/ivf/ivf_builder.h
index fda20aec6..4fad12707 100644
--- a/src/core/algorithm/ivf/ivf_builder.h
+++ b/src/core/algorithm/ivf/ivf_builder.h
@@ -209,7 +209,7 @@ class IVFBuilder : public IndexBuilder {
   using VectorList = std::vector<Vector>;
 
   //! Check MajorOrder in meta, and update the major order if needed
-  int CheckAndUpdateMajorOrder(IndexMeta &meta);
+  int check_and_update_major_order(IndexMeta &meta);
 
   //! Parse params
   int parse_centroids_num(const ailego::Params &params);
diff --git a/src/core/algorithm/ivf/ivf_distance_calculator.cc b/src/core/algorithm/ivf/ivf_distance_calculator.cc
index f0c731c10..198f1c0bd 100644
--- a/src/core/algorithm/ivf/ivf_distance_calculator.cc
+++ b/src/core/algorithm/ivf/ivf_distance_calculator.cc
@@ -22,7 +22,7 @@ IVFDistanceCalculator::IVFDistanceCalculator(const IndexMeta &meta,
                                              uint32_t block_vec_cnt)
     : metric_ptr_(metric), block_vec_cnt_(block_vec_cnt) {
   row_distance_ = metric->distance();
-  distanceXx1_ = metric->distance_matrix(block_vec_cnt, 1);
+  distance_xx1 = metric->distance_matrix(block_vec_cnt, 1);
   distances_.resize(33);
   for (size_t b = 32; b != 0; b /= 2) {
     distances_[b] = metric->distance_matrix(block_vec_cnt, b);
@@ -38,7 +38,7 @@ IVFDistanceCalculator::IVFDistanceCalculator(const IndexMeta &meta,
 
 IVFDistanceCalculator::~IVFDistanceCalculator() {
   row_distance_ = nullptr;
-  distanceXx1_ = nullptr;
+  distance_xx1 = nullptr;
   distances_.clear();
 }
 
diff --git a/src/core/algorithm/ivf/ivf_distance_calculator.h b/src/core/algorithm/ivf/ivf_distance_calculator.h
index 17a075dd4..458f8e029 100644
--- a/src/core/algorithm/ivf/ivf_distance_calculator.h
+++ b/src/core/algorithm/ivf/ivf_distance_calculator.h
@@ -61,7 +61,7 @@ class IVFDistanceCalculator {
  protected:
   IndexMetric::Pointer metric_ptr_{};
   IndexMetric::MatrixDistance row_distance_{nullptr};
-  IndexMetric::MatrixDistance distanceXx1_{nullptr};
+  IndexMetric::MatrixDistance distance_xx1{nullptr};
   std::vector<IndexMetric::MatrixDistance> distances_{};
 
   size_t element_size_{0};
@@ -122,7 +122,7 @@ void IVFDistanceCalculator::query_features_distance(const void *query,
                                                     float *distances) {
   if (column_major_order_) {
     if (fnum == block_vec_cnt_) {
-      distanceXx1_(feature, query, dimension_, distances);
+      distance_xx1(feature, query, dimension_, distances);
     } else {
       this->row_major_distance(query, feature, fnum, distances);
     }
@@ -138,7 +138,7 @@ void IVFDistanceCalculator::query_features_distance(const void *query,
                                                     float *distances) {
   if (column_major) {
     ailego_assert_with(fnum == block_vec_cnt_, "Invalid Block");
-    distanceXx1_(feature, query, dimension_, distances);
+    distance_xx1(feature, query, dimension_, distances);
   } else {
     this->row_major_distance(query, feature, fnum, distances);
   }
diff --git a/src/core/algorithm/ivf/ivf_utility.h b/src/core/algorithm/ivf/ivf_utility.h
index e7d213194..9586b445f 100644
--- a/src/core/algorithm/ivf/ivf_utility.h
+++ b/src/core/algorithm/ivf/ivf_utility.h
@@ -127,10 +127,10 @@ class IVFUtility {
 
   //! Transpose one vector in block
   template <typename T>
-  static inline void TransposeOne(const void *src, size_t M, size_t N,
+  static inline void TransposeOne(const void *src, size_t m, size_t n,
                                   void *dst) {
-    for (size_t i = 0; i < N; ++i) {
-      reinterpret_cast<T *>(dst)[i] = reinterpret_cast<const T *>(src)[i * M];
+    for (size_t i = 0; i < n; ++i) {
+      reinterpret_cast<T *>(dst)[i] = reinterpret_cast<const T *>(src)[i * m];
     }
   }
 };
diff --git a/src/core/algorithm/vamana/vamana_streamer_entity.cc b/src/core/algorithm/vamana/vamana_streamer_entity.cc
index cdfe90af2..69df86103 100644
--- a/src/core/algorithm/vamana/vamana_streamer_entity.cc
+++ b/src/core/algorithm/vamana/vamana_streamer_entity.cc
@@ -341,7 +341,7 @@ void VamanaStreamerEntity::update_entry_point(node_id_t ep) {
 int VamanaStreamerEntity::open(IndexStorage::Pointer stg,
                                uint64_t max_index_size, bool check_crc) {
   std::lock_guard<std::mutex> lock(mutex_);
-  bool huge_page = stg->isHugePage();
+  bool huge_page = stg->is_huge_page();
 
   int ret = broker_->open(std::move(stg), chunk_size_, check_crc);
   if (ailego_unlikely(ret != 0)) {
diff --git a/src/core/algorithm/vamana/vamana_streamer_entity.h b/src/core/algorithm/vamana/vamana_streamer_entity.h
index 204f12bba..0dcc25422 100644
--- a/src/core/algorithm/vamana/vamana_streamer_entity.h
+++ b/src/core/algorithm/vamana/vamana_streamer_entity.h
@@ -93,7 +93,7 @@ class VamanaStreamerEntity : public VamanaEntity {
 
  public:
   VamanaStreamerEntity(IndexStreamer::Stats &stats);
-  ~VamanaStreamerEntity();
+  ~VamanaStreamerEntity() override;
 
   const void *get_vector_by_key(key_t key) const override {
     auto id = get_id(key);
@@ -202,7 +202,7 @@ class VamanaStreamerEntity : public VamanaEntity {
   //! Lazy chunk synchronization: fetches chunks from broker when needed.
   //! Protected by node_chunks_mutex_ to synchronize with add_vector's
   //! emplace_back during concurrent build.
-  void sync_chunks(ChunkBroker::CHUNK_TYPE type, size_t idx,
+  void sync_chunks(ChunkBroker::ChunkType type, size_t idx,
                    std::vector<Chunk::Pointer> *chunks) const {
     if (ailego_likely(idx < chunks->size())) {
       return;
@@ -598,7 +598,7 @@ class VamanaContiguousStreamerEntity : public VamanaMmapStreamerEntity {
   //! Cloned entity shares contiguous memory via shared_ptr.
   const VamanaEntity::Pointer clone() const override;
 
-  ~VamanaContiguousStreamerEntity() = default;
+  ~VamanaContiguousStreamerEntity() override = default;
 
   // Build contiguous memory from chunks after open.
   int build_contiguous_memory();
diff --git a/src/core/framework/index_mapping.cc b/src/core/framework/index_mapping.cc
index 6094ec9b6..b5c793d9c 100644
--- a/src/core/framework/index_mapping.cc
+++ b/src/core/framework/index_mapping.cc
@@ -91,7 +91,7 @@ int IndexMapping::open(const std::string &path, bool cow, bool full_mode) {
   path_ = path;
   full_mode_ = full_mode;
   copy_on_write_ = cow;
-  huge_page_ = Ishugetlbfs(path);
+  huge_page_ = ishugetlbfs(path);
 
   bool read_only = copy_on_write_ && !full_mode_;
   if (!file_.open(path.c_str(), read_only, false)) {
@@ -126,7 +126,7 @@ int IndexMapping::create(const std::string &path, size_t seg_meta_capacity) {
               ailego::FileHelper::GetLastErrorString().c_str());
     return IndexError_CreateFile;
   }
-  huge_page_ = Ishugetlbfs(path);
+  huge_page_ = ishugetlbfs(path);
   if (huge_page_) {
     return init_hugepage_meta_section();
   }
@@ -599,7 +599,7 @@ int IndexMapping::init_index_mapping(size_t len) {
   return 0;
 }
 
-bool IndexMapping::Ishugetlbfs(const std::string &path) const {
+bool IndexMapping::ishugetlbfs(const std::string &path) const {
 #ifdef __linux__
   struct statfs buf;
   if (statfs(path.c_str(), &buf) != 0) {
diff --git a/src/core/interface/index.cc b/src/core/interface/index.cc
index b142a62d8..2ceb13bf9 100644
--- a/src/core/interface/index.cc
+++ b/src/core/interface/index.cc
@@ -183,14 +183,14 @@ int CreateReformerFromConverterMeta(
 // eliminate the pre-alloc of the context pool
 thread_local static std::array<core::IndexContext::Pointer,
                                (magic_enum::enum_count<IndexType>() - 1) * 2>
-    _context_list;
+    context_list;
 
 
 bool Index::init_context() {
   context_index_ = (magic_enum::enum_integer(param_.index_type) - 1) * 2 +
                    static_cast<size_t>(is_sparse_);
-  if (_context_list[context_index_] == nullptr) {
-    if ((_context_list[context_index_] = streamer_->create_context()) ==
+  if (context_list[context_index_] == nullptr) {
+    if ((context_list[context_index_] = streamer_->create_context()) ==
         nullptr) {
       LOG_ERROR("Failed to create context");
       return false;
@@ -201,7 +201,7 @@ bool Index::init_context() {
 
 core::IndexContext::Pointer &Index::acquire_context() {
   init_context();
-  return _context_list[context_index_];
+  return context_list[context_index_];
 }
 
 int Index::train() {
@@ -235,7 +235,7 @@ core::IndexProvider::Pointer Index::create_index_provider() const {
   return streamer_->create_provider();
 }
 
-int Index::ParseMetricName(const BaseIndexParam &param) {
+int Index::parse_metric_name(const BaseIndexParam &param) {
   std::string metric_name;
   if (is_sparse_) {
     // only inner product is supported for sparse index
@@ -275,7 +275,7 @@ int Index::ParseMetricName(const BaseIndexParam &param) {
   return 0;
 }
 
-int Index::CreateAndInitMetric(const BaseIndexParam & /*param*/) {
+int Index::create_and_init_metric(const BaseIndexParam & /*param*/) {
   auto &metric_name = proxima_index_meta_.metric_name();
 
   metric_ = core::IndexFactory::CreateMetric(metric_name);
@@ -297,8 +297,8 @@ int Index::CreateAndInitMetric(const BaseIndexParam & /*param*/) {
   return core::IndexError_Success;
 }
 
-int Index::CreateAndInitConverterReformer(const QuantizerParam &param,
-                                          const BaseIndexParam &index_param) {
+int Index::create_and_init_converter_reformer(
+    const QuantizerParam &param, const BaseIndexParam &index_param) {
   ailego::Params converter_params;
   std::string converter_name;
   if (is_sparse_) {
@@ -396,11 +396,11 @@ int Index::CreateAndInitConverterReformer(const QuantizerParam &param,
     }
   }
 
-  return InitConverterReformer(converter_name, converter_params);
+  return init_converter_reformer(converter_name, converter_params);
 }
 
-int Index::InitConverterReformer(const std::string &converter_name,
-                                 const ailego::Params &converter_params) {
+int Index::init_converter_reformer(const std::string &converter_name,
+                                   const ailego::Params &converter_params) {
   proxima_index_meta_.set_converter(converter_name, 0, converter_params);
   converter_ = core::IndexFactory::CreateConverter(converter_name);
   if (converter_ == nullptr ||
@@ -428,7 +428,7 @@ int Index::InitConverterReformer(const std::string &converter_name,
   return core::IndexError_Success;
 }
 
-int Index::Init(const BaseIndexParam &param) {
+int Index::init(const BaseIndexParam &param) {
   param_ = param;  // will lose the original type info
 
   is_sparse_ = param.is_sparse;
@@ -446,7 +446,7 @@ int Index::Init(const BaseIndexParam &param) {
 
   // when quantizer=int8/int4, the converter.init() will change the metric to
   // QuantizedInteger with params
-  if (ParseMetricName(param) != 0) {
+  if (parse_metric_name(param) != 0) {
     LOG_ERROR("Failed to parse metric name");
     return core::IndexError_Runtime;
   }
@@ -455,20 +455,20 @@ int Index::Init(const BaseIndexParam &param) {
   const auto quantizer_param = param.quantizer_param
                                    ? param.quantizer_param
                                    : std::make_shared<QuantizerParam>();
-  if (CreateAndInitConverterReformer(*quantizer_param, param) != 0) {
+  if (create_and_init_converter_reformer(*quantizer_param, param) != 0) {
     LOG_ERROR("Failed to create and init converter");
     return core::IndexError_Runtime;
   }
 
   // must after quantizer handled. e.g., cosine doesn't support int8 quantizer
   if (turbo_quantizer_ == nullptr) {
-    if (CreateAndInitMetric(param) != 0) {
+    if (create_and_init_metric(param) != 0) {
       LOG_ERROR("Failed to create and init metric");
       return core::IndexError_Runtime;
     }
   }
 
-  if (CreateAndInitStreamer(param) != 0) {
+  if (create_and_init_streamer(param) != 0) {
     LOG_ERROR("Failed to create and init streamer");
     return core::IndexError_Runtime;
   }
diff --git a/src/core/interface/index_factory.cc b/src/core/interface/index_factory.cc
index 77ad33764..4b02884f5 100644
--- a/src/core/interface/index_factory.cc
+++ b/src/core/interface/index_factory.cc
@@ -64,7 +64,7 @@ Index::Pointer IndexFactory::CreateAndInitIndex(const BaseIndexParam &param) {
     LOG_ERROR("Failed to create index");
     return nullptr;
   }
-  if (0 != ptr->Init(param)) {
+  if (0 != ptr->init(param)) {
     LOG_ERROR("Failed to init index");
     return nullptr;
   }
diff --git a/src/core/interface/index_param.cc b/src/core/interface/index_param.cc
index c0edf8a6b..2418aed35 100644
--- a/src/core/interface/index_param.cc
+++ b/src/core/interface/index_param.cc
@@ -89,8 +89,10 @@ IVFQueryParam::~IVFQueryParam() = default;
 
 BaseIndexQueryParam::Pointer IVFQueryParam::clone() const {
   auto cloned_this = std::make_shared<IVFQueryParam>(*this);
-  cloned_this->l1QueryParam = l1QueryParam ? l1QueryParam->clone() : nullptr;
-  cloned_this->l2QueryParam = l2QueryParam ? l2QueryParam->clone() : nullptr;
+  cloned_this->l1_query_param =
+      l1_query_param ? l1_query_param->clone() : nullptr;
+  cloned_this->l2_query_param =
+      l2_query_param ? l2_query_param->clone() : nullptr;
   return cloned_this;
 }
 
@@ -116,21 +118,21 @@ BaseIndexParam::~BaseIndexParam() = default;
 
 IVFIndexParam::IVFIndexParam() : BaseIndexParam(IndexType::kIVF) {}
 IVFIndexParam::IVFIndexParam(int nlist, int niters,
-                             std::shared_ptr<BaseIndexParam> l1Index,
-                             std::shared_ptr<BaseIndexParam> l2Index)
+                             std::shared_ptr<BaseIndexParam> l1_index,
+                             std::shared_ptr<BaseIndexParam> l2_index)
     : BaseIndexParam(IndexType::kIVF),
       nlist(nlist),
       niters(niters),
-      l1Index(std::move(l1Index)),
-      l2Index(std::move(l2Index)) {}
+      l1_index(std::move(l1_index)),
+      l2_index(std::move(l2_index)) {}
 IVFIndexParam::IVFIndexParam(MetricType metric, int dim, int nlist, int niters,
-                             std::shared_ptr<BaseIndexParam> l1Index,
-                             std::shared_ptr<BaseIndexParam> l2Index)
+                             std::shared_ptr<BaseIndexParam> l1_index,
+                             std::shared_ptr<BaseIndexParam> l2_index)
     : BaseIndexParam(IndexType::kIVF, metric, dim),
       nlist(nlist),
       niters(niters),
-      l1Index(std::move(l1Index)),
-      l2Index(std::move(l2Index)) {}
+      l1_index(std::move(l1_index)),
+      l2_index(std::move(l2_index)) {}
 IVFIndexParam::IVFIndexParam(const IVFIndexParam &) = default;
 IVFIndexParam::IVFIndexParam(IVFIndexParam &&) = default;
 IVFIndexParam &IVFIndexParam::operator=(const IVFIndexParam &) = default;
@@ -175,7 +177,7 @@ IVFRabitqIndexParam &IVFRabitqIndexParam::operator=(IVFRabitqIndexParam &&) =
     default;
 IVFRabitqIndexParam::~IVFRabitqIndexParam() = default;
 
-ailego::JsonObject BaseIndexParam::SerializeToJsonObject(
+ailego::JsonObject BaseIndexParam::serialize_to_json_object(
     bool omit_empty_value) const {
   ailego::JsonObject json_obj;
 
@@ -216,12 +218,12 @@ ailego::JsonObject BaseIndexParam::SerializeToJsonObject(
   if (quantizer_param) {
     if (!omit_empty_value || quantizer_param->type != QuantizerType::kNone) {
       json_obj.set("quantizer_param",
-                   quantizer_param->SerializeToJsonObject(omit_empty_value));
+                   quantizer_param->serialize_to_json_object(omit_empty_value));
     }
   } else if (!omit_empty_value) {
     // no quantizer configured, keep the default(kNone) object as before
     json_obj.set("quantizer_param",
-                 QuantizerParam().SerializeToJsonObject(false));
+                 QuantizerParam().serialize_to_json_object(false));
   }
   // if (refiner_param) {
   //   json.set("refiner_param", refiner_param->serialize_to_json());
@@ -234,9 +236,9 @@ ailego::JsonObject BaseIndexParam::SerializeToJsonObject(
 }
 
 
-ailego::JsonObject FlatIndexParam::SerializeToJsonObject(
+ailego::JsonObject FlatIndexParam::serialize_to_json_object(
     bool omit_empty_value) const {
-  auto json_obj = BaseIndexParam::SerializeToJsonObject(omit_empty_value);
+  auto json_obj = BaseIndexParam::serialize_to_json_object(omit_empty_value);
   if (!omit_empty_value || major_order != IndexMeta::MajorOrder::MO_UNDEFINED) {
     json_obj.set("major_order",
                  ailego::JsonValue(magic_enum::enum_name(major_order).data()));
@@ -253,9 +255,9 @@ ailego::JsonObject FlatIndexParam::SerializeToJsonObject(
   return json_obj;
 }
 
-ailego::JsonObject HNSWIndexParam::SerializeToJsonObject(
+ailego::JsonObject HNSWIndexParam::serialize_to_json_object(
     bool omit_empty_value) const {
-  auto json_obj = BaseIndexParam::SerializeToJsonObject(omit_empty_value);
+  auto json_obj = BaseIndexParam::serialize_to_json_object(omit_empty_value);
   json_obj.set("m", ailego::JsonValue(m));
   json_obj.set("ef_construction", ailego::JsonValue(ef_construction));
   if (!omit_empty_value || use_contiguous_memory) {
@@ -265,7 +267,7 @@ ailego::JsonObject HNSWIndexParam::SerializeToJsonObject(
   return json_obj;
 }
 
-bool BaseIndexParam::DeserializeFromJsonObject(
+bool BaseIndexParam::deserialize_from_json_object(
     const ailego::JsonObject &json_obj) {
   DESERIALIZE_ENUM_FIELD(json_obj, index_type, IndexType);
   DESERIALIZE_ENUM_FIELD(json_obj, metric_type, MetricType);
@@ -292,7 +294,7 @@ bool BaseIndexParam::DeserializeFromJsonObject(
         return false;
       }
       auto quantizer = QuantizerParam::Create(quantizer_type);
-      if (!quantizer->DeserializeFromJsonObject(quantizer_json_obj)) {
+      if (!quantizer->deserialize_from_json_object(quantizer_json_obj)) {
         LOG_ERROR("Error when deserialize json - field:quantizer_param");
       }
       quantizer_param = std::move(quantizer);
@@ -302,9 +304,9 @@ bool BaseIndexParam::DeserializeFromJsonObject(
   return true;
 }
 
-bool FlatIndexParam::DeserializeFromJsonObject(
+bool FlatIndexParam::deserialize_from_json_object(
     const ailego::JsonObject &json_obj) {
-  if (!BaseIndexParam::DeserializeFromJsonObject(json_obj)) {
+  if (!BaseIndexParam::deserialize_from_json_object(json_obj)) {
     return false;
   }
 
@@ -319,9 +321,9 @@ bool FlatIndexParam::DeserializeFromJsonObject(
   return true;
 }
 
-bool HNSWIndexParam::DeserializeFromJsonObject(
+bool HNSWIndexParam::deserialize_from_json_object(
     const ailego::JsonObject &json_obj) {
-  if (!BaseIndexParam::DeserializeFromJsonObject(json_obj)) {
+  if (!BaseIndexParam::deserialize_from_json_object(json_obj)) {
     return false;
   }
 
@@ -337,9 +339,9 @@ bool HNSWIndexParam::DeserializeFromJsonObject(
   return true;
 }
 
-bool HNSWRabitqIndexParam::DeserializeFromJsonObject(
+bool HNSWRabitqIndexParam::deserialize_from_json_object(
     const ailego::JsonObject &json_obj) {
-  if (!BaseIndexParam::DeserializeFromJsonObject(json_obj)) {
+  if (!BaseIndexParam::deserialize_from_json_object(json_obj)) {
     return false;
   }
 
@@ -357,9 +359,9 @@ bool HNSWRabitqIndexParam::DeserializeFromJsonObject(
   return true;
 }
 
-ailego::JsonObject HNSWRabitqIndexParam::SerializeToJsonObject(
+ailego::JsonObject HNSWRabitqIndexParam::serialize_to_json_object(
     bool omit_empty_value) const {
-  auto json_obj = BaseIndexParam::SerializeToJsonObject(omit_empty_value);
+  auto json_obj = BaseIndexParam::serialize_to_json_object(omit_empty_value);
   json_obj.set("m", ailego::JsonValue(m));
   json_obj.set("ef_construction", ailego::JsonValue(ef_construction));
   json_obj.set("total_bits", ailego::JsonValue(total_bits));
@@ -370,9 +372,9 @@ ailego::JsonObject HNSWRabitqIndexParam::SerializeToJsonObject(
   return json_obj;
 }
 
-bool IVFRabitqIndexParam::DeserializeFromJsonObject(
+bool IVFRabitqIndexParam::deserialize_from_json_object(
     const ailego::JsonObject &json_obj) {
-  if (!BaseIndexParam::DeserializeFromJsonObject(json_obj)) {
+  if (!BaseIndexParam::deserialize_from_json_object(json_obj)) {
     return false;
   }
 
@@ -388,9 +390,9 @@ bool IVFRabitqIndexParam::DeserializeFromJsonObject(
   return true;
 }
 
-ailego::JsonObject IVFRabitqIndexParam::SerializeToJsonObject(
+ailego::JsonObject IVFRabitqIndexParam::serialize_to_json_object(
     bool omit_empty_value) const {
-  auto json_obj = BaseIndexParam::SerializeToJsonObject(omit_empty_value);
+  auto json_obj = BaseIndexParam::serialize_to_json_object(omit_empty_value);
   json_obj.set("nlist", ailego::JsonValue(nlist));
   json_obj.set("total_bits", ailego::JsonValue(total_bits));
   if (!omit_empty_value || sample_count != 0) {
@@ -399,9 +401,9 @@ ailego::JsonObject IVFRabitqIndexParam::SerializeToJsonObject(
   return json_obj;
 }
 
-ailego::JsonObject VamanaIndexParam::SerializeToJsonObject(
+ailego::JsonObject VamanaIndexParam::serialize_to_json_object(
     bool omit_empty_value) const {
-  auto json_obj = BaseIndexParam::SerializeToJsonObject(omit_empty_value);
+  auto json_obj = BaseIndexParam::serialize_to_json_object(omit_empty_value);
   json_obj.set("max_degree", ailego::JsonValue(max_degree));
   json_obj.set("search_list_size", ailego::JsonValue(search_list_size));
   json_obj.set("alpha", ailego::JsonValue(alpha));
@@ -422,9 +424,9 @@ ailego::JsonObject VamanaIndexParam::SerializeToJsonObject(
   return json_obj;
 }
 
-bool DiskAnnIndexParam::DeserializeFromJsonObject(
+bool DiskAnnIndexParam::deserialize_from_json_object(
     const ailego::JsonObject &json_obj) {
-  if (!BaseIndexParam::DeserializeFromJsonObject(json_obj)) {
+  if (!BaseIndexParam::deserialize_from_json_object(json_obj)) {
     return false;
   }
 
@@ -440,18 +442,18 @@ bool DiskAnnIndexParam::DeserializeFromJsonObject(
   return true;
 }
 
-ailego::JsonObject DiskAnnIndexParam::SerializeToJsonObject(
+ailego::JsonObject DiskAnnIndexParam::serialize_to_json_object(
     bool omit_empty_value) const {
-  auto json_obj = BaseIndexParam::SerializeToJsonObject(omit_empty_value);
+  auto json_obj = BaseIndexParam::serialize_to_json_object(omit_empty_value);
   json_obj.set("max_degree", ailego::JsonValue(max_degree));
   json_obj.set("list_size", ailego::JsonValue(list_size));
   json_obj.set("pq_chunk_num", ailego::JsonValue(pq_chunk_num));
   return json_obj;
 }
 
-bool VamanaIndexParam::DeserializeFromJsonObject(
+bool VamanaIndexParam::deserialize_from_json_object(
     const ailego::JsonObject &json_obj) {
-  if (!BaseIndexParam::DeserializeFromJsonObject(json_obj)) {
+  if (!BaseIndexParam::deserialize_from_json_object(json_obj)) {
     return false;
   }
 
@@ -471,7 +473,7 @@ bool VamanaIndexParam::DeserializeFromJsonObject(
   return true;
 }
 
-ailego::JsonObject QuantizerParam::SerializeToJsonObject(
+ailego::JsonObject QuantizerParam::serialize_to_json_object(
     bool omit_empty_value) const {
   ailego::JsonObject json_obj;
   if (!omit_empty_value || type != QuantizerType::kNone) {
@@ -484,7 +486,7 @@ ailego::JsonObject QuantizerParam::SerializeToJsonObject(
   return json_obj;
 }
 
-bool QuantizerParam::DeserializeFromJsonObject(
+bool QuantizerParam::deserialize_from_json_object(
     const ailego::JsonObject &json_obj) {
   DESERIALIZE_ENUM_FIELD(json_obj, type, QuantizerType);
   DESERIALIZE_VALUE_FIELD(json_obj, enable_rotate);
@@ -500,17 +502,17 @@ QuantizerParam::Pointer QuantizerParam::Create(QuantizerType t) {
   }
 }
 
-ailego::JsonObject PqQuantizerParam::SerializeToJsonObject(
+ailego::JsonObject PqQuantizerParam::serialize_to_json_object(
     bool omit_empty_value) const {
-  auto json_obj = QuantizerParam::SerializeToJsonObject(omit_empty_value);
+  auto json_obj = QuantizerParam::serialize_to_json_object(omit_empty_value);
   json_obj.set("num_chunk", ailego::JsonValue(num_chunk));
   json_obj.set("num_bits", ailego::JsonValue(num_bits));
   return json_obj;
 }
 
-bool PqQuantizerParam::DeserializeFromJsonObject(
+bool PqQuantizerParam::deserialize_from_json_object(
     const ailego::JsonObject &json_obj) {
-  if (!QuantizerParam::DeserializeFromJsonObject(json_obj)) {
+  if (!QuantizerParam::deserialize_from_json_object(json_obj)) {
     return false;
   }
   DESERIALIZE_VALUE_FIELD(json_obj, num_chunk);
diff --git a/src/core/interface/indexes/diskann_index.cc b/src/core/interface/indexes/diskann_index.cc
index 83244f1e6..00b3fe83f 100644
--- a/src/core/interface/indexes/diskann_index.cc
+++ b/src/core/interface/indexes/diskann_index.cc
@@ -25,7 +25,7 @@ namespace zvec::core_interface {
 
 #if !DISKANN_SUPPORTED
 
-int DiskAnnIndex::CreateAndInitStreamer(const BaseIndexParam &param) {
+int DiskAnnIndex::create_and_init_streamer(const BaseIndexParam &param) {
   (void)param;
   LOG_ERROR("DiskAnn is not supported on this platform");
   return core::IndexError_Unsupported;
@@ -39,7 +39,7 @@ int DiskAnnIndex::open(const std::string &file_path,
   return core::IndexError_Unsupported;
 }
 
-int DiskAnnIndex::GenerateHolder() {
+int DiskAnnIndex::generate_holder() {
   LOG_ERROR("DiskAnn is not supported on this platform");
   return core::IndexError_Unsupported;
 }
@@ -86,7 +86,7 @@ int DiskAnnIndex::merge(const std::vector<Index::Pointer> &indexes,
 
 #else
 
-int DiskAnnIndex::CreateAndInitStreamer(const BaseIndexParam &param) {
+int DiskAnnIndex::create_and_init_streamer(const BaseIndexParam &param) {
   if (is_sparse_) {
     LOG_ERROR("Failed to create streamer. Sparse is not Supported.");
     return core::IndexError_Unsupported;
@@ -180,7 +180,7 @@ int DiskAnnIndex::open(const std::string &file_path,
   return 0;
 }
 
-int DiskAnnIndex::GenerateHolder() {
+int DiskAnnIndex::generate_holder() {
   return BuildMultiPassHolder(param_.data_type, param_.dimension, doc_cache_,
                               converter_, &holder_);
 }
@@ -210,7 +210,7 @@ int DiskAnnIndex::add(const VectorData &vector, uint32_t doc_id) {
 }
 
 int DiskAnnIndex::train() {
-  int ret = GenerateHolder();
+  int ret = generate_holder();
   if (ret != 0) {
     LOG_ERROR("Failed to generate holder, err: %s",
               core::IndexError::What(ret));
diff --git a/src/core/interface/indexes/flat_index.cc b/src/core/interface/indexes/flat_index.cc
index 08fc0ff02..29c5d2e70 100644
--- a/src/core/interface/indexes/flat_index.cc
+++ b/src/core/interface/indexes/flat_index.cc
@@ -149,7 +149,7 @@ int FlatIndex::open(const std::string &file_path,
           "Persisted flat index %s uses a legacy layout, falling back to the "
           "converter pipeline",
           file_path.c_str());
-      int ret = FallbackToLegacyPipeline();
+      int ret = fallback_to_legacy_pipeline();
       if (ret != 0) {
         return ret;
       }
@@ -165,11 +165,12 @@ int FlatIndex::open(const std::string &file_path,
         // opened an older file with a different storage precision.
         quantizer_params = persisted_meta.quantizer_params();
       }
-      int ret = CreateAndInitTurboQuantizer(quantizer_name, quantizer_params);
+      int ret =
+          create_and_init_turbo_quantizer(quantizer_name, quantizer_params);
       if (ret != 0) {
         return ret;
       }
-      ret = CreateAndInitStreamer(param_);
+      ret = create_and_init_streamer(param_);
       if (ret != 0) {
         return ret;
       }
@@ -178,7 +179,7 @@ int FlatIndex::open(const std::string &file_path,
   return Index::open(file_path, storage_options);
 }
 
-int FlatIndex::FallbackToLegacyPipeline() {
+int FlatIndex::fallback_to_legacy_pipeline() {
   turbo_quantizer_.reset();
   streamer_.reset();
 
@@ -193,29 +194,30 @@ int FlatIndex::FallbackToLegacyPipeline() {
   input_vector_meta_.set_meta_type(proxima_index_meta_.meta_type());
   streamer_vector_meta_ = input_vector_meta_;
 
-  if (ParseMetricName(param_) != 0) {
+  if (parse_metric_name(param_) != 0) {
     LOG_ERROR("Failed to parse metric name");
     return core::IndexError_Runtime;
   }
   const auto quantizer_param = param_.quantizer_param
                                    ? param_.quantizer_param
                                    : std::make_shared<QuantizerParam>();
-  if (CreateAndInitLegacyConverterReformer(*quantizer_param, param_) != 0) {
+  if (create_and_init_legacy_converter_reformer(*quantizer_param, param_) !=
+      0) {
     LOG_ERROR("Failed to create and init legacy converter");
     return core::IndexError_Runtime;
   }
-  if (CreateAndInitMetric(param_) != 0) {
+  if (create_and_init_metric(param_) != 0) {
     LOG_ERROR("Failed to create and init metric");
     return core::IndexError_Runtime;
   }
-  if (CreateAndInitStreamer(param_) != 0) {
+  if (create_and_init_streamer(param_) != 0) {
     LOG_ERROR("Failed to create and init streamer");
     return core::IndexError_Runtime;
   }
   return core::IndexError_Success;
 }
 
-int FlatIndex::CreateAndInitConverterReformer(
+int FlatIndex::create_and_init_converter_reformer(
     const QuantizerParam &quantizer_param, const BaseIndexParam &index_param) {
   const auto &flat_param = dynamic_cast<const FlatIndexParam &>(index_param);
   // Prefer the turbo quantizer path (quantized records + SIMD batch distance
@@ -225,14 +227,15 @@ int FlatIndex::CreateAndInitConverterReformer(
   const std::string quantizer_name =
       SelectTurboQuantizerName(quantizer_param, flat_param);
   if (!quantizer_name.empty()) {
-    return CreateAndInitTurboQuantizer(
+    return create_and_init_turbo_quantizer(
         quantizer_name, MakeTurboQuantizerParams(quantizer_param, flat_param));
   }
-  return CreateAndInitLegacyConverterReformer(quantizer_param, index_param);
+  return create_and_init_legacy_converter_reformer(quantizer_param,
+                                                   index_param);
 }
 
-int FlatIndex::CreateAndInitTurboQuantizer(const std::string &name,
-                                           const ailego::Params &params) {
+int FlatIndex::create_and_init_turbo_quantizer(const std::string &name,
+                                               const ailego::Params &params) {
   auto quantizer = core::IndexFactory::CreateQuantizer(name);
   if (!quantizer) {
     LOG_ERROR("Failed to create turbo %s", name.c_str());
@@ -254,13 +257,14 @@ int FlatIndex::CreateAndInitTurboQuantizer(const std::string &name,
   return core::IndexError_Success;
 }
 
-int FlatIndex::CreateAndInitLegacyConverterReformer(
+int FlatIndex::create_and_init_legacy_converter_reformer(
     const QuantizerParam &quantizer_param, const BaseIndexParam &index_param) {
   const auto &flat_param = dynamic_cast<const FlatIndexParam &>(index_param);
   const auto storage_type = flat_param.storage_data_type;
   if (storage_type == DataType::DT_UNDEFINED ||
       storage_type == flat_param.data_type) {
-    return Index::CreateAndInitConverterReformer(quantizer_param, index_param);
+    return Index::create_and_init_converter_reformer(quantizer_param,
+                                                     index_param);
   }
 
   if (flat_param.is_sparse || flat_param.data_type != DataType::DT_FP32 ||
@@ -273,14 +277,14 @@ int FlatIndex::CreateAndInitLegacyConverterReformer(
 
   if (storage_type == DataType::DT_FP16) {
     if (flat_param.metric_type == MetricType::kCosine) {
-      return InitConverterReformer("CosineRawFp16Converter");
+      return init_converter_reformer("CosineRawFp16Converter");
     }
-    return InitConverterReformer("HalfFloatConverter");
+    return init_converter_reformer("HalfFloatConverter");
   }
 
   if (storage_type == DataType::DT_UINT8 &&
       flat_param.metric_type == MetricType::kL2sq) {
-    return InitConverterReformer("RawUint8Converter");
+    return init_converter_reformer("RawUint8Converter");
   }
 
   LOG_ERROR("Unsupported Flat storage data type %d for metric %d",
@@ -289,7 +293,7 @@ int FlatIndex::CreateAndInitLegacyConverterReformer(
   return core::IndexError_Unsupported;
 }
 
-int FlatIndex::CreateAndInitStreamer(const BaseIndexParam &param) {
+int FlatIndex::create_and_init_streamer(const BaseIndexParam &param) {
   param_ = dynamic_cast<const FlatIndexParam &>(param);
 
   proxima_index_params_.set(core::PARAM_FLAT_COLUMN_MAJOR_ORDER,
diff --git a/src/core/interface/indexes/hnsw_index.cc b/src/core/interface/indexes/hnsw_index.cc
index 335ef36bf..0b9703af5 100644
--- a/src/core/interface/indexes/hnsw_index.cc
+++ b/src/core/interface/indexes/hnsw_index.cc
@@ -73,7 +73,7 @@ int HNSWIndex::search_with_source(
   return Index::search(query, search_param, result);
 }
 
-int HNSWIndex::CreateAndInitStreamer(const BaseIndexParam &param) {
+int HNSWIndex::create_and_init_streamer(const BaseIndexParam &param) {
   param_ = dynamic_cast<const HNSWIndexParam &>(param);
 
   // valid
diff --git a/src/core/interface/indexes/hnsw_rabitq_index.cc b/src/core/interface/indexes/hnsw_rabitq_index.cc
index 50a12752f..429850a85 100644
--- a/src/core/interface/indexes/hnsw_rabitq_index.cc
+++ b/src/core/interface/indexes/hnsw_rabitq_index.cc
@@ -25,7 +25,7 @@
 
 namespace zvec::core_interface {
 
-int HNSWRabitqIndex::CreateAndInitStreamer(const BaseIndexParam &param) {
+int HNSWRabitqIndex::create_and_init_streamer(const BaseIndexParam &param) {
 #if !RABITQ_SUPPORTED
   (void)param;
   LOG_ERROR("RaBitQ is not supported on this platform (Linux x86_64 only)");
diff --git a/src/core/interface/indexes/ivf_index.cc b/src/core/interface/indexes/ivf_index.cc
index 11399dab3..17059940a 100644
--- a/src/core/interface/indexes/ivf_index.cc
+++ b/src/core/interface/indexes/ivf_index.cc
@@ -22,7 +22,7 @@
 
 namespace zvec::core_interface {
 
-int IVFIndex::CreateAndInitStreamer(const BaseIndexParam &param) {
+int IVFIndex::create_and_init_streamer(const BaseIndexParam &param) {
   if (is_sparse_) {
     LOG_ERROR("IVF Index not support sparse vector");
     return core::IndexError_InvalidArgument;
@@ -141,7 +141,7 @@ int IVFIndex::open(const std::string &file_path,
   return 0;
 }
 
-int IVFIndex::GenerateHolder() {
+int IVFIndex::generate_holder() {
   return BuildMultiPassHolder(param_.data_type, param_.dimension, doc_cache_,
                               converter_, &holder_);
 }
@@ -175,7 +175,7 @@ int IVFIndex::train() {
     return 0;
   }
   if (build_stage_ == BuildStage::kCollecting) {
-    int ret = GenerateHolder();
+    int ret = generate_holder();
     if (ret != 0) {
       return ret;
     }
@@ -192,10 +192,10 @@ int IVFIndex::train() {
     }
     build_stage_ = BuildStage::kBuilt;
   }
-  return DumpAndOpen();
+  return dump_and_open();
 }
 
-int IVFIndex::ResetBuilder() {
+int IVFIndex::reset_builder() {
   auto next_builder = core::IndexFactory::CreateBuilder("IVFBuilder");
   if (!next_builder) {
     return core::IndexError_NoExist;
@@ -210,7 +210,7 @@ int IVFIndex::ResetBuilder() {
   return 0;
 }
 
-int IVFIndex::DumpAndOpen() {
+int IVFIndex::dump_and_open() {
   if (build_stage_ == BuildStage::kBuilt) {
     auto dumper = core::IndexFactory::CreateDumper("FileDumper");
     if (!dumper) {
@@ -241,7 +241,7 @@ int IVFIndex::DumpAndOpen() {
 
     // Release the full builder state before opening the persisted index.
     // If opening fails, retry only open: the replacement builder is empty.
-    ret = ResetBuilder();
+    ret = reset_builder();
     if (ret != 0) {
       return ret;
     }
@@ -346,7 +346,7 @@ int IVFIndex::merge(const std::vector<Index::Pointer> &indexes,
   }
   // A new merge (including a retry) rebuilds from its explicit inputs. Do not
   // reuse a partially trained builder or silently resume different inputs.
-  int ret = ResetBuilder();
+  int ret = reset_builder();
   if (ret != 0) {
     return ret;
   }
@@ -359,6 +359,6 @@ int IVFIndex::merge(const std::vector<Index::Pointer> &indexes,
   // Index::merge marks the reduce phase complete. IVF is not usable until
   // dump/open finishes; train() may resume that phase if it fails.
   is_trained_ = false;
-  return DumpAndOpen();
+  return dump_and_open();
 }
 }  // namespace zvec::core_interface
diff --git a/src/core/interface/indexes/ivf_rabitq_index.cc b/src/core/interface/indexes/ivf_rabitq_index.cc
index bbf7151e8..cc8dc7037 100644
--- a/src/core/interface/indexes/ivf_rabitq_index.cc
+++ b/src/core/interface/indexes/ivf_rabitq_index.cc
@@ -29,7 +29,7 @@
 
 namespace zvec::core_interface {
 
-int IVFRabitqIndex::CreateAndInitStreamer(const BaseIndexParam &param) {
+int IVFRabitqIndex::create_and_init_streamer(const BaseIndexParam &param) {
 #if !RABITQ_SUPPORTED
   (void)param;
   LOG_ERROR("RaBitQ is not supported on this platform (Linux x86_64 only)");
@@ -139,7 +139,7 @@ int IVFRabitqIndex::open(const std::string &file_path,
 #endif  // RABITQ_SUPPORTED
 }
 
-int IVFRabitqIndex::GenerateHolder() {
+int IVFRabitqIndex::generate_holder() {
 #if !RABITQ_SUPPORTED
   LOG_ERROR("RaBitQ is not supported on this platform (Linux x86_64 only)");
   return core::IndexError_Unsupported;
@@ -185,7 +185,7 @@ int IVFRabitqIndex::train() {
   LOG_ERROR("RaBitQ is not supported on this platform (Linux x86_64 only)");
   return core::IndexError_Unsupported;
 #else
-  int ret = GenerateHolder();
+  int ret = generate_holder();
   if (ret != 0) {
     LOG_ERROR("Failed to generate holder");
     return core::IndexError_Runtime;
diff --git a/src/core/interface/indexes/vamana_index.cc b/src/core/interface/indexes/vamana_index.cc
index 9e2ad969c..e2c73566e 100644
--- a/src/core/interface/indexes/vamana_index.cc
+++ b/src/core/interface/indexes/vamana_index.cc
@@ -41,7 +41,7 @@ int VamanaIndex::merge(const std::vector<Index::Pointer> &indexes,
   return ret;
 }
 
-int VamanaIndex::CreateAndInitStreamer(const BaseIndexParam &param) {
+int VamanaIndex::create_and_init_streamer(const BaseIndexParam &param) {
   param_ = dynamic_cast<const VamanaIndexParam &>(param);
 
   // Validate parameters
diff --git a/src/core/metric/quantized_integer_metric_batch.h b/src/core/metric/quantized_integer_metric_batch.h
index 9c1ee6f98..101930856 100644
--- a/src/core/metric/quantized_integer_metric_batch.h
+++ b/src/core/metric/quantized_integer_metric_batch.h
@@ -37,7 +37,7 @@ template <template <typename, size_t, size_t> class DistanceType,
           typename ValueType, size_t BatchSize, size_t PrefetchStep,
           typename = void>
 struct BaseDistanceBatchWithScoreUnquantized {
-  static inline void _ComputeBatch(const ValueType **m, const ValueType *q,
+  static inline void compute_batch(const ValueType **m, const ValueType *q,
                                    size_t num, size_t dim, float *out) {
     for (size_t i = 0; i < num; ++i) {
       DistanceType<ValueType, 1, 1>::Compute(m[i], q, dim, out + i);
@@ -63,7 +63,7 @@ struct BaseDistanceBatchWithScoreUnquantized {
                                                             out);
     }
 
-    _ComputeBatch(m, q, num, dim, out);
+    compute_batch(m, q, num, dim, out);
   }
 };
 
@@ -86,7 +86,7 @@ struct CosineMinusInnerProductDistanceBatchWithScoreUnquantized<
     ImplType::ComputeBatch(vecs, query, num_vecs, original_dim, results);
   }
 
-  static ailego::DistanceBatch::DistanceBatchQueryPreprocessFunc
+  static ailego::distance_batch::DistanceBatchQueryPreprocessFunc
   GetQueryPreprocessFunc() {
     return QueryPreprocess;
   }
@@ -120,8 +120,8 @@ template <size_t BatchSize, size_t PrefetchStep>
 struct MinusInnerProductDistanceBatchWithScoreUnquantized<int8_t, BatchSize,
                                                           PrefetchStep> {
   using ImplType =
-      ailego::DistanceBatch::InnerProductDistanceBatch<int8_t, BatchSize,
-                                                       PrefetchStep>;
+      ailego::distance_batch::InnerProductDistanceBatch<int8_t, BatchSize,
+                                                        PrefetchStep>;
   static inline void ComputeBatch(const int8_t **vecs, const int8_t *query,
                                   size_t num_vecs, size_t dim, float *results) {
     const size_t original_dim = dim;
@@ -148,7 +148,7 @@ struct MinusInnerProductDistanceBatchWithScoreUnquantized<int8_t, BatchSize,
     }
   }
 
-  static ailego::DistanceBatch::DistanceBatchQueryPreprocessFunc
+  static ailego::distance_batch::DistanceBatchQueryPreprocessFunc
   GetQueryPreprocessFunc() {
     return ImplType::GetQueryPreprocessFunc();
   }
@@ -163,7 +163,7 @@ struct MinusInnerProductDistanceBatchWithScoreUnquantized<uint8_t, BatchSize,
     const size_t original_dim = dim;
     const size_t original_dim_in_uint8_array = original_dim >> 1;
 
-    ailego::DistanceBatch::InnerProductDistanceBatch<
+    ailego::distance_batch::InnerProductDistanceBatch<
         uint8_t, BatchSize, PrefetchStep>::ComputeBatch(vecs, query, num_vecs,
                                                         original_dim, results);
     const float *q_tail = reinterpret_cast<const float *>(
@@ -194,12 +194,12 @@ template <size_t BatchSize, size_t PrefetchStep>
 struct SquaredEuclideanDistanceBatchWithScoreUnquantized<int8_t, BatchSize,
                                                          PrefetchStep> {
   using ImplType =
-      ailego::DistanceBatch::InnerProductDistanceBatch<int8_t, BatchSize,
-                                                       PrefetchStep>;
+      ailego::distance_batch::InnerProductDistanceBatch<int8_t, BatchSize,
+                                                        PrefetchStep>;
   static void ComputeBatch(const int8_t **vecs, const int8_t *query,
                            size_t num_vecs, size_t dim, float *results) {
     const size_t original_dim = dim - 20;
-    ailego::DistanceBatch::InnerProductDistanceBatch<
+    ailego::distance_batch::InnerProductDistanceBatch<
         int8_t, BatchSize, PrefetchStep>::ComputeBatch(vecs, query, num_vecs,
                                                        original_dim, results);
 
@@ -230,7 +230,7 @@ struct SquaredEuclideanDistanceBatchWithScoreUnquantized<int8_t, BatchSize,
     }
   }
 
-  static ailego::DistanceBatch::DistanceBatchQueryPreprocessFunc
+  static ailego::distance_batch::DistanceBatchQueryPreprocessFunc
   GetQueryPreprocessFunc() {
     return QueryPreprocess;
   }
@@ -250,7 +250,7 @@ struct SquaredEuclideanDistanceBatchWithScoreUnquantized<uint8_t, BatchSize,
                            size_t num_vecs, size_t dim, float *results) {
     const size_t original_dim = dim - 32;
     const size_t original_dim_in_uint8_array = original_dim >> 1;
-    ailego::DistanceBatch::InnerProductDistanceBatch<
+    ailego::distance_batch::InnerProductDistanceBatch<
         uint8_t, BatchSize, PrefetchStep>::ComputeBatch(vecs, query, num_vecs,
                                                         original_dim, results);
 
@@ -289,12 +289,12 @@ template <size_t BatchSize, size_t PrefetchStep>
 struct MipsSquaredEuclideanDistanceBatchWithScoreUnquantized<int8_t, BatchSize,
                                                              PrefetchStep> {
   using ImplType =
-      ailego::DistanceBatch::InnerProductDistanceBatch<int8_t, BatchSize,
-                                                       PrefetchStep>;
+      ailego::distance_batch::InnerProductDistanceBatch<int8_t, BatchSize,
+                                                        PrefetchStep>;
   static void ComputeBatch(const int8_t **vecs, const int8_t *query,
                            size_t num_vecs, size_t dim, float *results) {
     const size_t original_dim = dim - 20;
-    ailego::DistanceBatch::InnerProductDistanceBatch<
+    ailego::distance_batch::InnerProductDistanceBatch<
         int8_t, BatchSize, PrefetchStep>::ComputeBatch(vecs, query, num_vecs,
                                                        original_dim, results);
 
@@ -336,7 +336,7 @@ struct MipsSquaredEuclideanDistanceBatchWithScoreUnquantized<uint8_t, BatchSize,
                            size_t num_vecs, size_t dim, float *results) {
     const size_t original_dim = dim - 32;
     const size_t original_dim_in_uint8_array = original_dim >> 1;
-    ailego::DistanceBatch::InnerProductDistanceBatch<
+    ailego::distance_batch::InnerProductDistanceBatch<
         uint8_t, BatchSize, PrefetchStep>::ComputeBatch(vecs, query, num_vecs,
                                                         original_dim, results);
 
diff --git a/src/core/metric/uniform_uint7_metric.cc b/src/core/metric/uniform_uint7_metric.cc
index 1f7b00f6f..09f57ad66 100644
--- a/src/core/metric/uniform_uint7_metric.cc
+++ b/src/core/metric/uniform_uint7_metric.cc
@@ -117,8 +117,8 @@ class UniformUint7Metric : public IndexMetric {
       return turbo_ret;
     }
     return reinterpret_cast<IndexMetric::MatrixBatchDistanceHandle>(
-        ailego::DistanceBatch::SquaredEuclideanDistanceBatch<int8_t, 12,
-                                                             2>::ComputeBatch);
+        ailego::distance_batch::SquaredEuclideanDistanceBatch<int8_t, 12,
+                                                              2>::ComputeBatch);
   }
 
   //! Retrieve params of Metric
diff --git a/src/core/mixed_reducer/mixed_streamer_reducer.cc b/src/core/mixed_reducer/mixed_streamer_reducer.cc
index 0b12852db..85b31f269 100644
--- a/src/core/mixed_reducer/mixed_streamer_reducer.cc
+++ b/src/core/mixed_reducer/mixed_streamer_reducer.cc
@@ -696,10 +696,10 @@ int MixedStreamerReducer::reduce_with_builder(const IndexFilter &filter) {
       return ret;
     }
   }
-  return this->IndexBuild(std::move(target_holder));
+  return this->index_build(std::move(target_holder));
 }
 
-int MixedStreamerReducer::IndexBuild(IndexHolder::Pointer target_holder) {
+int MixedStreamerReducer::index_build(IndexHolder::Pointer target_holder) {
   if (target_builder_converter_) {
     int ret = core::IndexConverter::TrainAndTransform(target_builder_converter_,
                                                       target_holder);
diff --git a/src/core/mixed_reducer/mixed_streamer_reducer.h b/src/core/mixed_reducer/mixed_streamer_reducer.h
index 9de43c967..f388edaa4 100644
--- a/src/core/mixed_reducer/mixed_streamer_reducer.h
+++ b/src/core/mixed_reducer/mixed_streamer_reducer.h
@@ -71,7 +71,7 @@ class MixedStreamerReducer : public IndexStreamerReducer {
                       const uint32_t id_offset, uint32_t *next_id);
   void add_sparse_vec(int *result);
 
-  int IndexBuild(IndexHolder::Pointer target_holder);
+  int index_build(IndexHolder::Pointer target_holder);
 
   //! Retrieve statistics
   const Stats &stats() const override {
diff --git a/src/core/quantizer/rotator/matrix_rotator.cc b/src/core/quantizer/rotator/matrix_rotator.cc
index dc2053323..5ca670255 100644
--- a/src/core/quantizer/rotator/matrix_rotator.cc
+++ b/src/core/quantizer/rotator/matrix_rotator.cc
@@ -42,9 +42,9 @@ void random_gaussian_matrix(float *mat, size_t dim) {
 // Implemented manually to avoid rabitqlib/Eigen dependency whose ISA-sensitive
 // inline functions cause ODR violations (duplicate codegen with different
 // -march flags) leading to SEGFAULT on linux-x64-clang.
-void householder_qr(const float *A_in, float *q, size_t dim) {
+void householder_qr(const float *a_in, float *q, size_t dim) {
   // R starts as a copy of A
-  std::vector<float> R(A_in, A_in + dim * dim);
+  std::vector<float> r(a_in, a_in + dim * dim);
 
   // Q starts as identity
   std::fill(q, q + dim * dim, 0.0f);
@@ -58,18 +58,18 @@ void householder_qr(const float *A_in, float *q, size_t dim) {
     // x = R[k:dim, k]  (sub-column below and including diagonal)
     float norm_x_sq = 0.0f;
     for (size_t i = k; i < dim; ++i) {
-      norm_x_sq += R[i * dim + k] * R[i * dim + k];
+      norm_x_sq += r[i * dim + k] * r[i * dim + k];
     }
     if (norm_x_sq == 0.0f) continue;
 
     float norm_x = std::sqrt(norm_x_sq);
 
     // alpha = -sign(R[k][k]) * ||x||  (choose sign to avoid cancellation)
-    float alpha = (R[k * dim + k] >= 0.0f) ? -norm_x : norm_x;
+    float alpha = (r[k * dim + k] >= 0.0f) ? -norm_x : norm_x;
 
     // v = x - alpha * e1  (only the sub-vector [k, dim) is non-zero)
     for (size_t i = k; i < dim; ++i) {
-      v[i - k] = R[i * dim + k];
+      v[i - k] = r[i * dim + k];
     }
     v[0] -= alpha;
 
@@ -88,11 +88,11 @@ void householder_qr(const float *A_in, float *q, size_t dim) {
     for (size_t j = k; j < dim; ++j) {
       float dot = 0.0f;
       for (size_t i = 0; i < dim - k; ++i) {
-        dot += v[i] * R[(k + i) * dim + j];
+        dot += v[i] * r[(k + i) * dim + j];
       }
       dot *= 2.0f;
       for (size_t i = 0; i < dim - k; ++i) {
-        R[(k + i) * dim + j] -= v[i] * dot;
+        r[(k + i) * dim + j] -= v[i] * dot;
       }
     }
 
@@ -121,14 +121,14 @@ int MatrixRotator::init_impl(size_t dim) {
   random_gaussian_matrix(rand_mat.data(), dim);
 
   // Householder QR: A = Q * R, use Q^T as the rotation matrix
-  std::vector<float> Q(dim * dim);
-  householder_qr(rand_mat.data(), Q.data(), dim);
+  std::vector<float> q(dim * dim);
+  householder_qr(rand_mat.data(), q.data(), dim);
 
   // Store Q^T (transpose) as the rotation matrix
   matrix_.resize(dim * dim);
   for (size_t i = 0; i < dim; ++i) {
     for (size_t j = 0; j < dim; ++j) {
-      matrix_[j * dim + i] = Q[i * dim + j];
+      matrix_[j * dim + i] = q[i * dim + j];
     }
   }
   return 0;
diff --git a/src/core/quantizer/uniform_uint4_converter.cc b/src/core/quantizer/uniform_uint4_converter.cc
index 2ca0dacc1..604c6e718 100644
--- a/src/core/quantizer/uniform_uint4_converter.cc
+++ b/src/core/quantizer/uniform_uint4_converter.cc
@@ -147,7 +147,7 @@ class UniformUint4Converter : public IndexConverter {
     const bool has_range = params.get(UNIFORM_UINT4_REFORMER_RANGE, &range_);
     if (has_minimum && has_range && range_ > 0.0f && std::isfinite(minimum_) &&
         std::isfinite(range_)) {
-      SetReformerParams();
+      set_reformer_params();
     }
     return 0;
   }
@@ -262,7 +262,7 @@ class UniformUint4Converter : public IndexConverter {
 
     if (!(range_ > 0.0f)) range_ = 1.0f;
     *stats_.mutable_trained_count() = record_count;
-    SetReformerParams();
+    set_reformer_params();
 
     ailego::Params converter_params = meta_.converter_params();
     converter_params.set(UNIFORM_UINT4_REFORMER_MINIMUM, minimum_);
@@ -306,7 +306,7 @@ class UniformUint4Converter : public IndexConverter {
   }
 
  private:
-  void SetReformerParams() {
+  void set_reformer_params() {
     ailego::Params reformer_params;
     reformer_params.set(UNIFORM_UINT4_REFORMER_MINIMUM, minimum_);
     reformer_params.set(UNIFORM_UINT4_REFORMER_RANGE, range_);
@@ -324,7 +324,7 @@ class UniformUint4Converter : public IndexConverter {
           : owner_(owner),
             buffer_(owner->encoded_dimension_, 0),
             front_(std::move(front)) {
-        Encode();
+        encode();
       }
 
       const void *data() const override {
@@ -338,11 +338,11 @@ class UniformUint4Converter : public IndexConverter {
       }
       void next() override {
         front_->next();
-        Encode();
+        encode();
       }
 
      private:
-      void Encode() {
+      void encode() {
         if (!front_->is_valid()) return;
         const float *input = nullptr;
         if (owner_->source_type_ == IndexMeta::DataType::DT_FP32) {
diff --git a/src/core/quantizer/uniform_uint4_reformer.cc b/src/core/quantizer/uniform_uint4_reformer.cc
index ce54867ed..3db9c67a3 100644
--- a/src/core/quantizer/uniform_uint4_reformer.cc
+++ b/src/core/quantizer/uniform_uint4_reformer.cc
@@ -92,19 +92,19 @@ class UniformUint4Reformer : public IndexReformer {
 
   int transform(const void *query, const IndexQueryMeta &qmeta,
                 std::string *out, IndexQueryMeta *ometa) const override {
-    return Quantize(query, qmeta, 1, out, ometa);
+    return quantize(query, qmeta, 1, out, ometa);
   }
   int transform(const void *query, const IndexQueryMeta &qmeta, uint32_t count,
                 std::string *out, IndexQueryMeta *ometa) const override {
-    return Quantize(query, qmeta, count, out, ometa);
+    return quantize(query, qmeta, count, out, ometa);
   }
   int convert(const void *record, const IndexQueryMeta &rmeta, std::string *out,
               IndexQueryMeta *ometa) const override {
-    return Quantize(record, rmeta, 1, out, ometa);
+    return quantize(record, rmeta, 1, out, ometa);
   }
   int convert(const void *records, const IndexQueryMeta &rmeta, uint32_t count,
               std::string *out, IndexQueryMeta *ometa) const override {
-    return Quantize(records, rmeta, count, out, ometa);
+    return quantize(records, rmeta, count, out, ometa);
   }
 
   int normalize(const void * /*query*/, const IndexQueryMeta & /*qmeta*/,
@@ -140,7 +140,7 @@ class UniformUint4Reformer : public IndexReformer {
   }
 
  private:
-  int Quantize(const void *source, const IndexQueryMeta &source_meta,
+  int quantize(const void *source, const IndexQueryMeta &source_meta,
                uint32_t count, std::string *out,
                IndexQueryMeta *output_meta) const {
     if (!initialized_) return IndexError_Runtime;
diff --git a/src/core/quantizer/uniform_uint7_reformer.cc b/src/core/quantizer/uniform_uint7_reformer.cc
index 6df58d6d6..a2c40ab5d 100644
--- a/src/core/quantizer/uniform_uint7_reformer.cc
+++ b/src/core/quantizer/uniform_uint7_reformer.cc
@@ -41,7 +41,7 @@ class UniformUint7Reformer : public IndexReformer {
   //!
   //! Scale/bias are supplied through reformer params after converter training.
   int init(const ailego::Params &params) override {
-    Reset();
+    reset();
 
     float scale = 0.0f;
     float bias = 0.0f;
@@ -73,7 +73,7 @@ class UniformUint7Reformer : public IndexReformer {
 
   //! Cleanup Reformer
   int cleanup() override {
-    Reset();
+    reset();
     return 0;
   }
 
@@ -170,7 +170,7 @@ class UniformUint7Reformer : public IndexReformer {
   }
 
  private:
-  void Reset() {
+  void reset() {
     scale_ = 0.0f;
     bias_ = 0.0f;
     scale_reciprocal_sq_ = 1.0f;
diff --git a/src/core/quantizer/uniform_uint8_reformer.cc b/src/core/quantizer/uniform_uint8_reformer.cc
index 7030dfe23..1f800f0e3 100644
--- a/src/core/quantizer/uniform_uint8_reformer.cc
+++ b/src/core/quantizer/uniform_uint8_reformer.cc
@@ -29,7 +29,7 @@ class UniformUint8Reformer : public IndexReformer {
   explicit UniformUint8Reformer(IndexMeta::DataType /*destination_type*/) {}
 
   int init(const ailego::Params &params) override {
-    Reset();
+    reset();
 
     float scale = 0.0f;
     float bias = 0.0f;
@@ -42,11 +42,11 @@ class UniformUint8Reformer : public IndexReformer {
           static_cast<int>(has_scale), static_cast<int>(has_bias));
       return IndexError_InvalidArgument;
     }
-    return SetParams(scale, bias);
+    return set_params(scale, bias);
   }
 
   int cleanup() override {
-    Reset();
+    reset();
     return 0;
   }
 
@@ -61,24 +61,24 @@ class UniformUint8Reformer : public IndexReformer {
   int transform(const void *query, const IndexQueryMeta &query_meta,
                 std::string *output,
                 IndexQueryMeta *output_meta) const override {
-    return Encode(query, query_meta, 1, output, output_meta);
+    return encode(query, query_meta, 1, output, output_meta);
   }
 
   int transform(const void *queries, const IndexQueryMeta &query_meta,
                 uint32_t count, std::string *output,
                 IndexQueryMeta *output_meta) const override {
-    return Encode(queries, query_meta, count, output, output_meta);
+    return encode(queries, query_meta, count, output, output_meta);
   }
 
   int convert(const void *record, const IndexQueryMeta &record_meta,
               std::string *output, IndexQueryMeta *output_meta) const override {
-    return Encode(record, record_meta, 1, output, output_meta);
+    return encode(record, record_meta, 1, output, output_meta);
   }
 
   int convert(const void *records, const IndexQueryMeta &record_meta,
               uint32_t count, std::string *output,
               IndexQueryMeta *output_meta) const override {
-    return Encode(records, record_meta, count, output, output_meta);
+    return encode(records, record_meta, count, output, output_meta);
   }
 
   int normalize(const void * /*query*/, const IndexQueryMeta & /*query_meta*/,
@@ -128,14 +128,14 @@ class UniformUint8Reformer : public IndexReformer {
   }
 
  private:
-  void Reset() {
+  void reset() {
     initialized_ = false;
     scale_ = 0.0f;
     bias_ = 0.0f;
     scale_reciprocal_squared_ = 1.0f;
   }
 
-  int SetParams(float scale, float bias) {
+  int set_params(float scale, float bias) {
     if (!std::isfinite(scale) || scale <= 0.0f || !std::isfinite(bias)) {
       LOG_ERROR("UniformUint8Reformer: invalid params scale=%f bias=%f", scale,
                 bias);
@@ -149,7 +149,7 @@ class UniformUint8Reformer : public IndexReformer {
     return 0;
   }
 
-  int Encode(const void *input, const IndexQueryMeta &input_meta,
+  int encode(const void *input, const IndexQueryMeta &input_meta,
              uint32_t count, std::string *output,
              IndexQueryMeta *output_meta) const {
     if (!initialized_ || !input || !output || !output_meta || count == 0) {
@@ -176,13 +176,13 @@ class UniformUint8Reformer : public IndexReformer {
     const auto *source = static_cast<const float *>(input);
     auto *destination = reinterpret_cast<int8_t *>(output->data());
     for (uint32_t i = 0; i < count; ++i) {
-      EncodeOne(source + static_cast<size_t>(i) * dimension, dimension,
-                destination + static_cast<size_t>(i) * output_stride);
+      encode_one(source + static_cast<size_t>(i) * dimension, dimension,
+                 destination + static_cast<size_t>(i) * output_stride);
     }
     return 0;
   }
 
-  void EncodeOne(const float *input, size_t dimension, int8_t *output) const {
+  void encode_one(const float *input, size_t dimension, int8_t *output) const {
     int64_t sum_squared = 0;
     for (size_t i = 0; i < dimension; ++i) {
       float value = std::round(input[i] * scale_ + bias_);
diff --git a/src/core/utility/basic_refiner.cc b/src/core/utility/basic_refiner.cc
index 8af6a76c8..709872ddf 100644
--- a/src/core/utility/basic_refiner.cc
+++ b/src/core/utility/basic_refiner.cc
@@ -22,7 +22,7 @@ namespace core {
  */
 class BasicRefiner : public IndexRefiner {
  public:
-  const uint32_t kScaleFactor = 10;
+  const uint32_t k_scale_factor = 10;
 
  public:
   class BasicRefinerContext : public Context {
@@ -257,7 +257,7 @@ class BasicRefiner : public IndexRefiner {
   }
 
  private:
-  uint32_t scale_factor_{kScaleFactor};
+  uint32_t scale_factor_{k_scale_factor};
   ailego::Params params_;
 
   IndexRunner::Pointer base_runner_{nullptr};
diff --git a/src/core/utility/buffer_storage.cc b/src/core/utility/buffer_storage.cc
index fe9a7a0aa..66ad06a59 100644
--- a/src/core/utility/buffer_storage.cc
+++ b/src/core/utility/buffer_storage.cc
@@ -1086,7 +1086,7 @@ class BufferStorage : public IndexStorage {
         path, /*writable=*/create_if_missing);
     buffer_pool_handle_ =
         std::make_shared<ailego::VecBufferPoolHandle>(buffer_pool_);
-    int ret = ParseToMapping();
+    int ret = parse_to_mapping();
     if (ret != 0) {
       this->close_index();
       return ret;
@@ -1122,7 +1122,7 @@ class BufferStorage : public IndexStorage {
   }
 
   // Called from single-threaded open or under AllShardsExclusiveLatch.
-  int ParseHeader(size_t offset, IndexFormat::MetaHeader *out) {
+  int parse_header(size_t offset, IndexFormat::MetaHeader *out) {
     constexpr size_t kHeaderSize = sizeof(IndexFormat::MetaHeader);
     if (buffer_pool_handle_->get_meta(offset, kHeaderSize,
                                       reinterpret_cast<char *>(out)) != 0) {
@@ -1141,7 +1141,7 @@ class BufferStorage : public IndexStorage {
     return 0;
   }
 
-  int ParseFooter(size_t offset, IndexFormat::MetaFooter *footer) {
+  int parse_footer(size_t offset, IndexFormat::MetaFooter *footer) {
     if (buffer_pool_handle_->get_meta(offset, sizeof(*footer),
                                       reinterpret_cast<char *>(footer)) != 0) {
       LOG_ERROR("Get segment footer failed.");
@@ -1159,11 +1159,11 @@ class BufferStorage : public IndexStorage {
     return 0;
   }
 
-  int ParseSegment(size_t offset, uint64_t header_start_offset,
-                   IndexFormat::MetaHeader *chain_header,
-                   const IndexFormat::MetaFooter &footer,
-                   uint32_t &out_segment_ids_offset,
-                   std::unique_ptr<char[]> &segment_buffer) {
+  int parse_segment(size_t offset, uint64_t header_start_offset,
+                    IndexFormat::MetaHeader *chain_header,
+                    const IndexFormat::MetaFooter &footer,
+                    uint32_t &out_segment_ids_offset,
+                    std::unique_ptr<char[]> &segment_buffer) {
     segment_buffer = std::make_unique<char[]>(footer.segments_meta_size);
     if (buffer_pool_handle_->get_meta(offset, footer.segments_meta_size,
                                       segment_buffer.get()) != 0) {
@@ -1219,13 +1219,13 @@ class BufferStorage : public IndexStorage {
     return 0;
   }
 
-  int ParseToMapping() {
+  int parse_to_mapping() {
     uint64_t header_start_offset = 0;
     while (true) {
       int ret;
       auto header = std::make_unique<IndexFormat::MetaHeader>();
       IndexFormat::MetaHeader *chain_header = header.get();
-      ret = ParseHeader(header_start_offset, chain_header);
+      ret = parse_header(header_start_offset, chain_header);
       if (ret != 0) {
         LOG_ERROR("Failed to parse header, errno %d, %s", ret,
                   IndexError::What(ret));
@@ -1260,7 +1260,7 @@ class BufferStorage : public IndexStorage {
         return IndexError_InvalidValue;
       }
       IndexFormat::MetaFooter footer{};
-      ret = ParseFooter(footer_offset, &footer);
+      ret = parse_footer(footer_offset, &footer);
       if (ret != 0) {
         LOG_ERROR("Failed to parse footer, errno %d, %s", ret,
                   IndexError::What(ret));
@@ -1273,8 +1273,8 @@ class BufferStorage : public IndexStorage {
       uint32_t segment_ids_offset = footer.segments_meta_size;
       std::unique_ptr<char[]> segment_buffer;
       ret =
-          ParseSegment(segment_start_offset, header_start_offset, chain_header,
-                       footer, segment_ids_offset, segment_buffer);
+          parse_segment(segment_start_offset, header_start_offset, chain_header,
+                        footer, segment_ids_offset, segment_buffer);
       if (ret != 0) {
         LOG_ERROR("Failed to parse segment, errno %d, %s", ret,
                   IndexError::What(ret));
diff --git a/src/core/utility/mmap_file_storage.cc b/src/core/utility/mmap_file_storage.cc
index e4d2666af..7ebf4e451 100644
--- a/src/core/utility/mmap_file_storage.cc
+++ b/src/core/utility/mmap_file_storage.cc
@@ -282,7 +282,7 @@ class MMapFileStorage : public IndexStorage {
     return 0;
   }
 
-  bool isHugePage() const override {
+  bool is_huge_page() const override {
     return mapping_.huge_page();
   }
 
diff --git a/src/core/utility/visit_filter.h b/src/core/utility/visit_filter.h
index 91c76a7db..5c8e735a8 100644
--- a/src/core/utility/visit_filter.h
+++ b/src/core/utility/visit_filter.h
@@ -31,9 +31,9 @@ namespace zvec {
 namespace core {
 
 struct VisitFilterHeader {
-  VisitFilterHeader() : maxDocCnt(0), maxScanNum(0) {}
-  uint64_t maxDocCnt;
-  uint64_t maxScanNum;
+  VisitFilterHeader() : max_doc_cnt(0), max_scan_num(0) {}
+  uint64_t max_doc_cnt;
+  uint64_t max_scan_num;
 };
 
 constexpr int PROXIMA_HNSW_VISITFILTER_CUSTOM_PARAMS_INDEX_NEGPROB = 0;
@@ -71,16 +71,16 @@ class VisitBloomFilter {
     return c->filter->has(BLOOM_FILTER_HASH_BITS_OFFSETS(idx));
   }
 
-  inline static int set_max_scan_num(Context *c, uint64_t maxScanNum) {
-    if (maxScanNum == c->h.maxScanNum) {
+  inline static int set_max_scan_num(Context *c, uint64_t max_scan_num) {
+    if (max_scan_num == c->h.max_scan_num) {
       return 0;
     }
-    c->h.maxScanNum = maxScanNum;
-    if (c->filter->reset(maxScanNum, c->filter->probability()) != 0) {
+    c->h.max_scan_num = max_scan_num;
+    if (c->filter->reset(max_scan_num, c->filter->probability()) != 0) {
       LOG_ERROR("reset BloomFilter failed");
       return IndexError_Runtime;
     }
-    genRandomHashBits(c);
+    gen_random_hash_bits(c);
     return 0;
   }
 
@@ -89,10 +89,10 @@ class VisitBloomFilter {
     return;
   }
 
-  inline static bool reset(Context *c, uint64_t maxDocCnt,
+  inline static bool reset(Context *c, uint64_t max_doc_cnt,
                            uint64_t max_scan_num) {
-    if (ailego_unlikely(maxDocCnt > c->h.maxDocCnt ||
-                        max_scan_num > c->h.maxScanNum)) {
+    if (ailego_unlikely(max_doc_cnt > c->h.max_doc_cnt ||
+                        max_scan_num > c->h.max_scan_num)) {
       // Create a new one, if failed, we can reuse the old one
       auto filter = new (std::nothrow) ailego::BloomFilter<VisitBloomFilter::N>(
           max_scan_num, c->filter->probability());
@@ -105,15 +105,15 @@ class VisitBloomFilter {
 
       delete c->filter;
       c->filter = filter;
-      c->h.maxScanNum = max_scan_num;
-      c->h.maxDocCnt = maxDocCnt;
-      genRandomHashBits(c);
+      c->h.max_scan_num = max_scan_num;
+      c->h.max_doc_cnt = max_doc_cnt;
+      gen_random_hash_bits(c);
     }
     return true;
   }
 
-  inline static void genRandomHashBits(Context *c) {
-    std::uniform_int_distribution<int> dt(0, c->h.maxDocCnt);
+  inline static void gen_random_hash_bits(Context *c) {
+    std::uniform_int_distribution<int> dt(0, c->h.max_doc_cnt);
     for (size_t i = 0; i < sizeof(c->offset) / sizeof(c->offset[0]); ++i) {
       int r = dt(c->mt);
       size_t j = 0;
@@ -131,25 +131,25 @@ class VisitBloomFilter {
   }
 
   template <class... T>
-  static int init(Context *, void **ctx, uint64_t maxDocCnt,
-                  uint64_t maxScanNum, std::tuple<T...> &&tpl) {
+  static int init(Context *, void **ctx, uint64_t max_doc_cnt,
+                  uint64_t max_scan_num, std::tuple<T...> &&tpl) {
     Context *c = new (std::nothrow) Context;
     if (c == nullptr) {
       LOG_ERROR("New memory in initVisitBitMap failed");
       return IndexError_NoMemory;
     }
-    c->h.maxDocCnt = maxDocCnt;
-    c->h.maxScanNum = maxScanNum;
+    c->h.max_doc_cnt = max_doc_cnt;
+    c->h.max_scan_num = max_scan_num;
     float p =
         std::get<PROXIMA_HNSW_VISITFILTER_CUSTOM_PARAMS_INDEX_NEGPROB>(tpl);
     c->filter = new (std::nothrow)
-        ailego::BloomFilter<VisitBloomFilter::N>(maxScanNum, p);
+        ailego::BloomFilter<VisitBloomFilter::N>(max_scan_num, p);
     if (c->filter == nullptr) {
       LOG_ERROR("New BloomFilter failed");
       delete c;
       return IndexError_NoMemory;
     }
-    genRandomHashBits(c);
+    gen_random_hash_bits(c);
     *ctx = c;
     return 0;
   }
@@ -186,8 +186,8 @@ class VisitBitMap {
     return c->bitset.test(idx);
   }
 
-  inline static int set_max_scan_num(Context *c, uint64_t maxScanNum) {
-    c->h.maxScanNum = maxScanNum;
+  inline static int set_max_scan_num(Context *c, uint64_t max_scan_num) {
+    c->h.max_scan_num = max_scan_num;
     return 0;
   }
 
@@ -196,11 +196,11 @@ class VisitBitMap {
     return;
   }
 
-  inline static bool reset(Context *c, uint64_t maxDocCnt,
-                           uint64_t maxScanNum) {
-    if (ailego_unlikely(maxDocCnt > c->h.maxDocCnt ||
-                        maxScanNum > c->h.maxScanNum)) {
-      uint64_t len = ((maxDocCnt + 31) >> 5) << 2;  // round to uint32_t
+  inline static bool reset(Context *c, uint64_t max_doc_cnt,
+                           uint64_t max_scan_num) {
+    if (ailego_unlikely(max_doc_cnt > c->h.max_doc_cnt ||
+                        max_scan_num > c->h.max_scan_num)) {
+      uint64_t len = ((max_doc_cnt + 31) >> 5) << 2;  // round to uint32_t
       auto buf = new (std::nothrow) char[len];
       if (buf == nullptr) {
         LOG_ERROR("New memory in initVisitBitMap failed");
@@ -208,8 +208,8 @@ class VisitBitMap {
         return false;
       }
 
-      c->h.maxDocCnt = maxDocCnt;
-      c->h.maxScanNum = maxScanNum;
+      c->h.max_doc_cnt = max_doc_cnt;
+      c->h.max_scan_num = max_scan_num;
       delete[] c->buf;
       c->buf = buf;
       memset(c->buf, 0, len);
@@ -219,17 +219,17 @@ class VisitBitMap {
   }
 
   template <class... T>
-  static int init(Context *, void **ctx, uint64_t maxDocCnt,
-                  uint64_t maxScanNum, std::tuple<T...> &&tpl) {
+  static int init(Context *, void **ctx, uint64_t max_doc_cnt,
+                  uint64_t max_scan_num, std::tuple<T...> &&tpl) {
     (void)tpl;  // unused warning
     Context *c = new (std::nothrow) Context;
     if (c == nullptr) {
       LOG_ERROR("New memory in initVisitBitMap failed");
       return IndexError_NoMemory;
     }
-    c->h.maxDocCnt = maxDocCnt;
-    c->h.maxScanNum = maxScanNum;
-    uint64_t len = ((maxDocCnt + 31) >> 5) << 2;  // round to uint32_t
+    c->h.max_doc_cnt = max_doc_cnt;
+    c->h.max_scan_num = max_scan_num;
+    uint64_t len = ((max_doc_cnt + 31) >> 5) << 2;  // round to uint32_t
     c->buf = new (std::nothrow) char[len];
     if (c->buf == nullptr) {
       LOG_ERROR("New memory in initVisitBitMap failed, reuse old one");
@@ -253,18 +253,18 @@ class VisitByteMap {
   static constexpr int mode = 3;
   struct Context {
     VisitFilterHeader h;
-    uint8_t curNum{0};
+    uint8_t cur_num{0};
     std::vector<uint8_t> buf;
   };
 
   VisitByteMap() = delete;
 
   inline static void set_visited(Context *c, id_t idx) {
-    if (ailego_unlikely(idx >= c->h.maxDocCnt)) {
-      c->h.maxDocCnt = idx + 1024;  // reserved
-      c->buf.resize(c->h.maxDocCnt);
+    if (ailego_unlikely(idx >= c->h.max_doc_cnt)) {
+      c->h.max_doc_cnt = idx + 1024;  // reserved
+      c->buf.resize(c->h.max_doc_cnt);
     }
-    c->buf[idx] = c->curNum;
+    c->buf[idx] = c->cur_num;
     return;
   }
 
@@ -273,65 +273,65 @@ class VisitByteMap {
   }
 
   inline static bool visited(Context *c, id_t idx) {
-    if (ailego_unlikely(idx >= c->h.maxDocCnt)) {
+    if (ailego_unlikely(idx >= c->h.max_doc_cnt)) {
       return false;
     }
-    return c->buf[idx] == c->curNum;
+    return c->buf[idx] == c->cur_num;
   }
 
-  inline static int set_max_scan_num(Context *c, uint64_t maxScanNum) {
-    c->h.maxScanNum = maxScanNum;
+  inline static int set_max_scan_num(Context *c, uint64_t max_scan_num) {
+    c->h.max_scan_num = max_scan_num;
     return 0;
   }
 
   inline static void clear(Context *c) {
-    c->curNum++;
-    if (c->curNum == 0) {
-      memset(c->buf.data(), 0, c->h.maxDocCnt * sizeof(uint8_t));
-      c->curNum = 1;
+    c->cur_num++;
+    if (c->cur_num == 0) {
+      memset(c->buf.data(), 0, c->h.max_doc_cnt * sizeof(uint8_t));
+      c->cur_num = 1;
     }
     return;
   }
 
-  inline static bool reset(Context *c, uint64_t maxDocCnt,
-                           uint64_t maxScanNum) {
-    if (ailego_unlikely(maxDocCnt > c->h.maxDocCnt ||
-                        maxScanNum > c->h.maxScanNum)) {
+  inline static bool reset(Context *c, uint64_t max_doc_cnt,
+                           uint64_t max_scan_num) {
+    if (ailego_unlikely(max_doc_cnt > c->h.max_doc_cnt ||
+                        max_scan_num > c->h.max_scan_num)) {
       try {
-        c->buf.resize(maxDocCnt);
+        c->buf.resize(max_doc_cnt);
       } catch (const std::exception &e) {
         LOG_ERROR("New memory in initVisitByteMap failed, reuse old one");
         return false;
       }
-      memset(c->buf.data(), 0, maxDocCnt * sizeof(uint8_t));
-      c->curNum = 1;
-      c->h.maxDocCnt = maxDocCnt;
-      c->h.maxScanNum = maxScanNum;
+      memset(c->buf.data(), 0, max_doc_cnt * sizeof(uint8_t));
+      c->cur_num = 1;
+      c->h.max_doc_cnt = max_doc_cnt;
+      c->h.max_scan_num = max_scan_num;
       return true;
     }
     return true;
   }
 
   template <class... T>
-  static int init(Context *, void **ctx, uint64_t maxDocCnt,
-                  uint64_t maxScanNum, std::tuple<T...> &&tpl) {
+  static int init(Context *, void **ctx, uint64_t max_doc_cnt,
+                  uint64_t max_scan_num, std::tuple<T...> &&tpl) {
     (void)tpl;  // unused warning
     Context *c = new (std::nothrow) Context;
     if (c == nullptr) {
       LOG_ERROR("New memory in initVisitByteMap failed");
       return IndexError_NoMemory;
     }
-    c->h.maxDocCnt = maxDocCnt;
-    c->h.maxScanNum = maxScanNum;
+    c->h.max_doc_cnt = max_doc_cnt;
+    c->h.max_scan_num = max_scan_num;
     try {
-      c->buf.resize(maxDocCnt);
+      c->buf.resize(max_doc_cnt);
     } catch (const std::exception &e) {
       LOG_ERROR("New memory in initVisitByteMap failed");
       delete c;
       return IndexError_NoMemory;
     }
-    memset(c->buf.data(), 0, maxDocCnt * sizeof(uint8_t));
-    c->curNum = 1;
+    memset(c->buf.data(), 0, max_doc_cnt * sizeof(uint8_t));
+    c->cur_num = 1;
     *ctx = c;
     return 0;
   }
@@ -429,8 +429,8 @@ class VisitFilter {
     PROXIMA_HNSW_VISITFILTER_CALL_IMPL(clear);
   }
 
-  inline bool reset(uint64_t maxDocCnt, uint64_t maxScanNum) {
-    PROXIMA_HNSW_VISITFILTER_CALL_IMPL(reset, maxDocCnt, maxScanNum);
+  inline bool reset(uint64_t max_doc_cnt, uint64_t max_scan_num) {
+    PROXIMA_HNSW_VISITFILTER_CALL_IMPL(reset, max_doc_cnt, max_scan_num);
     return true;
   }
 
@@ -459,26 +459,26 @@ class VisitFilter {
     }
   }
 
-  int init(int mode, uint64_t maxDocCnt, uint64_t maxScanNum,
-           float negativeProbability) {
+  int init(int mode, uint64_t max_doc_cnt, uint64_t max_scan_num,
+           float negative_probability) {
     destroy();
     mode_ = mode;
     int ret = 0;
     switch (mode_) {
       case BloomFilter:
         ret = VisitBloomFilter::init(
-            static_cast<VisitBloomFilter::Context *>(nullptr), &ctx_, maxDocCnt,
-            maxScanNum, std::make_tuple(negativeProbability));
+            static_cast<VisitBloomFilter::Context *>(nullptr), &ctx_,
+            max_doc_cnt, max_scan_num, std::make_tuple(negative_probability));
         break;
       case BitMap:
         ret = VisitBitMap::init(static_cast<VisitBitMap::Context *>(nullptr),
-                                &ctx_, maxDocCnt, maxScanNum,
-                                std::make_tuple(negativeProbability));
+                                &ctx_, max_doc_cnt, max_scan_num,
+                                std::make_tuple(negative_probability));
         break;
       case ByteMap:
         ret = VisitByteMap::init(static_cast<VisitByteMap::Context *>(nullptr),
-                                 &ctx_, maxDocCnt, maxScanNum,
-                                 std::make_tuple(negativeProbability));
+                                 &ctx_, max_doc_cnt, max_scan_num,
+                                 std::make_tuple(negative_probability));
         break;
       default:
         // Preserve the existing contract for an unsupported mode: context
diff --git a/src/db/collection.cc b/src/db/collection.cc
index a96964494..080fdc45e 100644
--- a/src/db/collection.cc
+++ b/src/db/collection.cc
@@ -1582,7 +1582,7 @@ Status CollectionImpl::internal_fetch_by_doc(const Doc &doc,
     return Status::InternalError("Segment not found");
   }
 
-  auto old_doc = segment->Fetch(doc_id, std::nullopt, true);
+  auto old_doc = segment->fetch(doc_id, std::nullopt, true);
   if (!old_doc) {
     LOG_WARN("doc_id: %zu fetch doc failed", (size_t)doc_id);
     return Status::InternalError("Fetch doc failed");
@@ -1592,7 +1592,7 @@ Status CollectionImpl::internal_fetch_by_doc(const Doc &doc,
 }
 
 Status CollectionImpl::handle_upsert(Doc &doc) {
-  return writing_segment_->Upsert(doc);
+  return writing_segment_->upsert(doc);
 }
 
 Status CollectionImpl::handle_update(Doc &doc) {
@@ -1601,11 +1601,11 @@ Status CollectionImpl::handle_update(Doc &doc) {
   CHECK_RETURN_STATUS(s);
 
   old_doc->merge(doc);
-  return writing_segment_->Update(*old_doc);
+  return writing_segment_->update(*old_doc);
 }
 
 Status CollectionImpl::handle_insert(Doc &doc) {
-  return writing_segment_->Insert(doc);
+  return writing_segment_->insert(doc);
 }
 
 Result<WriteResults> CollectionImpl::write_impl(std::vector<Doc> &docs,
@@ -2022,7 +2022,7 @@ Result<DocPtrMap> CollectionImpl::fetch(
       results.insert({pk, nullptr});
       continue;
     }
-    results.insert({pk, segment->Fetch(doc_id, output_fields, include_vector)});
+    results.insert({pk, segment->fetch(doc_id, output_fields, include_vector)});
   }
 
   return results;
diff --git a/src/db/common/cgroup_util.cc b/src/db/common/cgroup_util.cc
index fbc78e8e0..7b2e3cf4c 100644
--- a/src/db/common/cgroup_util.cc
+++ b/src/db/common/cgroup_util.cc
@@ -35,35 +35,35 @@ void CgroupUtil::initialize() {
     return;
   }
 
-  updateCpuCores();
-  updateMemoryLimit();
-  initializeCpuStats();
+  update_cpu_cores();
+  update_memory_limit();
+  initialize_cpu_stats();
 
   initialized_ = true;
 }
 
-int CgroupUtil::getCpuLimit() {
+int CgroupUtil::get_cpu_limit() {
   initialize();
   return cpu_cores_;
 }
 
-uint64_t CgroupUtil::getMemoryLimit() {
+uint64_t CgroupUtil::get_memory_limit() {
   initialize();
   return memory_limit_;
 }
 
 // Other static methods implementation
-double CgroupUtil::getCpuUsage() {
+double CgroupUtil::get_cpu_usage() {
   initialize();
-  return calculateCpuUsage();
+  return calculate_cpu_usage();
 }
 
-uint64_t CgroupUtil::getMemoryUsage() {
+uint64_t CgroupUtil::get_memory_usage() {
   initialize();
-  return getCurrentMemoryUsage();
+  return get_current_memory_usage();
 }
 
-uint64_t CgroupUtil::getUptime() {
+uint64_t CgroupUtil::get_uptime() {
 #if defined(PLATFORM_LINUX)
   struct sysinfo info;
   if (sysinfo(&info) == 0) {
@@ -84,8 +84,8 @@ uint64_t CgroupUtil::getUptime() {
   return 0;
 }
 
-void CgroupUtil::updateCpuCores() {
-  if (readCpuCgroup()) {
+void CgroupUtil::update_cpu_cores() {
+  if (read_cpu_cgroup()) {
     return;
   }
 
@@ -112,7 +112,7 @@ void CgroupUtil::updateCpuCores() {
 #endif
 }
 
-bool CgroupUtil::readCpuCgroup() {
+bool CgroupUtil::read_cpu_cgroup() {
 #if defined(PLATFORM_LINUX)
   // cgroup v2
   std::ifstream file("/sys/fs/cgroup/cpu.max");
@@ -121,7 +121,7 @@ bool CgroupUtil::readCpuCgroup() {
     std::getline(file, cpu_max);
 
     int cpu_cores = 0;
-    if (parseCpuMax(cpu_max, &cpu_cores)) {
+    if (parse_cpu_max(cpu_max, &cpu_cores)) {
       cpu_cores_ = cpu_cores;
       return true;
     }
@@ -149,7 +149,7 @@ bool CgroupUtil::readCpuCgroup() {
   return false;
 }
 
-bool CgroupUtil::parseCpuMax(const std::string &cpu_max, int *cpu_cores) {
+bool CgroupUtil::parse_cpu_max(const std::string &cpu_max, int *cpu_cores) {
   if (cpu_cores == nullptr) {
     return false;
   }
@@ -186,8 +186,8 @@ bool CgroupUtil::parseCpuMax(const std::string &cpu_max, int *cpu_cores) {
   return true;
 }
 
-void CgroupUtil::updateMemoryLimit() {
-  if (readMemoryCgroup()) {
+void CgroupUtil::update_memory_limit() {
+  if (read_memory_cgroup()) {
     return;
   }
 
@@ -218,7 +218,7 @@ void CgroupUtil::updateMemoryLimit() {
 #endif
 }
 
-bool CgroupUtil::readMemoryCgroup() {
+bool CgroupUtil::read_memory_cgroup() {
 #if defined(PLATFORM_LINUX)
   // cgroup v2
   std::ifstream file("/sys/fs/cgroup/memory.max");
@@ -253,15 +253,15 @@ bool CgroupUtil::readMemoryCgroup() {
   return false;
 }
 
-void CgroupUtil::initializeCpuStats() {
+void CgroupUtil::initialize_cpu_stats() {
   last_cpu_check_ = std::chrono::steady_clock::now();
 #if defined(PLATFORM_LINUX)
-  readProcStat();
+  read_proc_stat();
 #endif
 }
 
 #if defined(PLATFORM_LINUX)
-bool CgroupUtil::readProcStat() {
+bool CgroupUtil::read_proc_stat() {
   std::ifstream file("/proc/stat");
   if (!file.is_open()) {
     return false;
@@ -294,18 +294,18 @@ bool CgroupUtil::readProcStat() {
 }
 #endif
 
-uint64_t CgroupUtil::getCurrentMemoryUsage() {
+uint64_t CgroupUtil::get_current_memory_usage() {
 #if defined(PLATFORM_LINUX)
   // cgroup
-  uint64_t usage = readMemoryUsageCgroup();
+  uint64_t usage = read_memory_usage_cgroup();
   if (usage > 0) {
     return usage;
   }
 
   // back to /proc/meminfo
-  return readMemoryUsageProc();
+  return read_memory_usage_proc();
 #elif defined(PLATFORM_MACOS)
-  return getMacOSMemoryUsage();
+  return get_mac_os_memory_usage();
 #elif defined(PLATFORM_WINDOWS)
   MEMORYSTATUSEX statex;
   statex.dwLength = sizeof(statex);
@@ -319,7 +319,7 @@ uint64_t CgroupUtil::getCurrentMemoryUsage() {
 }
 
 #if defined(PLATFORM_LINUX)
-uint64_t CgroupUtil::readMemoryUsageCgroup() {
+uint64_t CgroupUtil::read_memory_usage_cgroup() {
   // cgroup v2
   std::ifstream file("/sys/fs/cgroup/memory.current");
   if (file.is_open()) {
@@ -341,7 +341,7 @@ uint64_t CgroupUtil::readMemoryUsageCgroup() {
   return 0;
 }
 
-uint64_t CgroupUtil::readMemoryUsageProc() {
+uint64_t CgroupUtil::read_memory_usage_proc() {
   std::ifstream file("/proc/meminfo");
   if (!file.is_open()) {
     return 0;
@@ -356,15 +356,15 @@ uint64_t CgroupUtil::readMemoryUsageProc() {
 
   while (std::getline(file, line)) {
     if (line.find("MemTotal:") == 0) {
-      total_mem = extractMemoryValue(line);
+      total_mem = extract_memory_value(line);
     } else if (line.find("MemFree:") == 0) {
-      free_mem = extractMemoryValue(line);
+      free_mem = extract_memory_value(line);
     } else if (line.find("MemAvailable:") == 0) {
-      available_mem = extractMemoryValue(line);
+      available_mem = extract_memory_value(line);
     } else if (line.find("Buffers:") == 0) {
-      buffers = extractMemoryValue(line);
+      buffers = extract_memory_value(line);
     } else if (line.find("Cached:") == 0) {
-      cached = extractMemoryValue(line);
+      cached = extract_memory_value(line);
     }
   }
 
@@ -381,7 +381,7 @@ uint64_t CgroupUtil::readMemoryUsageProc() {
 #endif
 
 #if defined(PLATFORM_MACOS)
-uint64_t CgroupUtil::getMacOSMemoryUsage() {
+uint64_t CgroupUtil::get_mac_os_memory_usage() {
   mach_port_t host_port = mach_host_self();
   mach_msg_type_number_t host_size =
       sizeof(vm_statistics64_data_t) / sizeof(integer_t);
@@ -405,7 +405,7 @@ uint64_t CgroupUtil::getMacOSMemoryUsage() {
 }
 #endif
 
-uint64_t CgroupUtil::extractMemoryValue(const std::string &line) {
+uint64_t CgroupUtil::extract_memory_value(const std::string &line) {
   size_t colon_pos = line.find(':');
   if (colon_pos == std::string::npos) {
     return 0;
@@ -426,19 +426,19 @@ uint64_t CgroupUtil::extractMemoryValue(const std::string &line) {
   return value;
 }
 
-double CgroupUtil::calculateCpuUsage() {
+double CgroupUtil::calculate_cpu_usage() {
 #if defined(PLATFORM_LINUX)
-  return calculateLinuxCpuUsage();
+  return calculate_linux_cpu_usage();
 #elif defined(PLATFORM_MACOS)
-  return calculateMacOSCpuUsage();
+  return calculate_mac_os_cpu_usage();
 #else
   return 0.0;
 #endif
 }
 
 #if defined(PLATFORM_LINUX)
-double CgroupUtil::calculateLinuxCpuUsage() {
-  if (!readProcStat()) {
+double CgroupUtil::calculate_linux_cpu_usage() {
+  if (!read_proc_stat()) {
     return 0.0;
   }
 
@@ -486,7 +486,7 @@ double CgroupUtil::calculateLinuxCpuUsage() {
 #endif
 
 #if defined(PLATFORM_MACOS)
-double CgroupUtil::calculateMacOSCpuUsage() {
+double CgroupUtil::calculate_mac_os_cpu_usage() {
   host_cpu_load_info_data_t cpuinfo;
   mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
 
@@ -508,7 +508,7 @@ double CgroupUtil::calculateMacOSCpuUsage() {
     prev_total = total_tick;
     prev_idle = idle_tick;
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    return calculateMacOSCpuUsage();
+    return calculate_mac_os_cpu_usage();
   }
 
   unsigned long long total_delta = total_tick - prev_total;
diff --git a/src/db/common/cgroup_util.h b/src/db/common/cgroup_util.h
index 997c6bd8f..29361856e 100644
--- a/src/db/common/cgroup_util.h
+++ b/src/db/common/cgroup_util.h
@@ -41,17 +41,17 @@ namespace zvec {
 class CgroupUtil {
  public:
   // Static methods to get CPU and memory limits
-  static int getCpuLimit();
-  static uint64_t getMemoryLimit();
+  static int get_cpu_limit();
+  static uint64_t get_memory_limit();
 
   // Parse a cgroup v2 cpu.max value. Returns false for an unlimited or
   // malformed value so callers can fall back to the host CPU count.
-  static bool parseCpuMax(const std::string &cpu_max, int *cpu_cores);
+  static bool parse_cpu_max(const std::string &cpu_max, int *cpu_cores);
 
   // Static methods to get other resources
-  static double getCpuUsage();
-  static uint64_t getMemoryUsage();
-  static uint64_t getUptime();
+  static double get_cpu_usage();
+  static uint64_t get_memory_usage();
+  static uint64_t get_uptime();
 
  private:
   CgroupUtil() = default;
@@ -71,36 +71,36 @@ class CgroupUtil {
   static void initialize();
 
   // Helper methods (also made static)
-  static void updateCpuCores();
-  static bool readCpuCgroup();
-  static void updateMemoryLimit();
-  static bool readMemoryCgroup();
-  static void initializeCpuStats();
+  static void update_cpu_cores();
+  static bool read_cpu_cgroup();
+  static void update_memory_limit();
+  static bool read_memory_cgroup();
+  static void initialize_cpu_stats();
 
 #if defined(PLATFORM_LINUX)
-  static bool readProcStat();
+  static bool read_proc_stat();
 #endif
 
-  static uint64_t getCurrentMemoryUsage();
+  static uint64_t get_current_memory_usage();
 
 #if defined(PLATFORM_LINUX)
-  static uint64_t readMemoryUsageCgroup();
-  static uint64_t readMemoryUsageProc();
+  static uint64_t read_memory_usage_cgroup();
+  static uint64_t read_memory_usage_proc();
 #endif
 
 #if defined(PLATFORM_MACOS)
-  static uint64_t getMacOSMemoryUsage();
+  static uint64_t get_mac_os_memory_usage();
 #endif
 
-  static uint64_t extractMemoryValue(const std::string &line);
-  static double calculateCpuUsage();
+  static uint64_t extract_memory_value(const std::string &line);
+  static double calculate_cpu_usage();
 
 #if defined(PLATFORM_LINUX)
-  static double calculateLinuxCpuUsage();
+  static double calculate_linux_cpu_usage();
 #endif
 
 #if defined(PLATFORM_MACOS)
-  static double calculateMacOSCpuUsage();
+  static double calculate_mac_os_cpu_usage();
 #endif
 };
 
diff --git a/src/db/common/config.cc b/src/db/common/config.cc
index 28b364b44..91ccd667a 100644
--- a/src/db/common/config.cc
+++ b/src/db/common/config.cc
@@ -31,10 +31,10 @@ static void ExitLogHandler() {
 }
 
 GlobalConfig::ConfigData::ConfigData()
-    : memory_limit_bytes(CgroupUtil::getMemoryLimit() *
+    : memory_limit_bytes(CgroupUtil::get_memory_limit() *
                          DEFAULT_MEMORY_LIMIT_RATIO),
       log_config(std::make_shared<ConsoleLogConfig>()),
-      query_thread_count(CgroupUtil::getCpuLimit()),
+      query_thread_count(CgroupUtil::get_cpu_limit()),
       query_thread_binding(false),
       invert_to_forward_scan_ratio(0.9),
       brute_force_by_keys_ratio(0.1),
@@ -49,9 +49,9 @@ Status GlobalConfig::validate(const ConfigData &config) const {
                                    MIN_MEMORY_LIMIT_BYTES);
   }
 
-  if (config.memory_limit_bytes > CgroupUtil::getMemoryLimit()) {
+  if (config.memory_limit_bytes > CgroupUtil::get_memory_limit()) {
     return Status::InvalidArgument("memory_limit_bytes must be less than ",
-                                   CgroupUtil::getMemoryLimit());
+                                   CgroupUtil::get_memory_limit());
   }
 
   // Validate query thread count
diff --git a/src/db/common/glogger.h b/src/db/common/glogger.h
index 0d4943eff..769adb27b 100644
--- a/src/db/common/glogger.h
+++ b/src/db/common/glogger.h
@@ -39,7 +39,7 @@ class AppendLogger : public ailego::Logger {
  public:
   AppendLogger() = default;
 
-  ~AppendLogger() {
+  ~AppendLogger() override {
     this->cleanup();
   }
 
diff --git a/src/db/doc_iterator.cc b/src/db/doc_iterator.cc
index 47f09d9e2..a26922161 100644
--- a/src/db/doc_iterator.cc
+++ b/src/db/doc_iterator.cc
@@ -101,7 +101,7 @@ Status materialize_window(DocIterator::Impl *impl, int64_t begin, int64_t end) {
       }
       for (int64_t i = 0; i < num_rows; i++) {
         auto fetched =
-            indexer->Fetch(static_cast<uint32_t>(row_ids->Value(begin + i)));
+            indexer->fetch(static_cast<uint32_t>(row_ids->Value(begin + i)));
         if (!fetched.has_value()) {
           // Docs without a value for a vector field are accepted by insert
           // (the write path only warns and skips them, regardless of the
diff --git a/src/db/index/column/fts_column/gen/.clang-tidy b/src/db/index/column/fts_column/gen/.clang-tidy
new file mode 100644
index 000000000..9510802a1
--- /dev/null
+++ b/src/db/index/column/fts_column/gen/.clang-tidy
@@ -0,0 +1,2 @@
+Checks: "-*"
+InheritParentConfig: false
diff --git a/src/db/index/column/inverted_column/inverted_codec.h b/src/db/index/column/inverted_column/inverted_codec.h
index 37e3fbd0d..6f4929d01 100644
--- a/src/db/index/column/inverted_column/inverted_codec.h
+++ b/src/db/index/column/inverted_column/inverted_codec.h
@@ -127,7 +127,7 @@ class InvertedIndexCodec {
   }
 
 
-  static std::string Encode_Reversed(const std::string &term) {
+  static std::string encode_reversed(const std::string &term) {
     std::string reversed = term;
     std::reverse(reversed.begin(), reversed.end());
     return reversed;
@@ -136,7 +136,7 @@ class InvertedIndexCodec {
 
   // Format of range key:
   // [range_begin_key][separator_byte][range_end_key][range_begin_key_size]
-  static void Decode_Range_Key(const char *range_key_ptr, size_t range_key_size,
+  static void decode_range_key(const char *range_key_ptr, size_t range_key_size,
                                char **range_begin_pos,
                                size_t *range_begin_key_size,
                                char **range_end_pos,
@@ -165,7 +165,7 @@ class InvertedIndexCodec {
   }
 
 
-  static bool Has_Prefix(const char *value, size_t value_len,
+  static bool has_prefix(const char *value, size_t value_len,
                          const char *prefix, size_t prefix_len) {
     if (value_len < prefix_len) {
       return false;
@@ -238,7 +238,7 @@ class InvertedIndexCodec {
   }
 
 
-  static Status Merge_OR(const char *data, size_t size, bool lazy,
+  static Status merge_or(const char *data, size_t size, bool lazy,
                          roaring_bitmap_t *bitmap) {
     if (!data || size == 0) {
       LOG_ERROR("Input data is invalid");
@@ -279,7 +279,7 @@ class InvertedIndexCodec {
   }
 
 
-  static Status Merge_AND(const char *data, size_t size,
+  static Status merge_and(const char *data, size_t size,
                           roaring_bitmap_t *bitmap) {
     if (!data || size == 0) {
       LOG_ERROR("Input data is invalid");
diff --git a/src/db/index/column/inverted_column/inverted_column_indexer.h b/src/db/index/column/inverted_column/inverted_column_indexer.h
index a1de4fb59..1770be53b 100644
--- a/src/db/index/column/inverted_column/inverted_column_indexer.h
+++ b/src/db/index/column/inverted_column/inverted_column_indexer.h
@@ -224,7 +224,7 @@ class InvertedColumnIndexer {
   }
 
 
-  inline const std::string ID() const {
+  inline const std::string id() const {
     return "InvertedColumnIndexer[collection:" + collection_name_ +
            "|field:" + field_.name() + "|path:'" + path_ + "']";
   }
@@ -272,7 +272,7 @@ class InvertedColumnIndexer {
   }
 
   inline std::string encode_reversed(const std::string &term) const {
-    return InvertedIndexCodec::Encode_Reversed(term);
+    return InvertedIndexCodec::encode_reversed(term);
   }
 
   inline int cmp(const char *s1, size_t s1_len, const char *s2,
@@ -288,7 +288,7 @@ class InvertedColumnIndexer {
 
   inline bool has_prefix(const char *value, size_t value_len,
                          const char *prefix, size_t prefix_len) const {
-    return InvertedIndexCodec::Has_Prefix(value, value_len, prefix, prefix_len);
+    return InvertedIndexCodec::has_prefix(value, value_len, prefix, prefix_len);
   }
 
   inline void update_max_id(uint32_t id) {
diff --git a/src/db/index/column/inverted_column/inverted_column_indexer_search.cc b/src/db/index/column/inverted_column/inverted_column_indexer_search.cc
index c5e13e432..ccbfb9d03 100644
--- a/src/db/index/column/inverted_column/inverted_column_indexer_search.cc
+++ b/src/db/index/column/inverted_column/inverted_column_indexer_search.cc
@@ -33,7 +33,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_eq(
     }
     LOG_ERROR(
         "Failed to retrieve data for term[%s] from %s, code[%d], reason[%s]",
-        term.c_str(), ID().c_str(), s.code(), s.ToString().c_str());
+        term.c_str(), id().c_str(), s.code(), s.ToString().c_str());
     return tl::make_unexpected(Status::InternalError());
   }
 
@@ -45,7 +45,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_eq(
   } else {
     LOG_ERROR(
         "Failed to deserialize bitmap for term[%s] from %s, bitmap size[%zu]",
-        term.c_str(), ID().c_str(), bitmap_slice.size());
+        term.c_str(), id().c_str(), bitmap_slice.size());
     return tl::make_unexpected(Status::InternalError());
   }
 }
@@ -82,21 +82,21 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_contain(
                                           bitmap_slices[i].size(), &bitmap);
       if (!s.ok()) {
         LOG_ERROR("Failed to deserialize bitmap for term[%s] from %s",
-                  terms[i].c_str(), ID().c_str());
+                  terms[i].c_str(), id().c_str());
       }
       return;
     }
 
     if (is_any) {
-      s = InvertedIndexCodec::Merge_OR(bitmap_slices[i].data(),
+      s = InvertedIndexCodec::merge_or(bitmap_slices[i].data(),
                                        bitmap_slices[i].size(), true, bitmap);
     } else {
-      s = InvertedIndexCodec::Merge_AND(bitmap_slices[i].data(),
+      s = InvertedIndexCodec::merge_and(bitmap_slices[i].data(),
                                         bitmap_slices[i].size(), bitmap);
     }
     if (!s.ok()) {
       LOG_ERROR("Failed to merge bitmap for term[%s] from %s", terms[i].c_str(),
-                ID().c_str());
+                id().c_str());
     }
   };
 
@@ -114,7 +114,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_contain(
     } else {
       LOG_ERROR(
           "Failed to retrieve data for term[%s] from %s, code[%d], reason[%s]",
-          terms[i].c_str(), ID().c_str(), statuses[i].code(),
+          terms[i].c_str(), id().c_str(), statuses[i].code(),
           statuses[i].ToString().c_str());
       s = Status::InternalError();
       return tl::make_unexpected(s);
@@ -136,7 +136,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_ne(
       ret = flip_bitmap(ret.value());
     } else {
       LOG_ERROR("Failed to retrieve bitmap for term[%s] from %s", term.c_str(),
-                ID().c_str());
+                id().c_str());
     }
     return ret;
   } else {
@@ -154,13 +154,13 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_ne(
         iter->Next();
         continue;
       }
-      s = InvertedIndexCodec::Merge_OR(iter->value().data(),
+      s = InvertedIndexCodec::merge_or(iter->value().data(),
                                        iter->value().size(), true, bitmap);
       if (s.ok()) {
         iter->Next();
       } else {
         roaring_bitmap_free(bitmap);
-        LOG_ERROR("Failed to merge bitmap from %s", ID().c_str());
+        LOG_ERROR("Failed to merge bitmap from %s", id().c_str());
         return tl::make_unexpected(s);
       }
     }
@@ -196,7 +196,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_not_contain(
     roaring_bitmap_flip_inplace(ret.value(), 0, max_id_ + 1);
   } else {
     LOG_ERROR("Failed to retrieve bitmap[%s] from %s, term size[%zu]",
-              is_any ? "contain_any" : "contain_all", ID().c_str(),
+              is_any ? "contain_any" : "contain_all", id().c_str(),
               terms.size());
     return ret;
   }
@@ -221,7 +221,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_lt(
       ret = flip_bitmap(ret.value());
     } else {
       LOG_ERROR("Failed to retrieve range bitmap for term[%s] from %s",
-                term.c_str(), ID().c_str());
+                term.c_str(), id().c_str());
     }
     return ret;
   }
@@ -263,7 +263,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_lt(
     while (iter_range->Valid()) {
       char *range_begin, *range_end;
       size_t range_begin_key_size, range_end_key_size;
-      InvertedIndexCodec::Decode_Range_Key(
+      InvertedIndexCodec::decode_range_key(
           iter_range->key().data(), iter_range->key().size(), &range_begin,
           &range_begin_key_size, &range_end, &range_end_key_size);
       lt = cmp_lt(range_end, range_end_key_size, term.data(), term.length(),
@@ -272,10 +272,10 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_lt(
         point_seek_start_pos.emplace(range_begin, range_begin_key_size);
         break;
       }
-      s = InvertedIndexCodec::Merge_OR(
+      s = InvertedIndexCodec::merge_or(
           iter_range->value().data(), iter_range->value().size(), true, bitmap);
       if (!s.ok()) {
-        LOG_ERROR("Failed to merge range bitmap from %s", ID().c_str());
+        LOG_ERROR("Failed to merge range bitmap from %s", id().c_str());
         return tl::make_unexpected(s);
       }
       iter_range->Next();
@@ -304,10 +304,10 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_lt(
     if (!lt) {
       break;
     }
-    s = InvertedIndexCodec::Merge_OR(iter_point->value().data(),
+    s = InvertedIndexCodec::merge_or(iter_point->value().data(),
                                      iter_point->value().size(), true, bitmap);
     if (!s.ok()) {
-      LOG_ERROR("Failed to merge range bitmap from %s", ID().c_str());
+      LOG_ERROR("Failed to merge range bitmap from %s", id().c_str());
       return tl::make_unexpected(s);
     }
     iter_point->Next();
@@ -333,7 +333,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_gt(
       ret = flip_bitmap(ret.value());
     } else {
       LOG_ERROR("Failed to retrieve range bitmap for term[%s] from %s",
-                term.c_str(), ID().c_str());
+                term.c_str(), id().c_str());
     }
     return ret;
   }
@@ -373,7 +373,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_gt(
     if (iter_range->Valid()) {
       char *range_begin, *range_end;
       size_t range_begin_key_size, range_end_key_size;
-      InvertedIndexCodec::Decode_Range_Key(
+      InvertedIndexCodec::decode_range_key(
           iter_range->key().data(), iter_range->key().size(), &range_begin,
           &range_begin_key_size, &range_end, &range_end_key_size);
       int ret =
@@ -381,7 +381,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_gt(
       if (ret == 0 && !include_eq) {
         iter_range->Next();
         if (iter_range->Valid()) {
-          InvertedIndexCodec::Decode_Range_Key(
+          InvertedIndexCodec::decode_range_key(
               iter_range->key().data(), iter_range->key().size(), &range_begin,
               &range_begin_key_size, &range_end, &range_end_key_size);
           point_seek_end_pos.emplace(range_begin, range_begin_key_size);
@@ -392,10 +392,10 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_gt(
     }
     // 2. Merge ranges where the begin boundary is greater than the search term
     while (iter_range->Valid()) {
-      s = InvertedIndexCodec::Merge_OR(
+      s = InvertedIndexCodec::merge_or(
           iter_range->value().data(), iter_range->value().size(), true, bitmap);
       if (!s.ok()) {
-        LOG_ERROR("Failed to merge range bitmap from %s", ID().c_str());
+        LOG_ERROR("Failed to merge range bitmap from %s", id().c_str());
         return tl::make_unexpected(s);
       }
       iter_range->Next();
@@ -415,10 +415,10 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_gt(
             (*point_seek_end_pos).data(), (*point_seek_end_pos).size()) >= 0) {
       break;
     }
-    s = InvertedIndexCodec::Merge_OR(iter_point->value().data(),
+    s = InvertedIndexCodec::merge_or(iter_point->value().data(),
                                      iter_point->value().size(), true, bitmap);
     if (!s.ok()) {
-      LOG_ERROR("Failed to merge range bitmap from %s", ID().c_str());
+      LOG_ERROR("Failed to merge range bitmap from %s", id().c_str());
       return tl::make_unexpected(s);
     }
     iter_point->Next();
@@ -443,7 +443,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_array_len_eq(
     }
     LOG_ERROR(
         "Failed to retrieve data for len[%u] from %s, code[%d], reason[%s]",
-        len, ID().c_str(), rs.code(), rs.ToString().c_str());
+        len, id().c_str(), rs.code(), rs.ToString().c_str());
     return tl::make_unexpected(Status::InternalError());
   }
 
@@ -455,7 +455,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_array_len_eq(
   } else {
     LOG_ERROR(
         "Failed to deserialize bitmap for len[%u] from %s, bitmap size[%zu]",
-        len, ID().c_str(), bitmap_slice.size());
+        len, id().c_str(), bitmap_slice.size());
     return tl::make_unexpected(Status::InternalError());
   }
 }
@@ -480,13 +480,13 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_array_len_ne(
       iter->Next();
       continue;
     }
-    s = InvertedIndexCodec::Merge_OR(iter->value().data(), iter->value().size(),
+    s = InvertedIndexCodec::merge_or(iter->value().data(), iter->value().size(),
                                      true, bitmap);
     if (s.ok()) {
       iter->Next();
     } else {
       roaring_bitmap_free(bitmap);
-      LOG_ERROR("Failed to merge bitmap from %s", ID().c_str());
+      LOG_ERROR("Failed to merge bitmap from %s", id().c_str());
       return tl::make_unexpected(s);
     }
   }
@@ -515,13 +515,13 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_array_len_lt(
     if (!lt) {
       break;
     }
-    s = InvertedIndexCodec::Merge_OR(iter->value().data(), iter->value().size(),
+    s = InvertedIndexCodec::merge_or(iter->value().data(), iter->value().size(),
                                      true, bitmap);
     if (s.ok()) {
       iter->Next();
     } else {
       roaring_bitmap_free(bitmap);
-      LOG_ERROR("Failed to merge bitmap from %s", ID().c_str());
+      LOG_ERROR("Failed to merge bitmap from %s", id().c_str());
       return tl::make_unexpected(s);
     }
   }
@@ -550,13 +550,13 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_array_len_gt(
     }
   }
   while (iter->Valid()) {
-    s = InvertedIndexCodec::Merge_OR(iter->value().data(), iter->value().size(),
+    s = InvertedIndexCodec::merge_or(iter->value().data(), iter->value().size(),
                                      true, bitmap);
     if (s.ok()) {
       iter->Next();
     } else {
       roaring_bitmap_free(bitmap);
-      LOG_ERROR("Failed to merge bitmap from %s", ID().c_str());
+      LOG_ERROR("Failed to merge bitmap from %s", id().c_str());
       return tl::make_unexpected(s);
     }
   }
@@ -635,11 +635,11 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_prefix(
       iter->Next();
       continue;
     }
-    s = InvertedIndexCodec::Merge_OR(iter->value().data(), iter->value().size(),
+    s = InvertedIndexCodec::merge_or(iter->value().data(), iter->value().size(),
                                      true, bitmap);
     if (!s.ok()) {
       roaring_bitmap_free(bitmap);
-      LOG_ERROR("Failed to merge range bitmap from %s", ID().c_str());
+      LOG_ERROR("Failed to merge range bitmap from %s", id().c_str());
       return tl::make_unexpected(s);
     }
     iter->Next();
@@ -653,7 +653,7 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_prefix(
 Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_suffix(
     const std::string &term) const {
   if (!cf_reversed_terms_) {
-    LOG_ERROR("%s doesn't support suffix matching", ID().c_str());
+    LOG_ERROR("%s doesn't support suffix matching", id().c_str());
     return tl::make_unexpected(Status::PermissionDenied());
   }
 
@@ -674,11 +674,11 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_suffix(
                     reversed_term.data(), reversed_term.size())) {
       break;
     }
-    s = InvertedIndexCodec::Merge_OR(iter->value().data(), iter->value().size(),
+    s = InvertedIndexCodec::merge_or(iter->value().data(), iter->value().size(),
                                      true, bitmap);
     if (!s.ok()) {
       roaring_bitmap_free(bitmap);
-      LOG_ERROR("Failed to merge range bitmap from %s", ID().c_str());
+      LOG_ERROR("Failed to merge range bitmap from %s", id().c_str());
       return tl::make_unexpected(s);
     }
     iter->Next();
@@ -712,13 +712,13 @@ Result<roaring_bitmap_t *> InvertedColumnIndexer::get_bitmap_non_null() const {
     }
     iter->SeekToFirst();
     while (iter->Valid()) {
-      s = InvertedIndexCodec::Merge_OR(iter->value().data(),
+      s = InvertedIndexCodec::merge_or(iter->value().data(),
                                        iter->value().size(), true, bitmap);
       if (s.ok()) {
         iter->Next();
       } else {
         roaring_bitmap_free(bitmap);
-        LOG_ERROR("Failed to merge bitmap from %s", ID().c_str());
+        LOG_ERROR("Failed to merge bitmap from %s", id().c_str());
         return tl::make_unexpected(s);
       }
     }
@@ -732,7 +732,7 @@ InvertedSearchResult::Ptr InvertedColumnIndexer::search(
     const std::string &value, CompareOp op) const {
   if (field_.is_array_type()) {
     LOG_ERROR("%s: array type doesn't support single value search",
-              ID().c_str());
+              id().c_str());
     return nullptr;
   }
 
@@ -778,7 +778,7 @@ InvertedSearchResult::Ptr InvertedColumnIndexer::search(
       break;
     }
     default:
-      LOG_ERROR("%s: unsupported operator[%u]", ID().c_str(),
+      LOG_ERROR("%s: unsupported operator[%u]", id().c_str(),
                 static_cast<uint32_t>(op));
       return nullptr;
   }
@@ -787,7 +787,7 @@ InvertedSearchResult::Ptr InvertedColumnIndexer::search(
     search_res->set_and_own_bitmap(bitmap_res.value());
     return search_res;
   } else {
-    LOG_ERROR("%s: failed to search, code[%d]", ID().c_str(),
+    LOG_ERROR("%s: failed to search, code[%d]", id().c_str(),
               static_cast<int>(bitmap_res.error().code()));
     return nullptr;
   }
@@ -818,7 +818,7 @@ InvertedSearchResult::Ptr InvertedColumnIndexer::multi_search(
       break;
     }
     default:
-      LOG_ERROR("%s: unsupported operator[%u]", ID().c_str(),
+      LOG_ERROR("%s: unsupported operator[%u]", id().c_str(),
                 static_cast<uint32_t>(op));
       return nullptr;
   }
@@ -827,7 +827,7 @@ InvertedSearchResult::Ptr InvertedColumnIndexer::multi_search(
     search_res->set_and_own_bitmap(bitmap_res.value());
     return search_res;
   } else {
-    LOG_ERROR("%s: failed to search, code[%d]", ID().c_str(),
+    LOG_ERROR("%s: failed to search, code[%d]", id().c_str(),
               static_cast<int>(bitmap_res.error().code()));
     return nullptr;
   }
@@ -837,7 +837,7 @@ InvertedSearchResult::Ptr InvertedColumnIndexer::multi_search(
 InvertedSearchResult::Ptr InvertedColumnIndexer::search_array_len(
     uint32_t len, CompareOp op) const {
   if (!field_.is_array_type()) {
-    LOG_ERROR("%s: non-array type doesn't array length search", ID().c_str());
+    LOG_ERROR("%s: non-array type doesn't array length search", id().c_str());
     return nullptr;
   }
 
@@ -870,7 +870,7 @@ InvertedSearchResult::Ptr InvertedColumnIndexer::search_array_len(
       break;
     }
     default:
-      LOG_ERROR("%s: unsupported operator[%u]", ID().c_str(),
+      LOG_ERROR("%s: unsupported operator[%u]", id().c_str(),
                 static_cast<uint32_t>(op));
       return nullptr;
   }
@@ -879,7 +879,7 @@ InvertedSearchResult::Ptr InvertedColumnIndexer::search_array_len(
     search_res->set_and_own_bitmap(bitmap_res.value());
     return search_res;
   } else {
-    LOG_ERROR("%s: failed to search, code[%d]", ID().c_str(),
+    LOG_ERROR("%s: failed to search, code[%d]", id().c_str(),
               static_cast<int>(bitmap_res.error().code()));
     return nullptr;
   }
@@ -893,7 +893,7 @@ InvertedSearchResult::Ptr InvertedColumnIndexer::search_null() const {
     search_res->set_and_own_bitmap(bitmap_res.value());
     return search_res;
   } else {
-    LOG_ERROR("%s: failed to search, code[%d]", ID().c_str(),
+    LOG_ERROR("%s: failed to search, code[%d]", id().c_str(),
               static_cast<int>(bitmap_res.error().code()));
     return nullptr;
   }
@@ -907,7 +907,7 @@ InvertedSearchResult::Ptr InvertedColumnIndexer::search_non_null() const {
     search_res->set_and_own_bitmap(bitmap_res.value());
     return search_res;
   } else {
-    LOG_ERROR("%s: failed to search, code[%d]", ID().c_str(),
+    LOG_ERROR("%s: failed to search, code[%d]", id().c_str(),
               static_cast<int>(bitmap_res.error().code()));
     return nullptr;
   }
@@ -918,7 +918,7 @@ Status InvertedColumnIndexer::evaluate_ratio(const std::string &value,
                                              CompareOp op, uint64_t *total_size,
                                              uint64_t *range_size) const {
   if (field_.is_array_type()) {
-    LOG_ERROR("%s: array type doesn't support ratio evaluation", ID().c_str());
+    LOG_ERROR("%s: array type doesn't support ratio evaluation", id().c_str());
     return Status::PermissionDenied();
   }
 
@@ -938,7 +938,7 @@ inline Status InvertedColumnIndexer::estimate_range_ratio(
     uint64_t *matching_count) const {
   if (field_.is_array_type() || field_.element_data_type() == DataType::BOOL) {
     LOG_ERROR("%s: type[%d] doesn't support range ratio estimation",
-              ID().c_str(), (int)field_.data_type());
+              id().c_str(), (int)field_.data_type());
     return Status::PermissionDenied();
   }
 
diff --git a/src/db/index/column/inverted_column/inverted_column_indexer_util.cc b/src/db/index/column/inverted_column/inverted_column_indexer_util.cc
index e4c236499..3312394d4 100644
--- a/src/db/index/column/inverted_column/inverted_column_indexer_util.cc
+++ b/src/db/index/column/inverted_column/inverted_column_indexer_util.cc
@@ -21,7 +21,7 @@ namespace zvec {
 
 
 InvertedColumnIndexer::~InvertedColumnIndexer() {
-  LOG_INFO("Closed %s", ID().c_str());
+  LOG_INFO("Closed %s", id().c_str());
 }
 
 
@@ -41,14 +41,14 @@ Status InvertedColumnIndexer::open() {
 
   cf_terms_ = ctx_.get_cf(cf_name_terms());
   if (!cf_terms_) {
-    LOG_ERROR("Failed to get cf_terms for %s", ID().c_str());
+    LOG_ERROR("Failed to get cf_terms for %s", id().c_str());
     return Status::InternalError();
   }
 
   if (field_.is_array_type()) {
     cf_array_len_ = ctx_.get_cf(cf_name_array_len());
     if (!cf_array_len_) {
-      LOG_ERROR("Failed to get cf_array_len for %s", ID().c_str());
+      LOG_ERROR("Failed to get cf_array_len for %s", id().c_str());
       return Status::InternalError();
     }
   }
@@ -56,23 +56,23 @@ Status InvertedColumnIndexer::open() {
   if (enable_range_optimization_) {
     cf_ranges_ = ctx_.get_cf(cf_name_ranges());
     if (!cf_ranges_) {
-      LOG_ERROR("Failed to get cf_ranges for %s", ID().c_str());
+      LOG_ERROR("Failed to get cf_ranges for %s", id().c_str());
       return Status::InternalError();
     }
     cf_cdf_ = ctx_.get_cf(cf_name_cdf());
     if (!cf_cdf_) {
-      LOG_ERROR("Failed to get cf_cdf for %s", ID().c_str());
+      LOG_ERROR("Failed to get cf_cdf for %s", id().c_str());
       return Status::InternalError();
     }
     s = ctx_.db_->Get(ctx_.read_opts_, cf_cdf_, field_.name(), &value);
     if (s.ok()) {
       doc_range_stat_ = SegmentDocRangeStat::Create(value);
       if (!doc_range_stat_) {
-        LOG_ERROR("Failed to create doc range stats from %s", ID().c_str());
+        LOG_ERROR("Failed to create doc range stats from %s", id().c_str());
         return Status::InternalError();
       }
     } else if (s.code() != rocksdb::Status::kNotFound) {
-      LOG_ERROR("Failed to retrieve cdf from %s", ID().c_str());
+      LOG_ERROR("Failed to retrieve cdf from %s", id().c_str());
       return Status::InternalError();
     }
   }
@@ -80,7 +80,7 @@ Status InvertedColumnIndexer::open() {
   if (enable_extended_wildcard_) {
     cf_reversed_terms_ = ctx_.get_cf(cf_name_reversed_terms());
     if (!cf_reversed_terms_) {
-      LOG_ERROR("Failed to get cf_reversed_terms for %s", ID().c_str());
+      LOG_ERROR("Failed to get cf_reversed_terms for %s", id().c_str());
       return Status::InternalError();
     }
   }
@@ -92,11 +92,11 @@ Status InvertedColumnIndexer::open() {
       max_id_ = std::stoul(value);
     } catch (const std::exception &e) {
       LOG_ERROR("Failed to parse max id from %s for %s, exception[%s]",
-                value.c_str(), ID().c_str(), e.what());
+                value.c_str(), id().c_str(), e.what());
       return Status::InternalError();
     }
   } else if (s.code() != rocksdb::Status::kNotFound) {
-    LOG_ERROR("Failed to retrieve max id from %s", ID().c_str());
+    LOG_ERROR("Failed to retrieve max id from %s", id().c_str());
     return Status::InternalError();
   }
 
@@ -104,11 +104,11 @@ Status InvertedColumnIndexer::open() {
   s = ctx_.db_->Get(ctx_.read_opts_, key_null(), &value);
   if (s.ok()) {
     if (auto status = null_bitmap_.deserialize(value); !status.ok()) {
-      LOG_ERROR("Failed to deserialize null bitmap from %s", ID().c_str());
+      LOG_ERROR("Failed to deserialize null bitmap from %s", id().c_str());
       return status;
     }
   } else if (s.code() != rocksdb::Status::kNotFound) {
-    LOG_ERROR("Failed to retrieve null bitmap from %s", ID().c_str());
+    LOG_ERROR("Failed to retrieve null bitmap from %s", id().c_str());
     return Status::InternalError();
   }
 
@@ -120,11 +120,11 @@ Status InvertedColumnIndexer::open() {
   } else if (s.code() == rocksdb::Status::kNotFound) {
     sealed_ = false;
   } else {
-    LOG_ERROR("Failed to retrieve indexer state from %s", ID().c_str());
+    LOG_ERROR("Failed to retrieve indexer state from %s", id().c_str());
     return Status::InternalError();
   }
 
-  LOG_INFO("Opened %s", ID().c_str());
+  LOG_INFO("Opened %s", id().c_str());
   return Status::OK();
 }
 
@@ -148,9 +148,9 @@ Status InvertedColumnIndexer::drop_storage() {
   rocksdb::Status rs;
   AILEGO_DEFER([&]() {
     if (s.ok()) {
-      LOG_INFO("Dropped storage of %s", ID().c_str());
+      LOG_INFO("Dropped storage of %s", id().c_str());
     } else {
-      LOG_ERROR("Failed to drop storage of %s", ID().c_str());
+      LOG_ERROR("Failed to drop storage of %s", id().c_str());
     }
   });
 
@@ -168,7 +168,7 @@ Status InvertedColumnIndexer::drop_storage() {
     }
     rs = ctx_.db_->Delete(ctx_.write_opts_, cf_cdf_, field_.name());
     if (!rs.ok()) {
-      LOG_ERROR("Failed to delete cdf of %s", ID().c_str());
+      LOG_ERROR("Failed to delete cdf of %s", id().c_str());
       s = Status::InternalError();
       return s;
     }
@@ -181,21 +181,21 @@ Status InvertedColumnIndexer::drop_storage() {
 
   rs = ctx_.db_->Delete(ctx_.write_opts_, key_max_id());
   if (!rs.ok()) {
-    LOG_ERROR("Failed to delete max_id of %s", ID().c_str());
+    LOG_ERROR("Failed to delete max_id of %s", id().c_str());
     s = Status::InternalError();
     return s;
   }
 
   rs = ctx_.db_->Delete(ctx_.write_opts_, key_null());
   if (!rs.ok()) {
-    LOG_ERROR("Failed to delete null bitmap of %s", ID().c_str());
+    LOG_ERROR("Failed to delete null bitmap of %s", id().c_str());
     s = Status::InternalError();
     return s;
   }
 
   rs = ctx_.db_->Delete(ctx_.write_opts_, key_sealed());
   if (!rs.ok()) {
-    LOG_ERROR("Failed to delete indexer state of %s", ID().c_str());
+    LOG_ERROR("Failed to delete indexer state of %s", id().c_str());
     s = Status::InternalError();
     return s;
   }
diff --git a/src/db/index/column/inverted_column/inverted_column_indexer_write.cc b/src/db/index/column/inverted_column/inverted_column_indexer_write.cc
index d41a26c75..43d59c0f4 100644
--- a/src/db/index/column/inverted_column/inverted_column_indexer_write.cc
+++ b/src/db/index/column/inverted_column/inverted_column_indexer_write.cc
@@ -34,7 +34,7 @@ Status InvertedColumnIndexer::insert(uint32_t id, const std::string &value) {
   AILEGO_DEFER([&]() {
     if (!s.ok()) {
       LOG_ERROR("Failed to insert terms of id[%u] to %s, code[%d], reason[%s]",
-                id, ID().c_str(), s.code(), s.ToString().c_str());
+                id, this->id().c_str(), s.code(), s.ToString().c_str());
     }
   });
 
@@ -88,7 +88,7 @@ Status InvertedColumnIndexer::insert(uint32_t id,
   AILEGO_DEFER([&]() {
     if (!s.ok()) {
       LOG_ERROR("Failed to insert terms of id[%u] to %s, code[%d], reason[%s]",
-                id, ID().c_str(), s.code(), s.ToString().c_str());
+                id, this->id().c_str(), s.code(), s.ToString().c_str());
     }
   });
 
@@ -130,7 +130,7 @@ Status InvertedColumnIndexer::insert(uint32_t id, bool value) {
     return Status::OK();
   } else {
     LOG_ERROR("Failed to insert terms of id[%u] to %s, code[%d], reason[%s]",
-              id, ID().c_str(), s.code(), s.ToString().c_str());
+              id, this->id().c_str(), s.code(), s.ToString().c_str());
     return Status::InternalError();
   }
 }
@@ -147,7 +147,7 @@ Status InvertedColumnIndexer::insert(uint32_t id,
 
   rocksdb::Status rs;
   if (rs = index_array_len(id, values.size()); !rs.ok()) {
-    LOG_ERROR("Failed to index array length for %s", ID().c_str());
+    LOG_ERROR("Failed to index array length for %s", this->id().c_str());
     return Status::InternalError();
   }
 
@@ -174,7 +174,7 @@ Status InvertedColumnIndexer::insert(uint32_t id,
     return Status::OK();
   } else {
     LOG_ERROR("Failed to insert terms of id[%u] to %s, code[%d], reason[%s]",
-              id, ID().c_str(), rs.code(), rs.ToString().c_str());
+              id, this->id().c_str(), rs.code(), rs.ToString().c_str());
     return Status::InternalError();
   }
 }
@@ -204,7 +204,7 @@ Status InvertedColumnIndexer::flush_special_values() {
     auto s = ctx_.db_->Put(ctx_.write_opts_, key_null(), value);
     if (!s.ok()) {
       LOG_ERROR("Failed to insert null bitmap to %s, code[%d], reason[%s]",
-                ID().c_str(), s.code(), s.ToString().c_str());
+                id().c_str(), s.code(), s.ToString().c_str());
       return Status::InternalError();
     }
   }
@@ -212,25 +212,25 @@ Status InvertedColumnIndexer::flush_special_values() {
   auto s =
       ctx_.db_->Put(ctx_.write_opts_, key_max_id(), std::to_string(max_id_));
   if (s.ok()) {
-    LOG_DEBUG("Special values flushed to %s", ID().c_str());
+    LOG_DEBUG("Special values flushed to %s", id().c_str());
     return Status::OK();
   } else {
     LOG_ERROR("Failed to insert max_id to %s, code[%d], reason[%s]",
-              ID().c_str(), s.code(), s.ToString().c_str());
+              id().c_str(), s.code(), s.ToString().c_str());
     return Status::InternalError();
   }
 }
 
 
-rocksdb::Status InvertedColumnIndexer::index_array_len(uint32_t id,
+rocksdb::Status InvertedColumnIndexer::index_array_len(uint32_t array_id,
                                                        uint32_t len) {
   if (!cf_array_len_) {
-    LOG_ERROR("%s doesn't support array length index", ID().c_str());
+    LOG_ERROR("%s doesn't support array length index", id().c_str());
     return rocksdb::Status::NotSupported();
   }
 
   std::string encoded_id = std::string{1}.append(
-      reinterpret_cast<const char *>(&id), sizeof(uint32_t));
+      reinterpret_cast<const char *>(&array_id), sizeof(uint32_t));
   std::string encoded_len = InvertedIndexCodec::Encode(
       std::string((char *)&len, sizeof(uint32_t)), DataType::UINT32);
 
@@ -254,7 +254,7 @@ Status InvertedColumnIndexer::generate_statistical_indexes() {
   }
   cf_ranges_ = ctx_.get_cf(cf_name_ranges());
   if (!cf_ranges_) {
-    LOG_ERROR("Failed to get column families for %s", ID().c_str());
+    LOG_ERROR("Failed to get column families for %s", id().c_str());
     return Status::InternalError();
   }
 
@@ -340,7 +340,7 @@ Status InvertedColumnIndexer::generate_statistical_indexes() {
                                         iter_term->value().size(), &bitmap_cur);
     if (!s.ok()) {
       LOG_ERROR("Failed to deserialize bitmap for term[%s] from %s",
-                iter_term->key().ToString().c_str(), ID().c_str());
+                iter_term->key().ToString().c_str(), id().c_str());
       return Status::InternalError();
     }
     // The count of documents for the current term
@@ -391,14 +391,14 @@ Status InvertedColumnIndexer::generate_statistical_indexes() {
   if (num_range_slot_created >= term_count) {
     LOG_DEBUG(
         "Drop range index in %s, range_slot_count[%ld] vs term_count[%ld].",
-        ID().c_str(), num_range_slot_created, term_count);
+        id().c_str(), num_range_slot_created, term_count);
     if (!ctx_.reset_cf(cf_name_ranges()).ok()) {
       LOG_ERROR("Failed to drop range index");
       return Status::InternalError();
     }
     cf_ranges_ = ctx_.get_cf(cf_name_ranges());
     if (!cf_ranges_) {
-      LOG_ERROR("Failed to get cf_ranges for %s", ID().c_str());
+      LOG_ERROR("Failed to get cf_ranges for %s", id().c_str());
       return Status::InternalError();
     }
   }
@@ -415,7 +415,7 @@ Status InvertedColumnIndexer::generate_statistical_indexes() {
                      cdf_json.as_json_string().as_stl_string());
   if (!rs.ok()) {
     LOG_ERROR("Failed to insert CDF of field[%s] to %s, code[%d], reason[%s]",
-              field_.name().c_str(), ID().c_str(), rs.code(),
+              field_.name().c_str(), id().c_str(), rs.code(),
               rs.ToString().c_str());
     return Status::InternalError();
   }
@@ -423,11 +423,11 @@ Status InvertedColumnIndexer::generate_statistical_indexes() {
   doc_range_stat_ =
       SegmentDocRangeStat::Create(cdf_json.as_json_string().as_stl_string());
   if (!doc_range_stat_) {
-    LOG_ERROR("Failed to create doc range stats from %s", ID().c_str());
+    LOG_ERROR("Failed to create doc range stats from %s", id().c_str());
     return Status::InternalError();
   }
 
-  LOG_INFO("Generated statistical indexes in %s", ID().c_str());
+  LOG_INFO("Generated statistical indexes in %s", id().c_str());
   return Status::OK();
 }
 
@@ -439,14 +439,14 @@ Status InvertedColumnIndexer::seal() {
 
   Status status = flush_special_values();
   if (!status.ok()) {
-    LOG_ERROR("Failed to flush special values to %s", ID().c_str());
+    LOG_ERROR("Failed to flush special values to %s", id().c_str());
     return status;
   }
 
   if (enable_range_optimization_) {
     status = generate_statistical_indexes();
     if (!status.ok()) {
-      LOG_ERROR("Failed to generate statistical indexes in %s", ID().c_str());
+      LOG_ERROR("Failed to generate statistical indexes in %s", id().c_str());
       return status;
     }
   }
@@ -457,7 +457,7 @@ Status InvertedColumnIndexer::seal() {
     read_only_ = true;
     return Status::OK();
   } else {
-    LOG_ERROR("Failed to seal %s", ID().c_str());
+    LOG_ERROR("Failed to seal %s", id().c_str());
     return Status::InternalError();
   }
 }
diff --git a/src/db/index/column/inverted_column/inverted_indexer.cc b/src/db/index/column/inverted_column/inverted_indexer.cc
index b7390793a..1ee86ba7d 100644
--- a/src/db/index/column/inverted_column/inverted_indexer.cc
+++ b/src/db/index/column/inverted_column/inverted_indexer.cc
@@ -64,7 +64,7 @@ Status InvertedIndexer::open(bool create_dir_if_missing, bool read_only) {
   }
 
   if (!s.ok()) {
-    LOG_ERROR("Failed to open %s", ID().c_str());
+    LOG_ERROR("Failed to open %s", id().c_str());
     return s;
   }
 
@@ -79,7 +79,7 @@ Status InvertedIndexer::open(bool create_dir_if_missing, bool read_only) {
     indexers_.emplace(field.name(), std::move(column_indexer));
   }
 
-  LOG_INFO("Opened %s", ID().c_str());
+  LOG_INFO("Opened %s", id().c_str());
   return s;
 }
 
@@ -90,16 +90,16 @@ Status InvertedIndexer::flush() {
       continue;
     }
     if (!indexer->flush_special_values().ok()) {
-      LOG_ERROR("Failed to flush %s", indexer->ID().c_str());
+      LOG_ERROR("Failed to flush %s", indexer->id().c_str());
       return Status::InternalError();
     }
   }
 
   auto s = rocksdb_context_.flush();
   if (s.ok()) {
-    LOG_INFO("Flushed %s", ID().c_str());
+    LOG_INFO("Flushed %s", id().c_str());
   } else {
-    LOG_ERROR("Failed to flush %s", ID().c_str());
+    LOG_ERROR("Failed to flush %s", id().c_str());
   }
   return s;
 }
@@ -109,16 +109,16 @@ Status InvertedIndexer::create_snapshot(const std::string &snapshot_dir) {
   Status s;
   if (!rocksdb_context_.read_only()) {
     if (s = flush(); !s.ok()) {
-      LOG_ERROR("Failed to flush %s during creating a snapshot", ID().c_str());
+      LOG_ERROR("Failed to flush %s during creating a snapshot", id().c_str());
       return s;
     }
   }
 
   if (s = rocksdb_context_.create_checkpoint(snapshot_dir); s.ok()) {
-    LOG_INFO("Created snapshot[%s] of %s", snapshot_dir.c_str(), ID().c_str());
+    LOG_INFO("Created snapshot[%s] of %s", snapshot_dir.c_str(), id().c_str());
   } else {
     LOG_ERROR("Failed to create snapshot[%s] of %s", snapshot_dir.c_str(),
-              ID().c_str());
+              id().c_str());
   }
   return s;
 }
@@ -131,19 +131,19 @@ Status InvertedIndexer::seal() {
       continue;
     }
     if (s = indexer->seal(); !s.ok()) {
-      LOG_ERROR("Failed to seal %s", indexer->ID().c_str());
+      LOG_ERROR("Failed to seal %s", indexer->id().c_str());
     }
   }
 
   if (s = flush(); !s.ok()) {
-    LOG_ERROR("Failed to flush %s during sealing", ID().c_str());
+    LOG_ERROR("Failed to flush %s during sealing", id().c_str());
     return s;
   }
 
   if (s = rocksdb_context_.compact(); s.ok()) {
-    LOG_INFO("Sealed %s", ID().c_str());
+    LOG_INFO("Sealed %s", id().c_str());
   } else {
-    LOG_ERROR("Failed to compact %s during sealing", ID().c_str());
+    LOG_ERROR("Failed to compact %s during sealing", id().c_str());
   }
   return s;
 }
@@ -159,7 +159,7 @@ Status InvertedIndexer::create_column_indexer(const FieldSchema &field) {
                          });
   if (it != fields_.end()) {
     LOG_ERROR("InvertedColumnIndexer[%s] already exists in %s",
-              field.name().c_str(), ID().c_str());
+              field.name().c_str(), id().c_str());
     return Status::InvalidArgument();
   }
   auto params =
@@ -173,7 +173,7 @@ Status InvertedIndexer::create_column_indexer(const FieldSchema &field) {
   AILEGO_DEFER([&]() {
     if (s.ok()) {
       LOG_INFO("Created a new InvertedColumnIndexer[%s] in %s",
-               field.name().c_str(), ID().c_str());
+               field.name().c_str(), id().c_str());
     } else {
       if (cf_terms_created) {
         rocksdb_context_.drop_cf(field.name() + INVERT_SUFFIX_TERMS);
@@ -188,7 +188,7 @@ Status InvertedIndexer::create_column_indexer(const FieldSchema &field) {
         rocksdb_context_.drop_cf(field.name() + INVERT_SUFFIX_REVERSED_TERMS);
       }
       LOG_ERROR("Failed to create InvertedColumnIndexer[%s] in %s",
-                field.name().c_str(), ID().c_str());
+                field.name().c_str(), id().c_str());
     }
   });
 
@@ -244,24 +244,24 @@ Status InvertedIndexer::remove_column_indexer(const std::string &field_name) {
   auto column_indexer = (*this)[field_name];
   if (it == fields_.end() && !column_indexer) {
     LOG_ERROR("InvertedColumnIndexer[%s] doesn't exists in %s",
-              field_name.c_str(), ID().c_str());
+              field_name.c_str(), id().c_str());
     return Status::NotFound();
   }
   if (it == fields_.end() || !column_indexer) {
-    LOG_ERROR("%s is in corrupted state", ID().c_str());
+    LOG_ERROR("%s is in corrupted state", id().c_str());
     return Status::InternalError();
   }
 
   if (auto s = column_indexer->drop_storage(); !s.ok()) {
     LOG_ERROR("Failed to remove InvertedColumnIndexer[%s] in %s",
-              field_name.c_str(), ID().c_str());
+              field_name.c_str(), id().c_str());
     return s;
   }
 
   fields_.erase(it);
   indexers_.erase(field_name);
   LOG_INFO("Removed InvertedColumnIndexer[%s] in %s", field_name.c_str(),
-           ID().c_str());
+           id().c_str());
   return Status::OK();
 }
 
diff --git a/src/db/index/column/inverted_column/inverted_indexer.h b/src/db/index/column/inverted_column/inverted_indexer.h
index 19c7b392d..c89b11068 100644
--- a/src/db/index/column/inverted_column/inverted_indexer.h
+++ b/src/db/index/column/inverted_column/inverted_indexer.h
@@ -38,7 +38,7 @@ class InvertedIndexer {
 
   virtual ~InvertedIndexer() {
     rocksdb_context_.close();
-    LOG_INFO("Closed %s", ID().c_str());
+    LOG_INFO("Closed %s", id().c_str());
   }
 
 
@@ -84,7 +84,7 @@ class InvertedIndexer {
     return working_dir_;
   }
 
-  inline const std::string ID() const {
+  inline const std::string id() const {
     return "InvertedIndexer[collection:" + collection_name_ + "|path:'" +
            working_dir_ + "']";
   }
diff --git a/src/db/index/column/inverted_column/inverted_rocksdb_merger.h b/src/db/index/column/inverted_column/inverted_rocksdb_merger.h
index 8d5a35651..4a58e0572 100644
--- a/src/db/index/column/inverted_column/inverted_rocksdb_merger.h
+++ b/src/db/index/column/inverted_column/inverted_rocksdb_merger.h
@@ -57,7 +57,7 @@ class InvertedRocksdbValueMerger : public rocksdb::MergeOperator {
     AILEGO_DEFER([&]() { roaring_bitmap_free(bitmap); });
 
     for (const rocksdb::Slice &m : merge_in.operand_list) {
-      s = InvertedIndexCodec::Merge_OR(m.data(), m.size(), true, bitmap);
+      s = InvertedIndexCodec::merge_or(m.data(), m.size(), true, bitmap);
       if (!s.ok()) {
         LOG_ERROR("Failed to merge bitmap");
         return false;
@@ -88,7 +88,7 @@ class InvertedRocksdbValueMerger : public rocksdb::MergeOperator {
     }
     AILEGO_DEFER([&]() { roaring_bitmap_free(bitmap); });
 
-    s = InvertedIndexCodec::Merge_OR(right_operand.data(), right_operand.size(),
+    s = InvertedIndexCodec::merge_or(right_operand.data(), right_operand.size(),
                                      false, bitmap);
     if (!s.ok()) {
       LOG_ERROR("Failed to merge bitmap");
diff --git a/src/db/index/column/inverted_column/inverted_search_result.h b/src/db/index/column/inverted_column/inverted_search_result.h
index 89828626c..9fede9768 100644
--- a/src/db/index/column/inverted_column/inverted_search_result.h
+++ b/src/db/index/column/inverted_column/inverted_search_result.h
@@ -170,6 +170,8 @@ class InvertedSearchResult
   }
 
 
+  // Set-algebra op; 'and' is a C++ keyword so the method keeps an upper name.
+  // NOLINTNEXTLINE(readability-identifier-naming)
   void AND(const InvertedSearchResult &other) {
     if (!bitmap_ || !other.bitmap_) {
       destroy_bitmap();
@@ -179,6 +181,8 @@ class InvertedSearchResult
   }
 
 
+  // Set-algebra op; 'or' is a C++ keyword so the method keeps an upper name.
+  // NOLINTNEXTLINE(readability-identifier-naming)
   void OR(const InvertedSearchResult &other) {
     if (!other.bitmap_) {
       return;
diff --git a/src/db/index/column/vector_column/combined_vector_column_indexer.cc b/src/db/index/column/vector_column/combined_vector_column_indexer.cc
index 31a38526f..5af6fefeb 100644
--- a/src/db/index/column/vector_column/combined_vector_column_indexer.cc
+++ b/src/db/index/column/vector_column/combined_vector_column_indexer.cc
@@ -55,7 +55,7 @@ class VectorResultAccumulator {
  public:
   // Collect plain topk results from each block after translating block-local
   // doc IDs back to segment-level IDs.
-  void AddBlock(uint32_t block_offset, VectorIndexResults *results) {
+  void add_block(uint32_t block_offset, VectorIndexResults *results) {
     auto &docs = results->docs();
     auto &reverted_vectors = results->reverted_vector_list();
     auto &reverted_sparse_values = results->reverted_sparse_values_list();
@@ -77,7 +77,7 @@ class VectorResultAccumulator {
     }
   }
 
-  IndexResults::Ptr Finish(bool is_sparse, MetricType metric_type,
+  IndexResults::Ptr finish(bool is_sparse, MetricType metric_type,
                            uint32_t topk) {
     // Finish turns accumulated block docs into the public result format:
     // rank all docs globally, keep topk, then split ResultDoc back into the
@@ -131,7 +131,7 @@ class GroupResultAccumulator {
  public:
   // Merge same-named groups across blocks. The per-doc payload stays inside
   // ResultDoc until the final GroupVectorIndexResults is materialized.
-  void AddBlock(uint32_t block_offset, GroupVectorIndexResults *results) {
+  void add_block(uint32_t block_offset, GroupVectorIndexResults *results) {
     auto &groups = results->groups();
     auto &reverted_vectors = results->reverted_vector_list();
     auto &reverted_sparse_values = results->reverted_sparse_values_list();
@@ -166,7 +166,7 @@ class GroupResultAccumulator {
     return docs_by_group_.empty();
   }
 
-  IndexResults::Ptr Finish(MetricType metric_type, uint32_t group_topk,
+  IndexResults::Ptr finish(MetricType metric_type, uint32_t group_topk,
                            uint32_t group_count) {
     // Finish first ranks docs inside each merged group and trims group_topk.
     // It then ranks groups by their best remaining doc, trims group_count, and
@@ -286,7 +286,7 @@ CombinedVectorColumnIndexer::CombinedVectorColumnIndexer(
   min_doc_id_ = segment_meta.min_doc_id();
 }
 
-Result<IndexResults::Ptr> CombinedVectorColumnIndexer::Search(
+Result<IndexResults::Ptr> CombinedVectorColumnIndexer::search(
     const vector_column_params::VectorData &vector_data,
     const vector_column_params::QueryParams &query_params) {
   // Search runs each block with block-local query params, then folds those
@@ -381,7 +381,7 @@ Result<IndexResults::Ptr> CombinedVectorColumnIndexer::Search(
       modified_query_params.bf_pks.emplace_back(block_bf_pks[i]);
     }
 
-    result = indexers_[i]->Search(vector_data, modified_query_params);
+    result = indexers_[i]->search(vector_data, modified_query_params);
     if (!result) {
       return tl::make_unexpected(result.error());
     }
@@ -391,14 +391,14 @@ Result<IndexResults::Ptr> CombinedVectorColumnIndexer::Search(
     GroupVectorIndexResults *group_index_results =
         dynamic_cast<GroupVectorIndexResults *>(index_results.get());
     if (group_index_results != nullptr) {
-      group_results.AddBlock(block_offsets_[i], group_index_results);
+      group_results.add_block(block_offsets_[i], group_index_results);
       continue;
     }
 
     VectorIndexResults *vector_index_results =
         dynamic_cast<VectorIndexResults *>(index_results.get());
     if (vector_index_results != nullptr) {
-      vector_results.AddBlock(block_offsets_[i], vector_index_results);
+      vector_results.add_block(block_offsets_[i], vector_index_results);
     }
   }
 
@@ -407,14 +407,14 @@ Result<IndexResults::Ptr> CombinedVectorColumnIndexer::Search(
         query_params.group_by ? query_params.group_by->group_topk : 0;
     const uint32_t group_count =
         query_params.group_by ? query_params.group_by->group_count : 0;
-    return group_results.Finish(metric_type_, group_topk, group_count);
+    return group_results.finish(metric_type_, group_topk, group_count);
   }
-  return vector_results.Finish(field_schema_.is_sparse_vector(), metric_type_,
+  return vector_results.finish(field_schema_.is_sparse_vector(), metric_type_,
                                query_params.topk);
 }
 
 Result<vector_column_params::VectorDataBuffer>
-CombinedVectorColumnIndexer::Fetch(uint32_t segment_doc_id) const {
+CombinedVectorColumnIndexer::fetch(uint32_t segment_doc_id) const {
   int32_t target_block_doc_id = -1;
   size_t target_block_idx = 0;
 
@@ -437,7 +437,7 @@ CombinedVectorColumnIndexer::Fetch(uint32_t segment_doc_id) const {
   }
 
   auto indexer = indexers_[target_block_idx];
-  return indexer->Fetch(target_block_doc_id);
+  return indexer->fetch(target_block_doc_id);
 }
 
 }  // namespace zvec
diff --git a/src/db/index/column/vector_column/combined_vector_column_indexer.h b/src/db/index/column/vector_column/combined_vector_column_indexer.h
index c407b9bee..b4556c1ca 100644
--- a/src/db/index/column/vector_column/combined_vector_column_indexer.h
+++ b/src/db/index/column/vector_column/combined_vector_column_indexer.h
@@ -34,11 +34,11 @@ class CombinedVectorColumnIndexer {
 
   virtual ~CombinedVectorColumnIndexer() = default;
 
-  virtual Result<IndexResults::Ptr> Search(
+  virtual Result<IndexResults::Ptr> search(
       const vector_column_params::VectorData &vector_data,
       const vector_column_params::QueryParams &query_params);
 
-  virtual Result<vector_column_params::VectorDataBuffer> Fetch(
+  virtual Result<vector_column_params::VectorDataBuffer> fetch(
       uint32_t segment_doc_id) const;
 
 
diff --git a/src/db/index/column/vector_column/vector_column_indexer.cc b/src/db/index/column/vector_column/vector_column_indexer.cc
index 1caa9964b..d44b6dd48 100644
--- a/src/db/index/column/vector_column/vector_column_indexer.cc
+++ b/src/db/index/column/vector_column/vector_column_indexer.cc
@@ -20,7 +20,7 @@
 
 namespace zvec {
 
-Status VectorColumnIndexer::Open(
+Status VectorColumnIndexer::open(
     const vector_column_params::ReadOptions &read_options) {
   if (index != nullptr) {
     return Status::InvalidArgument("Index already opened");
@@ -28,13 +28,13 @@ Status VectorColumnIndexer::Open(
 
   // TODO: pass read_options to proxima index
   if (engine_name_ == "proxima") {
-    return CreateProximaIndex(read_options);
+    return create_proxima_index(read_options);
   } else {
     return Status::InvalidArgument("Engine name not supported");
   }
 }
 
-Status VectorColumnIndexer::CreateProximaIndex(
+Status VectorColumnIndexer::create_proxima_index(
     const vector_column_params::ReadOptions &read_options) {
   auto index_param_result =
       ProximaEngineHelper::convert_to_engine_index_param(field_schema_);
@@ -62,7 +62,7 @@ Status VectorColumnIndexer::CreateProximaIndex(
   return Status::OK();
 }
 
-Status VectorColumnIndexer::Flush() {
+Status VectorColumnIndexer::flush() {
   if (index == nullptr) {
     return Status::InvalidArgument("Index not opened");
   }
@@ -74,7 +74,7 @@ Status VectorColumnIndexer::Flush() {
 }
 
 
-Status VectorColumnIndexer::Close() {
+Status VectorColumnIndexer::close() {
   if (index == nullptr) {
     return Status::InvalidArgument("Index not opened");
   }
@@ -86,12 +86,12 @@ Status VectorColumnIndexer::Close() {
   return Status::OK();
 }
 
-Status VectorColumnIndexer::Destroy() {
+Status VectorColumnIndexer::destroy() {
   if (index == nullptr) {
     return Status::InvalidArgument("Index not opened");
   }
 
-  if (Close() != Status::OK()) {
+  if (close() != Status::OK()) {
     return Status::InternalError("Failed to close index");
   }
   if (!ailego::File::RemovePath(index_file_path_)) {
@@ -100,7 +100,7 @@ Status VectorColumnIndexer::Destroy() {
   return Status::OK();
 }
 
-Status VectorColumnIndexer::Merge(
+Status VectorColumnIndexer::merge(
     const std::vector<VectorColumnIndexer::Ptr> &indexers,
     const IndexFilter::Ptr &filter,
     const vector_column_params::MergeOptions &merge_options) {
@@ -133,7 +133,7 @@ Status VectorColumnIndexer::Merge(
   return Status::OK();
 }
 
-Status VectorColumnIndexer::Insert(
+Status VectorColumnIndexer::insert(
     const vector_column_params::VectorData &vector_data, uint32_t doc_id) {
   if (index == nullptr) {
     return Status::InvalidArgument("Index not opened");
@@ -147,7 +147,7 @@ Status VectorColumnIndexer::Insert(
   return Status::OK();
 }
 
-Result<vector_column_params::VectorDataBuffer> VectorColumnIndexer::Fetch(
+Result<vector_column_params::VectorDataBuffer> VectorColumnIndexer::fetch(
     uint32_t doc_id) const {
   if (index == nullptr) {
     return tl::make_unexpected(Status::InvalidArgument("Index not opened"));
@@ -164,7 +164,7 @@ Result<vector_column_params::VectorDataBuffer> VectorColumnIndexer::Fetch(
       .value();
 }
 
-Result<IndexResults::Ptr> VectorColumnIndexer::Search(
+Result<IndexResults::Ptr> VectorColumnIndexer::search(
     const vector_column_params::VectorData &vector_data,
     const vector_column_params::QueryParams &query_params) {
   if (index == nullptr) {
diff --git a/src/db/index/column/vector_column/vector_column_indexer.h b/src/db/index/column/vector_column/vector_column_indexer.h
index c37d37a37..a03e099e0 100644
--- a/src/db/index/column/vector_column/vector_column_indexer.h
+++ b/src/db/index/column/vector_column/vector_column_indexer.h
@@ -53,20 +53,20 @@ class VectorColumnIndexer {
   virtual ~VectorColumnIndexer() = default;
 
  public:
-  Status Open(const vector_column_params::ReadOptions &read_options);
+  Status open(const vector_column_params::ReadOptions &read_options);
 
-  Status Flush();
+  Status flush();
 
   // Close will call Flush()
-  Status Close();
+  Status close();
 
   // Destroy will call Close() and remove index file
-  Status Destroy();
+  Status destroy();
 
 
   // If HNSWIndexer.merge([FlatIndexer1, FlatIndexer2])
   // then the merged indexer is a HNSWIndexer
-  Status Merge(const std::vector<VectorColumnIndexer::Ptr> &indexers,
+  Status merge(const std::vector<VectorColumnIndexer::Ptr> &indexers,
                const IndexFilter::Ptr &filter = nullptr,
                const vector_column_params::MergeOptions &merge_options = {});
   // TODO: should we use this function? or a Reducer?
@@ -74,18 +74,18 @@ class VectorColumnIndexer {
 
 
   //! Insert vector
-  Status Insert(const vector_column_params::VectorData &vector_data,
+  Status insert(const vector_column_params::VectorData &vector_data,
                 uint32_t doc_id);
   // TODO: batch insert
 
-  virtual Result<IndexResults::Ptr> Search(
+  virtual Result<IndexResults::Ptr> search(
       const vector_column_params::VectorData &vector_data,
       const vector_column_params::QueryParams &query_params);
   // Result<std::vector<IndexResults::Ptr>> BatchSearch(
   //     const VectorDataset &vector_data,
   //     const  vector_column_params::QueryParams &query_params);
 
-  Result<vector_column_params::VectorDataBuffer> Fetch(uint32_t doc_id) const;
+  Result<vector_column_params::VectorDataBuffer> fetch(uint32_t doc_id) const;
   // Result<VectorDataset> BatchFetch(const std::vector<uint32_t> &doc_ids)
   // const;
 
@@ -125,7 +125,7 @@ class VectorColumnIndexer {
 
   // proxima or other engine index param like VSAGE
   // build proxima index
-  Status CreateProximaIndex(
+  Status create_proxima_index(
       const vector_column_params::ReadOptions &read_options);
 
  protected:
diff --git a/src/db/index/common/doc.cc b/src/db/index/common/doc.cc
index 48742ba2f..55c462720 100644
--- a/src/db/index/common/doc.cc
+++ b/src/db/index/common/doc.cc
@@ -181,12 +181,12 @@ std::string vec_to_string(const std::vector<T> &v) {
 }
 
 template <class... Ts>
-struct overloaded : Ts... {
+struct Overloaded : Ts... {
   using Ts::operator()...;
 };
 
 template <class... Ts>
-overloaded(Ts...) -> overloaded<Ts...>;
+Overloaded(Ts...) -> Overloaded<Ts...>;
 
 
 }  // namespace
@@ -1112,7 +1112,7 @@ std::string Doc::to_detail_string() const {
     oss << "\"" << key << "\": ";
 
     std::visit(
-        overloaded{
+        Overloaded{
             [&](std::monostate) { oss << "null"; },
             [&](bool b) { oss << (b ? "true" : "false"); },
             [&](int32_t i) { oss << i; },
diff --git a/src/db/index/common/manifest/manifest_codec.cc b/src/db/index/common/manifest/manifest_codec.cc
index 06af8e43b..f5b16ea49 100644
--- a/src/db/index/common/manifest/manifest_codec.cc
+++ b/src/db/index/common/manifest/manifest_codec.cc
@@ -163,24 +163,24 @@ struct BaseParams {
 
 void EncodeBase(const BaseParams &base, std::string *out) {
   Writer w(out);
-  w.PutVarint(f_base::kMetricType,
-              static_cast<uint64_t>(
-                  wire::ToNumber(MetricTypeCodeBook::Get(base.metric_type))));
-  w.PutVarint(f_base::kQuantizeType,
-              static_cast<uint64_t>(wire::ToNumber(
-                  QuantizeTypeCodeBook::Get(base.quantize_type))));
+  w.put_varint(f_base::kMetricType,
+               static_cast<uint64_t>(
+                   wire::ToNumber(MetricTypeCodeBook::Get(base.metric_type))));
+  w.put_varint(f_base::kQuantizeType,
+               static_cast<uint64_t>(wire::ToNumber(
+                   QuantizeTypeCodeBook::Get(base.quantize_type))));
   if (base.has_quantizer_param) {
     std::string quantizer;
     Writer qw(&quantizer);
-    qw.PutBool(f_quantizer::kEnableRotate, base.enable_rotate);
-    w.PutMessage(f_base::kQuantizerParam, quantizer);
+    qw.put_bool(f_quantizer::kEnableRotate, base.enable_rotate);
+    w.put_message(f_base::kQuantizerParam, quantizer);
   }
 }
 
 BaseParams DecodeBase(std::string_view buf) {
   BaseParams base;
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_base::kMetricType:
         base.metric_type = MetricTypeCodeBook::Get(
@@ -193,7 +193,7 @@ BaseParams DecodeBase(std::string_view buf) {
       case f_base::kQuantizerParam: {
         base.has_quantizer_param = true;
         Reader qr(r.bytes());
-        while (qr.Next()) {
+        while (qr.next()) {
           if (qr.field() == f_quantizer::kEnableRotate) {
             base.enable_rotate = qr.bool_value();
           }
@@ -222,17 +222,17 @@ void EncodeHnsw(const HnswIndexParams *params, std::string *out) {
   std::string base;
   EncodeBase(MakeBase(params), &base);
   Writer w(out);
-  w.PutMessage(f_hnsw::kBase, base);
-  w.PutVarint(f_hnsw::kM, static_cast<uint64_t>(params->m()));
-  w.PutVarint(f_hnsw::kEfConstruction,
-              static_cast<uint64_t>(params->ef_construction()));
-  w.PutBool(f_hnsw::kUseContiguousMemory, params->use_contiguous_memory());
-  w.PutBool(f_hnsw::kUseFlatContiguousMemory,
-            params->use_flat_contiguous_memory());
+  w.put_message(f_hnsw::kBase, base);
+  w.put_varint(f_hnsw::kM, static_cast<uint64_t>(params->m()));
+  w.put_varint(f_hnsw::kEfConstruction,
+               static_cast<uint64_t>(params->ef_construction()));
+  w.put_bool(f_hnsw::kUseContiguousMemory, params->use_contiguous_memory());
+  w.put_bool(f_hnsw::kUseFlatContiguousMemory,
+             params->use_flat_contiguous_memory());
   if (params->flat_data_type() != DataType::VECTOR_FP32) {
-    w.PutVarint(f_hnsw::kFlatDataType,
-                static_cast<uint64_t>(wire::ToNumber(
-                    DataTypeCodeBook::Get(params->flat_data_type()))));
+    w.put_varint(f_hnsw::kFlatDataType,
+                 static_cast<uint64_t>(wire::ToNumber(
+                     DataTypeCodeBook::Get(params->flat_data_type()))));
   }
 }
 
@@ -244,7 +244,7 @@ HnswIndexParams::OPtr DecodeHnsw(std::string_view buf) {
   bool use_flat_contiguous_memory = false;
   DataType flat_data_type = DataType::VECTOR_FP32;
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_hnsw::kBase:
         base = DecodeBase(r.bytes());
@@ -286,16 +286,16 @@ void EncodeHnswRabitq(const HnswRabitqIndexParams *params, std::string *out) {
   std::string base_buf;
   EncodeBase(base, &base_buf);
   Writer w(out);
-  w.PutMessage(f_hnsw_rabitq::kBase, base_buf);
-  w.PutVarint(f_hnsw_rabitq::kM, static_cast<uint64_t>(params->m()));
-  w.PutVarint(f_hnsw_rabitq::kEfConstruction,
-              static_cast<uint64_t>(params->ef_construction()));
-  w.PutVarint(f_hnsw_rabitq::kTotalBits,
-              static_cast<uint64_t>(params->total_bits()));
-  w.PutVarint(f_hnsw_rabitq::kNumClusters,
-              static_cast<uint64_t>(params->num_clusters()));
-  w.PutVarint(f_hnsw_rabitq::kSampleCount,
-              static_cast<uint64_t>(params->sample_count()));
+  w.put_message(f_hnsw_rabitq::kBase, base_buf);
+  w.put_varint(f_hnsw_rabitq::kM, static_cast<uint64_t>(params->m()));
+  w.put_varint(f_hnsw_rabitq::kEfConstruction,
+               static_cast<uint64_t>(params->ef_construction()));
+  w.put_varint(f_hnsw_rabitq::kTotalBits,
+               static_cast<uint64_t>(params->total_bits()));
+  w.put_varint(f_hnsw_rabitq::kNumClusters,
+               static_cast<uint64_t>(params->num_clusters()));
+  w.put_varint(f_hnsw_rabitq::kSampleCount,
+               static_cast<uint64_t>(params->sample_count()));
 }
 
 HnswRabitqIndexParams::OPtr DecodeHnswRabitq(std::string_view buf) {
@@ -306,7 +306,7 @@ HnswRabitqIndexParams::OPtr DecodeHnswRabitq(std::string_view buf) {
   int32_t num_clusters = 0;
   int32_t sample_count = 0;
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_hnsw_rabitq::kBase:
         base = DecodeBase(r.bytes());
@@ -346,12 +346,12 @@ void EncodeIvfRabitq(const IvfRabitqIndexParams *params, std::string *out) {
   std::string base_buf;
   EncodeBase(base, &base_buf);
   Writer w(out);
-  w.PutMessage(f_ivf_rabitq::kBase, base_buf);
-  w.PutVarint(f_ivf_rabitq::kNList, static_cast<uint64_t>(params->nlist()));
-  w.PutVarint(f_ivf_rabitq::kTotalBits,
-              static_cast<uint64_t>(params->total_bits()));
-  w.PutVarint(f_ivf_rabitq::kSampleCount,
-              static_cast<uint64_t>(params->sample_count()));
+  w.put_message(f_ivf_rabitq::kBase, base_buf);
+  w.put_varint(f_ivf_rabitq::kNList, static_cast<uint64_t>(params->nlist()));
+  w.put_varint(f_ivf_rabitq::kTotalBits,
+               static_cast<uint64_t>(params->total_bits()));
+  w.put_varint(f_ivf_rabitq::kSampleCount,
+               static_cast<uint64_t>(params->sample_count()));
 }
 
 IvfRabitqIndexParams::OPtr DecodeIvfRabitq(std::string_view buf) {
@@ -360,7 +360,7 @@ IvfRabitqIndexParams::OPtr DecodeIvfRabitq(std::string_view buf) {
   int32_t total_bits = 0;
   int32_t sample_count = 0;
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_ivf_rabitq::kBase:
         base = DecodeBase(r.bytes());
@@ -386,12 +386,12 @@ void EncodeFlat(const FlatIndexParams *params, std::string *out) {
   std::string base;
   EncodeBase(MakeBase(params), &base);
   Writer w(out);
-  w.PutMessage(f_flat::kBase, base);
-  w.PutBool(f_flat::kUseContiguousMemory, params->use_contiguous_memory());
+  w.put_message(f_flat::kBase, base);
+  w.put_bool(f_flat::kUseContiguousMemory, params->use_contiguous_memory());
   if (params->storage_data_type() != DataType::UNDEFINED) {
-    w.PutVarint(f_flat::kStorageDataType,
-                static_cast<uint64_t>(wire::ToNumber(
-                    DataTypeCodeBook::Get(params->storage_data_type()))));
+    w.put_varint(f_flat::kStorageDataType,
+                 static_cast<uint64_t>(wire::ToNumber(
+                     DataTypeCodeBook::Get(params->storage_data_type()))));
   }
 }
 
@@ -400,7 +400,7 @@ FlatIndexParams::OPtr DecodeFlat(std::string_view buf) {
   bool use_contiguous_memory = false;
   DataType storage_data_type = DataType::UNDEFINED;
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_flat::kBase:
         base = DecodeBase(r.bytes());
@@ -425,10 +425,10 @@ void EncodeIvf(const IVFIndexParams *params, std::string *out) {
   std::string base;
   EncodeBase(MakeBase(params), &base);
   Writer w(out);
-  w.PutMessage(f_ivf::kBase, base);
-  w.PutVarint(f_ivf::kNList, static_cast<uint64_t>(params->n_list()));
-  w.PutVarint(f_ivf::kNIters, static_cast<uint64_t>(params->n_iters()));
-  w.PutBool(f_ivf::kUseSoar, params->use_soar());
+  w.put_message(f_ivf::kBase, base);
+  w.put_varint(f_ivf::kNList, static_cast<uint64_t>(params->n_list()));
+  w.put_varint(f_ivf::kNIters, static_cast<uint64_t>(params->n_iters()));
+  w.put_bool(f_ivf::kUseSoar, params->use_soar());
 }
 
 IVFIndexParams::OPtr DecodeIvf(std::string_view buf) {
@@ -437,7 +437,7 @@ IVFIndexParams::OPtr DecodeIvf(std::string_view buf) {
   int32_t n_iters = 0;
   bool use_soar = false;
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_ivf::kBase:
         base = DecodeBase(r.bytes());
@@ -464,12 +464,13 @@ void EncodeDiskAnn(const DiskAnnIndexParams *params, std::string *out) {
   std::string base;
   EncodeBase(MakeBase(params), &base);
   Writer w(out);
-  w.PutMessage(f_diskann::kBase, base);
-  w.PutVarint(f_diskann::kMaxDegree,
-              static_cast<uint64_t>(params->max_degree()));
-  w.PutVarint(f_diskann::kListSize, static_cast<uint64_t>(params->list_size()));
-  w.PutVarint(f_diskann::kPqChunkNum,
-              static_cast<uint64_t>(params->pq_chunk_num()));
+  w.put_message(f_diskann::kBase, base);
+  w.put_varint(f_diskann::kMaxDegree,
+               static_cast<uint64_t>(params->max_degree()));
+  w.put_varint(f_diskann::kListSize,
+               static_cast<uint64_t>(params->list_size()));
+  w.put_varint(f_diskann::kPqChunkNum,
+               static_cast<uint64_t>(params->pq_chunk_num()));
 }
 
 DiskAnnIndexParams::OPtr DecodeDiskAnn(std::string_view buf) {
@@ -478,7 +479,7 @@ DiskAnnIndexParams::OPtr DecodeDiskAnn(std::string_view buf) {
   int32_t list_size = 0;
   int32_t pq_chunk_num = 0;
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_diskann::kBase:
         base = DecodeBase(r.bytes());
@@ -505,22 +506,22 @@ void EncodeVamana(const VamanaIndexParams *params, std::string *out) {
   std::string base;
   EncodeBase(MakeBase(params), &base);
   Writer w(out);
-  w.PutMessage(f_vamana::kBase, base);
-  w.PutVarint(f_vamana::kMaxDegree,
-              static_cast<uint64_t>(params->max_degree()));
-  w.PutVarint(f_vamana::kSearchListSize,
-              static_cast<uint64_t>(params->search_list_size()));
-  w.PutFloat(f_vamana::kAlpha, params->alpha());
-  w.PutBool(f_vamana::kSaturateGraph, params->saturate_graph());
-  w.PutBool(f_vamana::kUseContiguousMemory, params->use_contiguous_memory());
-  w.PutBool(f_vamana::kUseIdMap, params->use_id_map());
-  w.PutBool(f_vamana::kTwoPassBuild, params->two_pass_build());
-  w.PutBool(f_vamana::kUseFlatContiguousMemory,
-            params->use_flat_contiguous_memory());
+  w.put_message(f_vamana::kBase, base);
+  w.put_varint(f_vamana::kMaxDegree,
+               static_cast<uint64_t>(params->max_degree()));
+  w.put_varint(f_vamana::kSearchListSize,
+               static_cast<uint64_t>(params->search_list_size()));
+  w.put_float(f_vamana::kAlpha, params->alpha());
+  w.put_bool(f_vamana::kSaturateGraph, params->saturate_graph());
+  w.put_bool(f_vamana::kUseContiguousMemory, params->use_contiguous_memory());
+  w.put_bool(f_vamana::kUseIdMap, params->use_id_map());
+  w.put_bool(f_vamana::kTwoPassBuild, params->two_pass_build());
+  w.put_bool(f_vamana::kUseFlatContiguousMemory,
+             params->use_flat_contiguous_memory());
   if (params->flat_data_type() != DataType::VECTOR_FP32) {
-    w.PutVarint(f_vamana::kFlatDataType,
-                static_cast<uint64_t>(wire::ToNumber(
-                    DataTypeCodeBook::Get(params->flat_data_type()))));
+    w.put_varint(f_vamana::kFlatDataType,
+                 static_cast<uint64_t>(wire::ToNumber(
+                     DataTypeCodeBook::Get(params->flat_data_type()))));
   }
 }
 
@@ -536,7 +537,7 @@ VamanaIndexParams::OPtr DecodeVamana(std::string_view buf) {
   bool use_flat_contiguous_memory = false;
   DataType flat_data_type = DataType::VECTOR_FP32;
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_vamana::kBase:
         base = DecodeBase(r.bytes());
@@ -582,17 +583,17 @@ VamanaIndexParams::OPtr DecodeVamana(std::string_view buf) {
 
 void EncodeInvert(const InvertIndexParams *params, std::string *out) {
   Writer w(out);
-  w.PutBool(f_invert::kEnableRangeOptimization,
-            params->enable_range_optimization());
-  w.PutBool(f_invert::kEnableExtendedWildcard,
-            params->enable_extended_wildcard());
+  w.put_bool(f_invert::kEnableRangeOptimization,
+             params->enable_range_optimization());
+  w.put_bool(f_invert::kEnableExtendedWildcard,
+             params->enable_extended_wildcard());
 }
 
 InvertIndexParams::OPtr DecodeInvert(std::string_view buf) {
   bool enable_range_optimization = false;
   bool enable_extended_wildcard = false;
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     if (r.field() == f_invert::kEnableRangeOptimization) {
       enable_range_optimization = r.bool_value();
     } else if (r.field() == f_invert::kEnableExtendedWildcard) {
@@ -605,11 +606,11 @@ InvertIndexParams::OPtr DecodeInvert(std::string_view buf) {
 
 void EncodeFts(const FtsIndexParams *params, std::string *out) {
   Writer w(out);
-  w.PutString(f_fts::kTokenizerName, params->tokenizer_name());
+  w.put_string(f_fts::kTokenizerName, params->tokenizer_name());
   for (const auto &filter : params->filters()) {
-    w.AddString(f_fts::kFilters, filter);
+    w.add_string(f_fts::kFilters, filter);
   }
-  w.PutString(f_fts::kExtraParams, params->extra_params());
+  w.put_string(f_fts::kExtraParams, params->extra_params());
 }
 
 FtsIndexParams::Ptr DecodeFts(std::string_view buf) {
@@ -617,7 +618,7 @@ FtsIndexParams::Ptr DecodeFts(std::string_view buf) {
   std::vector<std::string> filters;
   std::string extra_params;
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_fts::kTokenizerName:
         tokenizer_name = r.string_value();
@@ -649,55 +650,55 @@ void ManifestCodec::EncodeIndexParams(const IndexParams *params,
     case IndexType::INVERT:
       if (auto *p = dynamic_cast<const InvertIndexParams *>(params)) {
         EncodeInvert(p, &payload);
-        w.PutMessage(f_index_params::kInvert, payload);
+        w.put_message(f_index_params::kInvert, payload);
       }
       break;
     case IndexType::HNSW:
       if (auto *p = dynamic_cast<const HnswIndexParams *>(params)) {
         EncodeHnsw(p, &payload);
-        w.PutMessage(f_index_params::kHnsw, payload);
+        w.put_message(f_index_params::kHnsw, payload);
       }
       break;
     case IndexType::FLAT:
       if (auto *p = dynamic_cast<const FlatIndexParams *>(params)) {
         EncodeFlat(p, &payload);
-        w.PutMessage(f_index_params::kFlat, payload);
+        w.put_message(f_index_params::kFlat, payload);
       }
       break;
     case IndexType::IVF:
       if (auto *p = dynamic_cast<const IVFIndexParams *>(params)) {
         EncodeIvf(p, &payload);
-        w.PutMessage(f_index_params::kIvf, payload);
+        w.put_message(f_index_params::kIvf, payload);
       }
       break;
     case IndexType::HNSW_RABITQ:
       if (auto *p = dynamic_cast<const HnswRabitqIndexParams *>(params)) {
         EncodeHnswRabitq(p, &payload);
-        w.PutMessage(f_index_params::kHnswRabitq, payload);
+        w.put_message(f_index_params::kHnswRabitq, payload);
       }
       break;
     case IndexType::IVF_RABITQ:
       if (auto *p = dynamic_cast<const IvfRabitqIndexParams *>(params)) {
         EncodeIvfRabitq(p, &payload);
-        w.PutMessage(f_index_params::kIvfRabitq, payload);
+        w.put_message(f_index_params::kIvfRabitq, payload);
       }
       break;
     case IndexType::VAMANA:
       if (auto *p = dynamic_cast<const VamanaIndexParams *>(params)) {
         EncodeVamana(p, &payload);
-        w.PutMessage(f_index_params::kVamana, payload);
+        w.put_message(f_index_params::kVamana, payload);
       }
       break;
     case IndexType::FTS:
       if (auto *p = dynamic_cast<const FtsIndexParams *>(params)) {
         EncodeFts(p, &payload);
-        w.PutMessage(f_index_params::kFts, payload);
+        w.put_message(f_index_params::kFts, payload);
       }
       break;
     case IndexType::DISKANN:
       if (auto *p = dynamic_cast<const DiskAnnIndexParams *>(params)) {
         EncodeDiskAnn(p, &payload);
-        w.PutMessage(f_index_params::kDiskann, payload);
+        w.put_message(f_index_params::kDiskann, payload);
       }
       break;
     default:
@@ -709,7 +710,7 @@ IndexParams::Ptr ManifestCodec::DecodeIndexParams(std::string_view buf) {
   // oneof semantics: the last branch present on the wire wins.
   IndexParams::Ptr params;
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_index_params::kInvert:
         params = DecodeInvert(r.bytes());
@@ -748,24 +749,24 @@ IndexParams::Ptr ManifestCodec::DecodeIndexParams(std::string_view buf) {
 void ManifestCodec::EncodeFieldSchema(const FieldSchema &field,
                                       std::string *out) {
   Writer w(out);
-  w.PutString(f_field::kName, field.name());
-  w.PutVarint(f_field::kDataType,
-              static_cast<uint64_t>(
-                  wire::ToNumber(DataTypeCodeBook::Get(field.data_type()))));
-  w.PutVarint(f_field::kDimension, field.dimension());
-  w.PutBool(f_field::kNullable, field.nullable());
+  w.put_string(f_field::kName, field.name());
+  w.put_varint(f_field::kDataType,
+               static_cast<uint64_t>(
+                   wire::ToNumber(DataTypeCodeBook::Get(field.data_type()))));
+  w.put_varint(f_field::kDimension, field.dimension());
+  w.put_bool(f_field::kNullable, field.nullable());
   auto index_params = field.index_params();
   if (index_params) {
     std::string payload;
     EncodeIndexParams(index_params.get(), &payload);
-    w.PutMessage(f_field::kIndexParams, payload);
+    w.put_message(f_field::kIndexParams, payload);
   }
 }
 
 FieldSchema::Ptr ManifestCodec::DecodeFieldSchema(std::string_view buf) {
   auto field = std::make_shared<FieldSchema>();
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_field::kName:
         field->set_name(r.string_value());
@@ -793,14 +794,14 @@ FieldSchema::Ptr ManifestCodec::DecodeFieldSchema(std::string_view buf) {
 void ManifestCodec::EncodeCollectionSchema(const CollectionSchema &schema,
                                            std::string *out) {
   Writer w(out);
-  w.PutString(f_collection::kName, schema.name());
+  w.put_string(f_collection::kName, schema.name());
   for (const auto &field : schema.fields()) {
     std::string payload;
     EncodeFieldSchema(*field, &payload);
-    w.PutMessage(f_collection::kFields, payload);
+    w.put_message(f_collection::kFields, payload);
   }
-  w.PutVarint(f_collection::kMaxDocCountPerSegment,
-              schema.max_doc_count_per_segment());
+  w.put_varint(f_collection::kMaxDocCountPerSegment,
+               schema.max_doc_count_per_segment());
 }
 
 CollectionSchema::Ptr ManifestCodec::DecodeCollectionSchema(
@@ -811,7 +812,7 @@ CollectionSchema::Ptr ManifestCodec::DecodeCollectionSchema(
   // the C++ default. Mirror that to stay compatible with such manifests.
   schema->set_max_doc_count_per_segment(0);
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_collection::kName:
         schema->set_name(r.string_value());
@@ -831,21 +832,21 @@ CollectionSchema::Ptr ManifestCodec::DecodeCollectionSchema(
 
 void ManifestCodec::EncodeBlockMeta(const BlockMeta &meta, std::string *out) {
   Writer w(out);
-  w.PutVarint(f_block::kBlockId, meta.id());
-  w.PutVarint(f_block::kBlockType, static_cast<uint64_t>(wire::ToNumber(
-                                       BlockTypeCodeBook::Get(meta.type()))));
-  w.PutVarint(f_block::kMinDocId, meta.min_doc_id());
-  w.PutVarint(f_block::kMaxDocId, meta.max_doc_id());
-  w.PutVarint(f_block::kDocCount, meta.doc_count());
+  w.put_varint(f_block::kBlockId, meta.id());
+  w.put_varint(f_block::kBlockType, static_cast<uint64_t>(wire::ToNumber(
+                                        BlockTypeCodeBook::Get(meta.type()))));
+  w.put_varint(f_block::kMinDocId, meta.min_doc_id());
+  w.put_varint(f_block::kMaxDocId, meta.max_doc_id());
+  w.put_varint(f_block::kDocCount, meta.doc_count());
   for (const auto &column : meta.columns()) {
-    w.AddString(f_block::kColumns, column);
+    w.add_string(f_block::kColumns, column);
   }
 }
 
 BlockMeta::Ptr ManifestCodec::DecodeBlockMeta(std::string_view buf) {
   auto meta = std::make_shared<BlockMeta>();
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_block::kBlockId:
         meta->set_id(r.uint32_value());
@@ -876,26 +877,26 @@ BlockMeta::Ptr ManifestCodec::DecodeBlockMeta(std::string_view buf) {
 void ManifestCodec::EncodeSegmentMeta(const SegmentMeta &meta,
                                       std::string *out) {
   Writer w(out);
-  w.PutVarint(f_segment::kSegmentId, meta.id());
+  w.put_varint(f_segment::kSegmentId, meta.id());
   for (const auto &block : meta.persisted_blocks()) {
     std::string payload;
     EncodeBlockMeta(block, &payload);
-    w.PutMessage(f_segment::kPersistedBlocks, payload);
+    w.put_message(f_segment::kPersistedBlocks, payload);
   }
   if (meta.has_writing_forward_block()) {
     std::string payload;
     EncodeBlockMeta(meta.writing_forward_block().value(), &payload);
-    w.PutMessage(f_segment::kWritingForwardBlock, payload);
+    w.put_message(f_segment::kWritingForwardBlock, payload);
   }
   for (const auto &field : meta.indexed_vector_fields()) {
-    w.AddString(f_segment::kIndexedVectorFields, field);
+    w.add_string(f_segment::kIndexedVectorFields, field);
   }
 }
 
 SegmentMeta::Ptr ManifestCodec::DecodeSegmentMeta(std::string_view buf) {
   auto meta = std::make_shared<SegmentMeta>(0);
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_segment::kSegmentId:
         meta->set_id(r.uint32_value());
@@ -918,36 +919,36 @@ SegmentMeta::Ptr ManifestCodec::DecodeSegmentMeta(std::string_view buf) {
 
 Status ManifestCodec::Encode(const ManifestData &data, std::string *out) {
   Writer w(out);
-  w.PutVarint(f_manifest::kVersion, data.version);
+  w.put_varint(f_manifest::kVersion, data.version);
   if (data.schema) {
     std::string payload;
     EncodeCollectionSchema(*data.schema, &payload);
-    w.PutMessage(f_manifest::kSchema, payload);
+    w.put_message(f_manifest::kSchema, payload);
   }
-  w.PutBool(f_manifest::kEnableMmap, data.enable_mmap);
+  w.put_bool(f_manifest::kEnableMmap, data.enable_mmap);
   for (const auto &meta : data.persisted_segment_metas) {
     if (!meta) {
       continue;
     }
     std::string payload;
     EncodeSegmentMeta(*meta, &payload);
-    w.PutMessage(f_manifest::kPersistedSegmentMetas, payload);
+    w.put_message(f_manifest::kPersistedSegmentMetas, payload);
   }
   if (data.writing_segment_meta) {
     std::string payload;
     EncodeSegmentMeta(*data.writing_segment_meta, &payload);
-    w.PutMessage(f_manifest::kWritingSegmentMeta, payload);
+    w.put_message(f_manifest::kWritingSegmentMeta, payload);
   }
-  w.PutVarint(f_manifest::kIdMapPathSuffix, data.id_map_path_suffix);
-  w.PutVarint(f_manifest::kDeleteSnapshotPathSuffix,
-              data.delete_snapshot_path_suffix);
-  w.PutVarint(f_manifest::kNextSegmentId, data.next_segment_id);
+  w.put_varint(f_manifest::kIdMapPathSuffix, data.id_map_path_suffix);
+  w.put_varint(f_manifest::kDeleteSnapshotPathSuffix,
+               data.delete_snapshot_path_suffix);
+  w.put_varint(f_manifest::kNextSegmentId, data.next_segment_id);
   return Status::OK();
 }
 
 Status ManifestCodec::Decode(std::string_view buf, ManifestData *data) {
   Reader r(buf);
-  while (r.Next()) {
+  while (r.next()) {
     switch (r.field()) {
       case f_manifest::kVersion:
         data->version = r.uint32_value();
diff --git a/src/db/index/common/manifest/pb_wire.cc b/src/db/index/common/manifest/pb_wire.cc
index 8fe647e7b..d9d4e98f6 100644
--- a/src/db/index/common/manifest/pb_wire.cc
+++ b/src/db/index/common/manifest/pb_wire.cc
@@ -18,26 +18,26 @@
 namespace zvec {
 namespace pbwire {
 
-bool Reader::Next() {
+bool Reader::next() {
   if (!ok_ || pos_ >= size_) {
     return false;
   }
   uint64_t tag = 0;
-  if (!ReadVarintRaw(&tag)) {
-    return Fail();
+  if (!read_varint_raw(&tag)) {
+    return fail();
   }
   field_ = static_cast<uint32_t>(tag >> 3);
   type_ = static_cast<WireType>(tag & 0x7);
   if (field_ == 0) {
-    return Fail();  // field number 0 is illegal
+    return fail();  // field number 0 is illegal
   }
 
   switch (type_) {
     case kVarint:
-      return ReadVarintRaw(&varint_) ? true : Fail();
+      return read_varint_raw(&varint_) ? true : fail();
     case kFixed64: {
       if (size_ - pos_ < 8) {
-        return Fail();
+        return fail();
       }
       uint64_t bits = 0;
       for (int i = 0; i < 8; ++i) {
@@ -50,7 +50,7 @@ bool Reader::Next() {
     }
     case kFixed32: {
       if (size_ - pos_ < 4) {
-        return Fail();
+        return fail();
       }
       uint32_t bits = 0;
       for (int i = 0; i < 4; ++i) {
@@ -63,22 +63,22 @@ bool Reader::Next() {
     }
     case kLenDelim: {
       uint64_t len = 0;
-      if (!ReadVarintRaw(&len)) {
-        return Fail();
+      if (!read_varint_raw(&len)) {
+        return fail();
       }
       if (len > size_ - pos_) {
-        return Fail();
+        return fail();
       }
       bytes_ = std::string_view(data_ + pos_, static_cast<size_t>(len));
       pos_ += static_cast<size_t>(len);
       return true;
     }
     default:
-      return Fail();  // groups and unknown wire types
+      return fail();  // groups and unknown wire types
   }
 }
 
-bool Reader::ReadVarintRaw(uint64_t *out) {
+bool Reader::read_varint_raw(uint64_t *out) {
   uint64_t result = 0;
   for (int shift = 0; shift < 64; shift += 7) {
     if (pos_ >= size_) {
diff --git a/src/db/index/common/manifest/pb_wire.h b/src/db/index/common/manifest/pb_wire.h
index 1c5d27b7a..aa26e235c 100644
--- a/src/db/index/common/manifest/pb_wire.h
+++ b/src/db/index/common/manifest/pb_wire.h
@@ -59,73 +59,73 @@ class Writer {
 
   //! Writes a varint field. Skipped when the value is zero, matching proto3
   //! semantics where default-valued singular fields are not serialized.
-  void PutVarint(uint32_t field, uint64_t value) {
+  void put_varint(uint32_t field, uint64_t value) {
     if (value == 0) {
       return;
     }
-    PutVarintAlways(field, value);
+    put_varint_always(field, value);
   }
 
   //! Writes a bool field. Skipped when false (proto3 default).
-  void PutBool(uint32_t field, bool value) {
+  void put_bool(uint32_t field, bool value) {
     if (!value) {
       return;
     }
-    PutVarintAlways(field, 1);
+    put_varint_always(field, 1);
   }
 
   //! Writes a float field as fixed32. Skipped when the value is +0.0f
   //! (proto3 default). Note -0.0f compares equal to 0.0f and is therefore
   //! also skipped, which matches the protobuf library behaviour.
-  void PutFloat(uint32_t field, float value) {
+  void put_float(uint32_t field, float value) {
     if (value == 0.0f) {
       return;
     }
-    PutTag(field, kFixed32);
+    put_tag(field, kFixed32);
     uint32_t bits;
     std::memcpy(&bits, &value, sizeof(bits));
-    PutLittleEndian32(bits);
+    put_little_endian32(bits);
   }
 
   //! Writes a singular string field. Skipped when empty (proto3 default).
-  void PutString(uint32_t field, const std::string &value) {
+  void put_string(uint32_t field, const std::string &value) {
     if (value.empty()) {
       return;
     }
-    PutLenDelim(field, value);
+    put_len_delim(field, value);
   }
 
   //! Writes one element of a repeated string field. Unlike singular fields,
   //! repeated elements are always written, including empty strings.
-  void AddString(uint32_t field, const std::string &value) {
-    PutLenDelim(field, value);
+  void add_string(uint32_t field, const std::string &value) {
+    put_len_delim(field, value);
   }
 
   //! Writes a length-delimited field holding an already encoded sub-message.
   //! Always written, including when the payload is empty: an empty but
   //! present sub-message is encoded as a zero-length field by protobuf.
-  void PutMessage(uint32_t field, std::string_view encoded) {
-    PutLenDelim(field, encoded);
+  void put_message(uint32_t field, std::string_view encoded) {
+    put_len_delim(field, encoded);
   }
 
  private:
-  void PutTag(uint32_t field, WireType type) {
-    PutVarintRaw((static_cast<uint64_t>(field) << 3) |
-                 static_cast<uint64_t>(type));
+  void put_tag(uint32_t field, WireType type) {
+    put_varint_raw((static_cast<uint64_t>(field) << 3) |
+                   static_cast<uint64_t>(type));
   }
 
-  void PutVarintAlways(uint32_t field, uint64_t value) {
-    PutTag(field, kVarint);
-    PutVarintRaw(value);
+  void put_varint_always(uint32_t field, uint64_t value) {
+    put_tag(field, kVarint);
+    put_varint_raw(value);
   }
 
-  void PutLenDelim(uint32_t field, std::string_view value) {
-    PutTag(field, kLenDelim);
-    PutVarintRaw(value.size());
+  void put_len_delim(uint32_t field, std::string_view value) {
+    put_tag(field, kLenDelim);
+    put_varint_raw(value.size());
     out_->append(value.data(), value.size());
   }
 
-  void PutVarintRaw(uint64_t value) {
+  void put_varint_raw(uint64_t value) {
     while (value >= 0x80) {
       out_->push_back(static_cast<char>((value & 0x7F) | 0x80));
       value >>= 7;
@@ -133,7 +133,7 @@ class Writer {
     out_->push_back(static_cast<char>(value));
   }
 
-  void PutLittleEndian32(uint32_t value) {
+  void put_little_endian32(uint32_t value) {
     for (int i = 0; i < 4; ++i) {
       out_->push_back(static_cast<char>(value & 0xFF));
       value >>= 8;
@@ -157,7 +157,7 @@ class Reader {
 
   //! Advances to the next field. Returns false at end of buffer or on error;
   //! use ok() to distinguish the two.
-  bool Next();
+  bool next();
 
   uint32_t field() const {
     return field_;
@@ -207,12 +207,12 @@ class Reader {
   }
 
  private:
-  bool Fail() {
+  bool fail() {
     ok_ = false;
     return false;
   }
 
-  bool ReadVarintRaw(uint64_t *out);
+  bool read_varint_raw(uint64_t *out);
 
   const char *data_;
   size_t size_;
diff --git a/src/db/index/segment/segment.cc b/src/db/index/segment/segment.cc
index efc27f758..eb847ff27 100644
--- a/src/db/index/segment/segment.cc
+++ b/src/db/index/segment/segment.cc
@@ -138,17 +138,17 @@ class SegmentImpl : public Segment,
 
   bool has_record() override;
 
-  Status Insert(Doc &doc) override;
+  Status insert(Doc &doc) override;
 
-  Status Update(Doc &doc) override;
+  Status update(Doc &doc) override;
 
-  Status Upsert(Doc &doc) override;
+  Status upsert(Doc &doc) override;
 
   Status Delete(const std::string &pk) override;
 
   Status Delete(uint64_t g_doc_id) override;
 
-  Doc::Ptr Fetch(uint64_t g_doc_id,
+  Doc::Ptr fetch(uint64_t g_doc_id,
                  const std::optional<std::vector<std::string>> &output_fields =
                      std::nullopt,
                  bool include_vector = true) override;
@@ -270,7 +270,7 @@ class SegmentImpl : public Segment,
 
  public:
   Status Open(const SegmentOptions &options);
-  Status Create(const SegmentOptions &options, uint64_t min_doc_id);
+  Status create(const SegmentOptions &options, uint64_t min_doc_id);
 
  private:
   Status close();
@@ -306,11 +306,11 @@ class SegmentImpl : public Segment,
 
   // Helper functions for Insert/Update/Upsert/Delete
   template <typename ValueType>
-  Status InsertScalar(InvertedColumnIndexer::Ptr &indexer, const Doc &doc,
-                      const FieldSchema::Ptr &field);
+  Status insert_scalar(InvertedColumnIndexer::Ptr &indexer, const Doc &doc,
+                       const FieldSchema::Ptr &field);
   template <typename ValueType>
-  Status InsertVector(VectorColumnIndexer::Ptr &indexer, const Doc &doc,
-                      const FieldSchema::Ptr &field);
+  Status insert_vector(VectorColumnIndexer::Ptr &indexer, const Doc &doc,
+                       const FieldSchema::Ptr &field);
 
   Status insert_scalar_indexer(Doc &doc);
   Status insert_fts_indexer(Doc &doc);
@@ -546,7 +546,7 @@ Status SegmentImpl::Open(const SegmentOptions &options) {
   return Status::OK();
 }
 
-Status SegmentImpl::Create(const SegmentOptions &options, uint64_t min_doc_id) {
+Status SegmentImpl::create(const SegmentOptions &options, uint64_t min_doc_id) {
   options_ = options;
   filter_ =
       std::make_shared<SegmentIndexFilter>(delete_store_, shared_from_this());
@@ -589,22 +589,22 @@ Status SegmentImpl::close() {
   close_fts_indexers();
   for (const auto &[name, indexers] : vector_indexers_) {
     for (auto indexer : indexers) {
-      indexer->Close();
+      indexer->close();
     }
   }
   vector_indexers_.clear();
   for (const auto &[name, indexers] : quant_vector_indexers_) {
     for (auto indexer : indexers) {
-      indexer->Close();
+      indexer->close();
     }
   }
   quant_vector_indexers_.clear();
   for (auto [name, indexer] : memory_vector_indexers_) {
-    indexer->Close();
+    indexer->close();
   }
   memory_vector_indexers_.clear();
   for (auto [name, indexer] : quant_memory_vector_indexers_) {
-    indexer->Close();
+    indexer->close();
   }
   quant_memory_vector_indexers_.clear();
 
@@ -658,15 +658,15 @@ bool SegmentImpl::has_record() {
 }
 
 template <typename T>
-struct is_vector : std::false_type {};
+struct IsVector : std::false_type {};
 
 template <typename T, typename A>
-struct is_vector<std::vector<T, A>> : std::true_type {};
+struct IsVector<std::vector<T, A>> : std::true_type {};
 
 template <typename ValueType>
-Status SegmentImpl::InsertScalar(InvertedColumnIndexer::Ptr &indexer,
-                                 const Doc &doc,
-                                 const FieldSchema::Ptr &field) {
+Status SegmentImpl::insert_scalar(InvertedColumnIndexer::Ptr &indexer,
+                                  const Doc &doc,
+                                  const FieldSchema::Ptr &field) {
   auto value = doc.get<ValueType>(field->name());
   auto segment_doc_id = doc_ids_.size();
   if (value.has_value()) {
@@ -674,7 +674,7 @@ Status SegmentImpl::InsertScalar(InvertedColumnIndexer::Ptr &indexer,
       return indexer->insert(segment_doc_id, value.value());
     } else if constexpr (std::is_same_v<ValueType, std::vector<std::string>>) {
       return indexer->insert(segment_doc_id, value.value());
-    } else if constexpr (is_vector<ValueType>::value) {
+    } else if constexpr (IsVector<ValueType>::value) {
       const auto &vec = value.value();
       std::string value_str(
           reinterpret_cast<const char *>(vec.data()),
@@ -699,9 +699,9 @@ Status SegmentImpl::InsertScalar(InvertedColumnIndexer::Ptr &indexer,
 }
 
 template <typename ValueType>
-Status SegmentImpl::InsertVector(VectorColumnIndexer::Ptr &indexer,
-                                 const Doc &doc,
-                                 const FieldSchema::Ptr &field) {
+Status SegmentImpl::insert_vector(VectorColumnIndexer::Ptr &indexer,
+                                  const Doc &doc,
+                                  const FieldSchema::Ptr &field) {
   auto value = doc.get<ValueType>(field->name());
   if (value.has_value()) {
     vector_column_params::VectorData vector_data;
@@ -729,7 +729,7 @@ Status SegmentImpl::InsertVector(VectorColumnIndexer::Ptr &indexer,
     auto &mem_block_meta = segment_meta_->writing_forward_block().value();
     auto &block_doc_id = mem_block_meta.doc_count_;
 
-    return indexer->Insert(vector_data, block_doc_id);
+    return indexer->insert(vector_data, block_doc_id);
   } else {
     LOG_WARN("Field %s not found or is null for doc: %s", field->name().c_str(),
              doc.to_detail_string().c_str());
@@ -751,60 +751,60 @@ Status SegmentImpl::insert_scalar_indexer(Doc &doc) {
     auto data_type = field->data_type();
     switch (field->data_type()) {
       case DataType::BINARY: {
-        status = InsertScalar<std::string>(indexer, doc, field);
+        status = insert_scalar<std::string>(indexer, doc, field);
         break;
       }
       case DataType::STRING: {
-        status = InsertScalar<std::string>(indexer, doc, field);
+        status = insert_scalar<std::string>(indexer, doc, field);
         break;
       }
       case DataType::BOOL:
-        status = InsertScalar<bool>(indexer, doc, field);
+        status = insert_scalar<bool>(indexer, doc, field);
         break;
       case DataType::INT32:
-        status = InsertScalar<int32_t>(indexer, doc, field);
+        status = insert_scalar<int32_t>(indexer, doc, field);
         break;
       case DataType::INT64:
-        status = InsertScalar<int64_t>(indexer, doc, field);
+        status = insert_scalar<int64_t>(indexer, doc, field);
         break;
       case DataType::UINT32:
-        status = InsertScalar<uint32_t>(indexer, doc, field);
+        status = insert_scalar<uint32_t>(indexer, doc, field);
         break;
       case DataType::UINT64:
-        status = InsertScalar<uint64_t>(indexer, doc, field);
+        status = insert_scalar<uint64_t>(indexer, doc, field);
         break;
       case DataType::FLOAT:
-        status = InsertScalar<float>(indexer, doc, field);
+        status = insert_scalar<float>(indexer, doc, field);
         break;
       case DataType::DOUBLE:
-        status = InsertScalar<double>(indexer, doc, field);
+        status = insert_scalar<double>(indexer, doc, field);
         break;
       case DataType::ARRAY_BINARY:
-        status = InsertScalar<std::vector<std::string>>(indexer, doc, field);
+        status = insert_scalar<std::vector<std::string>>(indexer, doc, field);
         break;
       case DataType::ARRAY_STRING:
-        status = InsertScalar<std::vector<std::string>>(indexer, doc, field);
+        status = insert_scalar<std::vector<std::string>>(indexer, doc, field);
         break;
       case DataType::ARRAY_BOOL:
-        status = InsertScalar<std::vector<bool>>(indexer, doc, field);
+        status = insert_scalar<std::vector<bool>>(indexer, doc, field);
         break;
       case DataType::ARRAY_INT32:
-        status = InsertScalar<std::vector<int32_t>>(indexer, doc, field);
+        status = insert_scalar<std::vector<int32_t>>(indexer, doc, field);
         break;
       case DataType::ARRAY_INT64:
-        status = InsertScalar<std::vector<int64_t>>(indexer, doc, field);
+        status = insert_scalar<std::vector<int64_t>>(indexer, doc, field);
         break;
       case DataType::ARRAY_UINT32:
-        status = InsertScalar<std::vector<uint32_t>>(indexer, doc, field);
+        status = insert_scalar<std::vector<uint32_t>>(indexer, doc, field);
         break;
       case DataType::ARRAY_UINT64:
-        status = InsertScalar<std::vector<uint64_t>>(indexer, doc, field);
+        status = insert_scalar<std::vector<uint64_t>>(indexer, doc, field);
         break;
       case DataType::ARRAY_FLOAT:
-        status = InsertScalar<std::vector<float>>(indexer, doc, field);
+        status = insert_scalar<std::vector<float>>(indexer, doc, field);
         break;
       case DataType::ARRAY_DOUBLE:
-        status = InsertScalar<std::vector<double>>(indexer, doc, field);
+        status = insert_scalar<std::vector<double>>(indexer, doc, field);
         break;
       default:
         status = Status::InternalError("unsupport data type ",
@@ -853,36 +853,36 @@ Status SegmentImpl::insert_vector_indexer(Doc &doc) {
       auto data_type = field->data_type();
       switch (data_type) {
         case DataType::VECTOR_BINARY32:
-          status = InsertVector<std::vector<uint32_t>>(indexer, doc, field);
+          status = insert_vector<std::vector<uint32_t>>(indexer, doc, field);
           break;
         case DataType::VECTOR_BINARY64:
-          status = InsertVector<std::vector<uint64_t>>(indexer, doc, field);
+          status = insert_vector<std::vector<uint64_t>>(indexer, doc, field);
           break;
         case DataType::VECTOR_FP16:
-          status = InsertVector<std::vector<float16_t>>(indexer, doc, field);
+          status = insert_vector<std::vector<float16_t>>(indexer, doc, field);
           break;
         case DataType::VECTOR_FP32:
-          status = InsertVector<std::vector<float>>(indexer, doc, field);
+          status = insert_vector<std::vector<float>>(indexer, doc, field);
           break;
         case DataType::VECTOR_FP64:
-          status = InsertVector<std::vector<double>>(indexer, doc, field);
+          status = insert_vector<std::vector<double>>(indexer, doc, field);
           break;
         // case DataType::VECTOR_INT4:
         //   status = InsertVector<std::vector<int8_t>>(indexer, doc, field);
         //   break;
         case DataType::VECTOR_INT8:
-          status = InsertVector<std::vector<int8_t>>(indexer, doc, field);
+          status = insert_vector<std::vector<int8_t>>(indexer, doc, field);
           break;
         case DataType::VECTOR_INT16:
-          status = InsertVector<std::vector<int16_t>>(indexer, doc, field);
+          status = insert_vector<std::vector<int16_t>>(indexer, doc, field);
           break;
         case DataType::SPARSE_VECTOR_FP16:
-          status = InsertVector<
+          status = insert_vector<
               std::pair<std::vector<uint32_t>, std::vector<float16_t>>>(
               indexer, doc, field);
           break;
         case DataType::SPARSE_VECTOR_FP32:
-          status = InsertVector<
+          status = insert_vector<
               std::pair<std::vector<uint32_t>, std::vector<float>>>(indexer,
                                                                     doc, field);
           break;
@@ -965,7 +965,7 @@ Status SegmentImpl::internal_delete(const Doc &doc) {
   return Status::OK();
 }
 
-Status SegmentImpl::Insert(Doc &doc) {
+Status SegmentImpl::insert(Doc &doc) {
   std::lock_guard lock(seg_mtx_);
 
   if (id_map_ && id_map_->has(doc.pk_ref())) {
@@ -982,7 +982,7 @@ Status SegmentImpl::Insert(Doc &doc) {
   return internal_insert(doc);
 }
 
-Status SegmentImpl::Update(Doc &doc) {
+Status SegmentImpl::update(Doc &doc) {
   std::lock_guard lock(seg_mtx_);
   uint64_t g_doc_id;
   if (!id_map_->has(doc.pk_ref(), &g_doc_id)) {
@@ -1000,7 +1000,7 @@ Status SegmentImpl::Update(Doc &doc) {
   return internal_update(doc);
 }
 
-Status SegmentImpl::Upsert(Doc &doc) {
+Status SegmentImpl::upsert(Doc &doc) {
   std::lock_guard lock(seg_mtx_);
 
   doc.set_operator(Operator::UPSERT);
@@ -1054,7 +1054,7 @@ Status SegmentImpl::Delete(uint64_t g_doc_id) {
 }
 
 
-Doc::Ptr SegmentImpl::Fetch(
+Doc::Ptr SegmentImpl::fetch(
     uint64_t g_doc_id,
     const std::optional<std::vector<std::string>> &output_fields,
     bool include_vector) {
@@ -1318,7 +1318,7 @@ Doc::Ptr SegmentImpl::Fetch(
           continue;
         }
         auto vector_indexer = vector_indexers[block_idx];
-        auto fetch_result = vector_indexer->Fetch(block_doc_id);
+        auto fetch_result = vector_indexer->fetch(block_doc_id);
         if (!fetch_result) {
           LOG_ERROR(
               "vector indexer fetch failed, block_doc_id: %d, block_idx: %d, "
@@ -1350,7 +1350,7 @@ Doc::Ptr SegmentImpl::Fetch(
         auto iter = memory_vector_indexers_.find(column_name);
         if (iter != memory_vector_indexers_.end()) {
           auto vector_indexer = iter->second;
-          auto fetch_result = vector_indexer->Fetch(block_doc_id);
+          auto fetch_result = vector_indexer->fetch(block_doc_id);
           if (!fetch_result.has_value()) {
             LOG_ERROR(
                 "vector indexer fetch failed, column: %s, doc_count: %lu, "
@@ -1533,7 +1533,7 @@ Result<VectorColumnIndexer::Ptr> SegmentImpl::merge_vector_indexer(
 
   vector_column_params::ReadOptions options{options_.enable_mmap_, true};
 
-  auto s = vector_indexer->Open(options);
+  auto s = vector_indexer->open(options);
   CHECK_RETURN_STATUS_EXPECTED(s);
   vector_column_params::MergeOptions merge_options;
   if (concurrency == 0) {
@@ -1544,9 +1544,9 @@ Result<VectorColumnIndexer::Ptr> SegmentImpl::merge_vector_indexer(
     merge_options.write_concurrency = concurrency;
   }
   // Keep tombstoned vectors: forward rows are unchanged.
-  s = vector_indexer->Merge(source_indexers, nullptr, merge_options);
+  s = vector_indexer->merge(source_indexers, nullptr, merge_options);
   CHECK_RETURN_STATUS_EXPECTED(s);
-  s = vector_indexer->Flush();
+  s = vector_indexer->flush();
   CHECK_RETURN_STATUS_EXPECTED(s);
 
   return vector_indexer;
@@ -1789,11 +1789,11 @@ Status SegmentImpl::drop_vector_index(
       index_file_path, *field_with_default_index);
   vector_column_params::ReadOptions options{options_.enable_mmap_, true};
 
-  auto s = new_vector_indexer->Open(options);
+  auto s = new_vector_indexer->open(options);
   CHECK_RETURN_STATUS(s);
-  s = new_vector_indexer->Merge(vector_indexers_[column], nullptr);
+  s = new_vector_indexer->merge(vector_indexers_[column], nullptr);
   CHECK_RETURN_STATUS(s);
-  s = new_vector_indexer->Flush();
+  s = new_vector_indexer->flush();
   CHECK_RETURN_STATUS(s);
 
   (*vector_indexers)[column] = new_vector_indexer;
@@ -1835,7 +1835,7 @@ Status SegmentImpl::reload_vector_index(
       if (iter != vector_indexers.end()) {
         auto indexers = vector_indexers_[field->name()];
         for (auto indexer : indexers) {
-          auto s = indexer->Destroy();
+          auto s = indexer->destroy();
           CHECK_RETURN_STATUS(s);
         }
         vector_indexers_[field->name()] = {iter->second};
@@ -1844,7 +1844,7 @@ Status SegmentImpl::reload_vector_index(
       if (q_iter != quant_vector_indexers_.end()) {
         auto q_indexers = q_iter->second;
         for (auto q_indexer : q_indexers) {
-          auto s = q_indexer->Destroy();
+          auto s = q_indexer->destroy();
           CHECK_RETURN_STATUS(s);
         }
         quant_vector_indexers_.erase(q_iter);
@@ -1854,7 +1854,7 @@ Status SegmentImpl::reload_vector_index(
       if (iter != vector_indexers.end()) {
         auto indexers = vector_indexers_[field->name()];
         for (auto indexer : indexers) {
-          auto s = indexer->Destroy();
+          auto s = indexer->destroy();
           CHECK_RETURN_STATUS(s);
         }
         vector_indexers_[field->name()] = {iter->second};
@@ -1863,7 +1863,7 @@ Status SegmentImpl::reload_vector_index(
       if (q_iter != quant_vector_indexers.end()) {
         auto q_indexers = quant_vector_indexers_[field->name()];
         for (auto q_indexer : q_indexers) {
-          auto s = q_indexer->Destroy();
+          auto s = q_indexer->destroy();
           CHECK_RETURN_STATUS(s);
         }
         quant_vector_indexers_[field->name()] = {q_iter->second};
@@ -2200,7 +2200,7 @@ Status SegmentImpl::flush() {
   // flush vector indexer
   for (const auto &indexer : memory_vector_indexers_) {
     if (indexer.second) {
-      s = indexer.second->Flush();
+      s = indexer.second->flush();
       CHECK_RETURN_STATUS(s);
     }
   }
@@ -2208,7 +2208,7 @@ Status SegmentImpl::flush() {
   // flush quant vector indexer
   for (const auto &indexer : quant_memory_vector_indexers_) {
     if (indexer.second) {
-      s = indexer.second->Flush();
+      s = indexer.second->flush();
       CHECK_RETURN_STATUS(s);
     }
   }
@@ -3267,7 +3267,7 @@ Status SegmentImpl::add_column(FieldSchema::Ptr column_schema,
     } else {
       forward_store = std::make_shared<BufferPoolForwardStore>(forward_path);
     }
-    auto s = forward_store->Open();
+    auto s = forward_store->open();
     CHECK_RETURN_STATUS(s);
     persist_stores_.push_back(forward_store);
     segment_meta_->add_persisted_block(block);
@@ -3496,7 +3496,7 @@ Status SegmentImpl::alter_column(const std::string &column_name,
     } else {
       forward_store = std::make_shared<BufferPoolForwardStore>(forward_path);
     }
-    auto s = forward_store->Open();
+    auto s = forward_store->open();
     CHECK_RETURN_STATUS(s);
     persist_stores_.push_back(forward_store);
     segment_meta_->add_persisted_block(block);
@@ -3967,7 +3967,7 @@ Status SegmentImpl::load_persist_scalar_blocks() {
       } else {
         forward_store = std::make_shared<BufferPoolForwardStore>(forward_path);
       }
-      auto s = forward_store->Open();
+      auto s = forward_store->open();
       CHECK_RETURN_STATUS(s);
       persist_stores_.push_back(forward_store);
 
@@ -4102,7 +4102,7 @@ Status SegmentImpl::load_vector_index_blocks() {
 
       auto vector_indexer =
           std::make_shared<VectorColumnIndexer>(index_path, new_field_params);
-      auto s = vector_indexer->Open(vector_column_params::ReadOptions{
+      auto s = vector_indexer->open(vector_column_params::ReadOptions{
           options_.enable_mmap_, false, true});
       CHECK_RETURN_STATUS(s);
 
@@ -4155,7 +4155,7 @@ VectorColumnIndexer::Ptr SegmentImpl::create_vector_indexer(
   auto vector_indexer =
       std::make_shared<VectorColumnIndexer>(index_file_path, field);
   vector_column_params::ReadOptions options{true, true};
-  auto status = vector_indexer->Open(options);
+  auto status = vector_indexer->open(options);
   if (!status.ok()) {
     LOG_ERROR("Failed to open vector indexer for field: %s, err: %s",
               field.to_string().c_str(), status.message().c_str());
@@ -4195,7 +4195,7 @@ Status SegmentImpl::init_memory_components() {
       collection_schema_, mem_path,
       options_.enable_mmap_ ? FileFormat::IPC : FileFormat::PARQUET,
       options_.max_buffer_size_);
-  auto s = memory_store_->Open();
+  auto s = memory_store_->open();
   CHECK_RETURN_STATUS(s);
 
   // create and open memory vector indexer
@@ -4464,7 +4464,7 @@ Status SegmentImpl::finish_memory_components() {
     persist_store =
         std::make_shared<BufferPoolForwardStore>(persist_forward_store_path);
   }
-  s = persist_store->Open();
+  s = persist_store->open();
   CHECK_RETURN_STATUS(s);
   persist_stores_.push_back(persist_store);
 
@@ -4572,7 +4572,7 @@ Result<Segment::Ptr> Segment::CreateAndOpen(
     }
   }
 
-  auto s = segment->Create(options, min_doc_id);
+  auto s = segment->create(options, min_doc_id);
   CHECK_RETURN_STATUS_EXPECTED(s);
 
   return segment;
diff --git a/src/db/index/segment/segment.h b/src/db/index/segment/segment.h
index 361fc3a7d..9579424df 100644
--- a/src/db/index/segment/segment.h
+++ b/src/db/index/segment/segment.h
@@ -150,17 +150,19 @@ class Segment {
                                   const FtsIndexer::Ptr &new_fts_indexer) = 0;
 
   // ---- Data operations ----------------------------------------------------
-  virtual Status Insert(Doc &doc) = 0;
+  virtual Status insert(Doc &doc) = 0;
 
-  virtual Status Upsert(Doc &doc) = 0;
+  virtual Status upsert(Doc &doc) = 0;
 
-  virtual Status Update(Doc &doc) = 0;
+  virtual Status update(Doc &doc) = 0;
 
+  // NOLINTNEXTLINE(readability-identifier-naming): 'delete' is a keyword
   virtual Status Delete(const std::string &pk) = 0;
 
+  // NOLINTNEXTLINE(readability-identifier-naming): 'delete' is a keyword
   virtual Status Delete(uint64_t g_doc_id) = 0;
 
-  virtual Doc::Ptr Fetch(uint64_t g_doc_id,
+  virtual Doc::Ptr fetch(uint64_t g_doc_id,
                          const std::optional<std::vector<std::string>>
                              &output_fields = std::nullopt,
                          bool include_vector = true) = 0;
diff --git a/src/db/index/segment/segment_helper.cc b/src/db/index/segment/segment_helper.cc
index 86a9e0ad2..8892d5469 100644
--- a/src/db/index/segment/segment_helper.cc
+++ b/src/db/index/segment/segment_helper.cc
@@ -748,7 +748,7 @@ Status SegmentHelper::ReduceVectorIndex(
       CHECK_RETURN_STATUS(s);
 
       if (vector_indexer != nullptr) {
-        s = vector_indexer->Close();
+        s = vector_indexer->close();
         CHECK_RETURN_STATUS(s);
       }
 
@@ -826,11 +826,11 @@ Status SegmentHelper::MergeWithOptionalReuse(
     if (FileHelper::CopyFile(first_indexer->index_file_path(),
                              output_index_path)) {
       // Open the copied file in-place (create_new=false).
-      s = vector_indexer->Open(vector_column_params::ReadOptions{true, false});
+      s = vector_indexer->open(vector_column_params::ReadOptions{true, false});
       CHECK_RETURN_STATUS(s);
 
       source_indexers.erase(source_indexers.begin());
-      s = vector_indexer->Merge(source_indexers, filter, merge_options);
+      s = vector_indexer->merge(source_indexers, filter, merge_options);
       CHECK_RETURN_STATUS(s);
       reused_base_index = true;
     } else {
@@ -841,19 +841,19 @@ Status SegmentHelper::MergeWithOptionalReuse(
   }
 
   if (!reused_base_index) {
-    s = vector_indexer->Open(vector_column_params::ReadOptions{true, true});
+    s = vector_indexer->open(vector_column_params::ReadOptions{true, true});
     CHECK_RETURN_STATUS(s);
 
-    s = vector_indexer->Merge(source_indexers, filter, merge_options);
+    s = vector_indexer->merge(source_indexers, filter, merge_options);
     CHECK_RETURN_STATUS(s);
   }
 
-  s = vector_indexer->Flush();
+  s = vector_indexer->flush();
   CHECK_RETURN_STATUS(s);
   if (merged_indexer != nullptr) {
     *merged_indexer = vector_indexer;
   } else {
-    s = vector_indexer->Close();
+    s = vector_indexer->close();
     CHECK_RETURN_STATUS(s);
   }
   return Status::OK();
diff --git a/src/db/index/segment/sql_expr_parser.cc b/src/db/index/segment/sql_expr_parser.cc
index 2e8ed2015..1cd94f0a8 100644
--- a/src/db/index/segment/sql_expr_parser.cc
+++ b/src/db/index/segment/sql_expr_parser.cc
@@ -35,10 +35,10 @@ class Parser {
   Parser(const std::string &expr, const std::shared_ptr<arrow::Schema> &schema)
       : expr_(expr), pos_(0), schema_(schema) {}
 
-  arrow::Result<Expression> Parse() {
-    SkipWhitespace();
-    ARROW_ASSIGN_OR_RAISE(auto e, ParseExpression());
-    SkipWhitespace();
+  arrow::Result<Expression> parse() {
+    skip_whitespace();
+    ARROW_ASSIGN_OR_RAISE(auto e, parse_expression());
+    skip_whitespace();
     if ((size_t)pos_ < expr_.size()) {
       return arrow::Status::Invalid("Unexpected character at position ", pos_,
                                     ": ", expr_[pos_]);
@@ -51,22 +51,22 @@ class Parser {
   int pos_;
   std::shared_ptr<arrow::Schema> schema_;
 
-  void SkipWhitespace() {
+  void skip_whitespace() {
     while ((size_t)pos_ < expr_.size() && std::isspace(expr_[pos_])) {
       ++pos_;
     }
   }
 
-  arrow::Result<Expression> ParseExpression() {
-    SkipWhitespace();
-    ARROW_ASSIGN_OR_RAISE(auto left, ParseTerm());
-    SkipWhitespace();
+  arrow::Result<Expression> parse_expression() {
+    skip_whitespace();
+    ARROW_ASSIGN_OR_RAISE(auto left, parse_term());
+    skip_whitespace();
     while ((size_t)pos_ < expr_.size() &&
            (expr_[pos_] == '+' || expr_[pos_] == '-')) {
       char op = expr_[pos_++];
-      SkipWhitespace();
-      ARROW_ASSIGN_OR_RAISE(auto right, ParseTerm());
-      SkipWhitespace();
+      skip_whitespace();
+      ARROW_ASSIGN_OR_RAISE(auto right, parse_term());
+      skip_whitespace();
       auto func = (op == '+') ? "add" : "subtract";
       left = call(std::string(func), {left, right});
     }
@@ -74,17 +74,17 @@ class Parser {
     return left;
   }
 
-  arrow::Result<Expression> ParseTerm() {
-    SkipWhitespace();
-    ARROW_ASSIGN_OR_RAISE(auto left, ParseFactor());
-    SkipWhitespace();
+  arrow::Result<Expression> parse_term() {
+    skip_whitespace();
+    ARROW_ASSIGN_OR_RAISE(auto left, parse_factor());
+    skip_whitespace();
 
     while ((size_t)pos_ < expr_.size() &&
            (expr_[pos_] == '*' || expr_[pos_] == '/')) {
       char op = expr_[pos_++];
-      SkipWhitespace();
-      ARROW_ASSIGN_OR_RAISE(auto right, ParseFactor());
-      SkipWhitespace();
+      skip_whitespace();
+      ARROW_ASSIGN_OR_RAISE(auto right, parse_factor());
+      skip_whitespace();
       auto func = (op == '*') ? "multiply" : "divide";
       left = call(std::string(func), {left, right});
     }
@@ -92,8 +92,8 @@ class Parser {
     return left;
   }
 
-  arrow::Result<Expression> ParseFactor() {
-    SkipWhitespace();
+  arrow::Result<Expression> parse_factor() {
+    skip_whitespace();
 
     if ((size_t)pos_ >= expr_.size()) {
       return arrow::Status::Invalid("Unexpected end of expression.");
@@ -104,47 +104,47 @@ class Parser {
     // Parenthetical expression
     if (c == '(') {
       ++pos_;
-      SkipWhitespace();
-      ARROW_ASSIGN_OR_RAISE(auto inner, ParseExpression());
-      SkipWhitespace();
+      skip_whitespace();
+      ARROW_ASSIGN_OR_RAISE(auto inner, parse_expression());
+      skip_whitespace();
       if ((size_t)pos_ >= expr_.size() || expr_[pos_] != ')') {
         return arrow::Status::Invalid("Mismatched parentheses.");
       }
       ++pos_;
-      SkipWhitespace();
+      skip_whitespace();
       return inner;
     }
 
     // Unary minus operator
     if (c == '-') {
       ++pos_;  // Skip the minus sign
-      SkipWhitespace();
-      ARROW_ASSIGN_OR_RAISE(auto operand, ParseFactor());
+      skip_whitespace();
+      ARROW_ASSIGN_OR_RAISE(auto operand, parse_factor());
       return call("negate", {operand});
     }
 
     // Unary plus operator (optional support)
     if (c == '+') {
       ++pos_;  // Skip the plus sign
-      SkipWhitespace();
-      return ParseFactor();
+      skip_whitespace();
+      return parse_factor();
     }
 
     // Numeric literal (integer or floating point)
     if (std::isdigit(c)) {
-      return ParseNumber();
+      return parse_number();
     }
 
     // Column name (starts with letter or _)
     if (std::isalpha(c) || c == '_') {
-      return ParseColumnName();
+      return parse_column_name();
     }
 
     return arrow::Status::Invalid("Unexpected character: '", std::string(1, c),
                                   "'");
   }
 
-  arrow::Result<Expression> ParseNumber() {
+  arrow::Result<Expression> parse_number() {
     int start = pos_;
     bool has_dot = false;
     bool has_exponent = false;
@@ -194,7 +194,7 @@ class Parser {
     return arrow::Status::Invalid("Failed to parse number: ", num_str);
   }
 
-  arrow::Result<Expression> ParseColumnName() {
+  arrow::Result<Expression> parse_column_name() {
     int start = pos_;
     while ((size_t)pos_ < expr_.size()) {
       char c = expr_[pos_];
@@ -346,7 +346,7 @@ arrow::Result<Expression> CheckSupportedArithmeticExpression(
 arrow::Result<Expression> ParseToExpression(
     const std::string &sql_expr, const std::shared_ptr<arrow::Schema> &schema) {
   Parser parser(sql_expr, schema);
-  return parser.Parse();
+  return parser.parse();
 }
 
 }  // namespace zvec
\ No newline at end of file
diff --git a/src/db/index/storage/arrow_ipc_writer.h b/src/db/index/storage/arrow_ipc_writer.h
index 3d53e7662..b9a51b655 100644
--- a/src/db/index/storage/arrow_ipc_writer.h
+++ b/src/db/index/storage/arrow_ipc_writer.h
@@ -28,7 +28,7 @@ class ArrowIpcWriter : public ForwardWriter {
  public:
   explicit ArrowIpcWriter(const std::string &filepath,
                           int64_t max_rows_per_batch = 0);
-  ~ArrowIpcWriter();
+  ~ArrowIpcWriter() override;
 
   arrow::Status insert(std::shared_ptr<arrow::RecordBatchReader> reader,
                        const IndexFilter::Ptr &filter = nullptr) override;
diff --git a/src/db/index/storage/base_forward_store.h b/src/db/index/storage/base_forward_store.h
index 1ec42b1ce..0c265df6a 100644
--- a/src/db/index/storage/base_forward_store.h
+++ b/src/db/index/storage/base_forward_store.h
@@ -40,7 +40,7 @@ class BaseForwardStore {
  public:
   using Ptr = std::shared_ptr<BaseForwardStore>;
 
-  virtual Status Open() = 0;
+  virtual Status open() = 0;
 
   virtual TablePtr fetch(const std::vector<std::string> &columns,
                          const std::vector<int> &indices) = 0;
diff --git a/src/db/index/storage/bufferpool_forward_store.cc b/src/db/index/storage/bufferpool_forward_store.cc
index 9b399601f..c24d1e16a 100644
--- a/src/db/index/storage/bufferpool_forward_store.cc
+++ b/src/db/index/storage/bufferpool_forward_store.cc
@@ -32,7 +32,7 @@ namespace zvec {
 BufferPoolForwardStore::BufferPoolForwardStore(const std::string &uri)
     : file_path_(uri) {}
 
-Status BufferPoolForwardStore::Open() {
+Status BufferPoolForwardStore::open() {
   std::string uri = file_path_;
   auto status = CreateRandomAccessFileByUri(uri, &file_, &file_path_);
   if (!status.ok()) {
@@ -41,7 +41,7 @@ Status BufferPoolForwardStore::Open() {
   }
   auto format = InferFileFormat(file_path_);
   if (format == FileFormat::PARQUET) {
-    status = OpenParquet(file_);
+    status = open_parquet(file_);
     if (!status.ok()) {
       return Status::InternalError("Failed to open parquet file: ", file_path_,
                                    " : ", status.ToString());
@@ -51,7 +51,7 @@ Status BufferPoolForwardStore::Open() {
   }
   return Status::OK();
 }
-arrow::Status BufferPoolForwardStore::OpenParquet(
+arrow::Status BufferPoolForwardStore::open_parquet(
     const std::shared_ptr<arrow::io::RandomAccessFile> &file) {
   auto parquet_file_reader = parquet::ParquetFileReader::Open(file);
   ARROW_RETURN_NOT_OK(parquet::arrow::FileReader::Make(
@@ -102,7 +102,7 @@ bool BufferPoolForwardStore::validate(
   return true;
 }
 
-int BufferPoolForwardStore::FindRowGroupForRow(int64_t row) {
+int BufferPoolForwardStore::find_row_group_for_row(int64_t row) {
   auto it = std::upper_bound(row_group_offsets_.begin(),
                              row_group_offsets_.end(), row);
   if (it == row_group_offsets_.begin()) {
@@ -111,7 +111,7 @@ int BufferPoolForwardStore::FindRowGroupForRow(int64_t row) {
   return static_cast<int>(std::distance(row_group_offsets_.begin(), it) - 1);
 }
 
-int64_t BufferPoolForwardStore::GetRowGroupOffset(int rg_id) {
+int64_t BufferPoolForwardStore::get_row_group_offset(int rg_id) {
   if (rg_id < 0 || rg_id >= static_cast<int>(row_group_offsets_.size())) {
     LOG_ERROR("Invalid row group id: %d, max: %zu", rg_id,
               row_group_offsets_.size());
@@ -169,8 +169,8 @@ TablePtr BufferPoolForwardStore::fetch(const std::vector<std::string> &columns,
                 static_cast<long long>(num_rows_));
       return nullptr;
     }
-    int rg_id = FindRowGroupForRow(global_row);
-    int64_t offset = GetRowGroupOffset(rg_id);
+    int rg_id = find_row_group_for_row(global_row);
+    int64_t offset = get_row_group_offset(rg_id);
     if (offset == -1) {
       LOG_ERROR("Failed to get row group offset for row: %d", global_row);
       return nullptr;
@@ -311,8 +311,8 @@ ExecBatchPtr BufferPoolForwardStore::fetch(
     col_indices.push_back(idx);
   }
 
-  int rg_id = FindRowGroupForRow(index);
-  int64_t offset = GetRowGroupOffset(rg_id);
+  int rg_id = find_row_group_for_row(index);
+  int64_t offset = get_row_group_offset(rg_id);
 
   std::vector<arrow::Datum> scalars;
   for (size_t i = 0; i < col_indices.size(); ++i) {
diff --git a/src/db/index/storage/bufferpool_forward_store.h b/src/db/index/storage/bufferpool_forward_store.h
index 672ac6985..1748b834a 100644
--- a/src/db/index/storage/bufferpool_forward_store.h
+++ b/src/db/index/storage/bufferpool_forward_store.h
@@ -43,7 +43,7 @@ class BufferPoolForwardStore
 
   virtual ~BufferPoolForwardStore() = default;
 
-  Status Open() override;
+  Status open() override;
 
   /// Fetch specific columns and row indices from the data source
   /// \param columns The list of column names to fetch
@@ -84,18 +84,18 @@ class BufferPoolForwardStore
   /// Open a parquet file and initialize metadata
   /// \param file The RandomAccessFile to read from
   /// \return arrow::Status indicating success or failure
-  arrow::Status OpenParquet(
+  arrow::Status open_parquet(
       const std::shared_ptr<arrow::io::RandomAccessFile> &file);
 
   /// Find which row group contains a given row
   /// \param row The row index to locate
   /// \return The row group ID containing the row
-  int FindRowGroupForRow(int64_t row);
+  int find_row_group_for_row(int64_t row);
 
   /// Get the row offset for a given row group
   /// \param rg_id The row group ID
   /// \return The row offset of the row group, or -1 on error
-  int64_t GetRowGroupOffset(int rg_id);
+  int64_t get_row_group_offset(int rg_id);
 
  private:
   /// Physical schema of the file
diff --git a/src/db/index/storage/chunked_file_writer.cc b/src/db/index/storage/chunked_file_writer.cc
index 0295b99cb..213d7522a 100644
--- a/src/db/index/storage/chunked_file_writer.cc
+++ b/src/db/index/storage/chunked_file_writer.cc
@@ -43,15 +43,15 @@ class IpcChunkedWriter : public ChunkedFileWriter {
         out_file_(std::move(out_file)),
         writer_(std::move(writer)) {}
 
-  arrow::Status Write(const arrow::RecordBatch &batch) override {
+  arrow::Status write(const arrow::RecordBatch &batch) override {
     return writer_->WriteRecordBatch(batch);
   }
 
-  arrow::Status Write(const arrow::Table &table) override {
+  arrow::Status write(const arrow::Table &table) override {
     return writer_->WriteTable(table);
   }
 
-  arrow::Status Close() override {
+  arrow::Status close() override {
     ARROW_RETURN_NOT_OK(writer_->Close());
     return out_file_->Close();
   }
@@ -88,15 +88,15 @@ class ParquetChunkedWriter : public ChunkedFileWriter {
         out_file_(std::move(out_file)),
         writer_(std::move(writer)) {}
 
-  arrow::Status Write(const arrow::RecordBatch &batch) override {
+  arrow::Status write(const arrow::RecordBatch &batch) override {
     return writer_->WriteRecordBatch(batch);
   }
 
-  arrow::Status Write(const arrow::Table &table) override {
+  arrow::Status write(const arrow::Table &table) override {
     return writer_->WriteTable(table);
   }
 
-  arrow::Status Close() override {
+  arrow::Status close() override {
     ARROW_RETURN_NOT_OK(writer_->Close());
     return out_file_->Close();
   }
diff --git a/src/db/index/storage/chunked_file_writer.h b/src/db/index/storage/chunked_file_writer.h
index 56c62cfcb..f806a58b8 100644
--- a/src/db/index/storage/chunked_file_writer.h
+++ b/src/db/index/storage/chunked_file_writer.h
@@ -31,11 +31,11 @@ class ChunkedFileWriter {
       const std::string &file_path,
       const std::shared_ptr<arrow::Schema> &schema, FileFormat format);
 
-  virtual arrow::Status Write(const arrow::RecordBatch &batch) = 0;
+  virtual arrow::Status write(const arrow::RecordBatch &batch) = 0;
 
-  virtual arrow::Status Write(const arrow::Table &table) = 0;
+  virtual arrow::Status write(const arrow::Table &table) = 0;
 
-  virtual arrow::Status Close() = 0;
+  virtual arrow::Status close() = 0;
 
   virtual ~ChunkedFileWriter() = default;  // LCOV_EXCL_BR_LINE
 
diff --git a/src/db/index/storage/memory_forward_store.cc b/src/db/index/storage/memory_forward_store.cc
index a532a3c9b..db06f83a7 100644
--- a/src/db/index/storage/memory_forward_store.cc
+++ b/src/db/index/storage/memory_forward_store.cc
@@ -44,7 +44,7 @@ MemForwardStore::MemForwardStore(
   cache_.reserve(128);
 }
 
-Status MemForwardStore::Open() {
+Status MemForwardStore::open() {
   arrow::FieldVector fields;
   auto status = ConvertCollectionSchemaToArrowFields(schema_, &fields);
   if (!status.ok()) {
@@ -61,7 +61,7 @@ Status MemForwardStore::Open() {
   return Status::OK();
 }
 
-RecordBatchBuilderPtr MemForwardStore::createBuilder() {
+RecordBatchBuilderPtr MemForwardStore::create_builder() {
   auto result = arrow::RecordBatchBuilder::Make(physic_schema_,
                                                 arrow::default_memory_pool());
   if (!result.ok()) {
@@ -116,7 +116,7 @@ arrow::Status MemForwardStore::append_doc_to_builder(
   return arrow::Status::OK();
 }
 
-arrow::Status MemForwardStore::convertToBuilder(
+arrow::Status MemForwardStore::convert_to_builder(
     RecordBatchBuilderPtr &rb_builder) {
   for (const auto &doc : cache_) {
     ARROW_RETURN_NOT_OK(append_doc_to_builder(doc, rb_builder));
@@ -134,8 +134,8 @@ Status MemForwardStore::insert(const Doc &doc) {
     return Status::OK();
   }
   // Flush cache when it reaches max size
-  auto rb_builder = createBuilder();
-  auto status = convertToBuilder(rb_builder);
+  auto rb_builder = create_builder();
+  auto status = convert_to_builder(rb_builder);
   if (!status.ok()) {
     return Status::InternalError("convertToBuilder error: ", status.ToString());
   }
@@ -154,9 +154,9 @@ Status MemForwardStore::insert(const Doc &doc) {
   return Status::OK();
 }
 
-arrow::Result<RecordBatchPtr> MemForwardStore::convertToRecordBatch() {
-  auto rb_builder = createBuilder();
-  ARROW_RETURN_NOT_OK(convertToBuilder(rb_builder));
+arrow::Result<RecordBatchPtr> MemForwardStore::convert_to_record_batch() {
+  auto rb_builder = create_builder();
+  ARROW_RETURN_NOT_OK(convert_to_builder(rb_builder));
   ARROW_ASSIGN_OR_RAISE(auto batch, rb_builder->Flush(false));
   return batch;
 }
@@ -199,7 +199,7 @@ bool MemForwardStore::locate_single_source(const std::vector<int> &indices,
     }
   }
   // Build a batch out of just the requested cache rows.
-  auto rb_builder = createBuilder();
+  auto rb_builder = create_builder();
   if (rb_builder == nullptr) {
     return false;
   }
@@ -265,7 +265,7 @@ arrow::Result<TablePtr> MemForwardStore::apply_row_and_column_selection(
   return selected_table;
 }
 
-arrow::Result<TablePtr> MemForwardStore::convertToTable(
+arrow::Result<TablePtr> MemForwardStore::convert_to_table(
     const std::vector<std::string> &columns, const std::vector<int> &indices) {
   // Fast path: when every requested row sits in one source, only that source is
   // materialised, so point fetches do not grow with the store's size.
@@ -278,7 +278,7 @@ arrow::Result<TablePtr> MemForwardStore::convertToTable(
   }
 
   std::shared_ptr<arrow::RecordBatch> batch;
-  ARROW_ASSIGN_OR_RAISE(batch, convertToRecordBatch());
+  ARROW_ASSIGN_OR_RAISE(batch, convert_to_record_batch());
   std::vector<std::shared_ptr<arrow::RecordBatch>> all_batches = batches_;
   if (batch->num_rows() > 0) {
     all_batches.push_back(batch);
@@ -311,7 +311,7 @@ Status MemForwardStore::flush_locked() {
         "forward store writer not open, cannot flush [", path_, "]");
   }
 
-  auto result = convertToRecordBatch();
+  auto result = convert_to_record_batch();
   if (!result.ok()) {
     return Status::InternalError("failed to convert cache to RecordBatch: ",
                                  result.status().ToString());
@@ -375,7 +375,7 @@ Status MemForwardStore::flush_locked() {
         batch_to_write = result.ValueOrDie();
       }
 
-      auto status = writer_->Write(*batch_to_write);
+      auto status = writer_->write(*batch_to_write);
       if (!status.ok()) {
         return Status::InternalError("failed to write RecordBatch to file: ",
                                      status.ToString());
@@ -404,7 +404,7 @@ Status MemForwardStore::close() {
     flush_locked();
   }
   if (writer_) {
-    auto status = writer_->Close();
+    auto status = writer_->close();
     if (!status.ok()) {
       LOG_WARN("failed to close writer: %s", status.ToString().c_str());
     }
@@ -418,7 +418,7 @@ Status MemForwardStore::close() {
 TablePtr MemForwardStore::get_table() {
   std::shared_lock<std::shared_mutex> lock(cache_mtx_);
   std::shared_ptr<arrow::RecordBatch> batch =
-      convertToRecordBatch().ValueOrDie();
+      convert_to_record_batch().ValueOrDie();
   std::vector<std::shared_ptr<arrow::RecordBatch>> all_batches = batches_;
   if (batch->num_rows() > 0) {
     all_batches.push_back(batch);
@@ -462,7 +462,7 @@ TablePtr MemForwardStore::fetch(const std::vector<std::string> &columns,
     }
   }
 
-  auto result = convertToTable(data_columns, indices);
+  auto result = convert_to_table(data_columns, indices);
   if (!result.ok()) {
     LOG_ERROR("failed to convert to table: %s",
               result.status().ToString().c_str());
@@ -528,7 +528,7 @@ ExecBatchPtr MemForwardStore::fetch(const std::vector<std::string> &columns,
     return nullptr;
   }
 
-  auto result = convertToTable(columns, std::vector<int>{index});
+  auto result = convert_to_table(columns, std::vector<int>{index});
   if (!result.ok()) {
     LOG_ERROR("failed to convert to table: %s",
               result.status().ToString().c_str());
@@ -562,7 +562,7 @@ RecordBatchReaderPtr MemForwardStore::scan(
     return nullptr;
   }
 
-  auto result = convertToTable(columns, {});
+  auto result = convert_to_table(columns, {});
   if (!result.ok()) {
     LOG_ERROR("failed to convert to table: %s",
               result.status().ToString().c_str());
diff --git a/src/db/index/storage/memory_forward_store.h b/src/db/index/storage/memory_forward_store.h
index 57285cdb1..fbb54bc21 100644
--- a/src/db/index/storage/memory_forward_store.h
+++ b/src/db/index/storage/memory_forward_store.h
@@ -59,7 +59,7 @@ class MemForwardStore : public BaseForwardStore {
 
   /// Open the store
   /// \return 0 on success, non-zero on failure
-  Status Open() override;
+  Status open() override;
 
   /// Insert a document into the store
   /// \param doc The document to insert
@@ -123,23 +123,23 @@ class MemForwardStore : public BaseForwardStore {
  private:
   /// Create a RecordBatchBuilder for this store
   /// \return A new RecordBatchBuilder
-  RecordBatchBuilderPtr createBuilder();
+  RecordBatchBuilderPtr create_builder();
 
   /// Convert internal data to a RecordBatch
   /// \return A Result containing the RecordBatch or an error status
-  arrow::Result<RecordBatchPtr> convertToRecordBatch();
+  arrow::Result<RecordBatchPtr> convert_to_record_batch();
 
   /// Convert internal data to a Table
   /// \param columns The list of column names to include
   /// \param indices The list of row indices to include
   /// \return A Result containing the Table or an error status
-  arrow::Result<TablePtr> convertToTable(
+  arrow::Result<TablePtr> convert_to_table(
       const std::vector<std::string> &columns, const std::vector<int> &indices);
 
   /// Convert internal data to a RecordBatchBuilder
   /// \param builder The builder to populate
   /// \return arrow::Status indicating success or failure
-  arrow::Status convertToBuilder(RecordBatchBuilderPtr &builder);
+  arrow::Status convert_to_builder(RecordBatchBuilderPtr &builder);
 
   /// Append a single document to a builder
   /// \param doc The document to append
diff --git a/src/db/index/storage/mmap_forward_store.cc b/src/db/index/storage/mmap_forward_store.cc
index bef4469eb..deb9d556e 100644
--- a/src/db/index/storage/mmap_forward_store.cc
+++ b/src/db/index/storage/mmap_forward_store.cc
@@ -27,7 +27,7 @@ namespace zvec {
 
 MmapForwardStore::MmapForwardStore(const std::string &uri) : file_path_(uri) {}
 
-Status MmapForwardStore::Open() {
+Status MmapForwardStore::open() {
   std::string uri = file_path_;
   auto status = CreateRandomAccessFileByUri(uri, &file_, &file_path_);
   if (!status.ok()) {
@@ -38,7 +38,7 @@ Status MmapForwardStore::Open() {
   format_ = InferFileFormat(file_path_);
   switch (format_) {
     case FileFormat::PARQUET: {
-      status = OpenParquet(file_);
+      status = open_parquet(file_);
       if (!status.ok()) {
         LOG_ERROR("Failed to open parquet file: %s : %s", file_path_.c_str(),
                   status.ToString().c_str());
@@ -47,7 +47,7 @@ Status MmapForwardStore::Open() {
       break;
     }
     case FileFormat::IPC: {
-      status = OpenIPC(file_);
+      status = open_ipc(file_);
       if (!status.ok()) {
         LOG_ERROR("Failed to open ipc file: %s : %s", file_path_.c_str(),
                   status.ToString().c_str());
@@ -63,7 +63,7 @@ Status MmapForwardStore::Open() {
   return Status::OK();
 }
 
-arrow::Status MmapForwardStore::OpenParquet(
+arrow::Status MmapForwardStore::open_parquet(
     const std::shared_ptr<arrow::io::RandomAccessFile> &file) {
   auto parquet_file_reader = parquet::ParquetFileReader::Open(file);
   ARROW_RETURN_NOT_OK(parquet::arrow::FileReader::Make(
@@ -93,7 +93,7 @@ arrow::Status MmapForwardStore::OpenParquet(
   return arrow::Status::OK();
 }
 
-arrow::Status MmapForwardStore::OpenIPC(
+arrow::Status MmapForwardStore::open_ipc(
     const std::shared_ptr<arrow::io::RandomAccessFile> &file) {
   std::shared_ptr<arrow::ipc::RecordBatchFileReader> reader;
   arrow::Result<std::shared_ptr<arrow::ipc::RecordBatchFileReader>> result =
@@ -159,7 +159,7 @@ bool MmapForwardStore::validate(const std::vector<std::string> &columns) const {
   return true;
 }
 
-RecordBatchReaderPtr MmapForwardStore::ScanParquet(
+RecordBatchReaderPtr MmapForwardStore::scan_parquet(
     const std::vector<std::string> &columns) {
   // Create a new parquet reader for scanning
   std::unique_ptr<parquet::arrow::FileReader> parquet_reader;
@@ -177,7 +177,7 @@ RecordBatchReaderPtr MmapForwardStore::ScanParquet(
   return rb_reader;
 }
 
-RecordBatchReaderPtr MmapForwardStore::ScanIPC(
+RecordBatchReaderPtr MmapForwardStore::scan_ipc(
     const std::vector<std::string> &columns) {
   std::vector<int> col_indices;
   for (auto &column : columns) {
@@ -197,8 +197,8 @@ RecordBatchReaderPtr MmapForwardStore::ScanIPC(
   return std::make_shared<arrow::TableBatchReader>(sub_table);
 }
 
-TablePtr MmapForwardStore::FetchParquet(const std::vector<std::string> &columns,
-                                        const std::vector<int> &indices) {
+TablePtr MmapForwardStore::fetch_parquet(
+    const std::vector<std::string> &columns, const std::vector<int> &indices) {
   bool need_local_doc_id = false;
   std::vector<int> col_indices;
   std::vector<int> data_column_positions;
@@ -223,8 +223,8 @@ TablePtr MmapForwardStore::FetchParquet(const std::vector<std::string> &columns,
   int output_row = 0;
   for (int global_row : indices) {
     if (global_row < 0 || global_row >= num_rows_) return nullptr;
-    int rg_id = FindRowGroupForRow(global_row);
-    int64_t offset = GetRowGroupOffset(rg_id);
+    int rg_id = find_row_group_for_row(global_row);
+    int64_t offset = get_row_group_offset(rg_id);
     uint64_t local_in_rg = global_row - offset;
     rg_to_local[rg_id].emplace_back(output_row, local_in_rg);
     if (need_local_doc_id) {
@@ -348,7 +348,7 @@ TablePtr MmapForwardStore::FetchParquet(const std::vector<std::string> &columns,
                             static_cast<int64_t>(indices.size()));
 }
 
-ExecBatchPtr MmapForwardStore::FetchParquet(
+ExecBatchPtr MmapForwardStore::fetch_parquet(
     const std::vector<std::string> &columns, int index) {
   std::vector<int> col_indices;
   for (const auto &col : columns) {
@@ -357,8 +357,8 @@ ExecBatchPtr MmapForwardStore::FetchParquet(
     col_indices.push_back(idx);
   }
 
-  int rg_id = FindRowGroupForRow(index);
-  int64_t offset = GetRowGroupOffset(rg_id);
+  int rg_id = find_row_group_for_row(index);
+  int64_t offset = get_row_group_offset(rg_id);
   uint64_t local_in_rg = index - offset;
 
   std::shared_ptr<arrow::Table> rg_table;
@@ -381,15 +381,15 @@ ExecBatchPtr MmapForwardStore::FetchParquet(
   return std::make_shared<arrow::compute::ExecBatch>(std::move(scalars), 1);
 }
 
-TablePtr MmapForwardStore::FetchIPC(const std::vector<std::string> &columns,
-                                    const std::vector<int> &indices) {
+TablePtr MmapForwardStore::fetch_ipc(const std::vector<std::string> &columns,
+                                     const std::vector<int> &indices) {
   std::vector<std::pair<int64_t, int64_t>> indices_in_table;
   auto chunked_array = table_->column(0);
   for (const auto &target_index : indices) {
     int target_chunk_index = -1;
     int64_t offset_in_chunk = -1;
-    if (FindTargetChunk(target_index, chunked_array->num_chunks(),
-                        &target_chunk_index, &offset_in_chunk)) {
+    if (find_target_chunk(target_index, chunked_array->num_chunks(),
+                          &target_chunk_index, &offset_in_chunk)) {
       indices_in_table.emplace_back(target_chunk_index, offset_in_chunk);
     } else {
       LOG_ERROR("Failed to find target chunk for index %d", target_index);
@@ -441,8 +441,8 @@ TablePtr MmapForwardStore::FetchIPC(const std::vector<std::string> &columns,
   return arrow::Table::Make(result_schema, result_columns, indices.size());
 }
 
-ExecBatchPtr MmapForwardStore::FetchIPC(const std::vector<std::string> &columns,
-                                        int index) {
+ExecBatchPtr MmapForwardStore::fetch_ipc(
+    const std::vector<std::string> &columns, int index) {
   // Extract scalars
   std::vector<arrow::Datum> scalars;
   scalars.reserve(columns.size());
@@ -463,7 +463,7 @@ ExecBatchPtr MmapForwardStore::FetchIPC(const std::vector<std::string> &columns,
   return std::make_shared<arrow::compute::ExecBatch>(std::move(scalars), 1);
 }
 
-int MmapForwardStore::FindRowGroupForRow(int64_t row) {
+int MmapForwardStore::find_row_group_for_row(int64_t row) {
   auto it = std::upper_bound(row_group_offsets_.begin(),
                              row_group_offsets_.end(), row);
   if (it == row_group_offsets_.begin()) {
@@ -472,13 +472,13 @@ int MmapForwardStore::FindRowGroupForRow(int64_t row) {
   return static_cast<int>(std::distance(row_group_offsets_.begin(), it) - 1);
 }
 
-int64_t MmapForwardStore::GetRowGroupOffset(int rg_id) {
+int64_t MmapForwardStore::get_row_group_offset(int rg_id) {
   return row_group_offsets_[rg_id];
 }
 
-bool MmapForwardStore::FindTargetChunk(int target_index, int num_chunks,
-                                       int *target_chunk_index,
-                                       int64_t *offset_in_chunk) {
+bool MmapForwardStore::find_target_chunk(int target_index, int num_chunks,
+                                         int *target_chunk_index,
+                                         int64_t *offset_in_chunk) {
   if (target_index < 0 || target_index >= num_rows_) {
     return false;
   }
@@ -533,9 +533,9 @@ TablePtr MmapForwardStore::fetch(const std::vector<std::string> &columns,
   }
 
   if (format_ == FileFormat::PARQUET) {
-    return FetchParquet(columns, indices);
+    return fetch_parquet(columns, indices);
   } else {
-    return FetchIPC(columns, indices);
+    return fetch_ipc(columns, indices);
   }
 }
 
@@ -551,9 +551,9 @@ ExecBatchPtr MmapForwardStore::fetch(const std::vector<std::string> &columns,
   }
 
   if (format_ == FileFormat::PARQUET) {
-    return FetchParquet(columns, index);
+    return fetch_parquet(columns, index);
   } else {
-    return FetchIPC(columns, index);
+    return fetch_ipc(columns, index);
   }
 }
 
@@ -564,9 +564,9 @@ RecordBatchReaderPtr MmapForwardStore::scan(
   }
 
   if (format_ == FileFormat::PARQUET) {
-    return ScanParquet(columns);
+    return scan_parquet(columns);
   } else {
-    return ScanIPC(columns);
+    return scan_ipc(columns);
   }
 }
 
diff --git a/src/db/index/storage/mmap_forward_store.h b/src/db/index/storage/mmap_forward_store.h
index 50d5e24db..dc7d65e14 100644
--- a/src/db/index/storage/mmap_forward_store.h
+++ b/src/db/index/storage/mmap_forward_store.h
@@ -50,7 +50,7 @@ class MmapForwardStore : public BaseForwardStore {
   MmapForwardStore(const std::string &uri);
   virtual ~MmapForwardStore() = default;
 
-  Status Open() override;
+  Status open() override;
 
   /// Fetch specific columns and row indices from the data source
   /// \param columns The list of column names to fetch
@@ -92,60 +92,61 @@ class MmapForwardStore : public BaseForwardStore {
   /// Open a parquet file and initialize metadata
   /// \param file The RandomAccessFile to read from
   /// \return arrow::Status indicating success or failure
-  arrow::Status OpenParquet(
+  arrow::Status open_parquet(
       const std::shared_ptr<arrow::io::RandomAccessFile> &file);
 
   /// Open an IPC file and initialize metadata
   /// \param file The RandomAccessFile to read from
   /// \return arrow::Status indicating success or failure
-  arrow::Status OpenIPC(
+  arrow::Status open_ipc(
       const std::shared_ptr<arrow::io::RandomAccessFile> &file);
 
   /// Fetch data from a parquet file
   /// \param columns The list of column names to fetch
   /// \param indices The list of row indices to fetch
   /// \return A table containing the requested data or nullptr on failure
-  TablePtr FetchParquet(const std::vector<std::string> &columns,
-                        const std::vector<int> &indices);
+  TablePtr fetch_parquet(const std::vector<std::string> &columns,
+                         const std::vector<int> &indices);
 
   /// Fetch specific columns and a single row index from parquet file
   /// \param columns The list of column names to fetch
   /// \param index The row index to fetch
   /// \return An ExecBatch containing the requested data or nullptr on failure
-  ExecBatchPtr FetchParquet(const std::vector<std::string> &columns, int index);
+  ExecBatchPtr fetch_parquet(const std::vector<std::string> &columns,
+                             int index);
 
   /// Fetch data from an IPC file
   /// \param columns The list of column names to fetch
   /// \param indices The list of row indices to fetch
   /// \return A table containing the requested data or nullptr on failure
-  TablePtr FetchIPC(const std::vector<std::string> &columns,
-                    const std::vector<int> &indices);
+  TablePtr fetch_ipc(const std::vector<std::string> &columns,
+                     const std::vector<int> &indices);
 
   /// Fetch specific columns and a single row index from IPC file
   /// \param columns The list of column names to fetch
   /// \param index The row index to fetch
   /// \return An ExecBatch containing the requested data or nullptr on failure
-  ExecBatchPtr FetchIPC(const std::vector<std::string> &columns, int index);
+  ExecBatchPtr fetch_ipc(const std::vector<std::string> &columns, int index);
 
   /// Scan data from a parquet file
   /// \param columns The list of column names to scan
   /// \return A RecordBatchReader for streaming the data or nullptr on failure
-  RecordBatchReaderPtr ScanParquet(const std::vector<std::string> &columns);
+  RecordBatchReaderPtr scan_parquet(const std::vector<std::string> &columns);
 
   /// Scan data from an IPC file
   /// \param columns The list of column names to scan
   /// \return A RecordBatchReader for streaming the data or nullptr on failure
-  RecordBatchReaderPtr ScanIPC(const std::vector<std::string> &columns);
+  RecordBatchReaderPtr scan_ipc(const std::vector<std::string> &columns);
 
   /// Find which row group contains a given row
   /// \param row The row index to locate
   /// \return The row group ID containing the row
-  int FindRowGroupForRow(int64_t row);
+  int find_row_group_for_row(int64_t row);
 
   /// Get the row offset for a given row group
   /// \param rg_id The row group ID
   /// \return The row offset of the row group, or -1 on error
-  int64_t GetRowGroupOffset(int rg_id);
+  int64_t get_row_group_offset(int rg_id);
 
   /// Find the chunk that contains a target row index using binary search
   /// \param target_index The row index to locate
@@ -155,8 +156,8 @@ class MmapForwardStore : public BaseForwardStore {
   /// \param offset_in_chunk Output parameter for the offset within the found
   /// chunk
   /// \return true if the target chunk was found, false otherwise
-  bool FindTargetChunk(int target_index, int num_chunks,
-                       int *target_chunk_index, int64_t *offset_in_chunk);
+  bool find_target_chunk(int target_index, int num_chunks,
+                         int *target_chunk_index, int64_t *offset_in_chunk);
 
  private:
   /// Format of the file being accessed
diff --git a/src/db/index/storage/parquet_writer.h b/src/db/index/storage/parquet_writer.h
index bdee33563..6f743a29b 100644
--- a/src/db/index/storage/parquet_writer.h
+++ b/src/db/index/storage/parquet_writer.h
@@ -29,7 +29,7 @@ class ParquetWriter : public ForwardWriter {
   explicit ParquetWriter(const std::string &filepath,
                          int64_t max_rows_per_group = 0);
 
-  ~ParquetWriter();
+  ~ParquetWriter() override;
 
   arrow::Status insert(std::shared_ptr<arrow::RecordBatchReader> reader,
                        const IndexFilter::Ptr &filter = nullptr) override;
diff --git a/src/db/index/storage/store_helper.h b/src/db/index/storage/store_helper.h
index a58d6f484..84a3bc57d 100644
--- a/src/db/index/storage/store_helper.h
+++ b/src/db/index/storage/store_helper.h
@@ -924,8 +924,8 @@ inline arrow::Status WriteColumnInBlocks(
     auto writer = ChunkedFileWriter::Open(
         path, physic_schema,
         use_parquet ? FileFormat::PARQUET : FileFormat::IPC);
-    ARROW_RETURN_NOT_OK(writer->Write(*table));
-    ARROW_RETURN_NOT_OK(writer->Close());
+    ARROW_RETURN_NOT_OK(writer->write(*table));
+    ARROW_RETURN_NOT_OK(writer->close());
 
     BlockMeta new_block(block_id, BlockType::SCALAR, block.min_doc_id_,
                         block.max_doc_id_, block.doc_count_, {column_name});
diff --git a/src/db/index/storage/wal/local_wal_file.h b/src/db/index/storage/wal/local_wal_file.h
index d4f392fa8..b0f0ce5f4 100644
--- a/src/db/index/storage/wal/local_wal_file.h
+++ b/src/db/index/storage/wal/local_wal_file.h
@@ -52,7 +52,7 @@ class LocalWalFile : public WalFile {
   LocalWalFile(const std::string &wal_path) : wal_path_(wal_path) {}
 
   //! Destructor
-  ~LocalWalFile() {
+  ~LocalWalFile() override {
     if (opened_) {
       close();
     }
diff --git a/src/db/sqlengine/analyzer/query_analyzer.cc b/src/db/sqlengine/analyzer/query_analyzer.cc
index e9594313a..1be32cd99 100644
--- a/src/db/sqlengine/analyzer/query_analyzer.cc
+++ b/src/db/sqlengine/analyzer/query_analyzer.cc
@@ -30,7 +30,7 @@
 
 namespace zvec::sqlengine {
 
-const std::map<NodeOp, QueryNodeOp> QueryAnalyzer::opMap_ = {
+const std::map<NodeOp, QueryNodeOp> QueryAnalyzer::opMap = {
     {NodeOp::T_AND, QueryNodeOp::Q_AND},
     {NodeOp::T_OR, QueryNodeOp::Q_OR},
     {NodeOp::T_EQ, QueryNodeOp::Q_EQ},
@@ -504,8 +504,8 @@ QueryNode::Ptr QueryAnalyzer::create_querynode_from_node(const Node::Ptr &node,
 }
 
 QueryNodeOp QueryAnalyzer::nodeop_2_query_nodeop(NodeOp op) {
-  auto iter = opMap_.find(op);
-  if (iter == opMap_.end()) {
+  auto iter = opMap.find(op);
+  if (iter == opMap.end()) {
     return QueryNodeOp::Q_NONE;
   }
   return iter->second;
diff --git a/src/db/sqlengine/analyzer/query_analyzer.h b/src/db/sqlengine/analyzer/query_analyzer.h
index 386b47cfe..da55f334d 100644
--- a/src/db/sqlengine/analyzer/query_analyzer.h
+++ b/src/db/sqlengine/analyzer/query_analyzer.h
@@ -52,7 +52,7 @@ class QueryAnalyzer {
                                  QueryInfo *query_info, QueryNode *filter_cond);
 
  private:
-  static const std::map<NodeOp, QueryNodeOp> opMap_;
+  static const std::map<NodeOp, QueryNodeOp> opMap;
   static const int DEFAULT_TOPN = 20;
   static const size_t kMaxNumOfFilters = 4096;
 };
diff --git a/src/db/sqlengine/analyzer/query_node.h b/src/db/sqlengine/analyzer/query_node.h
index 8f44adec1..dfd1025c7 100644
--- a/src/db/sqlengine/analyzer/query_node.h
+++ b/src/db/sqlengine/analyzer/query_node.h
@@ -57,7 +57,7 @@ enum class QueryNodeOp {
 };
 
 class QueryInfo;
-class QueryNode : public Generic_Node<QueryNodeOp, QueryNode> {
+class QueryNode : public GenericNode<QueryNodeOp, QueryNode> {
  public:
   using Ptr = std::shared_ptr<QueryNode>;
 
@@ -106,8 +106,8 @@ class QueryNode : public Generic_Node<QueryNodeOp, QueryNode> {
   };
 
  public:
-  QueryNode() : Generic_Node(QueryNodeOp::Q_NONE) {}
-  QueryNode(QueryNodeOp m_op) : Generic_Node(m_op) {
+  QueryNode() : GenericNode(QueryNodeOp::Q_NONE) {}
+  QueryNode(QueryNodeOp m_op) : GenericNode(m_op) {
     set_op(m_op);
   }
   ~QueryNode() override = default;
@@ -129,7 +129,7 @@ class QueryNode : public Generic_Node<QueryNodeOp, QueryNode> {
   virtual bool is_matched(const QueryNode &other) const;
 
   void set_op(QueryNodeOp value) override {
-    Generic_Node<QueryNodeOp, QueryNode>::set_op(value);
+    GenericNode<QueryNodeOp, QueryNode>::set_op(value);
     set_type_by_op();
   }
 
diff --git a/src/db/sqlengine/antlr/gen/.clang-tidy b/src/db/sqlengine/antlr/gen/.clang-tidy
new file mode 100644
index 000000000..9510802a1
--- /dev/null
+++ b/src/db/sqlengine/antlr/gen/.clang-tidy
@@ -0,0 +1,2 @@
+Checks: "-*"
+InheritParentConfig: false
diff --git a/src/db/sqlengine/common/generic_node.h b/src/db/sqlengine/common/generic_node.h
index 2275c3d57..5cb88ae70 100644
--- a/src/db/sqlengine/common/generic_node.h
+++ b/src/db/sqlengine/common/generic_node.h
@@ -20,12 +20,12 @@
 namespace zvec::sqlengine {
 
 template <typename NodeOp, typename Node>
-class Generic_Node {
+class GenericNode {
  public:
   using Ptr = std::shared_ptr<Node>;
 
-  Generic_Node(NodeOp m_op);
-  virtual ~Generic_Node() = default;
+  GenericNode(NodeOp m_op);
+  virtual ~GenericNode() = default;
 
   void set_left(Ptr m_left);
   void set_right(Ptr m_right);
@@ -41,8 +41,8 @@ class Generic_Node {
   Node *right_node() const {
     return right_.get();
   }
-  void set_parent(Generic_Node *m_parent);
-  Generic_Node *parent();
+  void set_parent(GenericNode *m_parent);
+  GenericNode *parent();
 
   virtual NodeOp op() const {
     return op_;
@@ -56,34 +56,34 @@ class Generic_Node {
   NodeOp op_;
   Ptr left_{nullptr};
   Ptr right_{nullptr};
-  Generic_Node *parent_{nullptr};
+  GenericNode *parent_{nullptr};
 };
 
 template <typename NodeOp, typename Node>
-Generic_Node<NodeOp, Node>::Generic_Node(NodeOp m_op) {
+GenericNode<NodeOp, Node>::GenericNode(NodeOp m_op) {
   op_ = m_op;
 }
 
 template <typename NodeOp, typename Node>
-void Generic_Node<NodeOp, Node>::set_left(Ptr m_left) {
+void GenericNode<NodeOp, Node>::set_left(Ptr m_left) {
   left_ = std::move(m_left);
   if (left_ != nullptr) {
     left_->set_parent(this);
   }
 }
 template <typename NodeOp, typename Node>
-void Generic_Node<NodeOp, Node>::set_right(Ptr m_right) {
+void GenericNode<NodeOp, Node>::set_right(Ptr m_right) {
   right_ = std::move(m_right);
   if (right_ != nullptr) {
     right_->set_parent(this);
   }
 }
 template <typename NodeOp, typename Node>
-void Generic_Node<NodeOp, Node>::set_parent(Generic_Node<NodeOp, Node> *value) {
+void GenericNode<NodeOp, Node>::set_parent(GenericNode<NodeOp, Node> *value) {
   this->parent_ = value;
 }
 template <typename NodeOp, typename Node>
-Generic_Node<NodeOp, Node> *Generic_Node<NodeOp, Node>::parent() {
+GenericNode<NodeOp, Node> *GenericNode<NodeOp, Node>::parent() {
   return parent_;
 }
 
diff --git a/src/db/sqlengine/parser/case_changing_charstream.h b/src/db/sqlengine/parser/case_changing_charstream.h
index eb6cb3f3e..b1ccd8005 100644
--- a/src/db/sqlengine/parser/case_changing_charstream.h
+++ b/src/db/sqlengine/parser/case_changing_charstream.h
@@ -33,15 +33,15 @@ class CaseChangingCharStream : public CharStream {
     upper_ = m_upper;
   }
 
-  std::string getText(const misc::Interval &interval) {
+  std::string getText(const misc::Interval &interval) override {
     return stream_->getText(interval);
   }
 
-  void consume() {
+  void consume() override {
     stream_->consume();
   }
 
-  size_t LA(ssize_t i) {
+  size_t LA(ssize_t i) override {
     size_t c = stream_->LA(i);
     if (c <= 0) {
       return c;
@@ -52,31 +52,31 @@ class CaseChangingCharStream : public CharStream {
     return tolower((int)c);
   }
 
-  ssize_t mark() {
+  ssize_t mark() override {
     return stream_->mark();
   }
 
-  void release(ssize_t marker) {
+  void release(ssize_t marker) override {
     stream_->release(marker);
   }
 
-  size_t index() {
+  size_t index() override {
     return stream_->index();
   }
 
-  void seek(size_t m_index) {
+  void seek(size_t m_index) override {
     stream_->seek(m_index);
   }
 
-  size_t size() {
+  size_t size() override {
     return stream_->size();
   }
 
-  std::string getSourceName() const {
+  std::string getSourceName() const override {
     return stream_->getSourceName();
   }
 
-  std::string toString() const {
+  std::string toString() const override {
     return stream_->toString();
   }
 
diff --git a/src/db/sqlengine/parser/error_verbose_listener.h b/src/db/sqlengine/parser/error_verbose_listener.h
index 1de99ab3c..59cb0342d 100644
--- a/src/db/sqlengine/parser/error_verbose_listener.h
+++ b/src/db/sqlengine/parser/error_verbose_listener.h
@@ -26,17 +26,17 @@ using namespace antlr4;
 class ErrorVerboseListener : BaseErrorListener {
  public:
   ErrorVerboseListener() = default;
-  ~ErrorVerboseListener() = default;
+  ~ErrorVerboseListener() override = default;
 
-  void syntaxError(Recognizer *recognizer, Token *offendingSymbol, size_t line,
-                   size_t charPositionInLine, const std::string &msg,
-                   std::exception_ptr e) {
+  void syntaxError(Recognizer *recognizer, Token *offending_symbol, size_t line,
+                   size_t char_position_in_line, const std::string &msg,
+                   std::exception_ptr e) override {
     UNUSED(recognizer);
-    UNUSED(offendingSymbol);
+    UNUSED(offending_symbol);
     UNUSED(e);
 
-    err_msg_ = std::to_string(line) + " " + std::to_string(charPositionInLine) +
-               " " + msg;
+    err_msg_ = std::to_string(line) + " " +
+               std::to_string(char_position_in_line) + " " + msg;
     return;
   }
 
diff --git a/src/db/sqlengine/parser/node.cc b/src/db/sqlengine/parser/node.cc
index 87a0db748..70f240805 100644
--- a/src/db/sqlengine/parser/node.cc
+++ b/src/db/sqlengine/parser/node.cc
@@ -19,14 +19,14 @@
 
 namespace zvec::sqlengine {
 
-Node::Node() : Generic_Node(NodeOp::T_NONE) {}
+Node::Node() : GenericNode(NodeOp::T_NONE) {}
 
-Node::Node(NodeOp m_op) : Generic_Node(m_op) {
+Node::Node(NodeOp m_op) : GenericNode(m_op) {
   set_op(m_op);
 }
 
 void Node::set_op(NodeOp value) {
-  Generic_Node<NodeOp, Node>::set_op(value);
+  GenericNode<NodeOp, Node>::set_op(value);
   set_type_by_op();
 }
 
diff --git a/src/db/sqlengine/parser/node.h b/src/db/sqlengine/parser/node.h
index e83ae7884..32a595981 100644
--- a/src/db/sqlengine/parser/node.h
+++ b/src/db/sqlengine/parser/node.h
@@ -57,7 +57,7 @@ enum class NodeOp {
   T_BOOL_VALUE
 };
 
-class Node : public Generic_Node<NodeOp, Node> {
+class Node : public GenericNode<NodeOp, Node> {
  public:
   using Ptr = std::shared_ptr<Node>;
 
diff --git a/src/db/sqlengine/parser/query_parser.cc b/src/db/sqlengine/parser/query_parser.cc
index f28b37cfe..97552e92d 100644
--- a/src/db/sqlengine/parser/query_parser.cc
+++ b/src/db/sqlengine/parser/query_parser.cc
@@ -17,11 +17,11 @@
 namespace zvec::sqlengine {
 
 SQLInfo::Ptr QueryParser::parse(const std::string &query) {
-  ZVecSQLParser se_sql_parser_;
+  ZVecSQLParser se_sql_parser;
 
-  SQLInfo::Ptr sql_info = se_sql_parser_.parse(query);
+  SQLInfo::Ptr sql_info = se_sql_parser.parse(query);
   if (sql_info == nullptr) {
-    err_msg_ = se_sql_parser_.err_msg();
+    err_msg_ = se_sql_parser.err_msg();
     return nullptr;
   }
 
diff --git a/src/db/sqlengine/parser/select_info.h b/src/db/sqlengine/parser/select_info.h
index c393ef756..39b127183 100644
--- a/src/db/sqlengine/parser/select_info.h
+++ b/src/db/sqlengine/parser/select_info.h
@@ -31,7 +31,7 @@ class SelectInfo : public BaseInfo {
   using Ptr = std::shared_ptr<SelectInfo>;
 
   SelectInfo(const std::string &m_table_name);
-  ~SelectInfo();
+  ~SelectInfo() override;
 
   SelectInfo(const SelectInfo &info);
   SelectInfo &operator=(const SelectInfo &info);
@@ -82,7 +82,7 @@ class SelectInfo : public BaseInfo {
     return fts_cond_info_ != nullptr;
   }
 
-  std::string to_string();
+  std::string to_string() override;
 
  private:
   Node::Ptr copy_node(const Node::Ptr &node);
diff --git a/src/db/sqlengine/parser/zvec_cached_sql_parser.cc b/src/db/sqlengine/parser/zvec_cached_sql_parser.cc
index 8a3b1e734..22a6aa601 100644
--- a/src/db/sqlengine/parser/zvec_cached_sql_parser.cc
+++ b/src/db/sqlengine/parser/zvec_cached_sql_parser.cc
@@ -36,8 +36,8 @@ namespace zvec::sqlengine {
 std::unordered_map<std::string, SQLInfo::Ptr>
     ZVecCachedSQLParser::sql_info_map_{};
 std::unordered_map<std::string, Node::Ptr> ZVecCachedSQLParser::filter_map_;
-uint32_t ZVecCachedSQLParser::Hit{0};
-uint32_t ZVecCachedSQLParser::Miss{0};
+uint32_t ZVecCachedSQLParser::hit{0};
+uint32_t ZVecCachedSQLParser::miss{0};
 
 ZVecCachedSQLParser::ZVecCachedSQLParser(uint32_t cache_count)
     : cache_count_(cache_count) {}
@@ -71,7 +71,7 @@ void ZVecCachedSQLParser::put_into_cache(const std::string &query_cache_key,
     if (sql_info_map_.size() >= cache_count_) {
       // if full, clear to refresh new sql
       sql_info_map_.clear();
-      Hit = Miss = 0;
+      hit = miss = 0;
     }
     sql_info_map_.emplace(query_cache_key, new_sql_info);
   }
@@ -107,7 +107,7 @@ SQLInfo::Ptr ZVecCachedSQLParser::get_from_cache(const std::string &query,
     std::shared_lock guard(shared_mutex_);
     auto iter = sql_info_map_.find(*query_cache_key);
     if (iter == sql_info_map_.end()) {
-      ++Miss;
+      ++miss;
       LOG_DEBUG("cache miss. key: [%s]", query_cache_key->c_str());
       return nullptr;
     }
@@ -130,7 +130,7 @@ SQLInfo::Ptr ZVecCachedSQLParser::get_from_cache(const std::string &query,
     return nullptr;
   }
 
-  ++Hit;
+  ++hit;
   LOG_DEBUG("cache hit. key: [%s] sql_info: [%s]", query_cache_key->c_str(),
             copied_sql_info->to_string().c_str());
   return copied_sql_info;
@@ -211,10 +211,10 @@ Node::Ptr ZVecCachedSQLParser::parse_filter(const std::string &filter,
     std::shared_lock guard(shared_mutex_);
     auto iter = filter_map_.find(filter);
     if (iter != filter_map_.end()) {
-      ++Hit;
+      ++hit;
       return iter->second;
     }
-    ++Miss;
+    ++miss;
   }
   auto node = real_parser_.parse_filter(filter, need_formatted_tree);
   err_msg_ = real_parser_.err_msg();
@@ -224,7 +224,7 @@ Node::Ptr ZVecCachedSQLParser::parse_filter(const std::string &filter,
     if (filter_map_.size() >= cache_count_) {
       // clear cache if full
       filter_map_.clear();
-      Hit = Miss = 0;
+      hit = miss = 0;
     }
     filter_map_.emplace(filter, node);
   }
diff --git a/src/db/sqlengine/parser/zvec_cached_sql_parser.h b/src/db/sqlengine/parser/zvec_cached_sql_parser.h
index 35c7bd624..3b1d9805d 100644
--- a/src/db/sqlengine/parser/zvec_cached_sql_parser.h
+++ b/src/db/sqlengine/parser/zvec_cached_sql_parser.h
@@ -24,7 +24,7 @@ namespace zvec::sqlengine {
 class ZVecCachedSQLParser : public ZVecParser {
  public:
   ZVecCachedSQLParser(uint32_t cache_count);
-  ~ZVecCachedSQLParser();
+  ~ZVecCachedSQLParser() override;
 
   SQLInfo::Ptr parse(const std::string &query,
                      bool need_formatted_tree = false) override;
@@ -44,8 +44,8 @@ class ZVecCachedSQLParser : public ZVecParser {
  private:
   static std::unordered_map<std::string, SQLInfo::Ptr> sql_info_map_;
   static std::unordered_map<std::string, Node::Ptr> filter_map_;
-  static uint32_t Hit;
-  static uint32_t Miss;
+  static uint32_t hit;
+  static uint32_t miss;
   inline static std::shared_mutex shared_mutex_;
 
  private:
diff --git a/src/db/sqlengine/parser/zvec_parser.cc b/src/db/sqlengine/parser/zvec_parser.cc
index d56253ff9..1a3975fee 100644
--- a/src/db/sqlengine/parser/zvec_parser.cc
+++ b/src/db/sqlengine/parser/zvec_parser.cc
@@ -63,7 +63,7 @@ std::string ZVecParser::to_formatted_string_tree(void *tree, void *parser) {
   int i = 0, num = 0;
   const std::string DELIMITER = "  ";
   const std::string LINE = "\n";
-  int lastPos1 = 0;
+  int last_pos1 = 0;
 
   std::string out;
 
@@ -83,14 +83,14 @@ std::string ZVecParser::to_formatted_string_tree(void *tree, void *parser) {
     }
 
     if (pos1 >= 0 && pos1 < pos2) {
-      if (lastPos1 == 1) {
+      if (last_pos1 == 1) {
         formatted += "(";
       }
       pos = pos1;
       formatted += tree_text.substr(start, (size_t)pos1 - start);
       num++;
     } else {
-      if (lastPos1 == 1) {
+      if (last_pos1 == 1) {
         formatted += "(";
       }
       pos = pos2;
@@ -106,9 +106,9 @@ std::string ZVecParser::to_formatted_string_tree(void *tree, void *parser) {
     start = pos + 1;
 
     if (pos == pos1) {
-      lastPos1 = 1;
+      last_pos1 = 1;
     } else {
-      lastPos1 = 0;
+      last_pos1 = 0;
     }
 
     out += formatted;
diff --git a/src/db/sqlengine/parser/zvec_sql_parser.cc b/src/db/sqlengine/parser/zvec_sql_parser.cc
index d9942b0b2..efcb032c3 100644
--- a/src/db/sqlengine/parser/zvec_sql_parser.cc
+++ b/src/db/sqlengine/parser/zvec_sql_parser.cc
@@ -85,8 +85,8 @@ SQLInfo::Ptr ZVecSQLParser::parse(const std::string &query,
       formatted_tree_ = to_formatted_string_tree(tree, &parser);
     }
 
-    SQLInfo::Ptr sqlInfo = sql_info(tree);
-    return sqlInfo;
+    SQLInfo::Ptr info = sql_info(tree);
+    return info;
   } catch (std::exception &e) {
     err_msg_ = "parse error [" + std::string(e.what()) + "]";
     return nullptr;
@@ -94,38 +94,38 @@ SQLInfo::Ptr ZVecSQLParser::parse(const std::string &query,
 }
 
 SQLInfo::Ptr ZVecSQLParser::sql_info(VoidPtr tree) {
-  ParseTree *parseTree = reinterpret_cast<ParseTree *>(tree);
+  ParseTree *parse_tree = reinterpret_cast<ParseTree *>(tree);
   SQLParser::Compilation_unitContext *compilation_unit_node =
-      (SQLParser::Compilation_unitContext *)parseTree;
+      (SQLParser::Compilation_unitContext *)parse_tree;
   SQLParser::Unit_statementContext *unit_statement_node =
       (SQLParser::Unit_statementContext *)compilation_unit_node->children[0];
 
-  SQLInfo::SQLType sqlType = sql_type(unit_statement_node);
-  if (sqlType == SQLInfo::SQLType::NONE) {
+  SQLInfo::SQLType type = sql_type(unit_statement_node);
+  if (type == SQLInfo::SQLType::NONE) {
     return nullptr;
   }
 
-  BaseInfo::Ptr baseInfo = nullptr;
-  switch (sqlType) {
+  BaseInfo::Ptr base_info = nullptr;
+  switch (type) {
     case SQLInfo::SQLType::SELECT:
-      baseInfo =
+      base_info =
           select_info(unit_statement_node->dql_statement()->select_statement());
       break;
     default:
       break;
   }
 
-  if (baseInfo == nullptr) {
+  if (base_info == nullptr) {
     return nullptr;
   }
 
-  if (baseInfo->validate() == false) {
-    err_msg_ = baseInfo->err_msg();
+  if (base_info->validate() == false) {
+    err_msg_ = base_info->err_msg();
     return nullptr;
   }
 
-  SQLInfo::Ptr sqlInfo = std::make_shared<SQLInfo>(sqlType, baseInfo);
-  return sqlInfo;
+  SQLInfo::Ptr info = std::make_shared<SQLInfo>(type, base_info);
+  return info;
 }
 
 SQLInfo::SQLType ZVecSQLParser::sql_type(VoidPtr node) {
@@ -164,7 +164,7 @@ SelectInfo::Ptr ZVecSQLParser::select_info(VoidPtr node) {
   if (from_clause_node->tableview_name() != nullptr) {
     table_name = from_clause_node->tableview_name()->getText();
   }
-  SelectInfo::Ptr selectInfo = std::make_shared<SelectInfo>(table_name);
+  SelectInfo::Ptr select_info = std::make_shared<SelectInfo>(table_name);
 
   for (auto selected_element_node :
        selected_elements_node->selected_element()) {
@@ -182,7 +182,7 @@ SelectInfo::Ptr ZVecSQLParser::select_info(VoidPtr node) {
       selected_elem_info->set_asterisk(true);
     }
 
-    selectInfo->add_selected_elem(std::move(selected_elem_info));
+    select_info->add_selected_elem(std::move(selected_elem_info));
   }
 
   if (where_node) {
@@ -190,7 +190,7 @@ SelectInfo::Ptr ZVecSQLParser::select_info(VoidPtr node) {
     if (cond == nullptr) {
       return nullptr;
     }
-    selectInfo->set_search_cond(std::move(cond));
+    select_info->set_search_cond(std::move(cond));
   }
 
   if (order_by_node != nullptr) {
@@ -201,15 +201,15 @@ SelectInfo::Ptr ZVecSQLParser::select_info(VoidPtr node) {
       if (order_by_element->DESC()) {
         orderby_elem_info->set_desc();
       }
-      selectInfo->add_order_by_elem(std::move(orderby_elem_info));
+      select_info->add_order_by_elem(std::move(orderby_elem_info));
     }
   }
 
   if (limit_node != nullptr) {
-    selectInfo->set_limit(std::stoi(limit_node->int_value()->getText()));
+    select_info->set_limit(std::stoi(limit_node->int_value()->getText()));
   }
 
-  return selectInfo;
+  return select_info;
 }
 
 Node::Ptr ZVecSQLParser::handle_logic_expr_node(VoidPtr node) {
@@ -262,17 +262,17 @@ Node::Ptr ZVecSQLParser::handle_logic_expr_node(VoidPtr node) {
     Frame frame = stack.back();
     stack.pop_back();
 
-    SQLParser::Logic_exprContext *logicExprNode = unwrap_enclosed(frame.node);
-    if (logicExprNode == nullptr) {
+    SQLParser::Logic_exprContext *logic_expr_node = unwrap_enclosed(frame.node);
+    if (logic_expr_node == nullptr) {
       attach_node(frame.parent, nullptr, frame.bind_type);
       continue;
     }
 
-    if (logicExprNode->OR() != nullptr) {
+    if (logic_expr_node->OR() != nullptr) {
       // An AND subtree remains one operand, preserving precedence and grouping.
       // Parentheses around OR are safe to flatten because OR is associative.
       std::vector<SQLParser::Logic_exprContext *> operands;
-      std::vector<SQLParser::Logic_exprContext *> pending{logicExprNode};
+      std::vector<SQLParser::Logic_exprContext *> pending{logic_expr_node};
       while (!pending.empty()) {
         SQLParser::Logic_exprContext *current = unwrap_enclosed(pending.back());
         pending.pop_back();
@@ -300,7 +300,7 @@ Node::Ptr ZVecSQLParser::handle_logic_expr_node(VoidPtr node) {
       }
 
       if (operands.size() <= kOrBalanceThreshold) {
-        const auto &children = logicExprNode->logic_expr();
+        const auto &children = logic_expr_node->logic_expr();
         Node::Ptr expr = std::make_shared<Node>(NodeOp::T_OR);
         Node *expr_raw = expr.get();
         attach_node(frame.parent, std::move(expr), frame.bind_type);
@@ -334,8 +334,8 @@ Node::Ptr ZVecSQLParser::handle_logic_expr_node(VoidPtr node) {
         stack.push_back({operands[i], operand_targets[i].parent,
                          operand_targets[i].bind_type});
       }
-    } else if (logicExprNode->AND() != nullptr) {
-      const auto &children = logicExprNode->logic_expr();
+    } else if (logic_expr_node->AND() != nullptr) {
+      const auto &children = logic_expr_node->logic_expr();
       if (children.size() != 2U) {
         err_msg_ = "Parse failed. Invalid AND expression.";
         attach_node(frame.parent, nullptr, frame.bind_type);
@@ -349,9 +349,9 @@ Node::Ptr ZVecSQLParser::handle_logic_expr_node(VoidPtr node) {
       // subroot selection is currently shape-dependent.
       stack.push_back({children[1], expr_raw, BindType::RIGHT});
       stack.push_back({children[0], expr_raw, BindType::LEFT});
-    } else if (logicExprNode->relation_expr() != nullptr) {
+    } else if (logic_expr_node->relation_expr() != nullptr) {
       attach_node(frame.parent,
-                  handle_rel_expr_node(logicExprNode->relation_expr()),
+                  handle_rel_expr_node(logic_expr_node->relation_expr()),
                   frame.bind_type);
     } else {
       attach_node(frame.parent, nullptr, frame.bind_type);
@@ -362,90 +362,90 @@ Node::Ptr ZVecSQLParser::handle_logic_expr_node(VoidPtr node) {
 }
 
 Node::Ptr ZVecSQLParser::handle_rel_expr_left_node(VoidPtr node) {
-  SQLParser::Relation_exprContext *relationExprNode =
+  SQLParser::Relation_exprContext *relation_expr_node =
       reinterpret_cast<SQLParser::Relation_exprContext *>(node);
   // either identifier or function call
-  if (relationExprNode->identifier() != nullptr) {
-    return handle_id_node(relationExprNode->identifier());
-  } else if (relationExprNode->function_call() != nullptr) {
-    return handle_function_call_node(relationExprNode->function_call());
+  if (relation_expr_node->identifier() != nullptr) {
+    return handle_id_node(relation_expr_node->identifier());
+  } else if (relation_expr_node->function_call() != nullptr) {
+    return handle_function_call_node(relation_expr_node->function_call());
   }
 
   err_msg_ = "Parse failed. Unexpected rel expr left node." +
-             relationExprNode->getText();
+             relation_expr_node->getText();
   return nullptr;
 }
 
 Node::Ptr ZVecSQLParser::handle_rel_expr_node(VoidPtr node) {
-  SQLParser::Relation_exprContext *relationExprNode =
+  SQLParser::Relation_exprContext *relation_expr_node =
       reinterpret_cast<SQLParser::Relation_exprContext *>(node);
-  if (relationExprNode->rel_oper() != nullptr) {
-    SQLParser::Rel_operContext *op = relationExprNode->rel_oper();
-    NodeOp nodeOp = NodeOp::T_NONE;
+  if (relation_expr_node->rel_oper() != nullptr) {
+    SQLParser::Rel_operContext *op = relation_expr_node->rel_oper();
+    NodeOp node_op = NodeOp::T_NONE;
     if (op->E_OP()) {
-      nodeOp = NodeOp::T_EQ;
+      node_op = NodeOp::T_EQ;
     } else if (op->ne_op()) {
-      nodeOp = NodeOp::T_NE;
+      node_op = NodeOp::T_NE;
     } else if (op->L_OP()) {
-      nodeOp = NodeOp::T_LT;
+      node_op = NodeOp::T_LT;
     } else if (op->G_OP()) {
-      nodeOp = NodeOp::T_GT;
+      node_op = NodeOp::T_GT;
     } else if (op->le_op()) {
-      nodeOp = NodeOp::T_LE;
+      node_op = NodeOp::T_LE;
     } else if (op->ge_op()) {
-      nodeOp = NodeOp::T_GE;
+      node_op = NodeOp::T_GE;
     }
-    Node::Ptr relationalExpr = std::make_shared<Node>(nodeOp);
-    relationalExpr->set_left(handle_rel_expr_left_node(relationExprNode));
+    Node::Ptr relational_expr = std::make_shared<Node>(node_op);
+    relational_expr->set_left(handle_rel_expr_left_node(relation_expr_node));
     Node::Ptr value_node =
-        handle_value_expr_node(relationExprNode->value_expr());
+        handle_value_expr_node(relation_expr_node->value_expr());
     if (value_node == nullptr) {
       return nullptr;
     }
-    relationalExpr->set_right(std::move(value_node));
-    return relationalExpr;
-  } else if (relationExprNode->LIKE() != nullptr) {
-    NodeOp nodeOp = NodeOp::T_LIKE;
-    Node::Ptr relationalExpr = std::make_shared<Node>(nodeOp);
-    relationalExpr->set_left(handle_rel_expr_left_node(relationExprNode));
+    relational_expr->set_right(std::move(value_node));
+    return relational_expr;
+  } else if (relation_expr_node->LIKE() != nullptr) {
+    NodeOp node_op = NodeOp::T_LIKE;
+    Node::Ptr relational_expr = std::make_shared<Node>(node_op);
+    relational_expr->set_left(handle_rel_expr_left_node(relation_expr_node));
     Node::Ptr value_node =
-        handle_value_expr_node(relationExprNode->value_expr());
+        handle_value_expr_node(relation_expr_node->value_expr());
     if (value_node == nullptr) {
       return nullptr;
     }
-    relationalExpr->set_right(std::move(value_node));
-    return relationalExpr;
-  } else if (relationExprNode->IN() != nullptr ||
-             relationExprNode->CONTAIN_ALL() != nullptr ||
-             relationExprNode->CONTAIN_ANY() != nullptr) {
-    NodeOp nodeOp = NodeOp::T_NONE;
-
-    if (relationExprNode->CONTAIN_ALL() != nullptr) {
-      nodeOp = NodeOp::T_CONTAIN_ALL;
-    } else if (relationExprNode->CONTAIN_ANY() != nullptr) {
-      nodeOp = NodeOp::T_CONTAIN_ANY;
+    relational_expr->set_right(std::move(value_node));
+    return relational_expr;
+  } else if (relation_expr_node->IN() != nullptr ||
+             relation_expr_node->CONTAIN_ALL() != nullptr ||
+             relation_expr_node->CONTAIN_ANY() != nullptr) {
+    NodeOp node_op = NodeOp::T_NONE;
+
+    if (relation_expr_node->CONTAIN_ALL() != nullptr) {
+      node_op = NodeOp::T_CONTAIN_ALL;
+    } else if (relation_expr_node->CONTAIN_ANY() != nullptr) {
+      node_op = NodeOp::T_CONTAIN_ANY;
     } else {
       //      relationExprNode->IN() != nullptr
-      nodeOp = NodeOp::T_IN;
+      node_op = NodeOp::T_IN;
     }
 
-    Node::Ptr relationalExpr = std::make_shared<Node>(nodeOp);
-    relationalExpr->set_left(handle_rel_expr_left_node(relationExprNode));
+    Node::Ptr relational_expr = std::make_shared<Node>(node_op);
+    relational_expr->set_left(handle_rel_expr_left_node(relation_expr_node));
     Node::Ptr in_value_expr_list_node =
-        handle_in_value_expr_list_node(relationExprNode->in_value_expr_list(),
-                                       relationExprNode->NOT() != nullptr);
+        handle_in_value_expr_list_node(relation_expr_node->in_value_expr_list(),
+                                       relation_expr_node->NOT() != nullptr);
     if (in_value_expr_list_node == nullptr) {
       return nullptr;
     }
-    relationalExpr->set_right(std::move(in_value_expr_list_node));
-    return relationalExpr;
-  } else if (relationExprNode->NULL_V() != nullptr) {
-    NodeOp nodeOp = NodeOp::T_IS_NULL;
-    if (relationExprNode->NOT() != nullptr) {
-      nodeOp = NodeOp::T_IS_NOT_NULL;
+    relational_expr->set_right(std::move(in_value_expr_list_node));
+    return relational_expr;
+  } else if (relation_expr_node->NULL_V() != nullptr) {
+    NodeOp node_op = NodeOp::T_IS_NULL;
+    if (relation_expr_node->NOT() != nullptr) {
+      node_op = NodeOp::T_IS_NOT_NULL;
     }
-    auto null_node = std::make_shared<Node>(nodeOp);
-    null_node->set_left(handle_rel_expr_left_node(relationExprNode));
+    auto null_node = std::make_shared<Node>(node_op);
+    null_node->set_left(handle_rel_expr_left_node(relation_expr_node));
     auto right = std::make_shared<ConstantNode>("");
     right->set_op(NodeOp::T_NULL_VALUE);
     null_node->set_right(std::move(right));
@@ -456,40 +456,40 @@ Node::Ptr ZVecSQLParser::handle_rel_expr_node(VoidPtr node) {
 }
 
 Node::Ptr ZVecSQLParser::handle_value_expr_node(VoidPtr node) {
-  SQLParser::Value_exprContext *valueExprNode =
+  SQLParser::Value_exprContext *value_expr_node =
       reinterpret_cast<SQLParser::Value_exprContext *>(node);
 
-  if (valueExprNode->constant() != nullptr) {
-    return handle_const_node(valueExprNode->constant());
-  } else if (valueExprNode->function_call() != nullptr) {
-    return handle_function_call_node(valueExprNode->function_call());
+  if (value_expr_node->constant() != nullptr) {
+    return handle_const_node(value_expr_node->constant());
+  } else if (value_expr_node->function_call() != nullptr) {
+    return handle_function_call_node(value_expr_node->function_call());
   }
 
   return nullptr;
 }
 
 Node::Ptr ZVecSQLParser::handle_function_value_expr_node(VoidPtr node) {
-  SQLParser::Function_value_exprContext *valueExprNode =
+  SQLParser::Function_value_exprContext *value_expr_node =
       reinterpret_cast<SQLParser::Function_value_exprContext *>(node);
 
-  if (valueExprNode->value_expr() != nullptr) {
-    return handle_value_expr_node(valueExprNode->value_expr());
-  } else if (valueExprNode->identifier() != nullptr) {
-    return handle_id_node(valueExprNode->identifier());
+  if (value_expr_node->value_expr() != nullptr) {
+    return handle_value_expr_node(value_expr_node->value_expr());
+  } else if (value_expr_node->identifier() != nullptr) {
+    return handle_id_node(value_expr_node->identifier());
   }
 
   return nullptr;
 }
 
 Node::Ptr ZVecSQLParser::handle_in_value_expr_node(VoidPtr node) {
-  SQLParser::In_value_exprContext *inValueExprNode =
+  SQLParser::In_value_exprContext *in_value_expr_node =
       reinterpret_cast<SQLParser::In_value_exprContext *>(node);
 
-  if (inValueExprNode->constant_num_and_str() != nullptr) {
+  if (in_value_expr_node->constant_num_and_str() != nullptr) {
     return handle_const_num_and_str_node(
-        inValueExprNode->constant_num_and_str());
-  } else if (inValueExprNode->bool_value() != nullptr) {
-    return handle_bool_value_node(inValueExprNode->bool_value());
+        in_value_expr_node->constant_num_and_str());
+  } else if (in_value_expr_node->bool_value() != nullptr) {
+    return handle_bool_value_node(in_value_expr_node->bool_value());
   }
 
   return nullptr;
@@ -499,24 +499,24 @@ Node::Ptr ZVecSQLParser::handle_bool_value_node(
     antlr4::SQLParser::Bool_valueContext *node) {
   // normalize bool value
   auto value = node->TRUE_V() ? "true" : "false";
-  auto constExpr = std::make_shared<ConstantNode>(value);
-  constExpr->set_op(NodeOp::T_BOOL_VALUE);
-  return constExpr;
+  auto const_expr = std::make_shared<ConstantNode>(value);
+  const_expr->set_op(NodeOp::T_BOOL_VALUE);
+  return const_expr;
 }
 
 Node::Ptr ZVecSQLParser::handle_in_value_expr_list_node(VoidPtr node,
                                                         bool exclude) {
-  SQLParser::In_value_expr_listContext *inValueExprListContext =
+  SQLParser::In_value_expr_listContext *in_value_expr_list_context =
       reinterpret_cast<SQLParser::In_value_expr_listContext *>(node);
 
   InValueExprListNode::Ptr in_value_expr_list_node =
       std::make_shared<InValueExprListNode>();
   in_value_expr_list_node->set_exclude(exclude);
-  if (!inValueExprListContext) {
+  if (!in_value_expr_list_context) {
     return in_value_expr_list_node;
   }
 
-  auto in_value_expr_list = inValueExprListContext->in_value_expr();
+  auto in_value_expr_list = in_value_expr_list_context->in_value_expr();
   for (auto in_value_expr : in_value_expr_list) {
     Node::Ptr in_value_node = handle_in_value_expr_node(in_value_expr);
     if (in_value_node == nullptr) {
@@ -549,78 +549,78 @@ Node::Ptr ZVecSQLParser::handle_function_call_node(VoidPtr node) {
 }
 
 Node::Ptr ZVecSQLParser::handle_const_node(VoidPtr node) {
-  Node::Ptr constExpr = nullptr;
-  SQLParser::ConstantContext *constantNode =
+  Node::Ptr const_expr = nullptr;
+  SQLParser::ConstantContext *constant_node =
       reinterpret_cast<SQLParser::ConstantContext *>(node);
-  if (constantNode->numeric()) {
-    constExpr =
-        std::make_shared<ConstantNode>(constantNode->numeric()->getText());
-    if (constantNode->numeric()->int_value()) {
-      constExpr->set_op(NodeOp::T_INT_VALUE);
-    } else if (constantNode->numeric()->float_value()) {
-      constExpr->set_op(NodeOp::T_FLOAT_VALUE);
+  if (constant_node->numeric()) {
+    const_expr =
+        std::make_shared<ConstantNode>(constant_node->numeric()->getText());
+    if (constant_node->numeric()->int_value()) {
+      const_expr->set_op(NodeOp::T_INT_VALUE);
+    } else if (constant_node->numeric()->float_value()) {
+      const_expr->set_op(NodeOp::T_FLOAT_VALUE);
     }
-  } else if (constantNode->quoted_string()) {
-    std::string value = constantNode->quoted_string()->getText();
+  } else if (constant_node->quoted_string()) {
+    std::string value = constant_node->quoted_string()->getText();
     value = trim(value);
     value = Util::normalize(value);
-    constExpr = std::make_shared<ConstantNode>(value);
-    constExpr->set_op(NodeOp::T_STRING_VALUE);
-  } else if (constantNode->vector_expr()) {
-    constExpr = handle_vector_expr_node(constantNode->vector_expr());
-    if (constExpr == nullptr) {
+    const_expr = std::make_shared<ConstantNode>(value);
+    const_expr->set_op(NodeOp::T_STRING_VALUE);
+  } else if (constant_node->vector_expr()) {
+    const_expr = handle_vector_expr_node(constant_node->vector_expr());
+    if (const_expr == nullptr) {
       err_msg_ = "Parse failed. vector format error." +
-                 constantNode->vector_expr()->getText();
+                 constant_node->vector_expr()->getText();
       LOG_ERROR("Parse failed. vector format error. [%s]",
-                constantNode->vector_expr()->getText().c_str());
+                constant_node->vector_expr()->getText().c_str());
       return nullptr;
     }
-  } else if (constantNode->bool_value()) {
-    constExpr = handle_bool_value_node(constantNode->bool_value());
+  } else if (constant_node->bool_value()) {
+    const_expr = handle_bool_value_node(constant_node->bool_value());
   }
 
-  return constExpr;
+  return const_expr;
 }
 
 Node::Ptr ZVecSQLParser::handle_const_num_and_str_node(VoidPtr node) {
-  Node::Ptr constExpr = nullptr;
-  SQLParser::Constant_num_and_strContext *constant_num_and_str_Node =
+  Node::Ptr const_expr = nullptr;
+  SQLParser::Constant_num_and_strContext *constant_num_and_str_node =
       reinterpret_cast<SQLParser::Constant_num_and_strContext *>(node);
-  if (constant_num_and_str_Node->numeric()) {
-    constExpr = std::make_shared<ConstantNode>(
-        constant_num_and_str_Node->numeric()->getText());
-    if (constant_num_and_str_Node->numeric()->int_value()) {
-      constExpr->set_op(NodeOp::T_INT_VALUE);
-    } else if (constant_num_and_str_Node->numeric()->float_value()) {
-      constExpr->set_op(NodeOp::T_FLOAT_VALUE);
+  if (constant_num_and_str_node->numeric()) {
+    const_expr = std::make_shared<ConstantNode>(
+        constant_num_and_str_node->numeric()->getText());
+    if (constant_num_and_str_node->numeric()->int_value()) {
+      const_expr->set_op(NodeOp::T_INT_VALUE);
+    } else if (constant_num_and_str_node->numeric()->float_value()) {
+      const_expr->set_op(NodeOp::T_FLOAT_VALUE);
     }
-  } else if (constant_num_and_str_Node->quoted_string()) {
-    std::string value = constant_num_and_str_Node->quoted_string()->getText();
+  } else if (constant_num_and_str_node->quoted_string()) {
+    std::string value = constant_num_and_str_node->quoted_string()->getText();
     value = trim(value);
     value = Util::normalize(value);
-    constExpr = std::make_shared<ConstantNode>(value);
-    constExpr->set_op(NodeOp::T_STRING_VALUE);
+    const_expr = std::make_shared<ConstantNode>(value);
+    const_expr->set_op(NodeOp::T_STRING_VALUE);
   }
 
-  return constExpr;
+  return const_expr;
 }
 
 Node::Ptr ZVecSQLParser::handle_vector_expr_node(VoidPtr node) {
-  SQLParser::Vector_exprContext *vector_ExprNode =
+  SQLParser::Vector_exprContext *vector_expr_node =
       reinterpret_cast<SQLParser::Vector_exprContext *>(node);
 
-  std::string vector_text = vector_ExprNode->getText();
+  std::string vector_text = vector_expr_node->getText();
   return parse_vector_text(&vector_text);
 }
 
 Node::Ptr ZVecSQLParser::handle_id_node(VoidPtr node) {
-  SQLParser::IdentifierContext *identifierNode =
+  SQLParser::IdentifierContext *identifier_node =
       reinterpret_cast<SQLParser::IdentifierContext *>(node);
 
-  Node::Ptr identifierExpr =
-      std::make_shared<IDNode>(identifierNode->getText());
-  identifierExpr->set_op(NodeOp::T_ID);
-  return identifierExpr;
+  Node::Ptr identifier_expr =
+      std::make_shared<IDNode>(identifier_node->getText());
+  identifier_expr->set_op(NodeOp::T_ID);
+  return identifier_expr;
 }
 
 Node::Ptr ZVecSQLParser::parse_filter(const std::string &filter,
diff --git a/src/db/sqlengine/planner/invert_search.cc b/src/db/sqlengine/planner/invert_search.cc
index 0f8980152..1b858a406 100644
--- a/src/db/sqlengine/planner/invert_search.cc
+++ b/src/db/sqlengine/planner/invert_search.cc
@@ -20,7 +20,7 @@
 
 namespace zvec::sqlengine {
 
-const std::unordered_map<QueryNodeOp, CompareOp> kOpMap_ = {
+const std::unordered_map<QueryNodeOp, CompareOp> kOpMap = {
     {QueryNodeOp::Q_EQ, CompareOp::EQ},
     {QueryNodeOp::Q_NE, CompareOp::NE},
     {QueryNodeOp::Q_LT, CompareOp::LT},
@@ -72,8 +72,8 @@ Result<InvertedSearchResult::Ptr> InvertSearch::exec_invert_cond_tree(
 }
 
 CompareOp InvertSearch::query_nodeop2search_op(QueryNodeOp op) {
-  auto iter = kOpMap_.find(op);
-  if (iter == kOpMap_.end()) {
+  auto iter = kOpMap.find(op);
+  if (iter == kOpMap.end()) {
     return CompareOp::NONE;
   }
   return iter->second;
diff --git a/src/db/sqlengine/planner/ops/fetch_vector_op.cc b/src/db/sqlengine/planner/ops/fetch_vector_op.cc
index f7f02e880..283b4959e 100644
--- a/src/db/sqlengine/planner/ops/fetch_vector_op.cc
+++ b/src/db/sqlengine/planner/ops/fetch_vector_op.cc
@@ -32,7 +32,7 @@ Result<std::shared_ptr<arrow::Array>> fetch_dense_vector_helper(
   CHECK_ARROW_STATUS("Reserve vector builder failed:",
                      vector_builder.Reserve(count));
   for (Iter i = begin; i != end; ++i) {
-    auto vector_res = indexer->Fetch(*i);
+    auto vector_res = indexer->fetch(*i);
     if (!vector_res) {
       return tl::make_unexpected(vector_res.error());
     }
@@ -88,7 +88,7 @@ Result<std::shared_ptr<arrow::Array>> fetch_sparse_vector_helper(
   CHECK_ARROW_STATUS("Reserve failed:", sparse_index_builder->Reserve(count));
   CHECK_ARROW_STATUS("Reserve failed:", sparse_value_builder->Reserve(count));
   for (auto i = begin; i != end; i++) {
-    auto vector_res = indexer->Fetch(*i);
+    auto vector_res = indexer->fetch(*i);
     if (!vector_res) {
       return tl::make_unexpected(vector_res.error());
     }
diff --git a/src/db/sqlengine/planner/segment_node.cc b/src/db/sqlengine/planner/segment_node.cc
index aa7729104..a2993e95c 100644
--- a/src/db/sqlengine/planner/segment_node.cc
+++ b/src/db/sqlengine/planner/segment_node.cc
@@ -64,15 +64,15 @@ SegmentNode::gen() {
 Status SegmentNode::prepare() {
   auto group = thread_pool_->make_group();
 
-  std::vector<Result<std::unique_ptr<arrow::RecordBatchReader>>> results_;
-  results_.resize(segment_plans_.size());
+  std::vector<Result<std::unique_ptr<arrow::RecordBatchReader>>> results;
+  results.resize(segment_plans_.size());
   for (size_t i = 0; i < segment_plans_.size(); i++) {
     auto &plan = segment_plans_[i];
-    group->execute([&, i]() { results_[i] = plan->execute_to_reader(); });
+    group->execute([&, i]() { results[i] = plan->execute_to_reader(); });
   }
   group->wait_finish();
   for (size_t i = 0; i < segment_plans_.size(); i++) {
-    auto &result = results_[i];
+    auto &result = results[i];
     if (!result) {
       return result.error();
     }
diff --git a/src/db/sqlengine/planner/vector_recall_node.cc b/src/db/sqlengine/planner/vector_recall_node.cc
index b1900b809..0fd4e6258 100644
--- a/src/db/sqlengine/planner/vector_recall_node.cc
+++ b/src/db/sqlengine/planner/vector_recall_node.cc
@@ -139,27 +139,27 @@ Result<IndexResults::Ptr> VectorRecallNode::prepare() {
   if (!filter_status.ok()) {
     return tl::make_unexpected(filter_status);
   }
-  auto &vector_cond_ = query_info_->vector_cond_info();
+  auto &vector_cond = query_info_->vector_cond_info();
   CombinedVectorColumnIndexer::Ptr vector_indexer;
   if (auto *vector_params = dynamic_cast<const VectorIndexParams *>(
-          vector_cond_->vector_schema()->index_params().get());
+          vector_cond->vector_schema()->index_params().get());
       vector_params == nullptr ||
       vector_params->quantize_type() == QuantizeType::UNDEFINED) {
-    vector_indexer = segment_->get_combined_vector_indexer(
-        vector_cond_->vector_field_name());
+    vector_indexer =
+        segment_->get_combined_vector_indexer(vector_cond->vector_field_name());
   } else {
     vector_indexer = segment_->get_quant_combined_vector_indexer(
-        vector_cond_->vector_field_name());
+        vector_cond->vector_field_name());
   }
   if (!vector_indexer) {
     return tl::make_unexpected(Status::InvalidArgument(
-        "vector index not found:", vector_cond_->vector_field_name()));
+        "vector index not found:", vector_cond->vector_field_name()));
   }
   vector_column_params::QueryParams query_params;
   query_params.topk = query_info_->query_topn();
-  query_params.data_type = vector_cond_->vector_schema()->data_type();
-  query_params.dimension = vector_cond_->dimension();
-  query_params.query_params = vector_cond_->query_params();
+  query_params.data_type = vector_cond->vector_schema()->data_type();
+  query_params.dimension = vector_cond->dimension();
+  query_params.query_params = vector_cond->query_params();
   auto brute_force_keys = doc_filter_->get_bf_by_keys_and_update(
       GlobalConfig::Instance().brute_force_by_keys_ratio());
   if (brute_force_keys) {
@@ -196,17 +196,17 @@ Result<IndexResults::Ptr> VectorRecallNode::prepare() {
   }
 
   vector_column_params::VectorData vector_data;
-  if (vector_cond_->vector_schema()->is_dense_vector()) {
+  if (vector_cond->vector_schema()->is_dense_vector()) {
     vector_data.vector =
-        vector_column_params::DenseVector{vector_cond_->vector_term().data()};
+        vector_column_params::DenseVector{vector_cond->vector_term().data()};
   } else {
     vector_data.vector = vector_column_params::SparseVector{
-        vector_cond_->sparse_count(),
-        vector_cond_->vector_sparse_indices().data(),
-        vector_cond_->vector_sparse_values().data()};
+        vector_cond->sparse_count(),
+        vector_cond->vector_sparse_indices().data(),
+        vector_cond->vector_sparse_values().data()};
   }
 
-  auto vector_ret = vector_indexer->Search(vector_data, query_params);
+  auto vector_ret = vector_indexer->search(vector_data, query_params);
   if (!vector_ret) {
     return tl::make_unexpected(vector_ret.error());
   }
diff --git a/src/include/zvec/ailego/buffer/concurrentqueue.h b/src/include/zvec/ailego/buffer/concurrentqueue.h
index 1bff8b08e..f6269b3d9 100644
--- a/src/include/zvec/ailego/buffer/concurrentqueue.h
+++ b/src/include/zvec/ailego/buffer/concurrentqueue.h
@@ -33,6 +33,8 @@
 
 #pragma once
 
+// NOLINTBEGIN
+
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
 // Disable -Wconversion warnings (spuriously triggered when Traits::size_t and
 // Traits::index_t are set to < 32 bits, causing integer promotion, causing
@@ -4409,4 +4411,6 @@ inline void swap(typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP &a,
 
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
 #pragma GCC diagnostic pop
-#endif
\ No newline at end of file
+#endif
+
+// NOLINTEND
\ No newline at end of file
diff --git a/src/include/zvec/ailego/buffer/external_cache.h b/src/include/zvec/ailego/buffer/external_cache.h
index a30167e4b..b4019526c 100644
--- a/src/include/zvec/ailego/buffer/external_cache.h
+++ b/src/include/zvec/ailego/buffer/external_cache.h
@@ -51,7 +51,7 @@ class ExternalCache : public EvictableBlockOwner {
     BlockEvictionQueue::get_instance().set_valid(this);
   }
 
-  ~ExternalCache() {
+  ~ExternalCache() override {
     BlockEvictionQueue::get_instance().set_invalid(this);
     std::unique_lock<std::shared_mutex> lock(mutex_);
     for (auto &item : table_) {
diff --git a/src/include/zvec/ailego/buffer/vector_page_table.h b/src/include/zvec/ailego/buffer/vector_page_table.h
index eef712f6f..a298c83ee 100644
--- a/src/include/zvec/ailego/buffer/vector_page_table.h
+++ b/src/include/zvec/ailego/buffer/vector_page_table.h
@@ -103,7 +103,7 @@ class ZVEC_AILEGO_API VectorPageTable : public EvictableBlockOwner {
   VectorPageTable() : owner_version_(next_owner_version()) {
     BlockEvictionQueue::get_instance().set_valid(this);
   }
-  ~VectorPageTable() {
+  ~VectorPageTable() override {
     BlockEvictionQueue::get_instance().set_invalid(this);
     // No readers remain during destruction.
     size_t cnt = segment_count_.load(std::memory_order_relaxed);
diff --git a/src/include/zvec/ailego/container/cube.h b/src/include/zvec/ailego/container/cube.h
index d2a19281c..c5feeb7e7 100644
--- a/src/include/zvec/ailego/container/cube.h
+++ b/src/include/zvec/ailego/container/cube.h
@@ -59,42 +59,42 @@ struct CubePolicy {
 template <typename T>
 struct SmallCubePolicy : public CubePolicy {
   //! Assign `src` to `dst`
-  void assign(const void *src, void **dst) {
+  void assign(const void *src, void **dst) override {
     new (dst) T(*reinterpret_cast<const T *>(src));
   }
 
   //! Cleanup value
-  void cleanup(void **val) {
+  void cleanup(void **val) override {
     reinterpret_cast<T *>(val)->~T();
   }
 
   //! Clone value of `src` to `dst`
-  void clone(void *const *src, void **dst) {
+  void clone(void *const *src, void **dst) override {
     new (dst) T(*reinterpret_cast<const T *>(src));
   }
 
   //! Move `src` to `dst`
-  void move(void *src, void **dst) {
+  void move(void *src, void **dst) override {
     new (dst) T(std::move(*reinterpret_cast<T *>(src)));
   }
 
   //! Retrieve size
-  size_t size() const {
+  size_t size() const override {
     return sizeof(T);
   }
 
   //! Retrieve type information
-  const std::type_info &type() const {
+  const std::type_info &type() const override {
     return typeid(T);
   }
 
   //! Retrieve value
-  void *value(void **src) {
+  void *value(void **src) override {
     return reinterpret_cast<void *>(src);
   }
 
   //! Retrieve value
-  const void *value(void *const *src) const {
+  const void *value(void *const *src) const override {
     return reinterpret_cast<const void *>(src);
   }
 };
@@ -104,42 +104,42 @@ struct SmallCubePolicy : public CubePolicy {
 template <typename T>
 struct LargeCubePolicy : public CubePolicy {
   //! Assign `src` to `dst`
-  void assign(const void *src, void **dst) {
+  void assign(const void *src, void **dst) override {
     *dst = new T(*reinterpret_cast<const T *>(src));
   }
 
   //! Cleanup value
-  void cleanup(void **val) {
+  void cleanup(void **val) override {
     delete (reinterpret_cast<T *>(*val));
   }
 
   //! Clone value of `src` to `dst`
-  void clone(void *const *src, void **dst) {
+  void clone(void *const *src, void **dst) override {
     *dst = new T(**reinterpret_cast<T *const *>(src));
   }
 
   //! Move `src` to `dst`
-  void move(void *src, void **dst) {
+  void move(void *src, void **dst) override {
     *dst = new T(std::move(*reinterpret_cast<T *>(src)));
   }
 
   //! Retrieve size
-  size_t size() const {
+  size_t size() const override {
     return sizeof(T);
   }
 
   //! Retrieve type information
-  const std::type_info &type() const {
+  const std::type_info &type() const override {
     return typeid(T);
   }
 
   //! Retrieve value
-  void *value(void **src) {
+  void *value(void **src) override {
     return *src;
   }
 
   //! Retrieve value
-  const void *value(void *const *src) const {
+  const void *value(void *const *src) const override {
     return *src;
   }
 };
diff --git a/src/include/zvec/ailego/math_batch/utils.h b/src/include/zvec/ailego/math_batch/utils.h
index 3a22dd931..719cef8c1 100644
--- a/src/include/zvec/ailego/math_batch/utils.h
+++ b/src/include/zvec/ailego/math_batch/utils.h
@@ -15,8 +15,8 @@
 #pragma once
 
 #include <cstddef>
-namespace zvec::ailego::DistanceBatch {
+namespace zvec::ailego::distance_batch {
 
 typedef void (*DistanceBatchQueryPreprocessFunc)(void *query, size_t dim);
 
-}  // namespace zvec::ailego::DistanceBatch
\ No newline at end of file
+}  // namespace zvec::ailego::distance_batch
\ No newline at end of file
diff --git a/src/include/zvec/ailego/pattern/expected.hpp b/src/include/zvec/ailego/pattern/expected.hpp
index 8f660e07c..8f26966f0 100644
--- a/src/include/zvec/ailego/pattern/expected.hpp
+++ b/src/include/zvec/ailego/pattern/expected.hpp
@@ -16,6 +16,8 @@
 #ifndef TL_EXPECTED_HPP
 #define TL_EXPECTED_HPP
 
+// NOLINTBEGIN
+
 #define TL_EXPECTED_VERSION_MAJOR 1
 #define TL_EXPECTED_VERSION_MINOR 2
 #define TL_EXPECTED_VERSION_PATCH 0
@@ -2602,4 +2604,6 @@ void swap(expected<T, E> &lhs,
 }
 }  // namespace tl
 
+// NOLINTEND
+
 #endif
diff --git a/src/include/zvec/ailego/pattern/factory.h b/src/include/zvec/ailego/pattern/factory.h
index 861b5336e..b47510a1c 100644
--- a/src/include/zvec/ailego/pattern/factory.h
+++ b/src/include/zvec/ailego/pattern/factory.h
@@ -108,7 +108,7 @@ class Factory {
 
  protected:
   //! Constructor
-  Factory() : map_() {}
+  Factory() = default;
 
   //! Retrieve the singleton factory.
   //!
diff --git a/src/include/zvec/core/framework/index_bundle.h b/src/include/zvec/core/framework/index_bundle.h
index f5650f87d..87468103f 100644
--- a/src/include/zvec/core/framework/index_bundle.h
+++ b/src/include/zvec/core/framework/index_bundle.h
@@ -55,7 +55,7 @@ class TrivialIndexBundle : public IndexBundle {
   typedef std::shared_ptr<TrivialIndexBundle> Pointer;
 
   //! Retrieve index buffer via key
-  virtual ailego::BlobWrap get(const std::string &key) const {
+  ailego::BlobWrap get(const std::string &key) const override {
     auto iter = map_.find(key);
     if (iter != map_.end()) {
       return iter->second;
@@ -64,17 +64,17 @@ class TrivialIndexBundle : public IndexBundle {
   }
 
   //! Test if the key is exist
-  virtual bool has(const std::string &key) const {
+  bool has(const std::string &key) const override {
     return (map_.find(key) != map_.end());
   }
 
   //! Retrieve all
-  virtual std::map<std::string, ailego::BlobWrap> all() const {
+  std::map<std::string, ailego::BlobWrap> all() const override {
     return map_;
   }
 
   //! Retrieve the count of indexes
-  virtual size_t count() const {
+  size_t count() const override {
     return map_.size();
   }
 
@@ -110,7 +110,7 @@ class MemoryIndexBundle : public IndexBundle {
   typedef std::shared_ptr<MemoryIndexBundle> Pointer;
 
   //! Retrieve index buffer via key
-  virtual ailego::BlobWrap get(const std::string &key) const {
+  ailego::BlobWrap get(const std::string &key) const override {
     auto iter = map_.find(key);
     if (iter != map_.end()) {
       return ailego::BlobWrap(iter->second.data(), iter->second.size());
@@ -119,12 +119,12 @@ class MemoryIndexBundle : public IndexBundle {
   }
 
   //! Test if the key is exist
-  virtual bool has(const std::string &key) const {
+  bool has(const std::string &key) const override {
     return (map_.find(key) != map_.end());
   }
 
   //! Retrieve all
-  virtual std::map<std::string, ailego::BlobWrap> all() const {
+  std::map<std::string, ailego::BlobWrap> all() const override {
     std::map<std::string, ailego::BlobWrap> result;
     for (const auto &it : map_) {
       result.emplace(it.first,
@@ -134,7 +134,7 @@ class MemoryIndexBundle : public IndexBundle {
   }
 
   //! Retrieve the count of indexes
-  virtual size_t count() const {
+  size_t count() const override {
     return map_.size();
   }
 
@@ -180,7 +180,7 @@ class MMapFileIndexBundle : public IndexBundle {
   typedef std::shared_ptr<MMapFileIndexBundle> Pointer;
 
   //! Retrieve index buffer via key
-  virtual ailego::BlobWrap get(const std::string &key) const {
+  ailego::BlobWrap get(const std::string &key) const override {
     auto iter = map_.find(key);
     if (iter != map_.end()) {
       return ailego::BlobWrap(iter->second.region(), iter->second.size());
@@ -189,12 +189,12 @@ class MMapFileIndexBundle : public IndexBundle {
   }
 
   //! Test if the key is exist
-  virtual bool has(const std::string &key) const {
+  bool has(const std::string &key) const override {
     return (map_.find(key) != map_.end());
   }
 
   //! Retrieve all
-  virtual std::map<std::string, ailego::BlobWrap> all() const {
+  std::map<std::string, ailego::BlobWrap> all() const override {
     std::map<std::string, ailego::BlobWrap> result;
     for (const auto &it : map_) {
       result.emplace(it.first,
@@ -204,7 +204,7 @@ class MMapFileIndexBundle : public IndexBundle {
   }
 
   //! Retrieve the count of indexes
-  virtual size_t count() const {
+  size_t count() const override {
     return map_.size();
   }
 
diff --git a/src/include/zvec/core/framework/index_features.h b/src/include/zvec/core/framework/index_features.h
index a37b5e133..d368b4e34 100644
--- a/src/include/zvec/core/framework/index_features.h
+++ b/src/include/zvec/core/framework/index_features.h
@@ -119,38 +119,38 @@ class CoherentIndexFeatures : public IndexFeatures {
   }
 
   //! Retrieve count of elements
-  virtual size_t count() const {
+  size_t count() const override {
     return features_count_;
   }
 
   //! Retrieve dimension
-  virtual size_t dimension() const {
+  size_t dimension() const override {
     return feature_dimension_;
   }
 
   //! Retrieve feature via index
-  virtual const void *element(size_t i) const {
+  const void *element(size_t i) const override {
     return (reinterpret_cast<const char *>(features_buffer_) +
             feature_size_ * i);
   }
 
   //! Retrieve type information
-  virtual IndexMeta::DataType data_type() const {
+  IndexMeta::DataType data_type() const override {
     return data_type_;
   }
 
   //! Test if it is a compacted buffer
-  virtual bool is_compacted() const {
+  bool is_compacted() const override {
     return true;
   }
 
   //! Retrieve pointer of compacted buffer
-  virtual const void *data() const {
+  const void *data() const override {
     return features_buffer_;
   }
 
   //! Retrieve size of feature
-  virtual size_t element_size() const {
+  size_t element_size() const override {
     return feature_size_;
   }
 
@@ -211,27 +211,27 @@ class FlexibleIndexFeatures : public IndexFeatures {
   }
 
   //! Retrieve count of elements
-  virtual size_t count() const {
+  size_t count() const override {
     return features_count_;
   }
 
   //! Retrieve dimension
-  virtual size_t dimension() const {
+  size_t dimension() const override {
     return feature_dimension_;
   }
 
   //! Retrieve feature via index
-  virtual const void *element(size_t i) const {
+  const void *element(size_t i) const override {
     return *(features_ + i);
   }
 
   //! Retrieve type information
-  virtual IndexMeta::DataType data_type() const {
+  IndexMeta::DataType data_type() const override {
     return data_type_;
   }
 
   //! Retrieve size of feature
-  virtual size_t element_size() const {
+  size_t element_size() const override {
     return feature_size_;
   }
 
@@ -345,37 +345,37 @@ class GapIndexFeatures : public IndexFeatures {
   }
 
   //! Retrieve count of elements
-  virtual size_t count() const {
+  size_t count() const override {
     return features_count_;
   }
 
   //! Retrieve dimension
-  virtual size_t dimension() const {
+  size_t dimension() const override {
     return feature_dimension_;
   }
 
   //! Retrieve feature via index
-  virtual const void *element(size_t i) const {
+  const void *element(size_t i) const override {
     return this->at(i);
   }
 
   //! Retrieve type information
-  virtual IndexMeta::DataType data_type() const {
+  IndexMeta::DataType data_type() const override {
     return data_type_;
   }
 
   //! Test if it is a compacted buffer
-  virtual bool is_compacted() const {
+  bool is_compacted() const override {
     return (features_.size() == 1u);
   }
 
   //! Retrieve pointer of compacted buffer
-  virtual const void *data() const {
+  const void *data() const override {
     return (features_.size() == 1u ? features_.front().data() : nullptr);
   }
 
   //! Retrieve size of feature
-  virtual size_t element_size() const {
+  size_t element_size() const override {
     return feature_size_;
   }
 
@@ -475,37 +475,37 @@ class CompactIndexFeatures : public IndexFeatures {
   }
 
   //! Retrieve count of elements
-  virtual size_t count() const {
+  size_t count() const override {
     return (features_.size() / feature_size_);
   }
 
   //! Retrieve dimension
-  virtual size_t dimension() const {
+  size_t dimension() const override {
     return feature_dimension_;
   }
 
   //! Retrieve feature via index
-  virtual const void *element(size_t i) const {
+  const void *element(size_t i) const override {
     return this->at(i);
   }
 
   //! Retrieve type information
-  virtual IndexMeta::DataType data_type() const {
+  IndexMeta::DataType data_type() const override {
     return data_type_;
   }
 
   //! Test if it is a compacted buffer
-  virtual bool is_compacted() const {
+  bool is_compacted() const override {
     return true;
   }
 
   //! Retrieve pointer of compacted buffer
-  virtual const void *data() const {
+  const void *data() const override {
     return features_.data();
   }
 
   //! Retrieve size of feature
-  virtual size_t element_size() const {
+  size_t element_size() const override {
     return feature_size_;
   }
 
diff --git a/src/include/zvec/core/framework/index_mapping.h b/src/include/zvec/core/framework/index_mapping.h
index 2ca3ae961..be564bca0 100644
--- a/src/include/zvec/core/framework/index_mapping.h
+++ b/src/include/zvec/core/framework/index_mapping.h
@@ -190,7 +190,7 @@ class IndexMapping {
   //! Initialize index file mapping
   int init_index_mapping(size_t len);
 
-  bool Ishugetlbfs(const std::string &path) const;
+  bool ishugetlbfs(const std::string &path) const;
 
   int init_meta_section();
   int init_hugepage_meta_section();
diff --git a/src/include/zvec/core/framework/index_metric.h b/src/include/zvec/core/framework/index_metric.h
index 691a02204..5cc9f402d 100644
--- a/src/include/zvec/core/framework/index_metric.h
+++ b/src/include/zvec/core/framework/index_metric.h
@@ -141,7 +141,7 @@ struct IndexMetric : public IndexModule {
   }
 
   using DistanceBatchQueryPreprocessFunc =
-      ailego::DistanceBatch::DistanceBatchQueryPreprocessFunc;
+      ailego::distance_batch::DistanceBatchQueryPreprocessFunc;
 
   virtual DistanceBatchQueryPreprocessFunc get_query_preprocess_func() const {
     return nullptr;
diff --git a/src/include/zvec/core/framework/index_refiner.h b/src/include/zvec/core/framework/index_refiner.h
index 4f88bde8e..44ca0c401 100644
--- a/src/include/zvec/core/framework/index_refiner.h
+++ b/src/include/zvec/core/framework/index_refiner.h
@@ -36,7 +36,7 @@ class IndexRefiner : public IndexModule {
   struct Context : public IndexContext {
    public:
     Context() = default;
-    ~Context() = default;
+    ~Context() override = default;
 
     virtual int set_contexts(IndexRunner::Context::Pointer base_ctx,
                              IndexRunner::Context::Pointer refine_ctx) = 0;
diff --git a/src/include/zvec/core/framework/index_storage.h b/src/include/zvec/core/framework/index_storage.h
index 46b2b8606..1d6745b64 100644
--- a/src/include/zvec/core/framework/index_storage.h
+++ b/src/include/zvec/core/framework/index_storage.h
@@ -681,7 +681,7 @@ class IndexStorage : public IndexModule {
   virtual uint32_t magic() const = 0;
 
   //! huge page
-  virtual bool isHugePage() const {
+  virtual bool is_huge_page() const {
     return false;
   }
 
diff --git a/src/include/zvec/core/interface/index.h b/src/include/zvec/core/interface/index.h
index 8ad3879ab..14ff98a81 100644
--- a/src/include/zvec/core/interface/index.h
+++ b/src/include/zvec/core/interface/index.h
@@ -216,17 +216,17 @@ class ZVEC_CORE_API Index {
  protected:
   friend class IndexFactory;
   Index() = default;
-  int Init(const BaseIndexParam &param);
+  int init(const BaseIndexParam &param);
 
 
  protected:
-  int ParseMetricName(const BaseIndexParam &param);
-  int CreateAndInitMetric(const BaseIndexParam &param);
-  virtual int CreateAndInitConverterReformer(const QuantizerParam &param,
-                                             const BaseIndexParam &index_param);
-  int InitConverterReformer(const std::string &converter_name,
-                            const ailego::Params &converter_params = {});
-  virtual int CreateAndInitStreamer(const BaseIndexParam &param) = 0;
+  int parse_metric_name(const BaseIndexParam &param);
+  int create_and_init_metric(const BaseIndexParam &param);
+  virtual int create_and_init_converter_reformer(
+      const QuantizerParam &param, const BaseIndexParam &index_param);
+  int init_converter_reformer(const std::string &converter_name,
+                              const ailego::Params &converter_params = {});
+  virtual int create_and_init_streamer(const BaseIndexParam &param) = 0;
 
  protected:
   bool init_context();
@@ -275,9 +275,9 @@ class ZVEC_CORE_API FlatIndex : public Index {
            StorageOptions storage_options) override;
 
  protected:
-  int CreateAndInitStreamer(const BaseIndexParam &param) override;
+  int create_and_init_streamer(const BaseIndexParam &param) override;
 
-  int CreateAndInitConverterReformer(
+  int create_and_init_converter_reformer(
       const QuantizerParam &param, const BaseIndexParam &index_param) override;
 
   int _prepare_for_search(const VectorData &query,
@@ -286,18 +286,18 @@ class ZVEC_CORE_API FlatIndex : public Index {
 
  private:
   //! Initialize the selected quantizer and synchronize encoding metadata.
-  int CreateAndInitTurboQuantizer(const std::string &name,
-                                  const ailego::Params &params);
+  int create_and_init_turbo_quantizer(const std::string &name,
+                                      const ailego::Params &params);
 
   //! Rebuild the legacy converter/reformer/metric/streamer pipeline,
   //! dropping the turbo quantizer.
-  int FallbackToLegacyPipeline();
+  int fallback_to_legacy_pipeline();
 
   //! Create the legacy converter/reformer for combinations the turbo
   //! quantizers cannot express (including the flat storage_data_type
   //! converters).
-  int CreateAndInitLegacyConverterReformer(const QuantizerParam &param,
-                                           const BaseIndexParam &index_param);
+  int create_and_init_legacy_converter_reformer(
+      const QuantizerParam &param, const BaseIndexParam &index_param);
 
   FlatIndexParam param_{};
 };
@@ -307,7 +307,7 @@ class ZVEC_CORE_API IVFIndex : public Index {
   IVFIndex() = default;
 
  protected:
-  int CreateAndInitStreamer(const BaseIndexParam &param) override;
+  int create_and_init_streamer(const BaseIndexParam &param) override;
 
   int _prepare_for_search(const VectorData &query,
                           const BaseIndexQueryParam::Pointer &search_param,
@@ -324,13 +324,13 @@ class ZVEC_CORE_API IVFIndex : public Index {
                    VectorDataBuffer *vector_data_buffer) override;
   int merge(const std::vector<Index::Pointer> &indexes,
             const IndexFilter &filter, const MergeOptions &options) override;
-  int GenerateHolder();
+  int generate_holder();
 
  private:
   enum class BuildStage { kCollecting, kTrained, kBuilt, kDumped };
 
-  int ResetBuilder();
-  int DumpAndOpen();
+  int reset_builder();
+  int dump_and_open();
 
   BuildStage build_stage_{BuildStage::kCollecting};
   IVFIndexParam param_{};
@@ -360,7 +360,7 @@ class ZVEC_CORE_API HNSWIndex : public Index {
                          SearchResult *result) override;
 
  protected:
-  int CreateAndInitStreamer(const BaseIndexParam &param) override;
+  int create_and_init_streamer(const BaseIndexParam &param) override;
 
   int _prepare_for_search(const VectorData &query,
                           const BaseIndexQueryParam::Pointer &search_param,
@@ -381,7 +381,7 @@ class ZVEC_CORE_API VamanaIndex : public Index {
             const MergeOptions &options = {}) override;
 
  protected:
-  int CreateAndInitStreamer(const BaseIndexParam &param) override;
+  int create_and_init_streamer(const BaseIndexParam &param) override;
 
   int _prepare_for_search(const VectorData &query,
                           const BaseIndexQueryParam::Pointer &search_param,
@@ -398,7 +398,7 @@ class ZVEC_CORE_API HNSWRabitqIndex : public Index {
   HNSWRabitqIndex() = default;
 
  protected:
-  int CreateAndInitStreamer(const BaseIndexParam &param) override;
+  int create_and_init_streamer(const BaseIndexParam &param) override;
 
   int _prepare_for_search(const VectorData &query,
                           const BaseIndexQueryParam::Pointer &search_param,
@@ -415,7 +415,7 @@ class ZVEC_CORE_API IVFRabitqIndex : public Index {
   IVFRabitqIndex() = default;
 
  protected:
-  int CreateAndInitStreamer(const BaseIndexParam &param) override;
+  int create_and_init_streamer(const BaseIndexParam &param) override;
 
   int _prepare_for_search(const VectorData &query,
                           const BaseIndexQueryParam::Pointer &search_param,
@@ -429,7 +429,7 @@ class ZVEC_CORE_API IVFRabitqIndex : public Index {
                    VectorDataBuffer *vector_data_buffer) override;
   int merge(const std::vector<Index::Pointer> &indexes,
             const IndexFilter &filter, const MergeOptions &options) override;
-  int GenerateHolder();
+  int generate_holder();
 
  private:
   IVFRabitqIndexParam param_{};
@@ -444,7 +444,7 @@ class ZVEC_CORE_API DiskAnnIndex : public Index {
   DiskAnnIndex() = default;
 
  protected:
-  int CreateAndInitStreamer(const BaseIndexParam &param) override;
+  int create_and_init_streamer(const BaseIndexParam &param) override;
 
   int _prepare_for_search(const VectorData &query,
                           const BaseIndexQueryParam::Pointer &search_param,
@@ -461,7 +461,7 @@ class ZVEC_CORE_API DiskAnnIndex : public Index {
                    VectorDataBuffer *vector_data_buffer) override;
   int merge(const std::vector<Index::Pointer> &indexes,
             const IndexFilter &filter, const MergeOptions &options) override;
-  int GenerateHolder();
+  int generate_holder();
 
  private:
   DiskAnnIndexParam param_{};
diff --git a/src/include/zvec/core/interface/index_param.h b/src/include/zvec/core/interface/index_param.h
index 428612b34..2f6146689 100644
--- a/src/include/zvec/core/interface/index_param.h
+++ b/src/include/zvec/core/interface/index_param.h
@@ -109,7 +109,7 @@ enum class QuantizerType {
 
 struct ZVEC_CORE_API SerializableBase {
   std::string serialize_to_json(bool omit_empty_value = false) const {
-    return zvec::ailego::JsonValue(SerializeToJsonObject(omit_empty_value))
+    return zvec::ailego::JsonValue(serialize_to_json_object(omit_empty_value))
         .as_json_string()
         .as_stl_string();
   }
@@ -119,13 +119,13 @@ struct ZVEC_CORE_API SerializableBase {
     if (!json_value.parse(json_str)) {
       return false;
     }
-    return DeserializeFromJsonObject(json_value.as_object());
+    return deserialize_from_json_object(json_value.as_object());
   }
 
  protected:
-  virtual ailego::JsonObject SerializeToJsonObject(
+  virtual ailego::JsonObject serialize_to_json_object(
       bool omit_empty_value = false) const = 0;
-  virtual bool DeserializeFromJsonObject(
+  virtual bool deserialize_from_json_object(
       const ailego::JsonObject &json_obj) = 0;
 };
 
@@ -152,10 +152,11 @@ struct ZVEC_CORE_API QuantizerParam : public SerializableBase {
 
  protected:
   friend class BaseIndexParam;
-  ailego::JsonObject SerializeToJsonObject(
+  ailego::JsonObject serialize_to_json_object(
       bool omit_empty_value = false) const override;
 
-  bool DeserializeFromJsonObject(const ailego::JsonObject &json_obj) override;
+  bool deserialize_from_json_object(
+      const ailego::JsonObject &json_obj) override;
 };
 
 //! Product-Quantization specific params
@@ -175,10 +176,11 @@ struct PqQuantizerParam : public QuantizerParam {
 
  protected:
   friend class BaseIndexParam;
-  ailego::JsonObject SerializeToJsonObject(
+  ailego::JsonObject serialize_to_json_object(
       bool omit_empty_value = false) const override;
 
-  bool DeserializeFromJsonObject(const ailego::JsonObject &json_obj) override;
+  bool deserialize_from_json_object(
+      const ailego::JsonObject &json_obj) override;
 };
 
 // preprocessor
@@ -289,8 +291,8 @@ struct ZVEC_CORE_API IVFQueryParam : public BaseIndexQueryParam {
   ~IVFQueryParam() override;
 
   int nprobe = 10;
-  std::shared_ptr<BaseIndexQueryParam> l1QueryParam = nullptr;
-  std::shared_ptr<BaseIndexQueryParam> l2QueryParam = nullptr;
+  std::shared_ptr<BaseIndexQueryParam> l1_query_param = nullptr;
+  std::shared_ptr<BaseIndexQueryParam> l2_query_param = nullptr;
 
   using Pointer = std::shared_ptr<IVFQueryParam>;
 
@@ -353,8 +355,9 @@ class ZVEC_CORE_API BaseIndexParam : public SerializableBase {
   //
 
  protected:
-  bool DeserializeFromJsonObject(const ailego::JsonObject &json_obj) override;
-  ailego::JsonObject SerializeToJsonObject(
+  bool deserialize_from_json_object(
+      const ailego::JsonObject &json_obj) override;
+  ailego::JsonObject serialize_to_json_object(
       bool omit_empty_value = false) const override;
 };
 
@@ -368,8 +371,9 @@ struct ZVEC_CORE_API FlatIndexParam : public BaseIndexParam {
   DataType storage_data_type = DataType::DT_UNDEFINED;
 
  protected:
-  bool DeserializeFromJsonObject(const ailego::JsonObject &json_obj) override;
-  ailego::JsonObject SerializeToJsonObject(
+  bool deserialize_from_json_object(
+      const ailego::JsonObject &json_obj) override;
+  ailego::JsonObject serialize_to_json_object(
       bool omit_empty_value = false) const override;
 };
 
@@ -377,17 +381,17 @@ struct ZVEC_CORE_API IVFIndexParam : public BaseIndexParam {
   using Pointer = std::shared_ptr<IVFIndexParam>;
   int nlist = 1024;
   int niters = 10;
-  std::shared_ptr<BaseIndexParam> l1Index = nullptr;
-  std::shared_ptr<BaseIndexParam> l2Index = nullptr;
+  std::shared_ptr<BaseIndexParam> l1_index = nullptr;
+  std::shared_ptr<BaseIndexParam> l2_index = nullptr;
   bool use_soar = false;
 
   // Constructors with delegation
   IVFIndexParam();
-  IVFIndexParam(int nlist, int niters, std::shared_ptr<BaseIndexParam> l1Index,
-                std::shared_ptr<BaseIndexParam> l2Index);
+  IVFIndexParam(int nlist, int niters, std::shared_ptr<BaseIndexParam> l1_index,
+                std::shared_ptr<BaseIndexParam> l2_index);
   IVFIndexParam(MetricType metric, int dim, int nlist, int niters,
-                std::shared_ptr<BaseIndexParam> l1Index,
-                std::shared_ptr<BaseIndexParam> l2Index);
+                std::shared_ptr<BaseIndexParam> l1_index,
+                std::shared_ptr<BaseIndexParam> l2_index);
   IVFIndexParam(const IVFIndexParam &);
   IVFIndexParam(IVFIndexParam &&);
   IVFIndexParam &operator=(const IVFIndexParam &);
@@ -427,8 +431,9 @@ struct ZVEC_CORE_API HNSWIndexParam : public BaseIndexParam {
         ef_construction(ef_construction) {}
 
  protected:
-  bool DeserializeFromJsonObject(const ailego::JsonObject &json_obj) override;
-  ailego::JsonObject SerializeToJsonObject(
+  bool deserialize_from_json_object(
+      const ailego::JsonObject &json_obj) override;
+  ailego::JsonObject serialize_to_json_object(
       bool omit_empty_value = false) const override;
 };
 
@@ -458,8 +463,9 @@ struct ZVEC_CORE_API VamanaIndexParam : public BaseIndexParam {
         alpha(alpha) {}
 
  protected:
-  bool DeserializeFromJsonObject(const ailego::JsonObject &json_obj) override;
-  ailego::JsonObject SerializeToJsonObject(
+  bool deserialize_from_json_object(
+      const ailego::JsonObject &json_obj) override;
+  ailego::JsonObject serialize_to_json_object(
       bool omit_empty_value = false) const override;
 };
 
@@ -501,8 +507,9 @@ struct ZVEC_CORE_API HNSWRabitqIndexParam : public BaseIndexParam {
   ~HNSWRabitqIndexParam() override;
 
  protected:
-  bool DeserializeFromJsonObject(const ailego::JsonObject &json_obj) override;
-  ailego::JsonObject SerializeToJsonObject(
+  bool deserialize_from_json_object(
+      const ailego::JsonObject &json_obj) override;
+  ailego::JsonObject serialize_to_json_object(
       bool omit_empty_value = false) const override;
 };
 
@@ -526,8 +533,9 @@ struct ZVEC_CORE_API IVFRabitqIndexParam : public BaseIndexParam {
   ~IVFRabitqIndexParam() override;
 
  protected:
-  bool DeserializeFromJsonObject(const ailego::JsonObject &json_obj) override;
-  ailego::JsonObject SerializeToJsonObject(
+  bool deserialize_from_json_object(
+      const ailego::JsonObject &json_obj) override;
+  ailego::JsonObject serialize_to_json_object(
       bool omit_empty_value = false) const override;
 };
 
@@ -564,8 +572,9 @@ struct ZVEC_CORE_API DiskAnnIndexParam : public BaseIndexParam {
         pq_chunk_num(pq_chunk_num) {}
 
  protected:
-  bool DeserializeFromJsonObject(const ailego::JsonObject &json_obj) override;
-  ailego::JsonObject SerializeToJsonObject(
+  bool deserialize_from_json_object(
+      const ailego::JsonObject &json_obj) override;
+  ailego::JsonObject serialize_to_json_object(
       bool omit_empty_value = false) const override;
 };
 
diff --git a/src/include/zvec/core/interface/index_param_builders.h b/src/include/zvec/core/interface/index_param_builders.h
index e8f4bdaae..7d4cdaa9b 100644
--- a/src/include/zvec/core/interface/index_param_builders.h
+++ b/src/include/zvec/core/interface/index_param_builders.h
@@ -144,12 +144,12 @@ class IVFIndexParamBuilder
     param->niters = niters;
     return *this;
   }
-  IVFIndexParamBuilder &with_l1_index(const BaseIndexParam &l1Index) {
-    param->l1Index = std::make_shared<BaseIndexParam>(l1Index);
+  IVFIndexParamBuilder &with_l1_index(const BaseIndexParam &l1_index) {
+    param->l1_index = std::make_shared<BaseIndexParam>(l1_index);
     return *this;
   }
-  IVFIndexParamBuilder &with_l2_index(const BaseIndexParam &l2Index) {
-    param->l2Index = std::make_shared<BaseIndexParam>(l2Index);
+  IVFIndexParamBuilder &with_l2_index(const BaseIndexParam &l2_index) {
+    param->l2_index = std::make_shared<BaseIndexParam>(l2_index);
     return *this;
   }
   IVFIndexParamBuilder &with_use_soar(bool use_soar) {
@@ -451,14 +451,14 @@ class IVFQueryParamBuilder
   // Since l1QueryParam and l2QueryParam are shared_ptr to BaseIndexQueryParam,
   // they can accept ANY derived configuration object.
   IVFQueryParamBuilder &with_l1_query_param(
-      BaseIndexQueryParam::Pointer l1QueryParam) {
-    m_param.l1QueryParam = std::move(l1QueryParam);
+      BaseIndexQueryParam::Pointer l1_query_param) {
+    m_param.l1_query_param = std::move(l1_query_param);
     return *this;
   }
 
   IVFQueryParamBuilder &with_l2_query_param(
-      BaseIndexQueryParam::Pointer l2QueryParam) {
-    m_param.l2QueryParam = std::move(l2QueryParam);
+      BaseIndexQueryParam::Pointer l2_query_param) {
+    m_param.l2_query_param = std::move(l2_query_param);
     return *this;
   }
 
diff --git a/src/include/zvec/db/query_params.h b/src/include/zvec/db/query_params.h
index 84ab96ce0..896b4840d 100644
--- a/src/include/zvec/db/query_params.h
+++ b/src/include/zvec/db/query_params.h
@@ -221,7 +221,7 @@ class ZVEC_API DiskAnnQueryParams : public QueryParams {
     set_list_size(list_size);
   }
 
-  virtual ~DiskAnnQueryParams() = default;
+  ~DiskAnnQueryParams() override = default;
 
   int list_size() const {
     return list_size_;
diff --git a/src/include/zvec/turbo/turbo.h b/src/include/zvec/turbo/turbo.h
index 2028b3f29..134b434d2 100644
--- a/src/include/zvec/turbo/turbo.h
+++ b/src/include/zvec/turbo/turbo.h
@@ -49,7 +49,7 @@ using BatchDistanceFunc =
     std::function<void(const void **m, const void *q, size_t num, size_t dim,
                        float *out, const void **extra_values)>;
 using QueryPreprocessFunc =
-    zvec::ailego::DistanceBatch::DistanceBatchQueryPreprocessFunc;
+    zvec::ailego::distance_batch::DistanceBatchQueryPreprocessFunc;
 
 // Uniform UINT7 quantize kernel: fp32 -> int8 code in [0, 127] with a global
 // affine transform. Raw function pointer (rather than std::function) avoids
diff --git a/src/turbo/quantizer/fp16_quantizer/fp16_quantizer.h b/src/turbo/quantizer/fp16_quantizer/fp16_quantizer.h
index ac3dd65ec..5fd2c97b3 100644
--- a/src/turbo/quantizer/fp16_quantizer/fp16_quantizer.h
+++ b/src/turbo/quantizer/fp16_quantizer/fp16_quantizer.h
@@ -29,7 +29,7 @@ class Fp16Quantizer : public Quantizer {
  public:
   Fp16Quantizer() : Quantizer(QuantizeType::kFp16) {}
 
-  virtual ~Fp16Quantizer() = default;
+  ~Fp16Quantizer() override = default;
 
  public:
   int init(const core::IndexMeta &meta, const ailego::Params &params) override;
diff --git a/src/turbo/quantizer/fp32_quantizer/fp32_quantizer.h b/src/turbo/quantizer/fp32_quantizer/fp32_quantizer.h
index b6012811e..24ccb4362 100644
--- a/src/turbo/quantizer/fp32_quantizer/fp32_quantizer.h
+++ b/src/turbo/quantizer/fp32_quantizer/fp32_quantizer.h
@@ -29,7 +29,7 @@ class Fp32Quantizer : public Quantizer {
  public:
   Fp32Quantizer() : Quantizer(QuantizeType::kFp32) {}
 
-  virtual ~Fp32Quantizer() = default;
+  ~Fp32Quantizer() override = default;
 
  public:
   int init(const core::IndexMeta &meta, const ailego::Params &params) override;
diff --git a/src/turbo/quantizer/int4_quantizer/int4_quantizer.h b/src/turbo/quantizer/int4_quantizer/int4_quantizer.h
index ecea88e32..9f2db8a5f 100644
--- a/src/turbo/quantizer/int4_quantizer/int4_quantizer.h
+++ b/src/turbo/quantizer/int4_quantizer/int4_quantizer.h
@@ -40,7 +40,7 @@ class Int4Quantizer : public Quantizer {
  public:
   Int4Quantizer() : Quantizer(QuantizeType::kRecord) {}
 
-  virtual ~Int4Quantizer() = default;
+  ~Int4Quantizer() override = default;
 
  public:
   int init(const core::IndexMeta &meta, const ailego::Params &params) override;
diff --git a/src/turbo/quantizer/int8_quantizer/int8_quantizer.h b/src/turbo/quantizer/int8_quantizer/int8_quantizer.h
index a46ec910b..d4e7617c8 100644
--- a/src/turbo/quantizer/int8_quantizer/int8_quantizer.h
+++ b/src/turbo/quantizer/int8_quantizer/int8_quantizer.h
@@ -37,7 +37,7 @@ class Int8Quantizer : public Quantizer {
  public:
   Int8Quantizer() : Quantizer(QuantizeType::kRecord) {}
 
-  virtual ~Int8Quantizer() = default;
+  ~Int8Quantizer() override = default;
 
  public:
   int init(const core::IndexMeta &meta, const ailego::Params &params) override;
diff --git a/tests/ailego/algorithm/integer_quantizer_test.cc b/tests/ailego/algorithm/integer_quantizer_test.cc
index f4ed60a9e..d6e4d3745 100644
--- a/tests/ailego/algorithm/integer_quantizer_test.cc
+++ b/tests/ailego/algorithm/integer_quantizer_test.cc
@@ -21,7 +21,7 @@ namespace zvec::ailego {
 
 TEST(IntegerQuantizer, INT8_Uniform_Distribution) {
   std::vector<size_t> tests = {1, 100, 1000, 10000, 100000};
-  for (auto COUNT : tests) {
+  for (auto count : tests) {
     std::random_device rd;
     std::mt19937 gen(rd());
     std::vector<float> data;
@@ -29,7 +29,7 @@ TEST(IntegerQuantizer, INT8_Uniform_Distribution) {
     std::uniform_real_distribution<float> dist(1.0, 2.0);
     float max = -std::numeric_limits<float>::max();
     float min = std::numeric_limits<float>::max();
-    for (size_t i = 0; i < COUNT; ++i) {
+    for (size_t i = 0; i < count; ++i) {
       auto v = dist(gen);
       max = std::max(max, v);
       min = std::min(min, v);
@@ -53,7 +53,7 @@ TEST(IntegerQuantizer, INT8_Uniform_Distribution) {
     for (size_t i = 0; i < data.size(); ++i) {
       var += (data[i] - recover_data[i]) * (data[i] - recover_data[i]);
     }
-    EXPECT_LT(var / COUNT, 0.01);
+    EXPECT_LT(var / count, 0.01);
   }
 }
 
@@ -147,7 +147,7 @@ TEST(IntegerQuantizer, INT8_Poisson_Distribution) {
 
 TEST(IntegerQuantizer, INT4_Uniform_Distribution) {
   std::vector<size_t> tests = {2, 1000, 10000, 100000};
-  for (auto COUNT : tests) {
+  for (auto count : tests) {
     std::random_device rd;
     std::mt19937 gen(rd());
     std::vector<float> data;
@@ -155,7 +155,7 @@ TEST(IntegerQuantizer, INT4_Uniform_Distribution) {
     std::uniform_real_distribution<float> dist(1.0, 2.0);
     float max = -std::numeric_limits<float>::min();
     float min = std::numeric_limits<float>::max();
-    for (size_t i = 0; i < COUNT; ++i) {
+    for (size_t i = 0; i < count; ++i) {
       auto v = dist(gen);
       max = std::max(max, v);
       min = std::min(min, v);
@@ -188,7 +188,7 @@ TEST(IntegerQuantizer, INT4_Uniform_Distribution) {
            *std::min_element(recover_data.begin(), recover_data.end()));
     printf("var=%f\n", var);
 #endif
-    EXPECT_LT(var / COUNT, 0.1);
+    EXPECT_LT(var / count, 0.1);
   }
 }
 
@@ -292,7 +292,7 @@ TEST(IntegerQuantizer, INT4_Poisson_Distribution) {
 
 TEST(IntegerQuantizer, UINT8_Uniform_Distribution) {
   std::vector<size_t> tests = {1, 100, 1000, 10000, 100000};
-  for (auto COUNT : tests) {
+  for (auto count : tests) {
     std::random_device rd;
     std::mt19937 gen(rd());
     std::vector<float> data;
@@ -300,7 +300,7 @@ TEST(IntegerQuantizer, UINT8_Uniform_Distribution) {
     std::uniform_real_distribution<float> dist(1.0, 2.0);
     float max = -std::numeric_limits<float>::max();
     float min = std::numeric_limits<float>::max();
-    for (size_t i = 0; i < COUNT; ++i) {
+    for (size_t i = 0; i < count; ++i) {
       auto v = dist(gen);
       max = std::max(max, v);
       min = std::min(min, v);
@@ -324,7 +324,7 @@ TEST(IntegerQuantizer, UINT8_Uniform_Distribution) {
     for (size_t i = 0; i < data.size(); ++i) {
       var += (data[i] - recover_data[i]) * (data[i] - recover_data[i]);
     }
-    EXPECT_LT(var / COUNT, 0.01);
+    EXPECT_LT(var / count, 0.01);
   }
 }
 
@@ -419,7 +419,7 @@ TEST(IntegerQuantizer, UINT8_Poisson_Distribution) {
 
 TEST(IntegerQuantizer, UINT4_Uniform_Distribution) {
   std::vector<size_t> tests = {2, 100, 5000, 10000, 100000};
-  for (auto COUNT : tests) {
+  for (auto count : tests) {
     std::random_device rd;
     std::mt19937 gen(rd());
     std::vector<float> data;
@@ -427,7 +427,7 @@ TEST(IntegerQuantizer, UINT4_Uniform_Distribution) {
     std::uniform_real_distribution<float> dist(1.0, 2.0);
     float max = -std::numeric_limits<float>::min();
     float min = std::numeric_limits<float>::max();
-    for (size_t i = 0; i < COUNT; ++i) {
+    for (size_t i = 0; i < count; ++i) {
       auto v = dist(gen);
       max = std::max(max, v);
       min = std::min(min, v);
@@ -460,7 +460,7 @@ TEST(IntegerQuantizer, UINT4_Uniform_Distribution) {
            *std::min_element(recover_data.begin(), recover_data.end()));
     printf("var=%f\n", var);
 #endif
-    EXPECT_LT(var / COUNT, 0.1);
+    EXPECT_LT(var / count, 0.1);
   }
 }
 
diff --git a/tests/ailego/buffer/vector_page_table_test.cc b/tests/ailego/buffer/vector_page_table_test.cc
index cb7398817..e6ca8adf2 100644
--- a/tests/ailego/buffer/vector_page_table_test.cc
+++ b/tests/ailego/buffer/vector_page_table_test.cc
@@ -78,18 +78,18 @@ class BufferPoolTest : public ::testing::Test {
     }
   }
 
-  void InitPool(size_t capacity_pages) {
+  void init_pool(size_t capacity_pages) {
     ASSERT_EQ(0, MemoryLimitPool::get_instance().init(capacity_pages *
                                                       kVectorPageSize));
   }
-  void InitVecPool(size_t capacity_pages, size_t file_pages,
-                   bool writable = false) {
+  void init_vec_pool(size_t capacity_pages, size_t file_pages,
+                     bool writable = false) {
     ASSERT_EQ(0, MemoryLimitPool::get_instance().init(
                      capacity_pages * kVectorPageSize +
                      VecBufferPool::metadata_bytes_for_page_count(file_pages,
                                                                   writable)));
   }
-  void InitTablePool(size_t capacity_pages, size_t entry_num) {
+  void init_table_pool(size_t capacity_pages, size_t entry_num) {
     ASSERT_EQ(0, MemoryLimitPool::get_instance().init(
                      capacity_pages * kVectorPageSize +
                      VectorPageTable::metadata_bytes_for_entries(entry_num)));
@@ -98,7 +98,7 @@ class BufferPoolTest : public ::testing::Test {
     for (const auto &p : files_) std::remove(p.c_str());
     files_.clear();
   }
-  std::string NewFile(size_t num_pages) {
+  std::string new_file(size_t num_pages) {
     files_.push_back(MakeBackingFile(num_pages));
     return files_.back();
   }
@@ -269,8 +269,8 @@ version_t FindLiveVersion(SizedExternalCache &cache, eviction_key_t owner_key) {
 }  // namespace
 
 TEST_F(BufferPoolTest, AdmissionControlRejectsFirstColdMissAfterPressure) {
-  InitVecPool(/*capacity_pages=*/1, /*file_pages=*/4);
-  std::string file = NewFile(/*num_pages=*/4);
+  init_vec_pool(/*capacity_pages=*/1, /*file_pages=*/4);
+  std::string file = new_file(/*num_pages=*/4);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -294,8 +294,8 @@ TEST_F(BufferPoolTest, AdmissionControlRejectsFirstColdMissAfterPressure) {
 
 TEST_F(BufferPoolTest, BulkReadDoesNotAdmitFirstTouchScanUnderPressure) {
   constexpr size_t kFilePages = 5;
-  InitVecPool(/*capacity_pages=*/1, /*file_pages=*/kFilePages);
-  std::string file = NewFile(kFilePages);
+  init_vec_pool(/*capacity_pages=*/1, /*file_pages=*/kFilePages);
+  std::string file = new_file(kFilePages);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -319,8 +319,8 @@ TEST_F(BufferPoolTest, BulkReadDoesNotAdmitFirstTouchScanUnderPressure) {
 }
 
 TEST_F(BufferPoolTest, WritableBypassPreservesDirtyPagesWithoutAdmission) {
-  InitVecPool(/*capacity_pages=*/1, /*file_pages=*/2, /*writable=*/true);
-  VecBufferPool pool(NewFile(/*num_pages=*/2), /*writable=*/true);
+  init_vec_pool(/*capacity_pages=*/1, /*file_pages=*/2, /*writable=*/true);
+  VecBufferPool pool(new_file(/*num_pages=*/2), /*writable=*/true);
   ASSERT_EQ(0, pool.init());
   char *page = pool.acquire_buffer(0, 0);
   ASSERT_NE(nullptr, page);
@@ -346,8 +346,8 @@ TEST_F(BufferPoolTest, WritableBypassPreservesDirtyPagesWithoutAdmission) {
 }
 
 TEST_F(BufferPoolTest, WritableBypassJoinsConcurrentLoadBeforeReading) {
-  InitVecPool(/*capacity_pages=*/16, /*file_pages=*/1, /*writable=*/true);
-  VecBufferPool pool(NewFile(/*num_pages=*/1), /*writable=*/true);
+  init_vec_pool(/*capacity_pages=*/16, /*file_pages=*/1, /*writable=*/true);
+  VecBufferPool pool(new_file(/*num_pages=*/1), /*writable=*/true);
   ASSERT_EQ(0, pool.init());
   ASSERT_EQ(VectorPageTable::LoadClaimResult::kClaimed,
             pool.page_table_.try_claim_block_load(0));
@@ -379,7 +379,7 @@ TEST_F(BufferPoolTest, ShortReadDoesNotEvictHotPageOnFirstTouch) {
   constexpr size_t kCapacity = 256UL * 1024UL * 1024UL;
   auto &memory_pool = MemoryLimitPool::get_instance();
   ASSERT_EQ(0, memory_pool.init(kCapacity));
-  std::string file = NewFile(kFilePages);
+  std::string file = new_file(kFilePages);
 
   size_t charged_metadata = 0;
   {
@@ -414,8 +414,8 @@ TEST_F(BufferPoolTest, ShortReadDoesNotEvictHotPageOnFirstTouch) {
 }
 
 TEST_F(BufferPoolTest, BypassRecheckRecognizesResidencyActivity) {
-  InitVecPool(/*capacity_pages=*/2, /*file_pages=*/2);
-  std::string file = NewFile(/*num_pages=*/2);
+  init_vec_pool(/*capacity_pages=*/2, /*file_pages=*/2);
+  std::string file = new_file(/*num_pages=*/2);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -434,8 +434,8 @@ TEST_F(BufferPoolTest, BypassRecheckRecognizesResidencyActivity) {
 }
 
 TEST_F(BufferPoolTest, ResidentOnlyAcquirePreservesTransitionStates) {
-  InitVecPool(/*capacity_pages=*/1, /*file_pages=*/1);
-  std::string file = NewFile(/*num_pages=*/1);
+  init_vec_pool(/*capacity_pages=*/1, /*file_pages=*/1);
+  std::string file = new_file(/*num_pages=*/1);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -468,9 +468,9 @@ TEST_F(BufferPoolTest, ResidentOnlyAcquirePreservesTransitionStates) {
 // ---------------------------------------------------------------------------
 TEST_F(BufferPoolTest, DataCorrectUnderEviction) {
   const size_t num_pages = 64;
-  InitVecPool(/*capacity_pages=*/16,
-              /*file_pages=*/num_pages);  // 4x smaller than working set
-  std::string file = NewFile(num_pages);
+  init_vec_pool(/*capacity_pages=*/16,
+                /*file_pages=*/num_pages);  // 4x smaller than working set
+  std::string file = new_file(num_pages);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -495,8 +495,8 @@ TEST_F(BufferPoolTest, DataCorrectUnderEviction) {
 // install-time queue registration used to keep release_block() free of the
 // steady-state in_evict_queue CAS.
 TEST_F(BufferPoolTest, PinnedEvictionBecomesReclaimableAfterRelease) {
-  InitVecPool(/*capacity_pages=*/2, /*file_pages=*/2);
-  std::string file = NewFile(/*num_pages=*/2);
+  init_vec_pool(/*capacity_pages=*/2, /*file_pages=*/2);
+  std::string file = new_file(/*num_pages=*/2);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -519,7 +519,7 @@ TEST_F(BufferPoolTest, PinnedEvictionBecomesReclaimableAfterRelease) {
 // reuses the same owner address. Version zero represents an entry issued by a
 // different/legacy owner generation; the current resident page must survive.
 TEST_F(BufferPoolTest, StaleOwnerGenerationIsDead) {
-  InitTablePool(/*capacity_pages=*/2, /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/2, /*entry_num=*/1);
   VectorPageTable table;
   ASSERT_TRUE(table.init(/*entry_num=*/1));
 
@@ -535,7 +535,7 @@ TEST_F(BufferPoolTest, StaleOwnerGenerationIsDead) {
 }
 
 TEST_F(BufferPoolTest, ForceEvictUnloadedPageDoesNotEnqueueDeadItem) {
-  InitTablePool(/*capacity_pages=*/0, /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/0, /*entry_num=*/1);
   auto &queue = BlockEvictionQueue::get_instance();
   BlockEvictionQueue::BlockType item;
   while (queue.evict_single_block(item)) {
@@ -549,7 +549,7 @@ TEST_F(BufferPoolTest, ForceEvictUnloadedPageDoesNotEnqueueDeadItem) {
 
 TEST_F(BufferPoolTest, ConcurrentInstallPublishesOneResidentBuffer) {
   constexpr size_t kThreadCount = 16;
-  InitTablePool(/*capacity_pages=*/kThreadCount, /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/kThreadCount, /*entry_num=*/1);
   VectorPageTable table;
   ASSERT_TRUE(table.init(/*entry_num=*/1));
 
@@ -595,7 +595,7 @@ TEST_F(BufferPoolTest, ConcurrentInstallPublishesOneResidentBuffer) {
 
 TEST_F(BufferPoolTest, PageLoadClaimCoalescesConcurrentWaiters) {
   constexpr size_t kThreadCount = 16;
-  InitTablePool(/*capacity_pages=*/1, /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/1, /*entry_num=*/1);
   VectorPageTable table;
   ASSERT_TRUE(table.init(/*entry_num=*/1));
   ASSERT_EQ(VectorPageTable::LoadClaimResult::kClaimed,
@@ -663,7 +663,7 @@ TEST_F(BufferPoolTest, PageLoadClaimCoalescesConcurrentWaiters) {
 
 TEST_F(BufferPoolTest, FailedPageLoadClaimCanBeRetried) {
   // Keep the background reclaimer from racing with the explicit eviction.
-  InitTablePool(/*capacity_pages=*/16, /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/16, /*entry_num=*/1);
   VectorPageTable table;
   ASSERT_TRUE(table.init(/*entry_num=*/1));
 
@@ -684,7 +684,7 @@ TEST_F(BufferPoolTest, FailedPageLoadClaimCanBeRetried) {
 
 TEST_F(BufferPoolTest, DirtyFlushFailureKeepsPageResident) {
   // Only this thread should drive eviction and update the flush callback.
-  InitTablePool(/*capacity_pages=*/16, /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/16, /*entry_num=*/1);
   VectorPageTable table;
   ASSERT_TRUE(table.init(/*entry_num=*/1));
 
@@ -724,10 +724,10 @@ TEST_F(BufferPoolTest, ConcurrentWritablePressureUsesBackgroundWriteback) {
   // at once. The file is still much larger than the pool, so the test retains
   // sustained writeback pressure without depending on scheduler fairness.
   constexpr size_t kCapacityPages = kThreadCount * 2;
-  InitVecPool(kCapacityPages, kFilePages, /*writable=*/true);
+  init_vec_pool(kCapacityPages, kFilePages, /*writable=*/true);
   // BufferStorage creates a small metadata-only file and grows it as segments
   // are appended. Exercise that path instead of opening a pre-sized file.
-  std::string file = NewFile(/*num_pages=*/1);
+  std::string file = new_file(/*num_pages=*/1);
 
   VecBufferPool::Stats final_stats;
   {
@@ -798,7 +798,7 @@ TEST_F(BufferPoolTest, ConcurrentWritablePressureUsesBackgroundWriteback) {
 TEST_F(BufferPoolTest, RecoversDirtyPageAfterQueueRegistrationFailure) {
   // Keep the single resident page below the background-reclaim watermark so
   // only this thread advances the failed-flush/recovery sequence.
-  InitTablePool(/*capacity_pages=*/16, /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/16, /*entry_num=*/1);
   auto &queue = BlockEvictionQueue::get_instance();
   BlockEvictionQueue::BlockType discarded;
   // Earlier tests can leave stale global queue entries. batch_recycle(1)
@@ -846,8 +846,8 @@ TEST_F(BufferPoolTest, MetadataIsCountedAndReleasedWithPool) {
   constexpr size_t kPageCount = 2;
   const size_t expected_metadata =
       VecBufferPool::metadata_bytes_for_page_count(kPageCount);
-  InitVecPool(/*capacity_pages=*/2, /*file_pages=*/kPageCount);
-  std::string file = NewFile(kPageCount);
+  init_vec_pool(/*capacity_pages=*/2, /*file_pages=*/kPageCount);
+  std::string file = new_file(kPageCount);
 
   {
     VecBufferPool pool(file, /*writable=*/false);
@@ -885,8 +885,8 @@ TEST_F(BufferPoolTest, FixedMetadataStaysCompactAndReadOnlyAvoidsPageLocks) {
 #endif
   EXPECT_EQ(expected_writable_bytes, writable_bytes - read_only_bytes);
 
-  InitVecPool(/*capacity_pages=*/1, /*file_pages=*/1);
-  std::string file = NewFile(/*num_pages=*/1);
+  init_vec_pool(/*capacity_pages=*/1, /*file_pages=*/1);
+  std::string file = new_file(/*num_pages=*/1);
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
   const auto stats = pool.stats();
@@ -911,8 +911,8 @@ TEST_F(BufferPoolTest, EmptyPageTableChargesDirectoryOnFirstExtend) {
 }
 
 TEST_F(BufferPoolTest, WritablePoolReportsPageLockMetadata) {
-  InitVecPool(/*capacity_pages=*/1, /*file_pages=*/1, /*writable=*/true);
-  std::string file = NewFile(/*num_pages=*/1);
+  init_vec_pool(/*capacity_pages=*/1, /*file_pages=*/1, /*writable=*/true);
+  std::string file = new_file(/*num_pages=*/1);
   VecBufferPool pool(file, /*writable=*/true);
   ASSERT_EQ(pool.init(), 0);
 
@@ -930,7 +930,7 @@ TEST_F(BufferPoolTest, WritablePoolReportsPageLockMetadata) {
 
 TEST_F(BufferPoolTest, FailedPageTableExtendLeavesStateUnchanged) {
   constexpr size_t kSecondSegmentEntry = 16UL * 1024UL + 1;
-  InitTablePool(/*capacity_pages=*/0, /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/0, /*entry_num=*/1);
   VectorPageTable table;
   ASSERT_TRUE(table.init(/*entry_num=*/1));
   const size_t metadata_before =
@@ -943,8 +943,8 @@ TEST_F(BufferPoolTest, FailedPageTableExtendLeavesStateUnchanged) {
 
 TEST_F(BufferPoolTest, FailedFileExtendDoesNotGrowBackingFile) {
   constexpr size_t kSecondSegmentEntry = 16UL * 1024UL + 1;
-  InitVecPool(/*capacity_pages=*/1, /*file_pages=*/1, /*writable=*/true);
-  std::string file = NewFile(/*num_pages=*/1);
+  init_vec_pool(/*capacity_pages=*/1, /*file_pages=*/1, /*writable=*/true);
+  std::string file = new_file(/*num_pages=*/1);
 
   VecBufferPool pool(file, /*writable=*/true);
   ASSERT_EQ(pool.init(), 0);
@@ -963,7 +963,7 @@ TEST_F(BufferPoolTest, FailedFileExtendDoesNotGrowBackingFile) {
 
 TEST_F(BufferPoolTest, ExternalReservationSharesThePageBudget) {
   auto &memory_pool = MemoryLimitPool::get_instance();
-  InitPool(/*capacity_pages=*/4);
+  init_pool(/*capacity_pages=*/4);
 
   ASSERT_TRUE(memory_pool.try_charge_external(3 * kVectorPageSize));
   EXPECT_EQ(3 * kVectorPageSize, memory_pool.used());
@@ -1009,7 +1009,7 @@ TEST_F(BufferPoolTest, ReadOnlyMissEvictsAtPageAdmissionLimit) {
   const size_t reserve = memory_pool.page_admission_reserve();
   ASSERT_EQ(16UL * 1024UL * 1024UL, reserve);
 
-  std::string file = NewFile(/*num_pages=*/2);
+  std::string file = new_file(/*num_pages=*/2);
   const size_t pool_metadata =
       VecBufferPool::metadata_bytes_for_page_count(/*page_count=*/2,
                                                    /*writable=*/false);
@@ -1061,7 +1061,7 @@ TEST_F(BufferPoolTest, TinyBufferDoesNotPoisonThePageFreeList) {
 
 TEST_F(BufferPoolTest, RejectsReinitializationWhileMemoryIsActive) {
   auto &memory_pool = MemoryLimitPool::get_instance();
-  InitPool(/*capacity_pages=*/4);
+  init_pool(/*capacity_pages=*/4);
   const size_t original_capacity = memory_pool.capacity();
 
   ASSERT_TRUE(memory_pool.try_charge_external(kVectorPageSize));
@@ -1079,7 +1079,7 @@ TEST_F(BufferPoolTest, RejectsReinitializationWhileMemoryIsActive) {
 
 TEST_F(BufferPoolTest, ExternalCacheRejectsOversizedEntryAndReleasesOnDestroy) {
   auto &memory_pool = MemoryLimitPool::get_instance();
-  InitPool(/*capacity_pages=*/2);
+  init_pool(/*capacity_pages=*/2);
 
   {
     SizedExternalCache cache;
@@ -1102,7 +1102,7 @@ TEST_F(BufferPoolTest,
   auto &memory_pool = MemoryLimitPool::get_instance();
   // Keep usage below the background high watermark so only the simulated
   // enqueue-failure callback can reclaim this entry during the assertion.
-  InitPool(/*capacity_pages=*/2);
+  init_pool(/*capacity_pages=*/2);
 
   SizedExternalCache cache;
   auto value = cache.acquire(kVectorPageSize);
@@ -1121,7 +1121,7 @@ TEST_F(BufferPoolTest,
 
 TEST_F(BufferPoolTest, ExternalCacheReusesOneQueueMembershipAcrossHits) {
   auto &memory_pool = MemoryLimitPool::get_instance();
-  InitPool(/*capacity_pages=*/4);
+  init_pool(/*capacity_pages=*/4);
 
   SizedExternalCache cache;
   auto value = cache.acquire(kVectorPageSize);
@@ -1150,7 +1150,7 @@ TEST_F(BufferPoolTest, ExternalCacheReusesOneQueueMembershipAcrossHits) {
 
 TEST_F(BufferPoolTest, PinnedExternalCacheEntryStaysQueuedForLaterEviction) {
   auto &memory_pool = MemoryLimitPool::get_instance();
-  InitPool(/*capacity_pages=*/4);
+  init_pool(/*capacity_pages=*/4);
 
   SizedExternalCache cache;
   auto value = cache.acquire(kVectorPageSize);
@@ -1170,7 +1170,7 @@ TEST_F(BufferPoolTest, PinnedExternalCacheEntryStaysQueuedForLaterEviction) {
 
 TEST_F(BufferPoolTest, ConcurrentLoadsUseSingleFlight) {
   constexpr size_t kThreadCount = 16;
-  InitPool(/*capacity_pages=*/4);
+  init_pool(/*capacity_pages=*/4);
   auto state = std::make_shared<BlockingLoadState>();
   BlockingExternalCache cache(BlockingLoader{state});
   std::atomic<size_t> acquired{0};
@@ -1208,7 +1208,7 @@ TEST_F(BufferPoolTest, ConcurrentLoadsUseSingleFlight) {
 
 TEST_F(BufferPoolTest, DistinctExternalCacheLoadsAreConcurrentByDefault) {
   constexpr size_t kThreadCount = 2;
-  InitPool(/*capacity_pages=*/4);
+  init_pool(/*capacity_pages=*/4);
   auto state = std::make_shared<BlockingLoadState>();
   BlockingExternalCache cache(BlockingLoader{state});
   std::array<std::shared_ptr<std::vector<char>>, kThreadCount> values;
@@ -1244,7 +1244,7 @@ TEST_F(BufferPoolTest, DistinctExternalCacheLoadsAreConcurrentByDefault) {
 
 TEST_F(BufferPoolTest, DistinctExternalCacheLoadsRespectInflightLimit) {
   constexpr size_t kThreadCount = 2;
-  InitPool(/*capacity_pages=*/4);
+  init_pool(/*capacity_pages=*/4);
   auto state = std::make_shared<BlockingLoadState>();
   BlockingExternalCache cache(BlockingLoader{state},
                               /*max_concurrent_loads=*/1);
@@ -1285,7 +1285,7 @@ TEST_F(BufferPoolTest, DistinctExternalCacheLoadsRespectInflightLimit) {
 }
 
 TEST_F(BufferPoolTest, WaitingExternalLoadRechecksCapacityBeforeLoading) {
-  InitPool(/*capacity_pages=*/1);
+  init_pool(/*capacity_pages=*/1);
   auto state = std::make_shared<BlockingLoadState>();
   BlockingExternalCache cache(BlockingLoader{state},
                               /*max_concurrent_loads=*/1);
@@ -1310,7 +1310,7 @@ TEST_F(BufferPoolTest, WaitingExternalLoadRechecksCapacityBeforeLoading) {
 }
 
 TEST_F(BufferPoolTest, ThrowingPayloadConstructorDoesNotClaimLoaderSlot) {
-  InitPool(/*capacity_pages=*/2);
+  init_pool(/*capacity_pages=*/2);
   ThrowingCachePayload::construction_count = 0;
   ThrowingCachePayload::throw_on_construction = 2;
   ThrowingExternalCache cache(/*max_concurrent_loads=*/1);
@@ -1325,7 +1325,7 @@ TEST_F(BufferPoolTest, ThrowingPayloadConstructorDoesNotClaimLoaderSlot) {
 }
 
 TEST_F(BufferPoolTest, EmptyLoaderValueRollsBackChargeAndPlaceholder) {
-  InitPool(/*capacity_pages=*/2);
+  init_pool(/*capacity_pages=*/2);
   EmptyValueExternalCache cache;
 
   EXPECT_THROW(cache.acquire(kVectorPageSize), std::runtime_error);
@@ -1363,7 +1363,7 @@ TEST_F(BufferPoolTest, BatchRecycleBoundsStaleQueueScanning) {
 
 TEST_F(BufferPoolTest, HighCardinalityEvictionRemovesKeyMetadata) {
   auto &memory_pool = MemoryLimitPool::get_instance();
-  InitPool(/*capacity_pages=*/8);
+  init_pool(/*capacity_pages=*/8);
   SizedExternalCache cache;
 
   for (size_t key = 1; key <= 256; ++key) {
@@ -1389,7 +1389,7 @@ TEST_F(BufferPoolTest, OwningHandleRejectsNullPool) {
 }
 
 TEST_F(BufferPoolTest, ExternalCacheRejectsStaleItemAfterAddressReuse) {
-  InitPool(/*capacity_pages=*/4);
+  init_pool(/*capacity_pages=*/4);
   alignas(SizedExternalCache) unsigned char storage[sizeof(SizedExternalCache)];
   constexpr eviction_key_t kOwnerKey = 1;
 
@@ -1420,7 +1420,7 @@ TEST_F(BufferPoolTest, ExternalCacheRejectsStaleItemAfterAddressReuse) {
 }
 
 TEST_F(BufferPoolTest, ExternalCacheUsesExplicitHotEvictionPriority) {
-  InitPool(/*capacity_pages=*/2);
+  init_pool(/*capacity_pages=*/2);
   SizedExternalCache cache;
   auto value = cache.acquire(kVectorPageSize);
   ASSERT_NE(nullptr, value);
@@ -1432,7 +1432,7 @@ TEST_F(BufferPoolTest, ExternalCacheUsesExplicitHotEvictionPriority) {
 TEST_F(BufferPoolTest, ExternalReservationTrimsRetainedPageBuffers) {
   constexpr size_t kCapacityPages = 4;
   auto &memory_pool = MemoryLimitPool::get_instance();
-  InitPool(kCapacityPages);
+  init_pool(kCapacityPages);
 
   std::vector<char *> pages;
   for (size_t i = 0; i < kCapacityPages; ++i) {
@@ -1486,8 +1486,8 @@ TEST_F(BufferPoolTest, LargeExternalReservationReclaimsMultipleBatches) {
   constexpr size_t kCapacityPages = 512;
   constexpr size_t kExternalPages = 400;
   auto &memory_pool = MemoryLimitPool::get_instance();
-  InitVecPool(kCapacityPages, /*file_pages=*/kCapacityPages);
-  std::string file = NewFile(kCapacityPages);
+  init_vec_pool(kCapacityPages, /*file_pages=*/kCapacityPages);
+  std::string file = new_file(kCapacityPages);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -1505,8 +1505,8 @@ TEST_F(BufferPoolTest, LargeExternalReservationReclaimsMultipleBatches) {
 }
 
 TEST_F(BufferPoolTest, PriorityChangeMigratesQueuedPageBeforeEviction) {
-  InitVecPool(/*capacity_pages=*/4, /*file_pages=*/2);
-  std::string file = NewFile(/*num_pages=*/2);
+  init_vec_pool(/*capacity_pages=*/4, /*file_pages=*/2);
+  std::string file = new_file(/*num_pages=*/2);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -1550,8 +1550,8 @@ TEST_F(BufferPoolTest, DominantProtectedQueueReceivesAgingSamples) {
 }
 
 TEST_F(BufferPoolTest, ReadOnlyPoolDefersAdaptivePriorityUntilPressure) {
-  InitVecPool(/*capacity_pages=*/2, /*file_pages=*/1);
-  std::string file = NewFile(/*num_pages=*/1);
+  init_vec_pool(/*capacity_pages=*/2, /*file_pages=*/1);
+  std::string file = new_file(/*num_pages=*/1);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -1566,8 +1566,8 @@ TEST_F(BufferPoolTest, ReadOnlyPoolDefersAdaptivePriorityUntilPressure) {
 }
 
 TEST_F(BufferPoolTest, ReusedReadOnlyPagePromotesAfterPressure) {
-  InitVecPool(/*capacity_pages=*/2, /*file_pages=*/4);
-  std::string file = NewFile(/*num_pages=*/4);
+  init_vec_pool(/*capacity_pages=*/2, /*file_pages=*/4);
+  std::string file = new_file(/*num_pages=*/4);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -1605,8 +1605,8 @@ TEST_F(BufferPoolTest, ReusedReadOnlyPagePromotesAfterPressure) {
 constexpr size_t kManualEvictionCapacityPages = 2;
 
 TEST_F(BufferPoolTest, ProtectedPageAgesThroughProbationBeforeEviction) {
-  InitTablePool(/*capacity_pages=*/kManualEvictionCapacityPages,
-                /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/kManualEvictionCapacityPages,
+                  /*entry_num=*/1);
   VectorPageTable table;
   ASSERT_TRUE(table.init(/*entry_num=*/1));
 
@@ -1640,8 +1640,8 @@ TEST_F(BufferPoolTest, ProtectedPageAgesThroughProbationBeforeEviction) {
 }
 
 TEST_F(BufferPoolTest, EvictedHotPageGetsProtectedGhostAdmission) {
-  InitTablePool(/*capacity_pages=*/kManualEvictionCapacityPages,
-                /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/kManualEvictionCapacityPages,
+                  /*entry_num=*/1);
   VectorPageTable table;
   ASSERT_TRUE(table.init(/*entry_num=*/1));
 
@@ -1672,8 +1672,8 @@ TEST_F(BufferPoolTest, EvictedHotPageGetsProtectedGhostAdmission) {
 }
 
 TEST_F(BufferPoolTest, UnusedGhostAdmissionDoesNotRenewItself) {
-  InitTablePool(/*capacity_pages=*/kManualEvictionCapacityPages,
-                /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/kManualEvictionCapacityPages,
+                  /*entry_num=*/1);
   VectorPageTable table;
   ASSERT_TRUE(table.init(/*entry_num=*/1));
 
@@ -1714,8 +1714,8 @@ TEST_F(BufferPoolTest, UnusedGhostAdmissionDoesNotRenewItself) {
 }
 
 TEST_F(BufferPoolTest, ReusedGhostAdmissionRenewsHotHistory) {
-  InitTablePool(/*capacity_pages=*/kManualEvictionCapacityPages,
-                /*entry_num=*/1);
+  init_table_pool(/*capacity_pages=*/kManualEvictionCapacityPages,
+                  /*entry_num=*/1);
   VectorPageTable table;
   ASSERT_TRUE(table.init(/*entry_num=*/1));
 
@@ -1762,8 +1762,8 @@ TEST_F(BufferPoolTest, ReusedGhostAdmissionRenewsHotHistory) {
 
 TEST_F(BufferPoolTest, ReusedPageSurvivesContinuousColdStream) {
   constexpr size_t kFilePages = 32;
-  InitVecPool(/*capacity_pages=*/3, /*file_pages=*/kFilePages);
-  std::string file = NewFile(kFilePages);
+  init_vec_pool(/*capacity_pages=*/3, /*file_pages=*/kFilePages);
+  std::string file = new_file(kFilePages);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -1792,8 +1792,8 @@ TEST_F(BufferPoolTest, ReusedPageSurvivesContinuousColdStream) {
 }
 
 TEST_F(BufferPoolTest, WritablePoolDoesNotAdaptReadPriority) {
-  InitVecPool(/*capacity_pages=*/2, /*file_pages=*/1, /*writable=*/true);
-  std::string file = NewFile(/*num_pages=*/1);
+  init_vec_pool(/*capacity_pages=*/2, /*file_pages=*/1, /*writable=*/true);
+  std::string file = new_file(/*num_pages=*/1);
 
   VecBufferPool pool(file, /*writable=*/true);
   ASSERT_EQ(pool.init(), 0);
@@ -1809,9 +1809,9 @@ TEST_F(BufferPoolTest, WritablePoolDoesNotAdaptReadPriority) {
 
 TEST_F(BufferPoolTest, WritablePrefetchUsesClaimedLoadPath) {
   constexpr size_t kPageCount = 2;
-  InitVecPool(/*capacity_pages=*/4, /*file_pages=*/kPageCount,
-              /*writable=*/true);
-  std::string file = NewFile(kPageCount);
+  init_vec_pool(/*capacity_pages=*/4, /*file_pages=*/kPageCount,
+                /*writable=*/true);
+  std::string file = new_file(kPageCount);
 
   VecBufferPool pool(file, /*writable=*/true);
   ASSERT_EQ(pool.init(), 0);
@@ -1831,8 +1831,8 @@ TEST_F(BufferPoolTest, WritablePrefetchUsesClaimedLoadPath) {
 }
 
 TEST_F(BufferPoolTest, BypassReadDoesNotAdmitPage) {
-  InitVecPool(/*capacity_pages=*/2, /*file_pages=*/4);
-  std::string file = NewFile(/*num_pages=*/4);
+  init_vec_pool(/*capacity_pages=*/2, /*file_pages=*/4);
+  std::string file = new_file(/*num_pages=*/4);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -1851,8 +1851,8 @@ TEST_F(BufferPoolTest, BypassReadDoesNotAdmitPage) {
 }
 
 TEST_F(BufferPoolTest, ReadAndPrefetchRangesRejectOverflow) {
-  InitVecPool(/*capacity_pages=*/2, /*file_pages=*/2);
-  std::string file = NewFile(/*num_pages=*/2);
+  init_vec_pool(/*capacity_pages=*/2, /*file_pages=*/2);
+  std::string file = new_file(/*num_pages=*/2);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -1869,8 +1869,8 @@ TEST_F(BufferPoolTest, ReadAndPrefetchRangesRejectOverflow) {
 
 #if defined(__linux__)
 TEST_F(BufferPoolTest, AioAdmissionUsesFreeCapacityBeforeEviction) {
-  InitVecPool(/*capacity_pages=*/8, /*file_pages=*/4);
-  std::string file = NewFile(/*num_pages=*/4);
+  init_vec_pool(/*capacity_pages=*/8, /*file_pages=*/4);
+  std::string file = new_file(/*num_pages=*/4);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -1898,8 +1898,8 @@ TEST_F(BufferPoolTest, AioAdmissionUsesFreeCapacityBeforeEviction) {
 // order, deduplicates cold I/O internally, and still returns one independent
 // pin for every occurrence of a duplicate page id.
 TEST_F(BufferPoolTest, BatchAcquireScatteredPagesWithDuplicates) {
-  InitVecPool(/*capacity_pages=*/16, /*file_pages=*/32);
-  std::string file = NewFile(/*num_pages=*/32);
+  init_vec_pool(/*capacity_pages=*/16, /*file_pages=*/32);
+  std::string file = new_file(/*num_pages=*/32);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -1925,8 +1925,8 @@ TEST_F(BufferPoolTest, BatchAcquireScatteredPagesWithDuplicates) {
 TEST_F(BufferPoolTest, ConcurrentBatchLoadsPopulateEachPageOnce) {
   static constexpr size_t kPageCount = 128;
   constexpr size_t kThreadCount = 8;
-  InitVecPool(/*capacity_pages=*/512, /*file_pages=*/kPageCount);
-  std::string file = NewFile(kPageCount);
+  init_vec_pool(/*capacity_pages=*/512, /*file_pages=*/kPageCount);
+  std::string file = new_file(kPageCount);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -1975,8 +1975,8 @@ TEST_F(BufferPoolTest, ConcurrentBatchLoadsPopulateEachPageOnce) {
 }
 
 TEST_F(BufferPoolTest, BatchMissesRemainProbationUntilLaterReuse) {
-  InitVecPool(/*capacity_pages=*/2, /*file_pages=*/4);
-  std::string file = NewFile(/*num_pages=*/4);
+  init_vec_pool(/*capacity_pages=*/2, /*file_pages=*/4);
+  std::string file = new_file(/*num_pages=*/4);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -2009,8 +2009,8 @@ TEST_F(BufferPoolTest, BatchMissesRemainProbationUntilLaterReuse) {
 }
 
 TEST_F(BufferPoolTest, BatchAcquireRollsBackPinsOnInvalidPage) {
-  InitVecPool(/*capacity_pages=*/4, /*file_pages=*/4);
-  std::string file = NewFile(/*num_pages=*/4);
+  init_vec_pool(/*capacity_pages=*/4, /*file_pages=*/4);
+  std::string file = new_file(/*num_pages=*/4);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -2030,8 +2030,8 @@ TEST_F(BufferPoolTest, BatchAcquireRollsBackPinsOnInvalidPage) {
 // ---------------------------------------------------------------------------
 TEST_F(BufferPoolTest, SecondChanceKeepsHotSet) {
   const size_t num_pages = 128;
-  InitVecPool(/*capacity_pages=*/32, /*file_pages=*/num_pages);
-  std::string file = NewFile(num_pages);
+  init_vec_pool(/*capacity_pages=*/32, /*file_pages=*/num_pages);
+  std::string file = new_file(num_pages);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -2090,8 +2090,8 @@ TEST_F(BufferPoolTest, SecondChanceKeepsHotSet) {
 TEST_F(BufferPoolTest, BackgroundReclaimsToLowWatermark) {
   const size_t cap_pages = 64;
   const size_t num_pages = 64;
-  InitVecPool(cap_pages, /*file_pages=*/num_pages);
-  std::string file = NewFile(num_pages);
+  init_vec_pool(cap_pages, /*file_pages=*/num_pages);
+  std::string file = new_file(num_pages);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -2118,8 +2118,8 @@ TEST_F(BufferPoolTest, BackgroundReclaimsToLowWatermark) {
 
 TEST_F(BufferPoolTest, BackgroundBacksOffWhenAllPagesArePinned) {
   constexpr size_t kPageCount = 4;
-  InitVecPool(/*capacity_pages=*/kPageCount, /*file_pages=*/kPageCount);
-  std::string file = NewFile(kPageCount);
+  init_vec_pool(/*capacity_pages=*/kPageCount, /*file_pages=*/kPageCount);
+  std::string file = new_file(kPageCount);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -2151,8 +2151,8 @@ TEST_F(BufferPoolTest, BackgroundBacksOffWhenAllPagesArePinned) {
 // ---------------------------------------------------------------------------
 TEST_F(BufferPoolTest, ConcurrentRandomReads) {
   const size_t num_pages = 256;
-  InitVecPool(/*capacity_pages=*/48, /*file_pages=*/num_pages);
-  std::string file = NewFile(num_pages);
+  init_vec_pool(/*capacity_pages=*/48, /*file_pages=*/num_pages);
+  std::string file = new_file(num_pages);
 
   VecBufferPool pool(file, /*writable=*/false);
   ASSERT_EQ(pool.init(), 0);
@@ -2191,7 +2191,7 @@ TEST_F(BufferPoolTest, ConcurrentRandomReads) {
 // ---------------------------------------------------------------------------
 TEST_F(BufferPoolTest, ShardedPoolAllocFreeAccounting) {
   const size_t cap_pages = 32;
-  InitPool(cap_pages);
+  init_pool(cap_pages);
   auto &mp = MemoryLimitPool::get_instance();
 
   std::vector<char *> bufs;
@@ -2223,7 +2223,7 @@ TEST_F(BufferPoolTest, ShardedPoolAllocFreeAccounting) {
 
 TEST_F(BufferPoolTest, SlabBaseIsFourMiBAlignedAndPagesAreDirectIoAligned) {
   constexpr size_t kPages = 8;
-  InitPool(kPages);
+  init_pool(kPages);
   auto &mp = MemoryLimitPool::get_instance();
 
   std::vector<char *> pages;
@@ -2256,7 +2256,7 @@ TEST_F(BufferPoolTest, SlabBaseIsFourMiBAlignedAndPagesAreDirectIoAligned) {
 }
 
 TEST_F(BufferPoolTest, ReinitializationReleasesSlabMappings) {
-  InitPool(/*capacity_pages=*/4);
+  init_pool(/*capacity_pages=*/4);
   auto &mp = MemoryLimitPool::get_instance();
 
   char *page = nullptr;
diff --git a/tests/ailego/container/cube_test.cc b/tests/ailego/container/cube_test.cc
index 456e6da54..0fcd49fdd 100644
--- a/tests/ailego/container/cube_test.cc
+++ b/tests/ailego/container/cube_test.cc
@@ -415,43 +415,43 @@ TEST(Cube, EnumObject) {
   EnumValueType a(EnumValueType::Binary), c(EnumValueType::Unknown);
   EnumClassType b(EnumClassType::RED), d(EnumClassType::Unknown);
 
-  Cube cubeA(a);
-  Cube cubeB(b);
+  Cube cube_a(a);
+  Cube cube_b(b);
 
-  EXPECT_EQ(a, cubeA.cast<EnumValueType>());
-  EXPECT_NE(c, cubeA.cast<EnumValueType>());
-  c = cubeA.cast<EnumValueType>();
+  EXPECT_EQ(a, cube_a.cast<EnumValueType>());
+  EXPECT_NE(c, cube_a.cast<EnumValueType>());
+  c = cube_a.cast<EnumValueType>();
   EXPECT_EQ(a, c);
 
-  EXPECT_EQ(b, cubeB.cast<EnumClassType>());
-  EXPECT_NE(d, cubeB.cast<EnumClassType>());
-  d = cubeB.cast<EnumClassType>();
+  EXPECT_EQ(b, cube_b.cast<EnumClassType>());
+  EXPECT_NE(d, cube_b.cast<EnumClassType>());
+  d = cube_b.cast<EnumClassType>();
   EXPECT_EQ(b, d);
 
-  Cube cubeC((std::underlying_type<EnumValueType>::type)1);
-  Cube cubeD((std::underlying_type<EnumClassType>::type)1);
+  Cube cube_c((std::underlying_type<EnumValueType>::type)1);
+  Cube cube_d((std::underlying_type<EnumClassType>::type)1);
 
-  std::cout << "* cubeA: " << cubeA.type().name() << std::endl;
-  std::cout << "* cubeB: " << cubeB.type().name() << std::endl;
-  std::cout << "* cubeC: " << cubeC.type().name() << std::endl;
-  std::cout << "* cubeD: " << cubeD.type().name() << std::endl;
+  std::cout << "* cubeA: " << cube_a.type().name() << std::endl;
+  std::cout << "* cubeB: " << cube_b.type().name() << std::endl;
+  std::cout << "* cubeC: " << cube_c.type().name() << std::endl;
+  std::cout << "* cubeD: " << cube_d.type().name() << std::endl;
 
   // EXPECT_TRUE(typeid(std::underlying_type<EnumValueType>::type) ==
   //             typeid(uint32_t));
   // EXPECT_TRUE(typeid(std::underlying_type<EnumClassType>::type) ==
   //             typeid(int32_t));
 
-  EXPECT_TRUE(cubeA.compatible<EnumValueType>());
-  EXPECT_TRUE(cubeB.compatible<EnumClassType>());
-  EXPECT_TRUE(cubeA.compatible<std::underlying_type<EnumValueType>::type>());
-  EXPECT_TRUE(cubeB.compatible<std::underlying_type<EnumClassType>::type>());
-  EXPECT_TRUE(cubeC.compatible<std::underlying_type<EnumValueType>::type>());
-  EXPECT_TRUE(cubeD.compatible<std::underlying_type<EnumClassType>::type>());
+  EXPECT_TRUE(cube_a.compatible<EnumValueType>());
+  EXPECT_TRUE(cube_b.compatible<EnumClassType>());
+  EXPECT_TRUE(cube_a.compatible<std::underlying_type<EnumValueType>::type>());
+  EXPECT_TRUE(cube_b.compatible<std::underlying_type<EnumClassType>::type>());
+  EXPECT_TRUE(cube_c.compatible<std::underlying_type<EnumValueType>::type>());
+  EXPECT_TRUE(cube_d.compatible<std::underlying_type<EnumClassType>::type>());
 
   EnumValueType e =
-      (EnumValueType)cubeA.cast<std::underlying_type<EnumValueType>::type>();
+      (EnumValueType)cube_a.cast<std::underlying_type<EnumValueType>::type>();
   EnumClassType f =
-      (EnumClassType)cubeB.cast<std::underlying_type<EnumClassType>::type>();
+      (EnumClassType)cube_b.cast<std::underlying_type<EnumClassType>::type>();
   EXPECT_EQ(a, e);
   EXPECT_EQ(b, f);
 }
diff --git a/tests/ailego/io/utf8_path_test.cc b/tests/ailego/io/utf8_path_test.cc
index aa5c50ea6..f878f24ee 100644
--- a/tests/ailego/io/utf8_path_test.cc
+++ b/tests/ailego/io/utf8_path_test.cc
@@ -50,7 +50,7 @@ class Utf8PathTest : public ::testing::Test {
       FileHelper::RemovePath(p.c_str());
     }
   }
-  void ScheduleCleanup(const std::string &path) {
+  void schedule_cleanup(const std::string &path) {
     cleanup_.push_back(path);
   }
 
@@ -63,7 +63,7 @@ class Utf8PathTest : public ::testing::Test {
 // ---------------------------------------------------------------------------
 TEST_F(Utf8PathTest, MakePath_Chinese) {
   std::string dir = "utf8_test_" + kChinese;
-  ScheduleCleanup(dir);
+  schedule_cleanup(dir);
 
   ASSERT_TRUE(FileHelper::MakePath(dir.c_str()));
   EXPECT_TRUE(FileHelper::IsExist(dir.c_str()));
@@ -80,7 +80,7 @@ TEST_F(Utf8PathTest, MakePath_Chinese) {
 TEST_F(Utf8PathTest, MakePath_Nested) {
   std::string root = "utf8_test_nested_" + kChinese;
   std::string nested = FileHelper::PathJoin(root, kJapanese, kMixed);
-  ScheduleCleanup(root);
+  schedule_cleanup(root);
 
   ASSERT_TRUE(FileHelper::MakePath(nested.c_str()));
   EXPECT_TRUE(FileHelper::IsDirectory(nested.c_str()));
@@ -95,7 +95,7 @@ TEST_F(Utf8PathTest, MakePath_Nested) {
 TEST_F(Utf8PathTest, FileCreateAndReadWrite) {
   std::string dir = "utf8_test_file_" + kChinese;
   std::string file_path = FileHelper::PathJoin(dir, kJapanese + ".dat");
-  ScheduleCleanup(dir);
+  schedule_cleanup(dir);
 
   ASSERT_TRUE(FileHelper::MakePath(dir.c_str()));
 
@@ -133,7 +133,7 @@ TEST_F(Utf8PathTest, RenameFile) {
   std::string dir = "utf8_test_rename_" + kChinese;
   std::string src = FileHelper::PathJoin(dir, "src_" + kJapanese);
   std::string dst = FileHelper::PathJoin(dir, "dst_" + kMixed);
-  ScheduleCleanup(dir);
+  schedule_cleanup(dir);
 
   ASSERT_TRUE(FileHelper::MakePath(dir.c_str()));
   {
@@ -153,7 +153,7 @@ TEST_F(Utf8PathTest, RenameFile) {
 TEST_F(Utf8PathTest, FstreamUtf8) {
   std::string dir = "utf8_test_fstream_" + kChinese;
   std::string file_path = FileHelper::PathJoin(dir, kMixed + ".txt");
-  ScheduleCleanup(dir);
+  schedule_cleanup(dir);
 
   ASSERT_TRUE(FileHelper::MakePath(dir.c_str()));
 
@@ -200,7 +200,7 @@ TEST_F(Utf8PathTest, NoGarbledNames_FindFirstFile) {
   std::string child_file = kJapanese + ".dat";
   std::string full_dir = FileHelper::PathJoin(parent, child_dir);
   std::string full_file = FileHelper::PathJoin(parent, child_file);
-  ScheduleCleanup(parent);
+  schedule_cleanup(parent);
 
   ASSERT_TRUE(FileHelper::MakePath(full_dir.c_str()));
   {
@@ -248,7 +248,7 @@ TEST_F(Utf8PathTest, NoGarbledNames_DirCmd) {
   std::string child = kChinese;
   std::string full = FileHelper::PathJoin(parent, child);
   std::string tmpfile = "utf8_test_dir_cmd_output.txt";
-  ScheduleCleanup(parent);
+  schedule_cleanup(parent);
 
   ASSERT_TRUE(FileHelper::MakePath(full.c_str()));
 
diff --git a/tests/ailego/math/cosine_distance_matrix_fp16_test.cc b/tests/ailego/math/cosine_distance_matrix_fp16_test.cc
index 3c6aa701e..24d6dd7d8 100644
--- a/tests/ailego/math/cosine_distance_matrix_fp16_test.cc
+++ b/tests/ailego/math/cosine_distance_matrix_fp16_test.cc
@@ -31,11 +31,11 @@ inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-inline void MatrixTranspose(Float16 *dst, const Float16 *src, size_t M,
-                            size_t N) {
-  for (size_t i = 0; i < N; ++i) {
-    for (size_t j = 0; j < M; ++j) {
-      dst[j * N + i] = src[i * M + j];
+inline void MatrixTranspose(Float16 *dst, const Float16 *src, size_t m,
+                            size_t n) {
+  for (size_t i = 0; i < n; ++i) {
+    for (size_t j = 0; j < m; ++j) {
+      dst[j * n + i] = src[i * m + j];
     }
   }
 }
diff --git a/tests/ailego/math/cosine_distance_matrix_fp32_test.cc b/tests/ailego/math/cosine_distance_matrix_fp32_test.cc
index 9c5b5d428..21f505a17 100644
--- a/tests/ailego/math/cosine_distance_matrix_fp32_test.cc
+++ b/tests/ailego/math/cosine_distance_matrix_fp32_test.cc
@@ -31,11 +31,11 @@ inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-inline void MatrixTranspose(float *dst, const float *src, size_t M, size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+inline void MatrixTranspose(float *dst, const float *src, size_t m, size_t n) {
+  for (size_t idx = 0; idx < n * m; idx++) {
+    size_t i = idx / n;
+    size_t j = idx % n;
+    dst[idx] = src[m * j + i];
   }
 }
 
@@ -405,4 +405,4 @@ TEST(DistanceMatrix, DISABLED_Cosine_Benchmark) {
   CosineBenchmark<1, 1, 1024, 256>();
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/tests/ailego/math/cosine_distance_matrix_int8_test.cc b/tests/ailego/math/cosine_distance_matrix_int8_test.cc
index d9c2ab463..f7e4b243f 100644
--- a/tests/ailego/math/cosine_distance_matrix_int8_test.cc
+++ b/tests/ailego/math/cosine_distance_matrix_int8_test.cc
@@ -27,11 +27,11 @@ inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t M,
-                            size_t N) {
-  for (size_t i = 0; i < N; ++i) {
-    for (size_t j = 0; j < M; ++j) {
-      dst[j * N + i] = src[i * M + j];
+inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t m,
+                            size_t n) {
+  for (size_t i = 0; i < n; ++i) {
+    for (size_t j = 0; j < m; ++j) {
+      dst[j * n + i] = src[i * m + j];
     }
   }
 }
diff --git a/tests/ailego/math/euclidean_distance_matrix_fp16_test.cc b/tests/ailego/math/euclidean_distance_matrix_fp16_test.cc
index 57ae5f2d1..3763a803c 100644
--- a/tests/ailego/math/euclidean_distance_matrix_fp16_test.cc
+++ b/tests/ailego/math/euclidean_distance_matrix_fp16_test.cc
@@ -31,11 +31,11 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(Float16 *dst, const Float16 *src, size_t M,
-                                   size_t N) {
-  for (size_t i = 0; i < N; ++i) {
-    for (size_t j = 0; j < M; ++j) {
-      dst[j * N + i] = src[i * M + j];
+static inline void MatrixTranspose(Float16 *dst, const Float16 *src, size_t m,
+                                   size_t n) {
+  for (size_t i = 0; i < n; ++i) {
+    for (size_t j = 0; j < m; ++j) {
+      dst[j * n + i] = src[i * m + j];
     }
   }
 }
diff --git a/tests/ailego/math/euclidean_distance_matrix_fp32_test.cc b/tests/ailego/math/euclidean_distance_matrix_fp32_test.cc
index a02875c5a..781c4ad6f 100644
--- a/tests/ailego/math/euclidean_distance_matrix_fp32_test.cc
+++ b/tests/ailego/math/euclidean_distance_matrix_fp32_test.cc
@@ -30,12 +30,12 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(float *dst, const float *src, size_t M,
-                                   size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+static inline void MatrixTranspose(float *dst, const float *src, size_t m,
+                                   size_t n) {
+  for (size_t idx = 0; idx < n * m; idx++) {
+    size_t i = idx / n;
+    size_t j = idx % n;
+    dst[idx] = src[m * j + i];
   }
 }
 
diff --git a/tests/ailego/math/euclidean_distance_matrix_int8_test.cc b/tests/ailego/math/euclidean_distance_matrix_int8_test.cc
index 4c130eb9f..7976c9742 100644
--- a/tests/ailego/math/euclidean_distance_matrix_int8_test.cc
+++ b/tests/ailego/math/euclidean_distance_matrix_int8_test.cc
@@ -30,11 +30,11 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t M,
-                                   size_t N) {
-  for (size_t i = 0; i < N; ++i) {
-    for (size_t j = 0; j < M; ++j) {
-      dst[j * N + i] = src[i * M + j];
+static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t m,
+                                   size_t n) {
+  for (size_t i = 0; i < n; ++i) {
+    for (size_t j = 0; j < m; ++j) {
+      dst[j * n + i] = src[i * m + j];
     }
   }
 }
diff --git a/tests/ailego/math/inner_product_matrix_fp16_test.cc b/tests/ailego/math/inner_product_matrix_fp16_test.cc
index 3aa71b499..b7f124942 100644
--- a/tests/ailego/math/inner_product_matrix_fp16_test.cc
+++ b/tests/ailego/math/inner_product_matrix_fp16_test.cc
@@ -32,11 +32,11 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(Float16 *dst, const Float16 *src, size_t M,
-                                   size_t N) {
-  for (size_t i = 0; i < N; ++i) {
-    for (size_t j = 0; j < M; ++j) {
-      dst[j * N + i] = src[i * M + j];
+static inline void MatrixTranspose(Float16 *dst, const Float16 *src, size_t m,
+                                   size_t n) {
+  for (size_t i = 0; i < n; ++i) {
+    for (size_t j = 0; j < m; ++j) {
+      dst[j * n + i] = src[i * m + j];
     }
   }
 }
diff --git a/tests/ailego/math/inner_product_matrix_fp32_test.cc b/tests/ailego/math/inner_product_matrix_fp32_test.cc
index ab5710779..f2e297d76 100644
--- a/tests/ailego/math/inner_product_matrix_fp32_test.cc
+++ b/tests/ailego/math/inner_product_matrix_fp32_test.cc
@@ -30,12 +30,12 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(float *dst, const float *src, size_t M,
-                                   size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+static inline void MatrixTranspose(float *dst, const float *src, size_t m,
+                                   size_t n) {
+  for (size_t idx = 0; idx < n * m; idx++) {
+    size_t i = idx / n;
+    size_t j = idx % n;
+    dst[idx] = src[m * j + i];
   }
 }
 
diff --git a/tests/ailego/math/inner_product_matrix_int8_test.cc b/tests/ailego/math/inner_product_matrix_int8_test.cc
index 0ba848324..e75944742 100644
--- a/tests/ailego/math/inner_product_matrix_int8_test.cc
+++ b/tests/ailego/math/inner_product_matrix_int8_test.cc
@@ -30,11 +30,11 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t M,
-                                   size_t N) {
-  for (size_t i = 0; i < N; ++i) {
-    for (size_t j = 0; j < M; ++j) {
-      dst[j * N + i] = src[i * M + j];
+static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t m,
+                                   size_t n) {
+  for (size_t i = 0; i < n; ++i) {
+    for (size_t j = 0; j < m; ++j) {
+      dst[j * n + i] = src[i * m + j];
     }
   }
 }
diff --git a/tests/ailego/math/mips_euclidean_distance_matrix_fp16_test.cc b/tests/ailego/math/mips_euclidean_distance_matrix_fp16_test.cc
index 0fdbe95f2..66aa602ec 100644
--- a/tests/ailego/math/mips_euclidean_distance_matrix_fp16_test.cc
+++ b/tests/ailego/math/mips_euclidean_distance_matrix_fp16_test.cc
@@ -32,12 +32,12 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(Float16 *dst, const Float16 *src, size_t M,
-                                   size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+static inline void MatrixTranspose(Float16 *dst, const Float16 *src, size_t m,
+                                   size_t n) {
+  for (size_t idx = 0; idx < n * m; idx++) {
+    size_t i = idx / n;
+    size_t j = idx % n;
+    dst[idx] = src[m * j + i];
   }
 }
 
diff --git a/tests/ailego/math/mips_euclidean_distance_matrix_fp32_test.cc b/tests/ailego/math/mips_euclidean_distance_matrix_fp32_test.cc
index 603c887d5..41f72b1de 100644
--- a/tests/ailego/math/mips_euclidean_distance_matrix_fp32_test.cc
+++ b/tests/ailego/math/mips_euclidean_distance_matrix_fp32_test.cc
@@ -32,12 +32,12 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(float *dst, const float *src, size_t M,
-                                   size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+static inline void MatrixTranspose(float *dst, const float *src, size_t m,
+                                   size_t n) {
+  for (size_t idx = 0; idx < n * m; idx++) {
+    size_t i = idx / n;
+    size_t j = idx % n;
+    dst[idx] = src[m * j + i];
   }
 }
 
diff --git a/tests/ailego/math/mips_euclidean_distance_matrix_int4_test.cc b/tests/ailego/math/mips_euclidean_distance_matrix_int4_test.cc
index bdebbc202..88cba7b35 100644
--- a/tests/ailego/math/mips_euclidean_distance_matrix_int4_test.cc
+++ b/tests/ailego/math/mips_euclidean_distance_matrix_int4_test.cc
@@ -34,12 +34,12 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t M,
-                                   size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t m,
+                                   size_t n) {
+  for (size_t idx = 0; idx < n * m; idx++) {
+    size_t i = idx / n;
+    size_t j = idx % n;
+    dst[idx] = src[m * j + i];
   }
 }
 
diff --git a/tests/ailego/math/mips_euclidean_distance_matrix_int8_test.cc b/tests/ailego/math/mips_euclidean_distance_matrix_int8_test.cc
index 712908350..9a1459cfe 100644
--- a/tests/ailego/math/mips_euclidean_distance_matrix_int8_test.cc
+++ b/tests/ailego/math/mips_euclidean_distance_matrix_int8_test.cc
@@ -32,12 +32,12 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t M,
-                                   size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t m,
+                                   size_t n) {
+  for (size_t idx = 0; idx < n * m; idx++) {
+    size_t i = idx / n;
+    size_t j = idx % n;
+    dst[idx] = src[m * j + i];
   }
 }
 
diff --git a/tests/ailego/math/norm_matrix_fp16_test.cc b/tests/ailego/math/norm_matrix_fp16_test.cc
index 55e3fb90e..f0890cab3 100644
--- a/tests/ailego/math/norm_matrix_fp16_test.cc
+++ b/tests/ailego/math/norm_matrix_fp16_test.cc
@@ -26,12 +26,12 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(Float16 *dst, const Float16 *src, size_t M,
-                                   size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+static inline void MatrixTranspose(Float16 *dst, const Float16 *src, size_t m,
+                                   size_t n) {
+  for (size_t idx = 0; idx < n * m; idx++) {
+    size_t i = idx / n;
+    size_t j = idx % n;
+    dst[idx] = src[m * j + i];
   }
 }
 
diff --git a/tests/ailego/math/norm_matrix_fp32_test.cc b/tests/ailego/math/norm_matrix_fp32_test.cc
index 933fa18ce..24f5b8362 100644
--- a/tests/ailego/math/norm_matrix_fp32_test.cc
+++ b/tests/ailego/math/norm_matrix_fp32_test.cc
@@ -27,12 +27,12 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(float *dst, const float *src, size_t M,
-                                   size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+static inline void MatrixTranspose(float *dst, const float *src, size_t m,
+                                   size_t n) {
+  for (size_t idx = 0; idx < n * m; idx++) {
+    size_t i = idx / n;
+    size_t j = idx % n;
+    dst[idx] = src[m * j + i];
   }
 }
 
diff --git a/tests/ailego/math/norm_matrix_int4_test.cc b/tests/ailego/math/norm_matrix_int4_test.cc
index 22b84aa58..105d1e743 100644
--- a/tests/ailego/math/norm_matrix_int4_test.cc
+++ b/tests/ailego/math/norm_matrix_int4_test.cc
@@ -26,12 +26,12 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t M,
-                                   size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t m,
+                                   size_t n) {
+  for (size_t idx = 0; idx < n * m; idx++) {
+    size_t i = idx / n;
+    size_t j = idx % n;
+    dst[idx] = src[m * j + i];
   }
 }
 
diff --git a/tests/ailego/math/norm_matrix_int8_test.cc b/tests/ailego/math/norm_matrix_int8_test.cc
index 354dfff1a..4dd992d94 100644
--- a/tests/ailego/math/norm_matrix_int8_test.cc
+++ b/tests/ailego/math/norm_matrix_int8_test.cc
@@ -26,12 +26,12 @@ static inline const char *IntelIntrinsics() {
   return internal::CpuFeatures::Intrinsics();
 }
 
-static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t M,
-                                   size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t m,
+                                   size_t n) {
+  for (size_t idx = 0; idx < n * m; idx++) {
+    size_t i = idx / n;
+    size_t j = idx % n;
+    dst[idx] = src[m * j + i];
   }
 }
 
diff --git a/tests/ailego/parallel/thread_pool_test.cc b/tests/ailego/parallel/thread_pool_test.cc
index 4c1f17d95..d35fcb9cd 100644
--- a/tests/ailego/parallel/thread_pool_test.cc
+++ b/tests/ailego/parallel/thread_pool_test.cc
@@ -107,7 +107,7 @@ TEST(ThreadPool, BindingRespectsCallerAffinityMask) {
 struct A {
   A() : pool(std::make_shared<ThreadPool>()) {}
 
-  int ThreadMain(int32_t &thread_index, uint32_t &num) {
+  int thread_main(int32_t &thread_index, uint32_t &num) {
     std::stringstream buf;
     buf << num << " Task (" << thread_index << " : " << pool->indexof_this()
         << ") " << pool->active_count() << ' ' << pool->pending_count()
@@ -126,9 +126,9 @@ struct B {
       : pool(std::make_shared<ThreadPool>(
             std::max(std::thread::hardware_concurrency(), 1u), true)) {}
 
-  std::string ThreadMain(uint32_t &num) {
+  std::string thread_main(uint32_t &num) {
     aaa.pool->enqueue(
-        Closure::New(&aaa, &A::ThreadMain, pool->indexof_this(), num));
+        Closure::New(&aaa, &A::thread_main, pool->indexof_this(), num));
     aaa.pool->wake_any();
     // std::this_thread::sleep_for(
     //    std::chrono::microseconds(std::rand() % 1000 + 1));
@@ -146,7 +146,7 @@ TEST(ThreadPool, General) {
 
   B bbb;
   for (uint32_t i = 0; i < 10000u; ++i) {
-    bbb.pool->execute(&bbb, &B::ThreadMain, i);
+    bbb.pool->execute(&bbb, &B::thread_main, i);
   }
   bbb.pool->wait_finish();
   bbb.aaa.pool->wait_finish();
diff --git a/tests/ailego/pattern/closure_test.cc b/tests/ailego/pattern/closure_test.cc
index 03389d71c..44e56b9d8 100644
--- a/tests/ailego/pattern/closure_test.cc
+++ b/tests/ailego/pattern/closure_test.cc
@@ -249,32 +249,32 @@ class ClassB {
     return a1 + b_;
   }
 
-  virtual void MemberProcess0() const {}
+  virtual void member_process0() const {}
 
-  virtual void MemberProcess1(int a1) {
+  virtual void member_process1(int a1) {
     EXPECT_EQ(a1, b_);
   }
 
-  void MemberProcess2(int a1, int *a2) {
+  void member_process2(int a1, int *a2) {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
   }
 
-  void MemberProcess3(int a1, int *a2, int &a3) const {
+  void member_process3(int a1, int *a2, int &a3) const {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
     EXPECT_EQ(*a2 + 1, a3);
   }
 
-  virtual void MemberProcess4(int a1, int *a2, int &a3, const int &a4) {
+  virtual void member_process4(int a1, int *a2, int &a3, const int &a4) {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
     EXPECT_EQ(*a2 + 1, a3);
     EXPECT_EQ(a3 + 1, a4);
   }
 
-  virtual void MemberProcess5(int a1, int *a2, int &a3, const int &a4,
-                              volatile int *a5) const {
+  virtual void member_process5(int a1, int *a2, int &a3, const int &a4,
+                               volatile int *a5) const {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
     EXPECT_EQ(*a2 + 1, a3);
@@ -282,8 +282,8 @@ class ClassB {
     EXPECT_EQ(a4 + 1, *a5);
   }
 
-  void MemberProcess6(int a1, int *a2, int &a3, const int &a4, volatile int *a5,
-                      int *const volatile a6) {
+  void member_process6(int a1, int *a2, int &a3, const int &a4,
+                       volatile int *a5, int *const volatile a6) {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
     EXPECT_EQ(*a2 + 1, a3);
@@ -292,8 +292,8 @@ class ClassB {
     EXPECT_EQ(*a5 + 1, *a6);
   }
 
-  void MemberProcess7(int a1, int *a2, int &a3, const int &a4, volatile int *a5,
-                      int *const volatile a6, int &&a7) {
+  void member_process7(int a1, int *a2, int &a3, const int &a4,
+                       volatile int *a5, int *const volatile a6, int &&a7) {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
     EXPECT_EQ(*a2 + 1, a3);
@@ -303,28 +303,28 @@ class ClassB {
     EXPECT_EQ(*a6 + 1, a7);
   }
 
-  size_t MemberFunction0() {
+  size_t member_function0() {
     return 0;
   }
-  size_t MemberFunction1(long a1) {
+  size_t member_function1(long a1) {
     EXPECT_EQ(a1, b_);
     return 1;
   }
 
-  size_t MemberFunction2(long a1, long *a2) {
+  size_t member_function2(long a1, long *a2) {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
     return 2;
   }
 
-  size_t MemberFunction3(long a1, long *a2, long &a3) volatile {
+  size_t member_function3(long a1, long *a2, long &a3) volatile {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
     EXPECT_EQ(*a2 + 1, a3);
     return 3;
   }
 
-  size_t MemberFunction4(long a1, long *a2, long &a3, const long &a4) const {
+  size_t member_function4(long a1, long *a2, long &a3, const long &a4) const {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
     EXPECT_EQ(*a2 + 1, a3);
@@ -332,8 +332,8 @@ class ClassB {
     return 4;
   }
 
-  size_t MemberFunction5(long a1, long *a2, long &a3, const long &a4,
-                         volatile long *a5) const volatile {
+  size_t member_function5(long a1, long *a2, long &a3, const long &a4,
+                          volatile long *a5) const volatile {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
     EXPECT_EQ(*a2 + 1, a3);
@@ -342,8 +342,8 @@ class ClassB {
     return 5;
   }
 
-  size_t MemberFunction6(long a1, long *a2, long &a3, const long &a4,
-                         volatile long *a5, long *const volatile a6) const {
+  size_t member_function6(long a1, long *a2, long &a3, const long &a4,
+                          volatile long *a5, long *const volatile a6) const {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
     EXPECT_EQ(*a2 + 1, a3);
@@ -353,9 +353,9 @@ class ClassB {
     return 6;
   }
 
-  size_t MemberFunction7(long a1, long *a2, long &a3, const long &a4,
-                         volatile long *a5, long *const volatile a6,
-                         long &&a7) const volatile {
+  size_t member_function7(long a1, long *a2, long &a3, const long &a4,
+                          volatile long *a5, long *const volatile a6,
+                          long &&a7) const volatile {
     EXPECT_EQ(a1, b_);
     EXPECT_EQ(a1 + 1, *a2);
     EXPECT_EQ(*a2 + 1, a3);
@@ -372,65 +372,65 @@ class ClassB {
 
 class ClassAB {
  public:
-  void Run1() const {
+  void run1() const {
     ClassB bbb(1);
-    ailego::Closure::New(this, &ClassAB::ConstFunc, &bbb);
+    ailego::Closure::New(this, &ClassAB::const_func, &bbb);
   }
 
-  void Run2() {
+  void run2() {
     ClassB bbb(1);
-    ailego::Closure::New(this, &ClassAB::ConstFunc, &bbb);
+    ailego::Closure::New(this, &ClassAB::const_func, &bbb);
   }
 
-  void Run3() {
+  void run3() {
     ClassB bbb(1);
-    ailego::Closure::New(this, &ClassAB::MutableFunc, &bbb);
+    ailego::Closure::New(this, &ClassAB::mutable_func, &bbb);
   }
 
-  void Run4() const {
+  void run4() const {
     ClassB bbb(1);
-    ailego::Closure::New(this, &ClassAB::VolatileConstFunc, &bbb);
+    ailego::Closure::New(this, &ClassAB::volatile_const_func, &bbb);
   }
 
-  void Run5() {
+  void run5() {
     ClassB bbb(1);
-    ailego::Closure::New(this, &ClassAB::VolatileMutableFunc, &bbb);
+    ailego::Closure::New(this, &ClassAB::volatile_mutable_func, &bbb);
   }
 
-  void Run6() const volatile {
+  void run6() const volatile {
     ClassB bbb(1);
-    ailego::Closure::New(this, &ClassAB::VolatileConstFunc, &bbb);
+    ailego::Closure::New(this, &ClassAB::volatile_const_func, &bbb);
   }
 
-  void Run7() volatile {
+  void run7() volatile {
     ClassB bbb(1);
-    ailego::Closure::New(this, &ClassAB::VolatileConstFunc, &bbb);
+    ailego::Closure::New(this, &ClassAB::volatile_const_func, &bbb);
   }
 
-  void Run8() volatile {
+  void run8() volatile {
     ClassB bbb(1);
-    ailego::Closure::New(this, &ClassAB::VolatileMutableFunc, &bbb);
+    ailego::Closure::New(this, &ClassAB::volatile_mutable_func, &bbb);
   }
 
  protected:
-  void ConstFunc(const ClassB *b) const {
+  void const_func(const ClassB *b) const {
     ClassA::StaticFunction0();
-    b->MemberProcess0();
+    b->member_process0();
   }
 
-  void MutableFunc(const ClassB *b) {
+  void mutable_func(const ClassB *b) {
     ClassA::StaticFunction0();
-    b->MemberProcess0();
+    b->member_process0();
   }
 
-  void VolatileConstFunc(const ClassB *b) const volatile {
+  void volatile_const_func(const ClassB *b) const volatile {
     ClassA::StaticFunction0();
-    b->MemberProcess0();
+    b->member_process0();
   }
 
-  void VolatileMutableFunc(const ClassB *b) volatile {
+  void volatile_mutable_func(const ClassB *b) volatile {
     ClassA::StaticFunction0();
-    b->MemberProcess0();
+    b->member_process0();
   }
 };
 
@@ -568,37 +568,37 @@ TEST(CallbackValidator, General) {
       ailego::CallbackValidator<decltype(&ClassA::StaticProcess7)>::Value);
 
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberFunction0)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_function0)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberFunction1)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_function1)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberFunction2)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_function2)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberFunction3)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_function3)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberFunction4)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_function4)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberFunction5)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_function5)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberFunction6)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_function6)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberFunction7)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_function7)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberProcess0)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_process0)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberProcess1)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_process1)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberProcess2)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_process2)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberProcess3)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_process3)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberProcess4)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_process4)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberProcess5)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_process5)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberProcess6)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_process6)>::Value);
   EXPECT_TRUE(
-      ailego::CallbackValidator<decltype(&ClassB::MemberProcess7)>::Value);
+      ailego::CallbackValidator<decltype(&ClassB::member_process7)>::Value);
 }
 
 TEST(CallbackTraits, General) {
@@ -629,28 +629,28 @@ TEST(CallbackTraits, General) {
             ailego::CallbackTraits<decltype(&ClassA::StaticProcess7)>::Arity);
 
   EXPECT_EQ(0,
-            ailego::CallbackTraits<decltype(&ClassB::MemberProcess0)>::Arity);
+            ailego::CallbackTraits<decltype(&ClassB::member_process0)>::Arity);
   EXPECT_EQ(1,
-            ailego::CallbackTraits<decltype(&ClassB::MemberProcess1)>::Arity);
+            ailego::CallbackTraits<decltype(&ClassB::member_process1)>::Arity);
   EXPECT_EQ(2,
-            ailego::CallbackTraits<decltype(&ClassB::MemberProcess2)>::Arity);
+            ailego::CallbackTraits<decltype(&ClassB::member_process2)>::Arity);
   EXPECT_EQ(3,
-            ailego::CallbackTraits<decltype(&ClassB::MemberProcess3)>::Arity);
+            ailego::CallbackTraits<decltype(&ClassB::member_process3)>::Arity);
   EXPECT_EQ(4,
-            ailego::CallbackTraits<decltype(&ClassB::MemberProcess4)>::Arity);
+            ailego::CallbackTraits<decltype(&ClassB::member_process4)>::Arity);
   EXPECT_EQ(5,
-            ailego::CallbackTraits<decltype(&ClassB::MemberProcess5)>::Arity);
+            ailego::CallbackTraits<decltype(&ClassB::member_process5)>::Arity);
   EXPECT_EQ(6,
-            ailego::CallbackTraits<decltype(&ClassB::MemberProcess6)>::Arity);
+            ailego::CallbackTraits<decltype(&ClassB::member_process6)>::Arity);
   EXPECT_EQ(7,
-            ailego::CallbackTraits<decltype(&ClassB::MemberProcess7)>::Arity);
+            ailego::CallbackTraits<decltype(&ClassB::member_process7)>::Arity);
 
   EXPECT_EQ(
       1u, sizeof(ailego::CallbackTraits<decltype(GlobalProcess0)>::TupleType));
   EXPECT_EQ(1u, sizeof(ailego::CallbackTraits<
                        decltype(&ClassA::StaticProcess0)>::TupleType));
   EXPECT_EQ(1u, sizeof(ailego::CallbackTraits<
-                       decltype(&ClassB::MemberProcess0)>::TupleType));
+                       decltype(&ClassB::member_process0)>::TupleType));
 }
 
 TEST(Closure, Static) {
@@ -758,40 +758,41 @@ TEST(Closure, Member) {
   int b[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   ClassB bbb(1);
 
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction0)->run();
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction1, 1)->run();
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction2, a[1], &a[2])->run();
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction3, 1, &a[2], a[3])->run();
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction4, a[1], &a[2], a[3], a[4])
+  ailego::Closure::New(&bbb, &ClassB::member_function0)->run();
+  ailego::Closure::New(&bbb, &ClassB::member_function1, 1)->run();
+  ailego::Closure::New(&bbb, &ClassB::member_function2, a[1], &a[2])->run();
+  ailego::Closure::New(&bbb, &ClassB::member_function3, 1, &a[2], a[3])->run();
+  ailego::Closure::New(&bbb, &ClassB::member_function4, a[1], &a[2], a[3], a[4])
       ->run();
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction5, 1, &a[2], a[3], 4, &a[5])
+  ailego::Closure::New(&bbb, &ClassB::member_function5, 1, &a[2], a[3], 4,
+                       &a[5])
       ->run();
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction6, a[1], &a[2], a[3], a[4],
+  ailego::Closure::New(&bbb, &ClassB::member_function6, a[1], &a[2], a[3], a[4],
                        &a[5], &a[6])
       ->run();
-  ailego::Closure::New((const ClassB *)(&bbb), &ClassB::MemberFunction7, a[1],
+  ailego::Closure::New((const ClassB *)(&bbb), &ClassB::member_function7, a[1],
                        &a[2], a[3], a[4], &a[5], &a[6], 7)
       ->run();
   ailego::Closure::New((const volatile ClassB *)(&bbb),
-                       &ClassB::MemberFunction7, a[1], &a[2], a[3], a[4], &a[5],
-                       &a[6], 7)
+                       &ClassB::member_function7, a[1], &a[2], a[3], a[4],
+                       &a[5], &a[6], 7)
       ->run();
 
   ClassB &&bbc = std::move(bbb);
-  ailego::Closure::New(&bbc, &ClassB::MemberProcess0)->run();
-  ailego::Closure::New(&bbc, &ClassB::MemberProcess1, 1)->run();
-  ailego::Closure::New(&bbc, &ClassB::MemberProcess2, b[1], &b[2])->run();
-  ailego::Closure::New(&bbc, &ClassB::MemberProcess3, 1, &b[2], b[3])->run();
-  ailego::Closure::New(&bbc, &ClassB::MemberProcess4, b[1], &b[2], b[3], b[4])
+  ailego::Closure::New(&bbc, &ClassB::member_process0)->run();
+  ailego::Closure::New(&bbc, &ClassB::member_process1, 1)->run();
+  ailego::Closure::New(&bbc, &ClassB::member_process2, b[1], &b[2])->run();
+  ailego::Closure::New(&bbc, &ClassB::member_process3, 1, &b[2], b[3])->run();
+  ailego::Closure::New(&bbc, &ClassB::member_process4, b[1], &b[2], b[3], b[4])
       ->run();
 
   ClassB &bbd = bbb;
-  ailego::Closure::New(&bbd, &ClassB::MemberProcess5, 1, &b[2], b[3], 4, &b[5])
+  ailego::Closure::New(&bbd, &ClassB::member_process5, 1, &b[2], b[3], 4, &b[5])
       ->run();
-  ailego::Closure::New(&bbd, &ClassB::MemberProcess6, b[1], &b[2], b[3], b[4],
+  ailego::Closure::New(&bbd, &ClassB::member_process6, b[1], &b[2], b[3], b[4],
                        &b[5], &b[6])
       ->run();
-  ailego::Closure::New(&bbd, &ClassB::MemberProcess7, b[1], &b[2], b[3], b[4],
+  ailego::Closure::New(&bbd, &ClassB::member_process7, b[1], &b[2], b[3], b[4],
                        &b[5], &b[6], 7)
       ->run();
 }
@@ -802,83 +803,83 @@ TEST(Closure, Function) {
   ClassB bbb(1);
 
   std::function<decltype(GlobalFunction0)> f0 =
-      std::bind(&ClassB::MemberFunction0, &bbb);
+      std::bind(&ClassB::member_function0, &bbb);
   ailego::Closure::New(f0)->run();
 
   std::function<decltype(GlobalFunction1)> f1 =
-      std::bind(&ClassB::MemberFunction1, &bbb, std::placeholders::_1);
+      std::bind(&ClassB::member_function1, &bbb, std::placeholders::_1);
   ailego::Closure::New(f1, 1)->run();
 
   std::function<decltype(GlobalFunction2)> f2 =
-      std::bind(&ClassB::MemberFunction2, &bbb, std::placeholders::_1,
+      std::bind(&ClassB::member_function2, &bbb, std::placeholders::_1,
                 std::placeholders::_2);
   ailego::Closure::New(f2, a[1], &a[2])->run();
 
   std::function<decltype(GlobalFunction3)> f3 =
-      std::bind(&ClassB::MemberFunction3, &bbb, std::placeholders::_1,
+      std::bind(&ClassB::member_function3, &bbb, std::placeholders::_1,
                 std::placeholders::_2, std::placeholders::_3);
   ailego::Closure::New(f3, a[1], &a[2], a[3])->run();
 
   std::function<decltype(GlobalFunction4)> f4 = std::bind(
-      &ClassB::MemberFunction4, &bbb, std::placeholders::_1,
+      &ClassB::member_function4, &bbb, std::placeholders::_1,
       std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
   ailego::Closure::New(f4, 1, &a[2], a[3], a[4])->run();
 
   std::function<decltype(GlobalFunction5)> f5 =
-      std::bind(&ClassB::MemberFunction5, &bbb, std::placeholders::_1,
+      std::bind(&ClassB::member_function5, &bbb, std::placeholders::_1,
                 std::placeholders::_2, std::placeholders::_3,
                 std::placeholders::_4, std::placeholders::_5);
   ailego::Closure::New(f5, 1, &a[2], a[3], 4, &a[5])->run();
 
   std::function<decltype(GlobalFunction6)> f6 = std::bind(
-      &ClassB::MemberFunction6, &bbb, std::placeholders::_1,
+      &ClassB::member_function6, &bbb, std::placeholders::_1,
       std::placeholders::_2, std::placeholders::_3, std::placeholders::_4,
       std::placeholders::_5, std::placeholders::_6);
   ailego::Closure::New(f6, 1, &a[2], a[3], a[4], &a[5], &a[6])->run();
 
   std::function<decltype(GlobalFunction7)> f7 = std::bind(
-      &ClassB::MemberFunction7, &bbb, std::placeholders::_1,
+      &ClassB::member_function7, &bbb, std::placeholders::_1,
       std::placeholders::_2, std::placeholders::_3, std::placeholders::_4,
       std::placeholders::_5, std::placeholders::_6, std::placeholders::_7);
   ailego::Closure::New(f7, a[1], &a[2], a[3], a[4], &a[5], &a[6], 7)->run();
 
   std::function<decltype(GlobalProcess0)> p0 =
-      std::bind(&ClassB::MemberProcess0, &bbb);
+      std::bind(&ClassB::member_process0, &bbb);
   ailego::Closure::New(p0)->run();
 
   std::function<decltype(GlobalProcess1)> p1 =
-      std::bind(&ClassB::MemberProcess1, &bbb, std::placeholders::_1);
+      std::bind(&ClassB::member_process1, &bbb, std::placeholders::_1);
   ailego::Closure::New(p1, 1)->run();
 
   std::function<decltype(GlobalProcess2)> p2 =
-      std::bind(&ClassB::MemberProcess2, &bbb, std::placeholders::_1,
+      std::bind(&ClassB::member_process2, &bbb, std::placeholders::_1,
                 std::placeholders::_2);
   ailego::Closure::New(p2, b[1], &b[2])->run();
 
   std::function<decltype(GlobalProcess3)> p3 =
-      std::bind(&ClassB::MemberProcess3, &bbb, std::placeholders::_1,
+      std::bind(&ClassB::member_process3, &bbb, std::placeholders::_1,
                 std::placeholders::_2, std::placeholders::_3);
   ailego::Closure::New(p3, b[1], &b[2], b[3])->run();
 
   std::function<decltype(GlobalProcess4)> p4 = std::bind(
-      &ClassB::MemberProcess4, &bbb, std::placeholders::_1,
+      &ClassB::member_process4, &bbb, std::placeholders::_1,
       std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
   ailego::Closure::New(p4, 1, &b[2], b[3], b[4])->run();
 
   std::function<decltype(GlobalProcess5)> p5 =
-      std::bind(&ClassB::MemberProcess5, &bbb, std::placeholders::_1,
+      std::bind(&ClassB::member_process5, &bbb, std::placeholders::_1,
                 std::placeholders::_2, std::placeholders::_3,
                 std::placeholders::_4, std::placeholders::_5);
   ailego::Closure::New(p5, 1, &b[2], b[3], 4, &b[5])->run();
 
   std::function<decltype(GlobalProcess6)> p6 = std::bind(
-      &ClassB::MemberProcess6, &bbb, std::placeholders::_1,
+      &ClassB::member_process6, &bbb, std::placeholders::_1,
       std::placeholders::_2, std::placeholders::_3, std::placeholders::_4,
       std::placeholders::_5, std::placeholders::_6);
   ailego::Closure::New(p6, 1, &b[2], b[3], b[4], &b[5], &b[6])->run();
 
   std::function<decltype(GlobalProcess7)> p7 = std::bind(
-      &ClassB::MemberProcess7, &bbb, std::placeholders::_1,
+      &ClassB::member_process7, &bbb, std::placeholders::_1,
       std::placeholders::_2, std::placeholders::_3, std::placeholders::_4,
       std::placeholders::_5, std::placeholders::_6, std::placeholders::_7);
   ailego::Closure::New(p7, b[1], &b[2], b[3], b[4], &b[5], &b[6], 7)->run();
@@ -892,37 +893,39 @@ TEST(Closure, Lambda) {
   long a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   ClassB bbb(1);
 
-  auto lambda1 = [&](long a1) { return bbb.MemberFunction1(a1); };
+  auto lambda1 = [&](long a1) { return bbb.member_function1(a1); };
   ailego::Closure::New(lambda1, 1)->run();
 
-  auto lambda2 = [&](long a1, long *a2) { return bbb.MemberFunction2(a1, a2); };
+  auto lambda2 = [&](long a1, long *a2) {
+    return bbb.member_function2(a1, a2);
+  };
   ailego::Closure::New(lambda2, 1, &a[2])->run();
 
   auto lambda3 = [&](long a1, long *a2, long &a3) {
-    return bbb.MemberFunction3(a1, a2, a3);
+    return bbb.member_function3(a1, a2, a3);
   };
   ailego::Closure::New(lambda3, 1, &a[2], a[3])->run();
 
   auto lambda4 = [&](long a1, long *a2, long &a3, const long &a4) {
-    return bbb.MemberFunction4(a1, a2, a3, a4);
+    return bbb.member_function4(a1, a2, a3, a4);
   };
   ailego::Closure::New(lambda4, a[1], &a[2], a[3], a[4])->run();
 
   auto lambda5 = [&](long a1, long *a2, long &a3, const long &a4,
                      volatile long *a5) {
-    return bbb.MemberFunction5(a1, a2, a3, a4, a5);
+    return bbb.member_function5(a1, a2, a3, a4, a5);
   };
   ailego::Closure::New(lambda5, 1, &a[2], a[3], 4, &a[5])->run();
 
   auto lambda6 = [&](long a1, long *a2, long &a3, const long &a4,
                      volatile long *a5, long *const volatile a6) {
-    return bbb.MemberFunction6(a1, a2, a3, a4, a5, a6);
+    return bbb.member_function6(a1, a2, a3, a4, a5, a6);
   };
   ailego::Closure::New(lambda6, 1, &a[2], a[3], 4, &a[5], &a[6])->run();
 
   auto lambda7 = [&](long a1, long *a2, long &a3, const long &a4,
                      volatile long *a5, long *const volatile a6, long &&a7) {
-    return bbb.MemberFunction7(a1, a2, a3, a4, a5, a6, std::move(a7));
+    return bbb.member_function7(a1, a2, a3, a4, a5, a6, std::move(a7));
   };
   ailego::Closure::New(lambda7, a[1], &a[2], a[3], a[4], &a[5], &a[6], 7)
       ->run();
@@ -953,25 +956,27 @@ TEST(Closure, Return) {
   EXPECT_EQ(7u, r);
 
   ClassB bbb(1);
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction0)->run(&r);
+  ailego::Closure::New(&bbb, &ClassB::member_function0)->run(&r);
   EXPECT_EQ(0u, r);
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction1, 1)->run(&r);
+  ailego::Closure::New(&bbb, &ClassB::member_function1, 1)->run(&r);
   EXPECT_EQ(1u, r);
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction2, a[1], &a[2])->run(&r);
+  ailego::Closure::New(&bbb, &ClassB::member_function2, a[1], &a[2])->run(&r);
   EXPECT_EQ(2u, r);
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction3, 1, &a[2], a[3])->run(&r);
+  ailego::Closure::New(&bbb, &ClassB::member_function3, 1, &a[2], a[3])
+      ->run(&r);
   EXPECT_EQ(3u, r);
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction4, a[1], &a[2], a[3], a[4])
+  ailego::Closure::New(&bbb, &ClassB::member_function4, a[1], &a[2], a[3], a[4])
       ->run(&r);
   EXPECT_EQ(4u, r);
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction5, 1, &a[2], a[3], 4, &a[5])
+  ailego::Closure::New(&bbb, &ClassB::member_function5, 1, &a[2], a[3], 4,
+                       &a[5])
       ->run(&r);
   EXPECT_EQ(5u, r);
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction6, a[1], &a[2], a[3], a[4],
+  ailego::Closure::New(&bbb, &ClassB::member_function6, a[1], &a[2], a[3], a[4],
                        &a[5], &a[6])
       ->run(&r);
   EXPECT_EQ(6u, r);
-  ailego::Closure::New(&bbb, &ClassB::MemberFunction7, a[1], &a[2], a[3], a[4],
+  ailego::Closure::New(&bbb, &ClassB::member_function7, a[1], &a[2], a[3], a[4],
                        &a[5], &a[6], 7)
       ->run(&r);
   EXPECT_EQ(7u, r);
diff --git a/tests/ailego/pattern/scope_guard_test.cc b/tests/ailego/pattern/scope_guard_test.cc
index c39a201e5..d92dd28d7 100644
--- a/tests/ailego/pattern/scope_guard_test.cc
+++ b/tests/ailego/pattern/scope_guard_test.cc
@@ -67,22 +67,22 @@ TEST(ScopeGuard, StaticFunction) {
 
 class ClassB {
  public:
-  virtual void MemberProcess0() const {
+  virtual void member_process0() const {
     printf("ScopeGuard: Member Function 0\n");
     ++count;
   }
 
-  virtual void MemberProcess1(int val) {
+  virtual void member_process1(int val) {
     printf("ScopeGuard: Member Function %d\n", val);
     ++count;
   }
 
-  virtual void MemberProcess2(long val) const volatile {
+  virtual void member_process2(long val) const volatile {
     printf("ScopeGuard: Member Function %ld\n", val);
     ++count;
   }
 
-  virtual void MemberProcess3(size_t val) volatile {
+  virtual void member_process3(size_t val) volatile {
     printf("ScopeGuard: Member Function %zu\n", val);
     ++count;
   }
@@ -94,9 +94,9 @@ int ClassB::count{0};
 
 TEST(ScopeGuard, MemberFunction) {
   ClassB bb;
-  auto a = ailego::ScopeGuard::Make(&bb, &ClassB::MemberProcess0);
-  auto b = ailego::ScopeGuard::Make(&bb, &ClassB::MemberProcess1, 2);
-  AILEGO_DEFER(&bb, &ClassB::MemberProcess2, 3);
-  AILEGO_DEFER(&bb, &ClassB::MemberProcess3, 4);
+  auto a = ailego::ScopeGuard::Make(&bb, &ClassB::member_process0);
+  auto b = ailego::ScopeGuard::Make(&bb, &ClassB::member_process1, 2);
+  AILEGO_DEFER(&bb, &ClassB::member_process2, 3);
+  AILEGO_DEFER(&bb, &ClassB::member_process3, 4);
   EXPECT_EQ(0, ClassB::count);
 }
diff --git a/tests/core/algorithm/diskann/diskann_searcher_test.cc b/tests/core/algorithm/diskann/diskann_searcher_test.cc
index 871a429a0..c22d987a3 100644
--- a/tests/core/algorithm/diskann/diskann_searcher_test.cc
+++ b/tests/core/algorithm/diskann/diskann_searcher_test.cc
@@ -408,23 +408,23 @@ TEST_F(DiskAnnSearcherTest, TestGeneral) {
   auto ctx = searcher->create_context();
   ASSERT_TRUE(!!ctx);
 
-  auto linearCtx = searcher->create_context();
-  auto linearByPKeysCtx = searcher->create_context();
-  auto knnCtx = searcher->create_context();
+  auto linear_ctx = searcher->create_context();
+  auto linear_by_p_keys_ctx = searcher->create_context();
+  auto knn_ctx = searcher->create_context();
 
-  ASSERT_TRUE(!!linearCtx);
-  ASSERT_TRUE(!!linearByPKeysCtx);
-  ASSERT_TRUE(!!knnCtx);
+  ASSERT_TRUE(!!linear_ctx);
+  ASSERT_TRUE(!!linear_by_p_keys_ctx);
+  ASSERT_TRUE(!!knn_ctx);
 
   NumericalVector<float> vec(dim);
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
   size_t topk = 200;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
-  linearCtx->set_topk(topk);
-  linearByPKeysCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
+  linear_ctx->set_topk(topk);
+  linear_by_p_keys_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
   auto *diskann_searcher = dynamic_cast<DiskAnnSearcher *>(searcher.get());
   ASSERT_NE(diskann_searcher, nullptr);
@@ -446,12 +446,12 @@ TEST_F(DiskAnnSearcherTest, TestGeneral) {
 
   size_t release_count = batch_counting_reader->release_count();
   ASSERT_EQ(0, searcher->search_impl(batch_queries.data(), qmeta,
-                                     kBatchQueryCount, knnCtx));
+                                     kBatchQueryCount, knn_ctx));
   EXPECT_EQ(release_count + 1, batch_counting_reader->release_count());
 
   release_count = batch_counting_reader->release_count();
   ASSERT_EQ(0, searcher->search_bf_impl(batch_queries.data(), qmeta,
-                                        kBatchQueryCount, linearCtx));
+                                        kBatchQueryCount, linear_ctx));
   EXPECT_EQ(release_count + 1, batch_counting_reader->release_count());
 
   std::vector<std::vector<uint64_t>> batch_p_keys(kBatchQueryCount,
@@ -459,7 +459,7 @@ TEST_F(DiskAnnSearcherTest, TestGeneral) {
   release_count = batch_counting_reader->release_count();
   ASSERT_EQ(0, searcher->search_bf_by_p_keys_impl(
                    batch_queries.data(), batch_p_keys, qmeta, kBatchQueryCount,
-                   linearByPKeysCtx));
+                   linear_by_p_keys_ctx));
   EXPECT_EQ(release_count + 1, batch_counting_reader->release_count());
 
   // do linear search test
@@ -468,18 +468,18 @@ TEST_F(DiskAnnSearcherTest, TestGeneral) {
     for (size_t i = 0; i < dim; ++i) {
       query[i] = 3.1f;
     }
-    ASSERT_EQ(0, searcher->search_bf_impl(query, qmeta, linearCtx));
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(3UL, linearResult[0].key());
-    ASSERT_EQ(4UL, linearResult[1].key());
-    ASSERT_EQ(2UL, linearResult[2].key());
-    ASSERT_EQ(5UL, linearResult[3].key());
-    ASSERT_EQ(1UL, linearResult[4].key());
-    ASSERT_EQ(6UL, linearResult[5].key());
-    ASSERT_EQ(0UL, linearResult[6].key());
-    ASSERT_EQ(7UL, linearResult[7].key());
+    ASSERT_EQ(0, searcher->search_bf_impl(query, qmeta, linear_ctx));
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(3UL, linear_result[0].key());
+    ASSERT_EQ(4UL, linear_result[1].key());
+    ASSERT_EQ(2UL, linear_result[2].key());
+    ASSERT_EQ(5UL, linear_result[3].key());
+    ASSERT_EQ(1UL, linear_result[4].key());
+    ASSERT_EQ(6UL, linear_result[5].key());
+    ASSERT_EQ(0UL, linear_result[6].key());
+    ASSERT_EQ(7UL, linear_result[7].key());
     for (size_t i = 8; i < topk; ++i) {
-      ASSERT_EQ(i, linearResult[i].key());
+      ASSERT_EQ(i, linear_result[i].key());
     }
   }
 
@@ -494,17 +494,17 @@ TEST_F(DiskAnnSearcherTest, TestGeneral) {
     }
 
     ASSERT_EQ(0, searcher->search_bf_by_p_keys_impl(query, p_keys, qmeta,
-                                                    linearByPKeysCtx));
-    auto &linearByPKeysResult = linearByPKeysCtx->result();
-    ASSERT_EQ(8, linearByPKeysResult.size());
-    ASSERT_EQ(3UL, linearByPKeysResult[0].key());
-    ASSERT_EQ(2UL, linearByPKeysResult[1].key());
-    ASSERT_EQ(1UL, linearByPKeysResult[2].key());
-    ASSERT_EQ(0UL, linearByPKeysResult[3].key());
-    ASSERT_EQ(8UL, linearByPKeysResult[4].key());
-    ASSERT_EQ(9UL, linearByPKeysResult[5].key());
-    ASSERT_EQ(10UL, linearByPKeysResult[6].key());
-    ASSERT_EQ(11UL, linearByPKeysResult[7].key());
+                                                    linear_by_p_keys_ctx));
+    auto &linear_by_p_keys_result = linear_by_p_keys_ctx->result();
+    ASSERT_EQ(8, linear_by_p_keys_result.size());
+    ASSERT_EQ(3UL, linear_by_p_keys_result[0].key());
+    ASSERT_EQ(2UL, linear_by_p_keys_result[1].key());
+    ASSERT_EQ(1UL, linear_by_p_keys_result[2].key());
+    ASSERT_EQ(0UL, linear_by_p_keys_result[3].key());
+    ASSERT_EQ(8UL, linear_by_p_keys_result[4].key());
+    ASSERT_EQ(9UL, linear_by_p_keys_result[5].key());
+    ASSERT_EQ(10UL, linear_by_p_keys_result[6].key());
+    ASSERT_EQ(11UL, linear_by_p_keys_result[7].key());
   }
 
   size_t step = 500;
@@ -512,33 +512,33 @@ TEST_F(DiskAnnSearcherTest, TestGeneral) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &knnResult = knnCtx->result();
+    auto &knn_result = knn_ctx->result();
     // TODO: check
-    topk1Hits += i == knnResult[0].key();
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
 
-  float recall = totalHits * step * step * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * step * 1.0f / doc_cnt;
+  float recall = total_hits * step * step * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * step * 1.0f / doc_cnt;
 
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
 
   // A context created by the streamer must carry the streamer's magic so it
   // can be reused instead of being recreated on every search.
@@ -597,12 +597,12 @@ TEST_F(DiskAnnSearcherTest, TestGeneral) {
   // mismatch must be rejected before either searcher touches the input.
   IndexQueryMeta wrong_type(IndexMeta::DataType::DT_FP16, dim);
   EXPECT_EQ(IndexError_Mismatch,
-            searcher->search_impl(vec.data(), wrong_type, knnCtx));
+            searcher->search_impl(vec.data(), wrong_type, knn_ctx));
   EXPECT_EQ(IndexError_Mismatch,
             streamer->search_impl(vec.data(), wrong_type, streamer_ctx));
   IndexQueryMeta wrong_dimension(IndexMeta::DataType::DT_FP32, dim - 1);
   EXPECT_EQ(IndexError_Mismatch,
-            searcher->search_bf_impl(vec.data(), wrong_dimension, linearCtx));
+            searcher->search_bf_impl(vec.data(), wrong_dimension, linear_ctx));
 
   // Group parameters without a grouping callback are invalid instead of a
   // successful search with an empty result.
@@ -621,7 +621,7 @@ TEST_F(DiskAnnSearcherTest, TestGeneral) {
   ASSERT_EQ(0, searcher->unload());
   EXPECT_EQ(nullptr, searcher->create_context());
   EXPECT_EQ(IndexError_NoReady,
-            searcher->search_impl(vec.data(), qmeta, knnCtx));
+            searcher->search_impl(vec.data(), qmeta, knn_ctx));
 }
 
 TEST_F(DiskAnnSearcherTest, TestNodeCache) {
@@ -704,56 +704,56 @@ TEST_F(DiskAnnSearcherTest, TestNodeCache) {
   auto ctx = searcher->create_context();
   ASSERT_TRUE(!!ctx);
 
-  auto linearCtx = searcher->create_context();
-  auto linearByPKeysCtx = searcher->create_context();
-  auto knnCtx = searcher->create_context();
+  auto linear_ctx = searcher->create_context();
+  auto linear_by_p_keys_ctx = searcher->create_context();
+  auto knn_ctx = searcher->create_context();
 
-  ASSERT_TRUE(!!linearCtx);
-  ASSERT_TRUE(!!linearByPKeysCtx);
-  ASSERT_TRUE(!!knnCtx);
+  ASSERT_TRUE(!!linear_ctx);
+  ASSERT_TRUE(!!linear_by_p_keys_ctx);
+  ASSERT_TRUE(!!knn_ctx);
 
   NumericalVector<float> vec(dim);
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
   size_t topk = 200;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
-  linearCtx->set_topk(topk);
-  linearByPKeysCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
+  linear_ctx->set_topk(topk);
+  linear_by_p_keys_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
   size_t step = 500;
   for (size_t i = 0; i < doc_cnt; i += step) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &knnResult = knnCtx->result();
+    auto &knn_result = knn_ctx->result();
     // TODO: check
-    topk1Hits += i == knnResult[0].key();
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
 
-  float recall = totalHits * step * step * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * step * 1.0f / doc_cnt;
+  float recall = total_hits * step * step * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * step * 1.0f / doc_cnt;
 
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
 }
 
 TEST_F(DiskAnnSearcherTest, TestFilter) {
@@ -817,21 +817,21 @@ TEST_F(DiskAnnSearcherTest, TestFilter) {
   auto ctx = searcher->create_context();
   ASSERT_TRUE(!!ctx);
 
-  auto linearCtx = searcher->create_context();
-  auto linearByPKeysCtx = searcher->create_context();
-  auto knnCtx = searcher->create_context();
+  auto linear_ctx = searcher->create_context();
+  auto linear_by_p_keys_ctx = searcher->create_context();
+  auto knn_ctx = searcher->create_context();
 
-  ASSERT_TRUE(!!linearCtx);
-  ASSERT_TRUE(!!linearByPKeysCtx);
-  ASSERT_TRUE(!!knnCtx);
+  ASSERT_TRUE(!!linear_ctx);
+  ASSERT_TRUE(!!linear_by_p_keys_ctx);
+  ASSERT_TRUE(!!knn_ctx);
 
   NumericalVector<float> vec(dim);
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
 
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  linearByPKeysCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  linear_ctx->set_topk(topk);
+  linear_by_p_keys_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
   size_t key = 50;
   for (size_t j = 0; j < dim; ++j) {
@@ -840,23 +840,23 @@ TEST_F(DiskAnnSearcherTest, TestFilter) {
 
   // no filter
   {
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
 
-    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(50UL, linearResult[0].key());
-    ASSERT_EQ(51UL, linearResult[1].key());
-    ASSERT_EQ(49UL, linearResult[2].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(50UL, linear_result[0].key());
+    ASSERT_EQ(51UL, linear_result[1].key());
+    ASSERT_EQ(49UL, linear_result[2].key());
   }
 
   // with filter
   {
-    auto filterFunc = [](uint64_t key) {
+    auto filter_func = [](uint64_t key) {
       if (key == 50UL || key == 51UL || key == 49UL) {
         return true;
       }
@@ -864,30 +864,30 @@ TEST_F(DiskAnnSearcherTest, TestFilter) {
     };
 
 
-    knnCtx->set_filter(filterFunc);
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
+    knn_ctx->set_filter(filter_func);
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
     std::unordered_set<uint64_t> knn_keys;
-    for (const auto &result : knnResult) {
+    for (const auto &result : knn_result) {
       ASSERT_TRUE(knn_keys.emplace(result.key()).second);
       EXPECT_NE(50UL, result.key());
       EXPECT_NE(51UL, result.key());
       EXPECT_NE(49UL, result.key());
     }
 
-    linearCtx->set_filter(filterFunc);
-    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
+    linear_ctx->set_filter(filter_func);
+    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(52UL, linearResult[0].key());
-    ASSERT_EQ(48UL, linearResult[1].key());
-    ASSERT_EQ(53UL, linearResult[2].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(52UL, linear_result[0].key());
+    ASSERT_EQ(48UL, linear_result[1].key());
+    ASSERT_EQ(53UL, linear_result[2].key());
 
     size_t hit_count = 0;
-    for (const auto &result : linearResult) {
+    for (const auto &result : linear_result) {
       hit_count += knn_keys.count(result.key());
     }
     const float recall = static_cast<float>(hit_count) / topk;
@@ -959,7 +959,7 @@ TEST_F(DiskAnnSearcherTest, TestGroup) {
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
   size_t group_topk = 20;
 
-  auto groupbyFunc = [](uint64_t key) {
+  auto groupby_func = [](uint64_t key) {
     uint32_t group_id = key / 10 % 10;
 
     // std::cout << "key: " << key << ", group id: " << group_id << std::endl;
@@ -970,7 +970,7 @@ TEST_F(DiskAnnSearcherTest, TestGroup) {
   size_t group_num = 5;
 
   ctx->set_group_params(group_num, group_topk);
-  ctx->set_group_by(groupbyFunc);
+  ctx->set_group_by(groupby_func);
 
   size_t query_value = doc_cnt / 2;
   for (size_t j = 0; j < dim; ++j) {
@@ -993,7 +993,7 @@ TEST_F(DiskAnnSearcherTest, TestGroup) {
     std::cout << "Group ID: " << group_id << std::endl;
 
     for (uint32_t j = 0; j < result.size(); ++j) {
-      EXPECT_EQ(group_id, groupbyFunc(result[j].key()));
+      EXPECT_EQ(group_id, groupby_func(result[j].key()));
       std::cout << "\tKey: " << result[j].key() << std::fixed
                 << std::setprecision(3) << ", Score: " << result[j].score()
                 << std::endl;
@@ -1022,19 +1022,19 @@ TEST_F(DiskAnnSearcherTest, TestGroup) {
   // scans, rather than grouping only the global top-k afterward.
   auto linear_ctx = searcher->create_context();
   linear_ctx->set_group_params(group_num, group_topk);
-  linear_ctx->set_group_by(groupbyFunc);
+  linear_ctx->set_group_by(groupby_func);
   ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
   const auto &linear_group_result = linear_ctx->group_result();
   ASSERT_EQ(group_num, linear_group_result.size());
   for (const auto &group : linear_group_result) {
     ASSERT_EQ(group_topk, group.docs().size());
     for (const auto &doc : group.docs()) {
-      EXPECT_EQ(group.group_id(), groupbyFunc(doc.key()));
+      EXPECT_EQ(group.group_id(), groupby_func(doc.key()));
     }
   }
 
   // do linear search by p_keys test
-  auto groupbyFuncLinear = [](uint64_t key) {
+  auto groupby_func_linear = [](uint64_t key) {
     uint32_t group_id = key % 10;
 
     return std::string("g_") + std::to_string(group_id);
@@ -1043,7 +1043,7 @@ TEST_F(DiskAnnSearcherTest, TestGroup) {
   auto linear_pk_ctx = searcher->create_context();
 
   linear_pk_ctx->set_group_params(group_num, group_topk);
-  linear_pk_ctx->set_group_by(groupbyFuncLinear);
+  linear_pk_ctx->set_group_by(groupby_func_linear);
 
   std::vector<std::vector<uint64_t>> p_keys;
   p_keys.resize(1);
@@ -1131,20 +1131,20 @@ TEST_F(DiskAnnSearcherTest, TestFetchVector) {
   ASSERT_EQ(0, searcher->load(storage, IndexMetric::Pointer()));
 
   size_t query_cnt = 20U;
-  auto linearCtx = searcher->create_context();
-  auto knnCtx = searcher->create_context();
-  auto linearByPKeysCtx = searcher->create_context();
+  auto linear_ctx = searcher->create_context();
+  auto knn_ctx = searcher->create_context();
+  auto linear_by_p_keys_ctx = searcher->create_context();
   auto *diskann_search_context =
-      dynamic_cast<DiskAnnContext *>(linearCtx.get());
+      dynamic_cast<DiskAnnContext *>(linear_ctx.get());
   ASSERT_NE(diskann_search_context, nullptr);
   EXPECT_EQ(static_cast<size_t>(DiskAnnUtil::kMaxSectorReadNum) *
                 DiskAnnUtil::kSectorSize,
             diskann_search_context->sector_buffer_size());
-  knnCtx->set_fetch_vector(true);
+  knn_ctx->set_fetch_vector(true);
 
   for (size_t i = 0; i < doc_cnt; i += doc_cnt / 10) {
     std::string vec_value;
-    ASSERT_EQ(0, searcher->get_vector(key_for_id(i), linearCtx, vec_value));
+    ASSERT_EQ(0, searcher->get_vector(key_for_id(i), linear_ctx, vec_value));
 
     ASSERT_GE(vec_value.size(), sizeof(float));
     float vector_value = 0.0f;
@@ -1153,8 +1153,8 @@ TEST_F(DiskAnnSearcherTest, TestFetchVector) {
   }
 
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
 
@@ -1164,30 +1164,30 @@ TEST_F(DiskAnnSearcherTest, TestFetchVector) {
       vec[j] = i;
     }
 
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(key_for_id(i), linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(key_for_id(i), linear_result[0].key());
 
-    const auto &vector_string = knnResult[0].vector_string();
+    const auto &vector_string = knn_result[0].vector_string();
     ASSERT_GE(vector_string.size(), sizeof(float));
     // DiskAnn is approximate, so the first KNN result is not guaranteed to
     // be the exact query vector on every graph build. Verify that the fetched
     // payload belongs to the returned key instead.
     std::string expected_vector;
-    ASSERT_EQ(0, searcher->get_vector(knnResult[0].key(), linearCtx,
+    ASSERT_EQ(0, searcher->get_vector(knn_result[0].key(), linear_ctx,
                                       expected_vector));
     ASSERT_EQ(vector_string, expected_vector);
   }
 
   std::string missing_vector;
   EXPECT_EQ(IndexError_NoExist,
-            searcher->get_vector(42, linearCtx, missing_vector));
+            searcher->get_vector(42, linear_ctx, missing_vector));
   EXPECT_TRUE(missing_vector.empty());
 
   // A DiskAnn provider reads through the aligned index reader rather than a
@@ -1367,7 +1367,7 @@ TEST_F(DiskAnnSearcherTest, TestFetchVector) {
                             DiskAnnCacheTestPeer::reader(diskann_searcher)));
   std::string vector_after_failure;
   EXPECT_EQ(IndexError_Runtime,
-            searcher->get_vector(key_for_id(doc_cnt - 1), linearCtx,
+            searcher->get_vector(key_for_id(doc_cnt - 1), linear_ctx,
                                  vector_after_failure));
   EXPECT_TRUE(vector_after_failure.empty());
 }
@@ -1588,23 +1588,23 @@ TEST_F(DiskAnnSearcherTest, TestGeneralTurbo) {
   auto ctx = searcher->create_context();
   ASSERT_TRUE(!!ctx);
 
-  auto linearCtx = searcher->create_context();
-  auto linearByPKeysCtx = searcher->create_context();
-  auto knnCtx = searcher->create_context();
+  auto linear_ctx = searcher->create_context();
+  auto linear_by_p_keys_ctx = searcher->create_context();
+  auto knn_ctx = searcher->create_context();
 
-  ASSERT_TRUE(!!linearCtx);
-  ASSERT_TRUE(!!linearByPKeysCtx);
-  ASSERT_TRUE(!!knnCtx);
+  ASSERT_TRUE(!!linear_ctx);
+  ASSERT_TRUE(!!linear_by_p_keys_ctx);
+  ASSERT_TRUE(!!knn_ctx);
 
   NumericalVector<float> vec(dim);
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
   size_t topk = 200;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
-  linearCtx->set_topk(topk);
-  linearByPKeysCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
+  linear_ctx->set_topk(topk);
+  linear_by_p_keys_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
   // do linear search test
   {
@@ -1612,18 +1612,18 @@ TEST_F(DiskAnnSearcherTest, TestGeneralTurbo) {
     for (size_t i = 0; i < dim; ++i) {
       query[i] = 3.1f;
     }
-    ASSERT_EQ(0, searcher->search_bf_impl(query, qmeta, linearCtx));
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(3UL, linearResult[0].key());
-    ASSERT_EQ(4UL, linearResult[1].key());
-    ASSERT_EQ(2UL, linearResult[2].key());
-    ASSERT_EQ(5UL, linearResult[3].key());
-    ASSERT_EQ(1UL, linearResult[4].key());
-    ASSERT_EQ(6UL, linearResult[5].key());
-    ASSERT_EQ(0UL, linearResult[6].key());
-    ASSERT_EQ(7UL, linearResult[7].key());
+    ASSERT_EQ(0, searcher->search_bf_impl(query, qmeta, linear_ctx));
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(3UL, linear_result[0].key());
+    ASSERT_EQ(4UL, linear_result[1].key());
+    ASSERT_EQ(2UL, linear_result[2].key());
+    ASSERT_EQ(5UL, linear_result[3].key());
+    ASSERT_EQ(1UL, linear_result[4].key());
+    ASSERT_EQ(6UL, linear_result[5].key());
+    ASSERT_EQ(0UL, linear_result[6].key());
+    ASSERT_EQ(7UL, linear_result[7].key());
     for (size_t i = 8; i < topk; ++i) {
-      ASSERT_EQ(i, linearResult[i].key());
+      ASSERT_EQ(i, linear_result[i].key());
     }
   }
 
@@ -1638,17 +1638,17 @@ TEST_F(DiskAnnSearcherTest, TestGeneralTurbo) {
     }
 
     ASSERT_EQ(0, searcher->search_bf_by_p_keys_impl(query, p_keys, qmeta,
-                                                    linearByPKeysCtx));
-    auto &linearByPKeysResult = linearByPKeysCtx->result();
-    ASSERT_EQ(8, linearByPKeysResult.size());
-    ASSERT_EQ(3UL, linearByPKeysResult[0].key());
-    ASSERT_EQ(2UL, linearByPKeysResult[1].key());
-    ASSERT_EQ(1UL, linearByPKeysResult[2].key());
-    ASSERT_EQ(0UL, linearByPKeysResult[3].key());
-    ASSERT_EQ(8UL, linearByPKeysResult[4].key());
-    ASSERT_EQ(9UL, linearByPKeysResult[5].key());
-    ASSERT_EQ(10UL, linearByPKeysResult[6].key());
-    ASSERT_EQ(11UL, linearByPKeysResult[7].key());
+                                                    linear_by_p_keys_ctx));
+    auto &linear_by_p_keys_result = linear_by_p_keys_ctx->result();
+    ASSERT_EQ(8, linear_by_p_keys_result.size());
+    ASSERT_EQ(3UL, linear_by_p_keys_result[0].key());
+    ASSERT_EQ(2UL, linear_by_p_keys_result[1].key());
+    ASSERT_EQ(1UL, linear_by_p_keys_result[2].key());
+    ASSERT_EQ(0UL, linear_by_p_keys_result[3].key());
+    ASSERT_EQ(8UL, linear_by_p_keys_result[4].key());
+    ASSERT_EQ(9UL, linear_by_p_keys_result[5].key());
+    ASSERT_EQ(10UL, linear_by_p_keys_result[6].key());
+    ASSERT_EQ(11UL, linear_by_p_keys_result[7].key());
   }
 
   size_t step = 500;
@@ -1656,32 +1656,32 @@ TEST_F(DiskAnnSearcherTest, TestGeneralTurbo) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &knnResult = knnCtx->result();
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
 
-  float recall = totalHits * step * step * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * step * 1.0f / doc_cnt;
+  float recall = total_hits * step * step * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * step * 1.0f / doc_cnt;
 
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
 
   // A context created by the streamer must carry the streamer's magic so it
   // can be reused instead of being recreated on every search.
@@ -1732,12 +1732,12 @@ TEST_F(DiskAnnSearcherTest, TestGeneralTurbo) {
   // mismatch must be rejected before either searcher touches the input.
   IndexQueryMeta wrong_type(IndexMeta::DataType::DT_FP16, dim);
   EXPECT_EQ(IndexError_Mismatch,
-            searcher->search_impl(vec.data(), wrong_type, knnCtx));
+            searcher->search_impl(vec.data(), wrong_type, knn_ctx));
   EXPECT_EQ(IndexError_Mismatch,
             streamer->search_impl(vec.data(), wrong_type, streamer_ctx));
   IndexQueryMeta wrong_dimension(IndexMeta::DataType::DT_FP32, dim - 1);
   EXPECT_EQ(IndexError_Mismatch,
-            searcher->search_bf_impl(vec.data(), wrong_dimension, linearCtx));
+            searcher->search_bf_impl(vec.data(), wrong_dimension, linear_ctx));
 
   // Group parameters without a grouping callback are invalid instead of a
   // successful search with an empty result.
@@ -1765,7 +1765,7 @@ TEST_F(DiskAnnSearcherTest, TestGeneralTurbo) {
   ASSERT_EQ(0, searcher->unload());
   EXPECT_EQ(nullptr, searcher->create_context());
   EXPECT_EQ(IndexError_NoReady,
-            searcher->search_impl(vec.data(), qmeta, knnCtx));
+            searcher->search_impl(vec.data(), qmeta, knn_ctx));
 }
 
 TEST_F(DiskAnnSearcherTest, TestNodeCacheTurbo) {
@@ -1831,55 +1831,55 @@ TEST_F(DiskAnnSearcherTest, TestNodeCacheTurbo) {
   auto ctx = searcher->create_context();
   ASSERT_TRUE(!!ctx);
 
-  auto linearCtx = searcher->create_context();
-  auto linearByPKeysCtx = searcher->create_context();
-  auto knnCtx = searcher->create_context();
+  auto linear_ctx = searcher->create_context();
+  auto linear_by_p_keys_ctx = searcher->create_context();
+  auto knn_ctx = searcher->create_context();
 
-  ASSERT_TRUE(!!linearCtx);
-  ASSERT_TRUE(!!linearByPKeysCtx);
-  ASSERT_TRUE(!!knnCtx);
+  ASSERT_TRUE(!!linear_ctx);
+  ASSERT_TRUE(!!linear_by_p_keys_ctx);
+  ASSERT_TRUE(!!knn_ctx);
 
   NumericalVector<float> vec(dim);
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
   size_t topk = 200;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
-  linearCtx->set_topk(topk);
-  linearByPKeysCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
+  linear_ctx->set_topk(topk);
+  linear_by_p_keys_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
   size_t step = 500;
   for (size_t i = 0; i < doc_cnt; i += step) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &knnResult = knnCtx->result();
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
 
-  float recall = totalHits * step * step * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * step * 1.0f / doc_cnt;
+  float recall = total_hits * step * step * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * step * 1.0f / doc_cnt;
 
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
 }
 
 TEST_F(DiskAnnSearcherTest, TestFilterTurbo) {
@@ -1945,21 +1945,21 @@ TEST_F(DiskAnnSearcherTest, TestFilterTurbo) {
   auto ctx = searcher->create_context();
   ASSERT_TRUE(!!ctx);
 
-  auto linearCtx = searcher->create_context();
-  auto linearByPKeysCtx = searcher->create_context();
-  auto knnCtx = searcher->create_context();
+  auto linear_ctx = searcher->create_context();
+  auto linear_by_p_keys_ctx = searcher->create_context();
+  auto knn_ctx = searcher->create_context();
 
-  ASSERT_TRUE(!!linearCtx);
-  ASSERT_TRUE(!!linearByPKeysCtx);
-  ASSERT_TRUE(!!knnCtx);
+  ASSERT_TRUE(!!linear_ctx);
+  ASSERT_TRUE(!!linear_by_p_keys_ctx);
+  ASSERT_TRUE(!!knn_ctx);
 
   NumericalVector<float> vec(dim);
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
 
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  linearByPKeysCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  linear_ctx->set_topk(topk);
+  linear_by_p_keys_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
   size_t key = 50;
   for (size_t j = 0; j < dim; ++j) {
@@ -1968,23 +1968,23 @@ TEST_F(DiskAnnSearcherTest, TestFilterTurbo) {
 
   // no filter
   {
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
 
-    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(50UL, linearResult[0].key());
-    ASSERT_EQ(51UL, linearResult[1].key());
-    ASSERT_EQ(49UL, linearResult[2].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(50UL, linear_result[0].key());
+    ASSERT_EQ(51UL, linear_result[1].key());
+    ASSERT_EQ(49UL, linear_result[2].key());
   }
 
   // with filter
   {
-    auto filterFunc = [](uint64_t key) {
+    auto filter_func = [](uint64_t key) {
       if (key == 50UL || key == 51UL || key == 49UL) {
         return true;
       }
@@ -1992,30 +1992,30 @@ TEST_F(DiskAnnSearcherTest, TestFilterTurbo) {
     };
 
 
-    knnCtx->set_filter(filterFunc);
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
+    knn_ctx->set_filter(filter_func);
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
     std::unordered_set<uint64_t> knn_keys;
-    for (const auto &result : knnResult) {
+    for (const auto &result : knn_result) {
       ASSERT_TRUE(knn_keys.emplace(result.key()).second);
       EXPECT_NE(50UL, result.key());
       EXPECT_NE(51UL, result.key());
       EXPECT_NE(49UL, result.key());
     }
 
-    linearCtx->set_filter(filterFunc);
-    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
+    linear_ctx->set_filter(filter_func);
+    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(52UL, linearResult[0].key());
-    ASSERT_EQ(48UL, linearResult[1].key());
-    ASSERT_EQ(53UL, linearResult[2].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(52UL, linear_result[0].key());
+    ASSERT_EQ(48UL, linear_result[1].key());
+    ASSERT_EQ(53UL, linear_result[2].key());
 
     size_t hit_count = 0;
-    for (const auto &result : linearResult) {
+    for (const auto &result : linear_result) {
       hit_count += knn_keys.count(result.key());
     }
     const float recall = static_cast<float>(hit_count) / topk;
@@ -2089,7 +2089,7 @@ TEST_F(DiskAnnSearcherTest, TestGroupTurbo) {
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
   size_t group_topk = 20;
 
-  auto groupbyFunc = [](uint64_t key) {
+  auto groupby_func = [](uint64_t key) {
     uint32_t group_id = key / 10 % 10;
 
     return std::string("g_") + std::to_string(group_id);
@@ -2098,7 +2098,7 @@ TEST_F(DiskAnnSearcherTest, TestGroupTurbo) {
   size_t group_num = 5;
 
   ctx->set_group_params(group_num, group_topk);
-  ctx->set_group_by(groupbyFunc);
+  ctx->set_group_by(groupby_func);
 
   size_t query_value = doc_cnt / 2;
   for (size_t j = 0; j < dim; ++j) {
@@ -2120,7 +2120,7 @@ TEST_F(DiskAnnSearcherTest, TestGroupTurbo) {
     ASSERT_LE(result.size(), group_topk);
 
     for (uint32_t j = 0; j < result.size(); ++j) {
-      EXPECT_EQ(group_id, groupbyFunc(result[j].key()));
+      EXPECT_EQ(group_id, groupby_func(result[j].key()));
     }
   }
 
@@ -2146,19 +2146,19 @@ TEST_F(DiskAnnSearcherTest, TestGroupTurbo) {
   // scans, rather than grouping only the global top-k afterward.
   auto linear_ctx = searcher->create_context();
   linear_ctx->set_group_params(group_num, group_topk);
-  linear_ctx->set_group_by(groupbyFunc);
+  linear_ctx->set_group_by(groupby_func);
   ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
   const auto &linear_group_result = linear_ctx->group_result();
   ASSERT_EQ(group_num, linear_group_result.size());
   for (const auto &group : linear_group_result) {
     ASSERT_EQ(group_topk, group.docs().size());
     for (const auto &doc : group.docs()) {
-      EXPECT_EQ(group.group_id(), groupbyFunc(doc.key()));
+      EXPECT_EQ(group.group_id(), groupby_func(doc.key()));
     }
   }
 
   // do linear search by p_keys test
-  auto groupbyFuncLinear = [](uint64_t key) {
+  auto groupby_func_linear = [](uint64_t key) {
     uint32_t group_id = key % 10;
 
     return std::string("g_") + std::to_string(group_id);
@@ -2167,7 +2167,7 @@ TEST_F(DiskAnnSearcherTest, TestGroupTurbo) {
   auto linear_pk_ctx = searcher->create_context();
 
   linear_pk_ctx->set_group_params(group_num, group_topk);
-  linear_pk_ctx->set_group_by(groupbyFuncLinear);
+  linear_pk_ctx->set_group_by(groupby_func_linear);
 
   std::vector<std::vector<uint64_t>> p_keys;
   p_keys.resize(1);
@@ -2248,14 +2248,14 @@ TEST_F(DiskAnnSearcherTest, TestFetchVectorTurbo) {
   ASSERT_EQ(0, searcher->load(storage, IndexMetric::Pointer()));
 
   size_t query_cnt = 20U;
-  auto linearCtx = searcher->create_context();
-  auto knnCtx = searcher->create_context();
-  auto linearByPKeysCtx = searcher->create_context();
-  knnCtx->set_fetch_vector(true);
+  auto linear_ctx = searcher->create_context();
+  auto knn_ctx = searcher->create_context();
+  auto linear_by_p_keys_ctx = searcher->create_context();
+  knn_ctx->set_fetch_vector(true);
 
   for (size_t i = 0; i < doc_cnt; i += doc_cnt / 10) {
     std::string vec_value;
-    ASSERT_EQ(0, searcher->get_vector(key_for_id(i), linearCtx, vec_value));
+    ASSERT_EQ(0, searcher->get_vector(key_for_id(i), linear_ctx, vec_value));
 
     ASSERT_GE(vec_value.size(), sizeof(float));
     float vector_value = 0.0f;
@@ -2264,8 +2264,8 @@ TEST_F(DiskAnnSearcherTest, TestFetchVectorTurbo) {
   }
 
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
 
@@ -2275,30 +2275,30 @@ TEST_F(DiskAnnSearcherTest, TestFetchVectorTurbo) {
       vec[j] = i;
     }
 
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(key_for_id(i), linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(key_for_id(i), linear_result[0].key());
 
-    const auto &vector_string = knnResult[0].vector_string();
+    const auto &vector_string = knn_result[0].vector_string();
     ASSERT_GE(vector_string.size(), sizeof(float));
     // DiskAnn is approximate, so the first KNN result is not guaranteed to
     // be the exact query vector on every graph build. Verify that the fetched
     // payload belongs to the returned key instead.
     std::string expected_vector;
-    ASSERT_EQ(0, searcher->get_vector(knnResult[0].key(), linearCtx,
+    ASSERT_EQ(0, searcher->get_vector(knn_result[0].key(), linear_ctx,
                                       expected_vector));
     ASSERT_EQ(vector_string, expected_vector);
   }
 
   std::string missing_vector;
   EXPECT_EQ(IndexError_NoExist,
-            searcher->get_vector(42, linearCtx, missing_vector));
+            searcher->get_vector(42, linear_ctx, missing_vector));
   EXPECT_TRUE(missing_vector.empty());
 
   // Cached nodes keep their coordinates and adjacency lists in separate
@@ -2338,7 +2338,7 @@ TEST_F(DiskAnnSearcherTest, TestFetchVectorTurbo) {
                             DiskAnnCacheTestPeer::reader(diskann_searcher)));
   std::string vector_after_failure;
   EXPECT_EQ(IndexError_Runtime,
-            searcher->get_vector(key_for_id(doc_cnt - 1), linearCtx,
+            searcher->get_vector(key_for_id(doc_cnt - 1), linear_ctx,
                                  vector_after_failure));
   EXPECT_TRUE(vector_after_failure.empty());
 }
diff --git a/tests/core/algorithm/flat/flat_streamer_test.cc b/tests/core/algorithm/flat/flat_streamer_test.cc
index 1345a25e3..c658aa96f 100644
--- a/tests/core/algorithm/flat/flat_streamer_test.cc
+++ b/tests/core/algorithm/flat/flat_streamer_test.cc
@@ -756,8 +756,8 @@ TEST_F(FlatStreamerTest, TestAddAndSearch) {
       vec[j] = i + 0.1f;
     }
     ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, ctx));
-    auto &knnResult = ctx->result();
-    ASSERT_EQ(std::min(i + 1, topk), knnResult.size());
+    auto &knn_result = ctx->result();
+    ASSERT_EQ(std::min(i + 1, topk), knn_result.size());
   }
 }
 
@@ -802,15 +802,15 @@ TEST_F(FlatStreamerTest, TestAddAndSearcherSearch) {
   ASSERT_EQ(0, searcher->init(Params()));
   ASSERT_EQ(0, searcher->load(container, IndexMetric::Pointer()));
 
-  auto linearCtx = searcher->create_context();
-  linearCtx->set_topk(topk);
+  auto linear_ctx = searcher->create_context();
+  linear_ctx->set_topk(topk);
   for (size_t i = 0; i < cnt; i++) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, linearCtx));
-    auto &knnResult = linearCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, linear_ctx));
+    auto &knn_result = linear_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
   }
 }
 
@@ -844,57 +844,57 @@ TEST_F(FlatStreamerTest, TestLinearSearchRandomData) {
     streamer->add_impl(i + cnt, vec.data(), qmeta, ctx);
   }
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   size_t topk = 100;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
   cnt = 500;
   for (size_t i = 0; i < cnt; i += 1) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
     }
     auto t1 = Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
     auto t2 = Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
     auto t3 = Realtime::MicroSeconds();
-    knnTotalTime += t3 - t2;
-    linearTotalTime += t2 - t1;
+    knn_total_time += t3 - t2;
+    linear_total_time += t2 - t1;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
 
-    topk1Hits += linearResult[0].key() == knnResult[0].key();
+    topk1_hits += linear_result[0].key() == knn_result[0].key();
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 1.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 1.0f / cnt;
 #if 1
   printf(
       "knnTotalTime=%zu linearTotalTime=%zu totalHits=%d totalCnts=%d "
       "R@%zd=%f R@1=%f\n",
-      (size_t)knnTotalTime, (size_t)linearTotalTime, totalHits, totalCnts, topk,
-      recall, topk1Recall);
+      (size_t)knn_total_time, (size_t)linear_total_time, total_hits, total_cnts,
+      topk, recall, topk1_recall);
 #endif
   EXPECT_GT(recall, 0.50f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
 }
 
 TEST_F(FlatStreamerTest, TestOpenClose) {
@@ -917,8 +917,8 @@ TEST_F(FlatStreamerTest, TestOpenClose) {
   ASSERT_EQ(0, storage2->init(stg_params));
   ASSERT_EQ(0, storage2->open(dir_ + "TestOpenAndClose2", true));
   ASSERT_EQ(0, streamer->init(meta, params));
-  auto checkIter = [](size_t base, size_t total,
-                      IndexStreamer::Pointer &streamer) {
+  auto check_iter = [](size_t base, size_t total,
+                       IndexStreamer::Pointer &streamer) {
     auto provider = streamer->create_provider();
     auto iter = provider->create_iterator();
     ASSERT_TRUE(!!iter);
@@ -936,9 +936,9 @@ TEST_F(FlatStreamerTest, TestOpenClose) {
     ASSERT_EQ(cnt, total);
   };
 
-  size_t testCnt = 200;
+  size_t test_cnt = 200;
   IndexQueryMeta qmeta(IndexMeta::DT_FP32, dim);
-  for (size_t i = 0; i < testCnt; i += 2) {
+  for (size_t i = 0; i < test_cnt; i += 2) {
     float v1 = (float)i;
     ASSERT_EQ(0, streamer->open(storage1));
     auto ctx = streamer->create_context();
@@ -948,7 +948,7 @@ TEST_F(FlatStreamerTest, TestOpenClose) {
       vec1[d] = v1;
     }
     ASSERT_EQ(0, streamer->add_impl(i, vec1.data(), qmeta, ctx));
-    checkIter(0, i / 2 + 1, streamer);
+    check_iter(0, i / 2 + 1, streamer);
     ASSERT_EQ(0, streamer->flush(0UL));
     ASSERT_EQ(0, streamer->close());
 
@@ -961,7 +961,7 @@ TEST_F(FlatStreamerTest, TestOpenClose) {
     ctx = streamer->create_context();
     ASSERT_TRUE(!!ctx);
     ASSERT_EQ(0, streamer->add_impl(i + 1, vec2.data(), qmeta, ctx));
-    checkIter(1, i / 2 + 1, streamer);
+    check_iter(1, i / 2 + 1, streamer);
     ASSERT_EQ(0, streamer->flush(0UL));
     ASSERT_EQ(0, streamer->close());
   }
@@ -978,8 +978,8 @@ TEST_F(FlatStreamerTest, TestOpenClose) {
   ASSERT_EQ(0, streamer2->init(meta, params));
   ASSERT_EQ(0, streamer2->open(storage2));
 
-  checkIter(0, testCnt / 2, streamer1);
-  checkIter(1, testCnt / 2, streamer2);
+  check_iter(0, test_cnt / 2, streamer1);
+  check_iter(1, test_cnt / 2, streamer2);
 }
 
 TEST_F(FlatStreamerTest, TestNoInit) {
@@ -1006,7 +1006,7 @@ TEST_F(FlatStreamerTest, TestForceFlush) {
   ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto checkIter = [](size_t total, IndexStreamer::Pointer &streamer) {
+  auto check_iter = [](size_t total, IndexStreamer::Pointer &streamer) {
     auto provider = streamer->create_provider();
     auto iter = provider->create_iterator();
     ASSERT_TRUE(!!iter);
@@ -1032,7 +1032,7 @@ TEST_F(FlatStreamerTest, TestForceFlush) {
       vec[j] = i;
     }
     streamer->add_impl(i, vec.data(), qmeta, ctx);
-    checkIter(i + 1, streamer);
+    check_iter(i + 1, streamer);
   }
 
   streamer->flush(0UL);
@@ -1044,7 +1044,7 @@ TEST_F(FlatStreamerTest, TestForceFlush) {
   ASSERT_EQ(0, storage->init(stg_params));
   ASSERT_EQ(0, storage->open(dir_ + "TestForceFlush", true));
   ASSERT_EQ(0, streamer->open(storage));
-  checkIter(cnt, streamer);
+  check_iter(cnt, streamer);
 
   // check getVector
   auto provider = streamer->create_provider();
@@ -1074,23 +1074,23 @@ TEST_F(FlatStreamerTest, TestMultiThread) {
   ASSERT_EQ(0, storage->open(dir_ + "TessKnnMultiThread", true));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto addVector = [&streamer](int baseKey, size_t addCnt) {
+  auto add_vector = [&streamer](int base_key, size_t add_cnt) {
     NumericalVector<float> vec(dim);
     IndexQueryMeta qmeta(IndexMeta::DT_FP32, dim);
-    size_t succAdd = 0;
+    size_t succ_add = 0;
     auto ctx = streamer->create_context();
-    for (size_t i = 0; i < addCnt; i++) {
+    for (size_t i = 0; i < add_cnt; i++) {
       for (size_t j = 0; j < dim; ++j) {
-        vec[j] = (float)i + baseKey;
+        vec[j] = (float)i + base_key;
       }
-      succAdd += !streamer->add_impl(baseKey + i, vec.data(), qmeta, ctx);
+      succ_add += !streamer->add_impl(base_key + i, vec.data(), qmeta, ctx);
     }
     streamer->flush(0UL);
-    return succAdd;
+    return succ_add;
   };
-  auto t2 = std::async(std::launch::async, addVector, 1000, 1000);
-  auto t3 = std::async(std::launch::async, addVector, 2000, 1000);
-  auto t1 = std::async(std::launch::async, addVector, 0, 1000);
+  auto t2 = std::async(std::launch::async, add_vector, 1000, 1000);
+  auto t3 = std::async(std::launch::async, add_vector, 2000, 1000);
+  auto t1 = std::async(std::launch::async, add_vector, 0, 1000);
   ASSERT_EQ(1000U, t1.get());
   ASSERT_EQ(1000U, t2.get());
   ASSERT_EQ(1000U, t3.get());
@@ -1121,26 +1121,26 @@ TEST_F(FlatStreamerTest, TestMultiThread) {
   // ====== multi thread search
   size_t topk = 100;
   size_t cnt = 3000;
-  auto knnSearch = [&]() {
+  auto knn_search = [&]() {
     NumericalVector<float> vec(dim);
-    auto linearCtx = streamer->create_context();
-    auto linearByPkeysCtx = streamer->create_context();
+    auto linear_ctx = streamer->create_context();
+    auto linear_by_pkeys_ctx = streamer->create_context();
     auto ctx = streamer->create_context();
     IndexQueryMeta qmeta(IndexMeta::DT_FP32, dim);
-    linearCtx->set_topk(topk);
-    linearByPkeysCtx->set_topk(topk);
+    linear_ctx->set_topk(topk);
+    linear_by_pkeys_ctx->set_topk(topk);
     ctx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     for (size_t i = 0; i < cnt; i += 1) {
       for (size_t j = 0; j < dim; ++j) {
         vec[j] = i + 0.1f;
       }
       ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, ctx));
-      ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+      ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
       auto &r1 = ctx->result();
       ASSERT_EQ(topk, r1.size());
-      auto &r2 = linearCtx->result();
+      auto &r2 = linear_ctx->result();
       ASSERT_EQ(topk, r2.size());
       ASSERT_EQ(i, r2[0].key());
 #if 0
@@ -1150,21 +1150,21 @@ TEST_F(FlatStreamerTest, TestMultiThread) {
                    r1[2].key, r1[3].key, r1[4].key);
 #endif
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
           if (r2[j].key() == r1[k].key()) {
-            totalHits++;
+            total_hits++;
             break;
           }
         }
       }
     }
     // printf("%f\n", totalHits * 1.0f / totalCnts);
-    ASSERT_TRUE((totalHits * 1.0f / totalCnts) > 0.80f);
+    ASSERT_TRUE((total_hits * 1.0f / total_cnts) > 0.80f);
   };
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
-  auto s3 = std::async(std::launch::async, knnSearch);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
+  auto s3 = std::async(std::launch::async, knn_search);
   s1.wait();
   s2.wait();
   s3.wait();
@@ -1187,45 +1187,45 @@ TEST_F(FlatStreamerTest, TestConcurrentAddAndSearch) {
   ASSERT_EQ(0, storage->open(dir_ + "TessKnnConcurrentAddAndSearch", true));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto addVector = [&streamer](int baseKey, size_t addCnt) {
+  auto add_vector = [&streamer](int base_key, size_t add_cnt) {
     NumericalVector<float> vec(dim);
     IndexQueryMeta qmeta(IndexMeta::DT_FP32, dim);
     auto ctx = streamer->create_context();
-    size_t succAdd = 0;
-    for (size_t i = 0; i < addCnt; i++) {
+    size_t succ_add = 0;
+    for (size_t i = 0; i < add_cnt; i++) {
       for (size_t j = 0; j < dim; ++j) {
-        vec[j] = (float)i + baseKey;
+        vec[j] = (float)i + base_key;
       }
-      succAdd += !streamer->add_impl(baseKey + i, vec.data(), qmeta, ctx);
+      succ_add += !streamer->add_impl(base_key + i, vec.data(), qmeta, ctx);
     }
     streamer->flush(0UL);
-    return succAdd;
+    return succ_add;
   };
 
   // ====== multi thread search
-  auto knnSearch = [&]() {
+  auto knn_search = [&]() {
     size_t topk = 100;
     size_t cnt = 3000;
     NumericalVector<float> vec(dim);
-    auto linearCtx = streamer->create_context();
-    auto linearByPKeysCtx = streamer->create_context();
+    auto linear_ctx = streamer->create_context();
+    auto linear_by_p_keys_ctx = streamer->create_context();
     auto ctx = streamer->create_context();
-    linearCtx->set_topk(topk);
-    linearByPKeysCtx->set_topk(topk);
+    linear_ctx->set_topk(topk);
+    linear_by_p_keys_ctx->set_topk(topk);
     ctx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     IndexQueryMeta qmeta(IndexMeta::DT_FP32, dim);
     for (size_t i = 0; i < cnt; i += 1) {
       for (size_t j = 0; j < dim; ++j) {
         vec[j] = i + 0.1f;
       }
       ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, ctx));
-      ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+      ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
       std::vector<std::vector<uint64_t>> p_keys = {{0, 1, 2}};
       auto &r1 = ctx->result();
       ASSERT_EQ(topk, r1.size());
-      auto &r2 = linearCtx->result();
+      auto &r2 = linear_ctx->result();
       ASSERT_EQ(topk, r2.size());
 #if 0
       printf("linear: %zd => %zd %zd %zd %zd %zd\n", i, r2[0].key,
@@ -1234,24 +1234,24 @@ TEST_F(FlatStreamerTest, TestConcurrentAddAndSearch) {
               r1[2].key, r1[3].key, r1[4].key);
 #endif
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
           if (r2[j].key() == r1[k].key()) {
-            totalHits++;
+            total_hits++;
             break;
           }
         }
       }
     }
     //        printf("%f\n", totalHits * 1.0f / totalCnts);
-    ASSERT_TRUE((totalHits * 1.0f / totalCnts) > 0.80f);
+    ASSERT_TRUE((total_hits * 1.0f / total_cnts) > 0.80f);
   };
-  auto t0 = std::async(std::launch::async, addVector, 0, 1000);
+  auto t0 = std::async(std::launch::async, add_vector, 0, 1000);
   ASSERT_EQ(1000, t0.get());
-  auto t1 = std::async(std::launch::async, addVector, 1000, 1000);
-  auto t2 = std::async(std::launch::async, addVector, 2000, 1000);
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
+  auto t1 = std::async(std::launch::async, add_vector, 1000, 1000);
+  auto t2 = std::async(std::launch::async, add_vector, 2000, 1000);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
   ASSERT_EQ(1000, t1.get());
   ASSERT_EQ(1000, t2.get());
   s1.wait();
@@ -1400,13 +1400,13 @@ TEST_F(FlatStreamerTest, TestFilter) {
   ASSERT_EQ(101, results[1].key());
   ASSERT_EQ(99, results[2].key());
 
-  auto filterFunc = [](uint64_t key) {
+  auto filter_func = [](uint64_t key) {
     if (key == 100UL || key == 101UL) {
       return true;
     }
     return false;
   };
-  ctx->set_filter(filterFunc);
+  ctx->set_filter(filter_func);
 
   // after set filter
   ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, ctx));
@@ -1461,10 +1461,10 @@ TEST_F(FlatStreamerTest, TestMaxIndexSize) {
   }
 
   NumericalVector<float> vec(dim);
-  size_t writeCnt1 = 10000;
+  size_t write_cnt1 = 10000;
   IndexQueryMeta qmeta(IndexMeta::DT_FP32, dim);
   auto ctx = streamer->create_context();
-  for (size_t i = 0; i < writeCnt1; i++) {
+  for (size_t i = 0; i < write_cnt1; i++) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i;
     }
@@ -1476,7 +1476,7 @@ TEST_F(FlatStreamerTest, TestMaxIndexSize) {
   size_t increment1 = rss1 - rss0;
   // data + key + block_header
   size_t expect_size =
-      writeCnt1 * 128 * 4 + writeCnt1 * 8 + writeCnt1 * 28 / 32;
+      write_cnt1 * 128 * 4 + write_cnt1 * 8 + write_cnt1 * 28 / 32;
   LOG_INFO("increment1: %lu, expect_size: %lu", increment1, expect_size);
 
   ASSERT_GT(expect_size, increment1 * 0.75f);
@@ -1644,7 +1644,7 @@ TEST_F(FlatStreamerTest, TestGroup) {
   size_t group_topk = 20;
   uint64_t total_time = 0;
 
-  auto groupbyFunc = [](uint64_t key) {
+  auto groupby_func = [](uint64_t key) {
     uint32_t group_id = key / 10 % 10;
 
     // std::cout << "key: " << key << ", group id: " << group_id << std::endl;
@@ -1655,7 +1655,7 @@ TEST_F(FlatStreamerTest, TestGroup) {
   size_t group_num = 5;
 
   ctx->set_group_params(group_num, group_topk);
-  ctx->set_group_by(groupbyFunc);
+  ctx->set_group_by(groupby_func);
 
   size_t query_value = doc_cnt / 2;
   for (size_t j = 0; j < dim; ++j) {
@@ -1686,7 +1686,7 @@ TEST_F(FlatStreamerTest, TestGroup) {
   }
 
   // do linear search by p_keys test
-  auto groupbyFuncLinear = [](uint64_t key) {
+  auto groupby_func_linear = [](uint64_t key) {
     uint32_t group_id = key % 10;
 
     return std::string("g_") + std::to_string(group_id);
@@ -1695,7 +1695,7 @@ TEST_F(FlatStreamerTest, TestGroup) {
   auto linear_pk_ctx = streamer->create_context();
 
   linear_pk_ctx->set_group_params(group_num, group_topk);
-  linear_pk_ctx->set_group_by(groupbyFuncLinear);
+  linear_pk_ctx->set_group_by(groupby_func_linear);
 
   std::vector<std::vector<uint64_t>> p_keys;
   p_keys.resize(1);
@@ -1736,8 +1736,8 @@ TEST_F(FlatStreamerTest, TestAddAndSearchWithID) {
   ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
   ASSERT_EQ(0, streamer->open(storage));
   auto ctx = streamer->create_context();
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   ASSERT_TRUE(!!ctx);
 
   size_t cnt = 20000U;
@@ -1757,51 +1757,51 @@ TEST_F(FlatStreamerTest, TestAddAndSearchWithID) {
   }
   // streamer->print_debug_info();
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
   for (size_t i = 0; i < cnt; i += 100) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
     auto t1 = Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
     auto t2 = Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
     auto t3 = Realtime::MicroSeconds();
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 100.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 100.0f / cnt;
 #if 1
   printf(
       "knnTotalTime=%zu linearTotalTime=%zu totalHits=%d totalCnts=%d "
       "R@%zd=%f R@1=%f\n",
-      (size_t)knnTotalTime, (size_t)linearTotalTime, totalHits, totalCnts, topk,
-      recall, topk1Recall);
+      (size_t)knn_total_time, (size_t)linear_total_time, total_hits, total_cnts,
+      topk, recall, topk1_recall);
 #endif
   EXPECT_GT(recall, 0.80f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
 }
 
 TEST_F(FlatStreamerTest, TestAddAndSearchWithID2) {
@@ -1849,47 +1849,47 @@ TEST_F(FlatStreamerTest, TestAddAndSearchWithID2) {
   ASSERT_EQ(0, read_storage->open(dir_ + "TestGroup.index", true));
   ASSERT_EQ(0, read_streamer->init(*index_meta_ptr_, read_params));
   ASSERT_EQ(0, read_streamer->open(read_storage));
-  auto linearCtx = read_streamer->create_context();
-  auto knnCtx = read_streamer->create_context();
+  auto linear_ctx = read_streamer->create_context();
+  auto knn_ctx = read_streamer->create_context();
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
   for (size_t i = 0; i < cnt; i += 100) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
     auto t1 = Realtime::MicroSeconds();
-    ASSERT_EQ(0, read_streamer->search_impl(vec.data(), qmeta, knnCtx));
+    ASSERT_EQ(0, read_streamer->search_impl(vec.data(), qmeta, knn_ctx));
     auto t2 = Realtime::MicroSeconds();
-    ASSERT_EQ(0, read_streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, read_streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
     auto t3 = Realtime::MicroSeconds();
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
-  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 100.0f / cnt;
+  std::cout << "knnTotalTime: " << knn_total_time << std::endl;
+  std::cout << "linearTotalTime: " << linear_total_time << std::endl;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 100.0f / cnt;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
            "R@%zd=%f R@1=%f cost=%f\n",
@@ -1897,7 +1897,7 @@ TEST_F(FlatStreamerTest, TestAddAndSearchWithID2) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.80f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
 }
 
 // Test Flat + INT8 quantization + rotation end-to-end
@@ -1974,10 +1974,10 @@ TEST_F(FlatStreamerTest, TestInt8WithRotate) {
   ASSERT_EQ(0, reformer2->load(storage2));
 
   // Search: verify results are non-empty
-  auto knnCtx = streamer2->create_context();
-  knnCtx->set_topk(kTopk);
-  auto linearCtx = streamer2->create_context();
-  linearCtx->set_topk(kTopk);
+  auto knn_ctx = streamer2->create_context();
+  knn_ctx->set_topk(kTopk);
+  auto linear_ctx = streamer2->create_context();
+  linear_ctx->set_topk(kTopk);
 
   NumericalVector<float> query(kTestDim);
   for (size_t j = 0; j < kTestDim; ++j) query[j] = dist(gen);
@@ -1986,12 +1986,12 @@ TEST_F(FlatStreamerTest, TestInt8WithRotate) {
   IndexQueryMeta new_qmeta;
   ASSERT_EQ(0,
             reformer2->transform(query.data(), qmeta, &new_query, &new_qmeta));
-  ASSERT_EQ(0, streamer2->search_impl(new_query.data(), new_qmeta, knnCtx));
+  ASSERT_EQ(0, streamer2->search_impl(new_query.data(), new_qmeta, knn_ctx));
   ASSERT_EQ(0,
-            streamer2->search_bf_impl(new_query.data(), new_qmeta, linearCtx));
+            streamer2->search_bf_impl(new_query.data(), new_qmeta, linear_ctx));
 
-  EXPECT_EQ(kTopk, knnCtx->result().size());
-  EXPECT_EQ(kTopk, linearCtx->result().size());
+  EXPECT_EQ(kTopk, knn_ctx->result().size());
+  EXPECT_EQ(kTopk, linear_ctx->result().size());
 }
 
 // The streamer computes distances with the turbo quantizer.
diff --git a/tests/core/algorithm/flat_sparse/flat_sparse_searcher_test.cc b/tests/core/algorithm/flat_sparse/flat_sparse_searcher_test.cc
index 5e06a06a6..709891993 100644
--- a/tests/core/algorithm/flat_sparse/flat_sparse_searcher_test.cc
+++ b/tests/core/algorithm/flat_sparse/flat_sparse_searcher_test.cc
@@ -250,13 +250,13 @@ TEST_F(FlatSparseSearcherTest, TestStreamerDump) {
   ASSERT_TRUE(searcher != nullptr);
   ASSERT_EQ(0, searcher->init(Params()));
   ASSERT_EQ(0, searcher->load(read_storage, IndexMetric::Pointer()));
-  auto linearCtx = searcher->create_context();
-  auto knnCtx = searcher->create_context();
+  auto linear_ctx = searcher->create_context();
+  auto knn_ctx = searcher->create_context();
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
 
   for (size_t i = 0; i < cnt; i += 50) {
     const auto &sparse_indices = sparse_indices_list[i];
@@ -265,33 +265,33 @@ TEST_F(FlatSparseSearcherTest, TestStreamerDump) {
     auto t1 = Realtime::MicroSeconds();
 
     ASSERT_EQ(0, searcher->search_impl(sparse_dim_count, sparse_indices.data(),
-                                       sparse_vec.data(), qmeta, knnCtx));
+                                       sparse_vec.data(), qmeta, knn_ctx));
 
     auto t2 = Realtime::MicroSeconds();
 
     ASSERT_EQ(0,
               searcher->search_bf_impl(sparse_dim_count, sparse_indices.data(),
-                                       sparse_vec.data(), qmeta, linearCtx));
+                                       sparse_vec.data(), qmeta, linear_ctx));
 
     auto t3 = Realtime::MicroSeconds();
 
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
-    auto &knnResult = knnCtx->result();
-    auto &linearResult = linearCtx->result();
+    auto &knn_result = knn_ctx->result();
+    auto &linear_result = linear_ctx->result();
 
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(topk, knnResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(topk, knn_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      ASSERT_EQ(linearResult[k].key(), knnResult[k].key());
+      ASSERT_EQ(linear_result[k].key(), knn_result[k].key());
     }
   }
 
-  printf("linear: %zu, knn: %zu\n", (size_t)linearTotalTime,
-         (size_t)knnTotalTime);
+  printf("linear: %zu, knn: %zu\n", (size_t)linear_total_time,
+         (size_t)knn_total_time);
 }
 
 TEST_F(FlatSparseSearcherTest, TestLoadClose) {
@@ -663,30 +663,30 @@ TEST_F(FlatSparseSearcherTest, TestMultiThread) {
   ASSERT_EQ(0, storage->open(dir_ + "TessKnnMultiThread", true));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto addVector = [&streamer](int baseKey, size_t addCnt) {
+  auto add_vector = [&streamer](int base_key, size_t add_cnt) {
     IndexQueryMeta qmeta(IndexMeta::DT_FP32);
-    size_t succAdd = 0;
+    size_t succ_add = 0;
     auto ctx = streamer->create_context();
-    for (size_t i = 0; i < addCnt; i++) {
+    for (size_t i = 0; i < add_cnt; i++) {
       NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
       NumericalVector<float> sparse_velues(sparse_dim_count);
 
       for (size_t j = 0; j < sparse_dim_count; ++j) {
         sparse_indices[j] = j * 20;
-        sparse_velues[j] = (float)i + baseKey;
+        sparse_velues[j] = (float)i + base_key;
       }
 
-      succAdd += !streamer->add_impl(baseKey + i, sparse_dim_count,
-                                     sparse_indices.data(),
-                                     sparse_velues.data(), qmeta, ctx);
+      succ_add += !streamer->add_impl(base_key + i, sparse_dim_count,
+                                      sparse_indices.data(),
+                                      sparse_velues.data(), qmeta, ctx);
     }
     streamer->flush(0UL);
-    return succAdd;
+    return succ_add;
   };
 
-  auto t2 = std::async(std::launch::async, addVector, 1000, 1000);
-  auto t3 = std::async(std::launch::async, addVector, 2000, 1000);
-  auto t1 = std::async(std::launch::async, addVector, 0, 1000);
+  auto t2 = std::async(std::launch::async, add_vector, 1000, 1000);
+  auto t3 = std::async(std::launch::async, add_vector, 2000, 1000);
+  auto t1 = std::async(std::launch::async, add_vector, 0, 1000);
   ASSERT_EQ(1000U, t1.get());
   ASSERT_EQ(1000U, t2.get());
   ASSERT_EQ(1000U, t3.get());
@@ -746,16 +746,16 @@ TEST_F(FlatSparseSearcherTest, TestMultiThread) {
   // ====== multi thread search
   size_t topk = 10;
   size_t cnt = 3000;
-  auto knnSearch = [&]() {
-    auto linearCtx = searcher->create_context();
-    auto linearByPkeysCtx = searcher->create_context();
+  auto knn_search = [&]() {
+    auto linear_ctx = searcher->create_context();
+    auto linear_by_pkeys_ctx = searcher->create_context();
     auto ctx = searcher->create_context();
     IndexQueryMeta qmeta(IndexMeta::DT_FP32);
-    linearCtx->set_topk(topk);
-    linearByPkeysCtx->set_topk(topk);
+    linear_ctx->set_topk(topk);
+    linear_by_pkeys_ctx->set_topk(topk);
     ctx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     for (size_t i = 0; i < cnt; i += 1) {
       NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
       NumericalVector<float> sparse_velues(sparse_dim_count);
@@ -770,22 +770,23 @@ TEST_F(FlatSparseSearcherTest, TestMultiThread) {
                                       sparse_velues.data(), qmeta, ctx));
       ASSERT_EQ(
           0, searcher->search_bf_impl(sparse_dim_count, sparse_indices.data(),
-                                      sparse_velues.data(), qmeta, linearCtx));
+                                      sparse_velues.data(), qmeta, linear_ctx));
       std::vector<std::vector<uint64_t>> p_keys = {{cnt - 1, cnt - 2, cnt - 3}};
-      ASSERT_EQ(0, searcher->search_bf_by_p_keys_impl(
-                       sparse_dim_count, sparse_indices.data(),
-                       sparse_velues.data(), p_keys, qmeta, linearByPkeysCtx));
+      ASSERT_EQ(
+          0, searcher->search_bf_by_p_keys_impl(
+                 sparse_dim_count, sparse_indices.data(), sparse_velues.data(),
+                 p_keys, qmeta, linear_by_pkeys_ctx));
       auto &r1 = ctx->result();
       ASSERT_EQ(topk, r1.size());
       // std::cout << "r1 top1: " << r1[0].key() << ", score: " << r1[0].score()
       //           << std::endl;
       ASSERT_EQ(cnt - 1, r1[0].key());
-      auto &r2 = linearCtx->result();
+      auto &r2 = linear_ctx->result();
       ASSERT_EQ(topk, r2.size());
       // std::cout << "r2 top1: " << r2[0].key() << ", score: " << r2[0].score()
       //           << std::endl;
       ASSERT_EQ(cnt - 1, r2[0].key());
-      auto &r3 = linearByPkeysCtx->result();
+      auto &r3 = linear_by_pkeys_ctx->result();
       ASSERT_EQ(std::min(topk, p_keys[0].size()), r3.size());
 #if 0
             printf("linear: %zd => %zd %zd %zd %zd %zd\n", i, r2[0].key,
@@ -794,22 +795,22 @@ TEST_F(FlatSparseSearcherTest, TestMultiThread) {
                    r1[2].key, r1[3].key, r1[4].key);
 #endif
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
           if (r2[j].key() == r1[k].key()) {
-            totalHits++;
+            total_hits++;
             break;
           }
         }
       }
     }
-    printf("%f\n", totalHits * 1.0f / totalCnts);
-    ASSERT_FLOAT_EQ(1.0f, totalHits * 1.0f / totalCnts);
+    printf("%f\n", total_hits * 1.0f / total_cnts);
+    ASSERT_FLOAT_EQ(1.0f, total_hits * 1.0f / total_cnts);
   };
 
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
-  auto s3 = std::async(std::launch::async, knnSearch);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
+  auto s3 = std::async(std::launch::async, knn_search);
   s1.wait();
   s2.wait();
   s3.wait();
diff --git a/tests/core/algorithm/flat_sparse/flat_sparse_streamer_buffer_test.cc b/tests/core/algorithm/flat_sparse/flat_sparse_streamer_buffer_test.cc
index 20e607190..92114ada1 100644
--- a/tests/core/algorithm/flat_sparse/flat_sparse_streamer_buffer_test.cc
+++ b/tests/core/algorithm/flat_sparse/flat_sparse_streamer_buffer_test.cc
@@ -145,23 +145,23 @@ TEST_F(FlatSparseStreamerTest, TestGeneral) {
   ASSERT_EQ(0, read_storage->open(dir_ + "Test/FlatSparseSearch", false));
   ASSERT_EQ(0, read_streamer->open(read_storage));
 
-  auto linearCtx = read_streamer->create_context();
-  ASSERT_TRUE(!!linearCtx);
+  auto linear_ctx = read_streamer->create_context();
+  ASSERT_TRUE(!!linear_ctx);
 
-  auto knnCtx = read_streamer->create_context();
-  ASSERT_TRUE(!!knnCtx);
+  auto knn_ctx = read_streamer->create_context();
+  ASSERT_TRUE(!!knn_ctx);
 
   // streamer->print_debug_info();
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
 
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
 
   for (size_t i = 0; i < cnt; i += 100) {
     const auto &sparse_indices = sparse_indices_list[i];
@@ -171,45 +171,45 @@ TEST_F(FlatSparseStreamerTest, TestGeneral) {
 
     ASSERT_EQ(
         0, read_streamer->search_impl(sparse_dim_count, sparse_indices.data(),
-                                      sparse_vec.data(), qmeta, knnCtx));
+                                      sparse_vec.data(), qmeta, knn_ctx));
 
     auto t2 = ailego::Realtime::MicroSeconds();
 
     ASSERT_EQ(0, read_streamer->search_bf_impl(
                      sparse_dim_count, sparse_indices.data(), sparse_vec.data(),
-                     qmeta, linearCtx));
+                     qmeta, linear_ctx));
 
     auto t3 = ailego::Realtime::MicroSeconds();
 
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
     // std::cout << "i: " << i << std::endl;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 100.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 100.0f / cnt;
   // float cost = linearTotalTime * 1.0f / knnTotalTime;
 
-  std::cout << "knnTotalTime=" << knnTotalTime
-            << " linearTotalTime=" << linearTotalTime << std::endl;
+  std::cout << "knnTotalTime=" << knn_total_time
+            << " linearTotalTime=" << linear_total_time << std::endl;
 
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
@@ -218,7 +218,7 @@ TEST_F(FlatSparseStreamerTest, TestGeneral) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.80f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
   // EXPECT_GT(cost, 2.0f);
 }
 
diff --git a/tests/core/algorithm/flat_sparse/flat_sparse_streamer_test.cc b/tests/core/algorithm/flat_sparse/flat_sparse_streamer_test.cc
index 90480dc85..28fd78982 100644
--- a/tests/core/algorithm/flat_sparse/flat_sparse_streamer_test.cc
+++ b/tests/core/algorithm/flat_sparse/flat_sparse_streamer_test.cc
@@ -376,7 +376,7 @@ TEST_F(FlatSparseStreamerTest, TestCreateIterator) {
   ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto checkIter = [](size_t total, IndexStreamer::Pointer &streamer) {
+  auto check_iter = [](size_t total, IndexStreamer::Pointer &streamer) {
     auto provider = streamer->create_sparse_provider();
     auto iter = provider->create_iterator();
     ASSERT_TRUE(!!iter);
@@ -407,7 +407,7 @@ TEST_F(FlatSparseStreamerTest, TestCreateIterator) {
 
     ASSERT_EQ(0, streamer->add_impl(i, sparse_dim_count, sparse_indices1.data(),
                                     sparse_velues1.data(), qmeta, ctx));
-    checkIter(i + 1, streamer);
+    check_iter(i + 1, streamer);
   }
 
   // check getVector
@@ -432,7 +432,7 @@ TEST_F(FlatSparseStreamerTest, TestCreateIterator) {
   streamer->flush(0UL);
   streamer->close();
   ASSERT_EQ(0, streamer->open(storage));
-  checkIter(cnt, streamer);
+  check_iter(cnt, streamer);
 
   // check getVector
   provider = streamer->create_sparse_provider();
@@ -474,8 +474,8 @@ TEST_F(FlatSparseStreamerTest, TestOpenAndClose) {
   ASSERT_EQ(0, storage2->init(stg_params));
   ASSERT_EQ(0, storage2->open(dir_ + "TessOpenAndClose2", true));
   ASSERT_EQ(0, streamer->init(meta, params));
-  auto checkIter = [](size_t base, size_t total,
-                      IndexStreamer::Pointer &streamer) {
+  auto check_iter = [](size_t base, size_t total,
+                       IndexStreamer::Pointer &streamer) {
     auto provider = streamer->create_sparse_provider();
     auto iter = provider->create_iterator();
     ASSERT_TRUE(!!iter);
@@ -494,9 +494,9 @@ TEST_F(FlatSparseStreamerTest, TestOpenAndClose) {
     ASSERT_EQ(cnt, total);
   };
 
-  size_t testCnt = 200;
+  size_t test_cnt = 200;
   IndexQueryMeta qmeta(IndexMeta::DT_FP32);
-  for (size_t i = 0; i < testCnt; i += 2) {
+  for (size_t i = 0; i < test_cnt; i += 2) {
     float v1 = (float)i;
     ASSERT_EQ(0, streamer->open(storage1));
     auto ctx = streamer->create_context();
@@ -512,7 +512,7 @@ TEST_F(FlatSparseStreamerTest, TestOpenAndClose) {
     ASSERT_EQ(0, streamer->add_impl(i, sparse_dim_count, sparse_indices1.data(),
                                     sparse_velues1.data(), qmeta, ctx));
 
-    checkIter(0, i / 2 + 1, streamer);
+    check_iter(0, i / 2 + 1, streamer);
     ASSERT_EQ(0, streamer->flush(0UL));
     ASSERT_EQ(0, streamer->close());
 
@@ -530,7 +530,7 @@ TEST_F(FlatSparseStreamerTest, TestOpenAndClose) {
     ASSERT_EQ(
         0, streamer->add_impl(i + 1, sparse_dim_count, sparse_indices2.data(),
                               sparse_velues2.data(), qmeta, ctx));
-    checkIter(1, i / 2 + 1, streamer);
+    check_iter(1, i / 2 + 1, streamer);
     ASSERT_EQ(0, streamer->flush(0UL));
     ASSERT_EQ(0, streamer->close());
   }
@@ -547,8 +547,8 @@ TEST_F(FlatSparseStreamerTest, TestOpenAndClose) {
   ASSERT_EQ(0, streamer2->init(meta, params));
   ASSERT_EQ(0, streamer2->open(storage2));
 
-  checkIter(0, testCnt / 2, streamer1);
-  checkIter(1, testCnt / 2, streamer2);
+  check_iter(0, test_cnt / 2, streamer1);
+  check_iter(1, test_cnt / 2, streamer2);
 }
 
 TEST_F(FlatSparseStreamerTest, TestNoInit) {
@@ -575,7 +575,7 @@ TEST_F(FlatSparseStreamerTest, TestForceFlush) {
   ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto checkIter = [](size_t total, IndexStreamer::Pointer &streamer) {
+  auto check_iter = [](size_t total, IndexStreamer::Pointer &streamer) {
     auto provider = streamer->create_sparse_provider();
     auto iter = provider->create_iterator();
     ASSERT_TRUE(!!iter);
@@ -611,7 +611,7 @@ TEST_F(FlatSparseStreamerTest, TestForceFlush) {
 
     ASSERT_EQ(0, streamer->add_impl(i, sparse_dim_count, sparse_indices.data(),
                                     sparse_velues.data(), qmeta, ctx));
-    checkIter(i + 1, streamer);
+    check_iter(i + 1, streamer);
   }
 
   streamer->flush(0UL);
@@ -623,7 +623,7 @@ TEST_F(FlatSparseStreamerTest, TestForceFlush) {
   ASSERT_EQ(0, storage->init(stg_params));
   ASSERT_EQ(0, storage->open(dir_ + "TestForceFlush", true));
   ASSERT_EQ(0, streamer->open(storage));
-  checkIter(cnt, streamer);
+  check_iter(cnt, streamer);
 
   // check getVector
   auto provider = streamer->create_sparse_provider();
@@ -662,30 +662,30 @@ TEST_F(FlatSparseStreamerTest, TestMultiThread) {
   ASSERT_EQ(0, storage->open(dir_ + "TessKnnMultiThread", true));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto addVector = [&streamer](int baseKey, size_t addCnt) {
+  auto add_vector = [&streamer](int base_key, size_t add_cnt) {
     IndexQueryMeta qmeta(IndexMeta::DT_FP32);
-    size_t succAdd = 0;
+    size_t succ_add = 0;
     auto ctx = streamer->create_context();
-    for (size_t i = 0; i < addCnt; i++) {
+    for (size_t i = 0; i < add_cnt; i++) {
       NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
       NumericalVector<float> sparse_velues(sparse_dim_count);
 
       for (size_t j = 0; j < sparse_dim_count; ++j) {
         sparse_indices[j] = j * 20;
-        sparse_velues[j] = (float)i + baseKey;
+        sparse_velues[j] = (float)i + base_key;
       }
 
-      succAdd += !streamer->add_impl(baseKey + i, sparse_dim_count,
-                                     sparse_indices.data(),
-                                     sparse_velues.data(), qmeta, ctx);
+      succ_add += !streamer->add_impl(base_key + i, sparse_dim_count,
+                                      sparse_indices.data(),
+                                      sparse_velues.data(), qmeta, ctx);
     }
     streamer->flush(0UL);
-    return succAdd;
+    return succ_add;
   };
 
-  auto t2 = std::async(std::launch::async, addVector, 1000, 1000);
-  auto t3 = std::async(std::launch::async, addVector, 2000, 1000);
-  auto t1 = std::async(std::launch::async, addVector, 0, 1000);
+  auto t2 = std::async(std::launch::async, add_vector, 1000, 1000);
+  auto t3 = std::async(std::launch::async, add_vector, 2000, 1000);
+  auto t1 = std::async(std::launch::async, add_vector, 0, 1000);
   ASSERT_EQ(1000U, t1.get());
   ASSERT_EQ(1000U, t2.get());
   ASSERT_EQ(1000U, t3.get());
@@ -726,16 +726,16 @@ TEST_F(FlatSparseStreamerTest, TestMultiThread) {
   // ====== multi thread search
   size_t topk = 10;
   size_t cnt = 3000;
-  auto knnSearch = [&]() {
-    auto linearCtx = streamer->create_context();
-    auto linearByPkeysCtx = streamer->create_context();
+  auto knn_search = [&]() {
+    auto linear_ctx = streamer->create_context();
+    auto linear_by_pkeys_ctx = streamer->create_context();
     auto ctx = streamer->create_context();
     IndexQueryMeta qmeta(IndexMeta::DT_FP32);
-    linearCtx->set_topk(topk);
-    linearByPkeysCtx->set_topk(topk);
+    linear_ctx->set_topk(topk);
+    linear_by_pkeys_ctx->set_topk(topk);
     ctx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     for (size_t i = 0; i < cnt; i += 1) {
       NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
       NumericalVector<float> sparse_velues(sparse_dim_count);
@@ -750,17 +750,18 @@ TEST_F(FlatSparseStreamerTest, TestMultiThread) {
                                       sparse_velues.data(), qmeta, ctx));
       ASSERT_EQ(
           0, streamer->search_bf_impl(sparse_dim_count, sparse_indices.data(),
-                                      sparse_velues.data(), qmeta, linearCtx));
+                                      sparse_velues.data(), qmeta, linear_ctx));
       std::vector<std::vector<uint64_t>> p_keys = {{cnt - 1, cnt - 2, cnt - 3}};
-      ASSERT_EQ(0, streamer->search_bf_by_p_keys_impl(
-                       sparse_dim_count, sparse_indices.data(),
-                       sparse_velues.data(), p_keys, qmeta, linearByPkeysCtx));
+      ASSERT_EQ(
+          0, streamer->search_bf_by_p_keys_impl(
+                 sparse_dim_count, sparse_indices.data(), sparse_velues.data(),
+                 p_keys, qmeta, linear_by_pkeys_ctx));
       auto &r1 = ctx->result();
       ASSERT_EQ(topk, r1.size());
-      auto &r2 = linearCtx->result();
+      auto &r2 = linear_ctx->result();
       ASSERT_EQ(topk, r2.size());
       ASSERT_EQ(cnt - 1, r2[0].key());
-      auto &r3 = linearByPkeysCtx->result();
+      auto &r3 = linear_by_pkeys_ctx->result();
       ASSERT_EQ(std::min(topk, p_keys[0].size()), r3.size());
 #if 0
             printf("linear: %zd => %zd %zd %zd %zd %zd\n", i, r2[0].key,
@@ -769,22 +770,22 @@ TEST_F(FlatSparseStreamerTest, TestMultiThread) {
                    r1[2].key, r1[3].key, r1[4].key);
 #endif
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
           if (r2[j].key() == r1[k].key()) {
-            totalHits++;
+            total_hits++;
             break;
           }
         }
       }
     }
-    printf("%f\n", totalHits * 1.0f / totalCnts);
-    ASSERT_FLOAT_EQ(1.0f, totalHits * 1.0f / totalCnts);
+    printf("%f\n", total_hits * 1.0f / total_cnts);
+    ASSERT_FLOAT_EQ(1.0f, total_hits * 1.0f / total_cnts);
   };
 
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
-  auto s3 = std::async(std::launch::async, knnSearch);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
+  auto s3 = std::async(std::launch::async, knn_search);
   s1.wait();
   s2.wait();
   s3.wait();
@@ -810,39 +811,39 @@ TEST_F(FlatSparseStreamerTest, TestConcurrentAddAndSearch) {
   ASSERT_EQ(0, storage->open(dir_ + "TessConcurrentAddAndSearch", true));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto addVector = [&streamer](int baseKey, size_t addCnt) {
+  auto add_vector = [&streamer](int base_key, size_t add_cnt) {
     IndexQueryMeta qmeta(IndexMeta::DT_FP32);
-    size_t succAdd = 0;
+    size_t succ_add = 0;
     auto ctx = streamer->create_context();
-    for (size_t i = 0; i < addCnt; i++) {
+    for (size_t i = 0; i < add_cnt; i++) {
       NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
       NumericalVector<float> sparse_velues(sparse_dim_count);
 
       for (size_t j = 0; j < sparse_dim_count; ++j) {
         sparse_indices[j] = j * 20;
-        sparse_velues[j] = (float)i + baseKey;
+        sparse_velues[j] = (float)i + base_key;
       }
 
-      succAdd += !streamer->add_impl(baseKey + i, sparse_dim_count,
-                                     sparse_indices.data(),
-                                     sparse_velues.data(), qmeta, ctx);
+      succ_add += !streamer->add_impl(base_key + i, sparse_dim_count,
+                                      sparse_indices.data(),
+                                      sparse_velues.data(), qmeta, ctx);
     }
     streamer->flush(0UL);
-    return succAdd;
+    return succ_add;
   };
 
-  auto knnSearch = [&]() {
+  auto knn_search = [&]() {
     size_t topk = 100;
     size_t cnt = 3000;
-    auto linearCtx = streamer->create_context();
-    auto linearByPkeysCtx = streamer->create_context();
+    auto linear_ctx = streamer->create_context();
+    auto linear_by_pkeys_ctx = streamer->create_context();
     auto ctx = streamer->create_context();
     IndexQueryMeta qmeta(IndexMeta::DT_FP32);
-    linearCtx->set_topk(topk);
-    linearByPkeysCtx->set_topk(topk);
+    linear_ctx->set_topk(topk);
+    linear_by_pkeys_ctx->set_topk(topk);
     ctx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     for (size_t i = 0; i < cnt; i += 1) {
       NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
       NumericalVector<float> sparse_velues(sparse_dim_count);
@@ -857,17 +858,18 @@ TEST_F(FlatSparseStreamerTest, TestConcurrentAddAndSearch) {
                                       sparse_velues.data(), qmeta, ctx));
       ASSERT_EQ(
           0, streamer->search_bf_impl(sparse_dim_count, sparse_indices.data(),
-                                      sparse_velues.data(), qmeta, linearCtx));
+                                      sparse_velues.data(), qmeta, linear_ctx));
       std::vector<std::vector<uint64_t>> p_keys = {{0, 1, 2}};
-      ASSERT_EQ(0, streamer->search_bf_by_p_keys_impl(
-                       sparse_dim_count, sparse_indices.data(),
-                       sparse_velues.data(), p_keys, qmeta, linearByPkeysCtx));
+      ASSERT_EQ(
+          0, streamer->search_bf_by_p_keys_impl(
+                 sparse_dim_count, sparse_indices.data(), sparse_velues.data(),
+                 p_keys, qmeta, linear_by_pkeys_ctx));
       auto &r1 = ctx->result();
       ASSERT_EQ(topk, r1.size());
-      auto &r2 = linearCtx->result();
+      auto &r2 = linear_ctx->result();
       ASSERT_EQ(topk, r2.size());
       ASSERT_EQ(0, r2[0].key());
-      auto &r3 = linearByPkeysCtx->result();
+      auto &r3 = linear_by_pkeys_ctx->result();
       ASSERT_EQ(std::min(topk, p_keys[0].size()), r3.size());
 #if 0
             printf("linear: %zd => %zd %zd %zd %zd %zd\n", i, r2[0].key,
@@ -876,25 +878,25 @@ TEST_F(FlatSparseStreamerTest, TestConcurrentAddAndSearch) {
                    r1[2].key, r1[3].key, r1[4].key);
 #endif
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
           if (r2[j].key() == r1[k].key()) {
-            totalHits++;
+            total_hits++;
             break;
           }
         }
       }
     }
-    printf("%f\n", totalHits * 1.0f / totalCnts);
-    ASSERT_TRUE(totalHits * 1.0f / totalCnts > 0.8f);
+    printf("%f\n", total_hits * 1.0f / total_cnts);
+    ASSERT_TRUE(total_hits * 1.0f / total_cnts > 0.8f);
   };
 
-  auto t0 = std::async(std::launch::async, addVector, 0, 1000);
+  auto t0 = std::async(std::launch::async, add_vector, 0, 1000);
   ASSERT_EQ(1000, t0.get());
-  auto t1 = std::async(std::launch::async, addVector, 1000, 1000);
-  auto t2 = std::async(std::launch::async, addVector, 2000, 1000);
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
+  auto t1 = std::async(std::launch::async, add_vector, 1000, 1000);
+  auto t2 = std::async(std::launch::async, add_vector, 2000, 1000);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
   ASSERT_EQ(1000, t1.get());
   ASSERT_EQ(1000, t2.get());
   s1.wait();
@@ -973,13 +975,13 @@ TEST_F(FlatSparseStreamerTest, TestFilter) {
   ASSERT_EQ(1, results[1].key());
   ASSERT_EQ(2, results[2].key());
 
-  auto filterFunc = [](uint64_t key) {
+  auto filter_func = [](uint64_t key) {
     if (key == 0UL || key == 3UL) {
       return true;
     }
     return false;
   };
-  ctx->set_filter(filterFunc);
+  ctx->set_filter(filter_func);
 
   // after set filter
   ASSERT_EQ(0, streamer->search_impl(sparse_dim_count, sparse_indices.data(),
@@ -1503,7 +1505,7 @@ TEST_F(FlatSparseStreamerTest, TestGroupBy) {
                                     sparse_velues.data(), qmeta, ctx));
   }
 
-  auto groupbyFunc = [](uint64_t key) {
+  auto groupby_func = [](uint64_t key) {
     uint32_t group_id = key / 10 % 10;
     // std::cout << "key: " << key << ", group id: " << group_id << std::endl;
     return std::string("g_") + std::to_string(group_id);
@@ -1512,7 +1514,7 @@ TEST_F(FlatSparseStreamerTest, TestGroupBy) {
   size_t group_topk = 200;
   size_t group_num = 5;
   ctx->set_group_params(group_num, group_topk);
-  ctx->set_group_by(groupbyFunc);
+  ctx->set_group_by(groupby_func);
 
   std::vector<std::string> expect_group_ids = {
       "g_0", "g_1", "g_2", "g_3", "g_4", "g_5", "g_6", "g_7", "g_8", "g_9"};
@@ -1578,7 +1580,7 @@ TEST_F(FlatSparseStreamerTest, TestGroupByNotEnoughNum) {
                                     sparse_velues.data(), qmeta, ctx));
   }
 
-  auto groupbyFunc = [](uint64_t key) {
+  auto groupby_func = [](uint64_t key) {
     uint32_t group_id = key / 10 % 10;
     // std::cout << "key: " << key << ", group id: " << group_id << std::endl;
     return std::string("g_") + std::to_string(group_id);
@@ -1587,7 +1589,7 @@ TEST_F(FlatSparseStreamerTest, TestGroupByNotEnoughNum) {
   size_t group_topk = 200;
   size_t group_num = 12;
   ctx->set_group_params(group_num, group_topk);
-  ctx->set_group_by(groupbyFunc);
+  ctx->set_group_by(groupby_func);
 
   std::vector<std::string> expect_group_ids = {
       "g_0", "g_1", "g_2", "g_3", "g_4", "g_5", "g_6", "g_7", "g_8", "g_9"};
@@ -1636,8 +1638,8 @@ TEST_F(FlatSparseStreamerTest, TestAddAndSearchWithID) {
   ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
   ASSERT_EQ(0, streamer->open(storage));
   auto ctx = streamer->create_context();
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   ASSERT_TRUE(!!ctx);
 
   constexpr size_t cnt = 1000U;
@@ -1667,13 +1669,13 @@ TEST_F(FlatSparseStreamerTest, TestAddAndSearchWithID) {
   }
   // streamer->print_debug_info();
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
   for (size_t i = 0; i < cnt; i += 100) {
     NumericalVector<uint32_t> query_sparse_indices(sparse_dim_count);
     NumericalVector<float> query_sparse_velues(sparse_dim_count);
@@ -1684,34 +1686,34 @@ TEST_F(FlatSparseStreamerTest, TestAddAndSearchWithID) {
     auto t1 = Realtime::MicroSeconds();
     ASSERT_EQ(
         0, streamer->search_impl(sparse_dim_count, query_sparse_indices.data(),
-                                 query_sparse_velues.data(), qmeta, knnCtx));
+                                 query_sparse_velues.data(), qmeta, knn_ctx));
     auto t2 = Realtime::MicroSeconds();
     ASSERT_EQ(0, streamer->search_bf_impl(
                      sparse_dim_count, query_sparse_indices.data(),
-                     query_sparse_velues.data(), qmeta, linearCtx));
+                     query_sparse_velues.data(), qmeta, linear_ctx));
     auto t3 = Realtime::MicroSeconds();
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
-  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 100.0f / cnt;
+  std::cout << "knnTotalTime: " << knn_total_time << std::endl;
+  std::cout << "linearTotalTime: " << linear_total_time << std::endl;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 100.0f / cnt;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
            "R@%zd=%f R@1=%f cost=%f\n",
@@ -1719,7 +1721,7 @@ TEST_F(FlatSparseStreamerTest, TestAddAndSearchWithID) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.80f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
 }
 
 #if defined(__GNUC__) || defined(__GNUG__)
diff --git a/tests/core/algorithm/hnsw/hnsw_dist_calculator_test.cc b/tests/core/algorithm/hnsw/hnsw_dist_calculator_test.cc
index d2ebf9d8e..06ef53fb7 100644
--- a/tests/core/algorithm/hnsw/hnsw_dist_calculator_test.cc
+++ b/tests/core/algorithm/hnsw/hnsw_dist_calculator_test.cc
@@ -156,7 +156,7 @@ TEST(HnswDistCalculatorTest, ContextPassesInlineTailForSingleNodeBatch) {
 }
 
 TEST(HnswDistCalculatorTest, PassesNullWhenMetricHasNoExtraValues) {
-  InlineVectorHnswEntity entity({{}});
+  InlineVectorHnswEntity entity(std::vector<InlineVectorHnswEntity::Record>(1));
   auto metric = CreateMetric();
   ASSERT_NE(nullptr, metric);
 
diff --git a/tests/core/algorithm/hnsw/hnsw_streamer_test.cc b/tests/core/algorithm/hnsw/hnsw_streamer_test.cc
index 6d1a18e11..d6bae6dfd 100644
--- a/tests/core/algorithm/hnsw/hnsw_streamer_test.cc
+++ b/tests/core/algorithm/hnsw/hnsw_streamer_test.cc
@@ -331,48 +331,48 @@ TEST_F(HnswStreamerTest, TestKnnSearch) {
     streamer->add_impl(i, vec.data(), qmeta, ctx);
   }
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  [[maybe_unused]] uint64_t knnTotalTime = 0;
-  [[maybe_unused]] uint64_t linearTotalTime = 0;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  [[maybe_unused]] uint64_t knn_total_time = 0;
+  [[maybe_unused]] uint64_t linear_total_time = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
   for (size_t i = 0; i < cnt; i++) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
     auto t1 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
     auto t2 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
     auto t3 = ailego::Realtime::MicroSeconds();
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 1.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 1.0f / cnt;
   // float cost = linearTotalTime * 1.0f / knnTotalTime;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
@@ -381,7 +381,7 @@ TEST_F(HnswStreamerTest, TestKnnSearch) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.95f);
+  EXPECT_GT(topk1_recall, 0.95f);
   // // EXPECT_GT(cost, 2.0f);
 }
 
@@ -424,46 +424,46 @@ TEST_F(HnswStreamerTest, TestBuildFromOriginalVectorProvider) {
   }
   streamer->flush(0UL);
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
-  int queryCnt = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
+  int query_cnt = 0;
   NumericalVector<float> vec(dim);
   for (size_t i = 0; i < cnt; i += 10) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
-    queryCnt++;
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
+    query_cnt++;
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 1.0f / queryCnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 1.0f / query_cnt;
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.95f);
+  EXPECT_GT(topk1_recall, 0.95f);
 }
 
 TEST_F(HnswStreamerTest, TestBuildFromProviderWithMismatchedMeta) {
@@ -520,45 +520,45 @@ TEST_F(HnswStreamerTest, TestBuildFromProviderWithMismatchedMeta) {
   }
   streamer->flush(0UL);
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   size_t topk = 100;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
-  int queryCnt = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
+  int query_cnt = 0;
   for (size_t i = 0; i < cnt; i += 10) {
     for (size_t j = 0; j < dim; ++j) {
       fp16_vec[j] = ailego::FloatHelper::ToFP16(i * scale);
     }
-    ASSERT_EQ(0, streamer->search_impl(fp16_vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, streamer->search_bf_impl(fp16_vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_impl(fp16_vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, streamer->search_bf_impl(fp16_vec.data(), qmeta, linear_ctx));
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
-    queryCnt++;
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
+    query_cnt++;
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 1.0f / queryCnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 1.0f / query_cnt;
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.95f);
+  EXPECT_GT(topk1_recall, 0.95f);
 }
 
 TEST_F(HnswStreamerTest, TestBuildFromProviderWithDifferentMetric) {
@@ -604,46 +604,46 @@ TEST_F(HnswStreamerTest, TestBuildFromProviderWithDifferentMetric) {
   }
   streamer->flush(0UL);
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   size_t topk = 100;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
-  int queryCnt = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
+  int query_cnt = 0;
   NumericalVector<float> query(dim);
   for (size_t i = 0; i < cnt; i += 10) {
     for (size_t j = 0; j < dim; ++j) {
       query[j] = i;
     }
-    ASSERT_EQ(0, streamer->search_impl(query.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, streamer->search_bf_impl(query.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_impl(query.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, streamer->search_bf_impl(query.data(), qmeta, linear_ctx));
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
-    queryCnt++;
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
+    query_cnt++;
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 1.0f / queryCnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 1.0f / query_cnt;
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.95f);
+  EXPECT_GT(topk1_recall, 0.95f);
 }
 
 TEST_F(HnswStreamerTest, TestBuildFromProviderAddWithId) {
@@ -690,45 +690,45 @@ TEST_F(HnswStreamerTest, TestBuildFromProviderAddWithId) {
   }
   streamer->flush(0UL);
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   size_t topk = 100;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
-  int queryCnt = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
+  int query_cnt = 0;
   for (size_t i = 0; i < cnt; i += 10) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
-    queryCnt++;
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
+    query_cnt++;
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 1.0f / queryCnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 1.0f / query_cnt;
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.95f);
+  EXPECT_GT(topk1_recall, 0.95f);
 }
 
 TEST_F(HnswStreamerTest, TestBuildFromProviderMissingKey) {
@@ -788,17 +788,17 @@ TEST_F(HnswStreamerTest, TestBuildFromProviderMissingKey) {
   EXPECT_EQ(1UL, streamer->stats().discarded_count());
 
   // the rejected vector must not appear in brute force results
-  auto linearCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
   size_t topk = 10;
-  linearCtx->set_topk(topk);
+  linear_ctx->set_topk(topk);
   for (size_t j = 0; j < dim; ++j) {
     vec[j] = missing_key;
   }
-  ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
-  auto &linearResult = linearCtx->result();
-  ASSERT_EQ(topk, linearResult.size());
+  ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
+  auto &linear_result = linear_ctx->result();
+  ASSERT_EQ(topk, linear_result.size());
   for (size_t k = 0; k < topk; ++k) {
-    EXPECT_NE(missing_key, linearResult[k].key());
+    EXPECT_NE(missing_key, linear_result[k].key());
   }
 }
 
@@ -848,8 +848,8 @@ TEST_F(HnswStreamerTest, TestAddAndSearch) {
   NumericalVector<float> vec(dim);
   size_t cnt = 20000U;
   auto ctx = streamer->create_context();
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   ASSERT_TRUE(!!ctx);
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
   for (size_t i = 0; i < cnt; i++) {
@@ -862,45 +862,45 @@ TEST_F(HnswStreamerTest, TestAddAndSearch) {
   // streamer->print_debug_info();
 
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  [[maybe_unused]] uint64_t knnTotalTime = 0;
-  [[maybe_unused]] uint64_t linearTotalTime = 0;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  [[maybe_unused]] uint64_t knn_total_time = 0;
+  [[maybe_unused]] uint64_t linear_total_time = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
   for (size_t i = 0; i < cnt; i += 100) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
     auto t1 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
     auto t2 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
     auto t3 = ailego::Realtime::MicroSeconds();
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 100.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 100.0f / cnt;
   // float cost = linearTotalTime * 1.0f / knnTotalTime;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
@@ -909,7 +909,7 @@ TEST_F(HnswStreamerTest, TestAddAndSearch) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.80f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
   // EXPECT_GT(cost, 2.0f);
 }
 
@@ -1002,52 +1002,52 @@ TEST_F(HnswStreamerTest, TestKnnSearchRandomData) {
     streamer->add_impl(i + cnt, vec.data(), qmeta, ctx);
   }
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   size_t topk = 100;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
   cnt = 500;
   for (size_t i = 0; i < cnt; i += 1) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
     }
     auto t1 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
     auto t2 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
     auto t3 = ailego::Realtime::MicroSeconds();
-    knnTotalTime += t3 - t2;
-    linearTotalTime += t2 - t1;
+    knn_total_time += t3 - t2;
+    linear_total_time += t2 - t1;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
 
-    topk1Hits += linearResult[0].key() == knnResult[0].key();
+    topk1_hits += linear_result[0].key() == knn_result[0].key();
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
 
-  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
-  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
+  std::cout << "knnTotalTime: " << knn_total_time << std::endl;
+  std::cout << "linearTotalTime: " << linear_total_time << std::endl;
 
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 1.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 1.0f / cnt;
   // float cost = linearTotalTime * 1.0f / knnTotalTime;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
@@ -1056,7 +1056,7 @@ TEST_F(HnswStreamerTest, TestKnnSearchRandomData) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.50f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
   // EXPECT_GT(cost, 5.0f);
 }
 
@@ -1081,8 +1081,8 @@ TEST_F(HnswStreamerTest, TestOpenClose) {
   ASSERT_EQ(0, storage2->init(stg_params));
   ASSERT_EQ(0, storage2->open(dir_ + "TessOpenAndClose2", true));
   ASSERT_EQ(0, streamer->init(meta, params));
-  auto checkIter = [](size_t base, size_t total,
-                      IndexStreamer::Pointer &streamer) {
+  auto check_iter = [](size_t base, size_t total,
+                       IndexStreamer::Pointer &streamer) {
     auto provider = streamer->create_provider();
     auto iter = provider->create_iterator();
     ASSERT_TRUE(!!iter);
@@ -1101,9 +1101,9 @@ TEST_F(HnswStreamerTest, TestOpenClose) {
     ASSERT_EQ(cnt, total);
   };
 
-  size_t testCnt = 200;
+  size_t test_cnt = 200;
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
-  for (size_t i = 0; i < testCnt; i += 2) {
+  for (size_t i = 0; i < test_cnt; i += 2) {
     float v1 = (float)i;
     ASSERT_EQ(0, streamer->open(storage1));
     auto ctx = streamer->create_context();
@@ -1113,7 +1113,7 @@ TEST_F(HnswStreamerTest, TestOpenClose) {
       vec1[d] = v1;
     }
     ASSERT_EQ(0, streamer->add_impl(i, vec1.data(), qmeta, ctx));
-    checkIter(0, i / 2 + 1, streamer);
+    check_iter(0, i / 2 + 1, streamer);
     ASSERT_EQ(0, streamer->flush(0UL));
     ASSERT_EQ(0, streamer->close());
 
@@ -1126,7 +1126,7 @@ TEST_F(HnswStreamerTest, TestOpenClose) {
     ctx = streamer->create_context();
     ASSERT_TRUE(!!ctx);
     ASSERT_EQ(0, streamer->add_impl(i + 1, vec2.data(), qmeta, ctx));
-    checkIter(1, i / 2 + 1, streamer);
+    check_iter(1, i / 2 + 1, streamer);
     ASSERT_EQ(0, streamer->flush(0UL));
     ASSERT_EQ(0, streamer->close());
   }
@@ -1143,8 +1143,8 @@ TEST_F(HnswStreamerTest, TestOpenClose) {
   ASSERT_EQ(0, streamer2->init(meta, params));
   ASSERT_EQ(0, streamer2->open(storage2));
 
-  checkIter(0, testCnt / 2, streamer1);
-  checkIter(1, testCnt / 2, streamer2);
+  check_iter(0, test_cnt / 2, streamer1);
+  check_iter(1, test_cnt / 2, streamer2);
 }
 
 TEST_F(HnswStreamerTest, TestCreateIterator) {
@@ -1164,7 +1164,7 @@ TEST_F(HnswStreamerTest, TestCreateIterator) {
   ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto checkIter = [](size_t total, IndexStreamer::Pointer &streamer) {
+  auto check_iter = [](size_t total, IndexStreamer::Pointer &streamer) {
     auto provider = streamer->create_provider();
     auto iter = provider->create_iterator();
     ASSERT_TRUE(!!iter);
@@ -1191,13 +1191,13 @@ TEST_F(HnswStreamerTest, TestCreateIterator) {
       vec[j] = i;
     }
     streamer->add_impl(i, vec.data(), qmeta, ctx);
-    checkIter(i + 1, streamer);
+    check_iter(i + 1, streamer);
   }
 
   streamer->flush(0UL);
   streamer->close();
   ASSERT_EQ(0, streamer->open(storage));
-  checkIter(cnt, streamer);
+  check_iter(cnt, streamer);
 
   // check getVector
   auto provider = streamer->create_provider();
@@ -1237,7 +1237,7 @@ TEST_F(HnswStreamerTest, TestForceFlush) {
   ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto checkIter = [](size_t total, IndexStreamer::Pointer &streamer) {
+  auto check_iter = [](size_t total, IndexStreamer::Pointer &streamer) {
     auto provider = streamer->create_provider();
     auto iter = provider->create_iterator();
     ASSERT_TRUE(!!iter);
@@ -1264,7 +1264,7 @@ TEST_F(HnswStreamerTest, TestForceFlush) {
       vec[j] = i;
     }
     streamer->add_impl(i, vec.data(), qmeta, ctx);
-    checkIter(i + 1, streamer);
+    check_iter(i + 1, streamer);
   }
 
   streamer->flush(0UL);
@@ -1276,7 +1276,7 @@ TEST_F(HnswStreamerTest, TestForceFlush) {
   ASSERT_EQ(0, storage->init(stg_params));
   ASSERT_EQ(0, storage->open(dir_ + "TestForceFlush", true));
   ASSERT_EQ(0, streamer->open(storage));
-  checkIter(cnt, streamer);
+  check_iter(cnt, streamer);
 
   // check getVector
   auto provider = streamer->create_provider();
@@ -1313,23 +1313,23 @@ TEST_F(HnswStreamerTest, TestKnnMultiThread) {
   ASSERT_EQ(0, storage->open(dir_ + "TessKnnMultiThread", true));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto addVector = [&streamer](int baseKey, size_t addCnt) {
+  auto add_vector = [&streamer](int base_key, size_t add_cnt) {
     NumericalVector<float> vec(dim);
     IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
-    size_t succAdd = 0;
+    size_t succ_add = 0;
     auto ctx = streamer->create_context();
-    for (size_t i = 0; i < addCnt; i++) {
+    for (size_t i = 0; i < add_cnt; i++) {
       for (size_t j = 0; j < dim; ++j) {
-        vec[j] = (float)i + baseKey;
+        vec[j] = (float)i + base_key;
       }
-      succAdd += !streamer->add_impl(baseKey + i, vec.data(), qmeta, ctx);
+      succ_add += !streamer->add_impl(base_key + i, vec.data(), qmeta, ctx);
     }
     streamer->flush(0UL);
-    return succAdd;
+    return succ_add;
   };
-  auto t2 = std::async(std::launch::async, addVector, 1000, 1000);
-  auto t3 = std::async(std::launch::async, addVector, 2000, 1000);
-  auto t1 = std::async(std::launch::async, addVector, 0, 1000);
+  auto t2 = std::async(std::launch::async, add_vector, 1000, 1000);
+  auto t3 = std::async(std::launch::async, add_vector, 2000, 1000);
+  auto t1 = std::async(std::launch::async, add_vector, 0, 1000);
   ASSERT_EQ(1000U, t1.get());
   ASSERT_EQ(1000U, t2.get());
   ASSERT_EQ(1000U, t3.get());
@@ -1360,32 +1360,32 @@ TEST_F(HnswStreamerTest, TestKnnMultiThread) {
   // ====== multi thread search
   size_t topk = 100;
   size_t cnt = 3000;
-  auto knnSearch = [&]() {
+  auto knn_search = [&]() {
     NumericalVector<float> vec(dim);
-    auto linearCtx = streamer->create_context();
-    auto linearByPkeysCtx = streamer->create_context();
+    auto linear_ctx = streamer->create_context();
+    auto linear_by_pkeys_ctx = streamer->create_context();
     auto ctx = streamer->create_context();
     IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
-    linearCtx->set_topk(topk);
-    linearByPkeysCtx->set_topk(topk);
+    linear_ctx->set_topk(topk);
+    linear_by_pkeys_ctx->set_topk(topk);
     ctx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     for (size_t i = 0; i < cnt; i += 1) {
       for (size_t j = 0; j < dim; ++j) {
         vec[j] = i + 0.1f;
       }
       ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, ctx));
-      ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+      ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
       std::vector<std::vector<uint64_t>> p_keys = {{0, 1, 2}};
       ASSERT_EQ(0, streamer->search_bf_by_p_keys_impl(vec.data(), p_keys, qmeta,
-                                                      linearByPkeysCtx));
+                                                      linear_by_pkeys_ctx));
       auto &r1 = ctx->result();
       ASSERT_EQ(topk, r1.size());
-      auto &r2 = linearCtx->result();
+      auto &r2 = linear_ctx->result();
       ASSERT_EQ(topk, r2.size());
       ASSERT_EQ(i, r2[0].key());
-      auto &r3 = linearByPkeysCtx->result();
+      auto &r3 = linear_by_pkeys_ctx->result();
       ASSERT_EQ(std::min(topk, p_keys[0].size()), r3.size());
 #if 0
             printf("linear: %zd => %zd %zd %zd %zd %zd\n", i, r2[0].key,
@@ -1394,21 +1394,21 @@ TEST_F(HnswStreamerTest, TestKnnMultiThread) {
                    r1[2].key, r1[3].key, r1[4].key);
 #endif
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
           if (r2[j].key() == r1[k].key()) {
-            totalHits++;
+            total_hits++;
             break;
           }
         }
       }
     }
     // printf("%f\n", totalHits * 1.0f / totalCnts);
-    ASSERT_TRUE((totalHits * 1.0f / totalCnts) > 0.80f);
+    ASSERT_TRUE((total_hits * 1.0f / total_cnts) > 0.80f);
   };
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
-  auto s3 = std::async(std::launch::async, knnSearch);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
+  auto s3 = std::async(std::launch::async, knn_search);
   s1.wait();
   s2.wait();
   s3.wait();
@@ -1439,49 +1439,49 @@ TEST_F(HnswStreamerTest, TestKnnConcurrentAddAndSearch) {
   ASSERT_EQ(0, storage->open(dir_ + "TessKnnConcurrentAddAndSearch", true));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto addVector = [&streamer](int baseKey, size_t addCnt) {
+  auto add_vector = [&streamer](int base_key, size_t add_cnt) {
     NumericalVector<float> vec(dim);
     IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
     auto ctx = streamer->create_context();
-    size_t succAdd = 0;
-    for (size_t i = 0; i < addCnt; i++) {
+    size_t succ_add = 0;
+    for (size_t i = 0; i < add_cnt; i++) {
       for (size_t j = 0; j < dim; ++j) {
-        vec[j] = (float)i + baseKey;
+        vec[j] = (float)i + base_key;
       }
-      succAdd += !streamer->add_impl(baseKey + i, vec.data(), qmeta, ctx);
+      succ_add += !streamer->add_impl(base_key + i, vec.data(), qmeta, ctx);
     }
     streamer->flush(0UL);
-    return succAdd;
+    return succ_add;
   };
 
   // ====== multi thread search
-  auto knnSearch = [&]() {
+  auto knn_search = [&]() {
     size_t topk = 100;
     size_t cnt = 3000;
     NumericalVector<float> vec(dim);
-    auto linearCtx = streamer->create_context();
-    auto linearByPKeysCtx = streamer->create_context();
+    auto linear_ctx = streamer->create_context();
+    auto linear_by_p_keys_ctx = streamer->create_context();
     auto ctx = streamer->create_context();
-    linearCtx->set_topk(topk);
-    linearByPKeysCtx->set_topk(topk);
+    linear_ctx->set_topk(topk);
+    linear_by_p_keys_ctx->set_topk(topk);
     ctx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
     for (size_t i = 0; i < cnt; i += 1) {
       for (size_t j = 0; j < dim; ++j) {
         vec[j] = i + 0.1f;
       }
       ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, ctx));
-      ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+      ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
       std::vector<std::vector<uint64_t>> p_keys = {{0, 1, 2}};
       ASSERT_EQ(0, streamer->search_bf_by_p_keys_impl(vec.data(), p_keys, qmeta,
-                                                      linearByPKeysCtx));
+                                                      linear_by_p_keys_ctx));
       auto &r1 = ctx->result();
       ASSERT_EQ(topk, r1.size());
-      auto &r2 = linearCtx->result();
+      auto &r2 = linear_ctx->result();
       ASSERT_EQ(topk, r2.size());
-      auto &r3 = linearByPKeysCtx->result();
+      auto &r3 = linear_by_p_keys_ctx->result();
       ASSERT_EQ(std::min(topk, p_keys[0].size()), r3.size());
 // ASSERT_EQ(i, r2[0].key);
 #if 0
@@ -1491,24 +1491,24 @@ TEST_F(HnswStreamerTest, TestKnnConcurrentAddAndSearch) {
                    r1[2].key, r1[3].key, r1[4].key);
 #endif
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
           if (r2[j].key() == r1[k].key()) {
-            totalHits++;
+            total_hits++;
             break;
           }
         }
       }
     }
     //        printf("%f\n", totalHits * 1.0f / totalCnts);
-    ASSERT_TRUE((totalHits * 1.0f / totalCnts) > 0.80f);
+    ASSERT_TRUE((total_hits * 1.0f / total_cnts) > 0.80f);
   };
-  auto t0 = std::async(std::launch::async, addVector, 0, 1000);
+  auto t0 = std::async(std::launch::async, add_vector, 0, 1000);
   ASSERT_EQ(1000, t0.get());
-  auto t1 = std::async(std::launch::async, addVector, 1000, 1000);
-  auto t2 = std::async(std::launch::async, addVector, 2000, 1000);
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
+  auto t1 = std::async(std::launch::async, add_vector, 1000, 1000);
+  auto t2 = std::async(std::launch::async, add_vector, 2000, 1000);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
   ASSERT_EQ(1000, t1.get());
   ASSERT_EQ(1000, t2.get());
   s1.wait();
@@ -1654,13 +1654,13 @@ TEST_F(HnswStreamerTest, TestFilter) {
   ASSERT_EQ(101, results[1].key());
   ASSERT_EQ(99, results[2].key());
 
-  auto filterFunc = [](uint64_t key) {
+  auto filter_func = [](uint64_t key) {
     if (key == 100UL || key == 101UL) {
       return true;
     }
     return false;
   };
-  ctx->set_filter(filterFunc);
+  ctx->set_filter(filter_func);
 
   // after set filter
   ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, ctx));
@@ -1719,10 +1719,10 @@ TEST_F(HnswStreamerTest, TestMaxIndexSize) {
   }
 
   NumericalVector<float> vec(dim);
-  size_t writeCnt1 = 10000;
+  size_t write_cnt1 = 10000;
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
   auto ctx = streamer->create_context();
-  for (size_t i = 0; i < writeCnt1; i++) {
+  for (size_t i = 0; i < write_cnt1; i++) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i;
     }
@@ -1732,8 +1732,8 @@ TEST_F(HnswStreamerTest, TestMaxIndexSize) {
   size_t rss1 = 0;
   ailego::MemoryHelper::SelfUsage(&vsz1, &rss1);
   size_t increment1 = rss1 - rss0;
-  ASSERT_GT(writeCnt1 * 128 * 4 + writeCnt1 * 100 * 4, increment1 * 0.8f);
-  ASSERT_LT(writeCnt1 * 128 * 4 + writeCnt1 * 100 * 4, increment1 * 1.2f);
+  ASSERT_GT(write_cnt1 * 128 * 4 + write_cnt1 * 100 * 4, increment1 * 0.8f);
+  ASSERT_LT(write_cnt1 * 128 * 4 + write_cnt1 * 100 * 4, increment1 * 1.2f);
 
   streamer->flush(0UL);
   streamer.reset();
@@ -1798,17 +1798,17 @@ TEST_F(HnswStreamerTest, TestIndexSizeQuota) {
   ASSERT_EQ(0, streamer->init(meta, params));
   ASSERT_EQ(0, streamer->open(storage));
   NumericalVector<float> vec(dim);
-  size_t writeCnt1 = 850;
+  size_t write_cnt1 = 850;
   int ret = 0;
   auto ctx = streamer->create_context();
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
-  for (size_t i = 0; i < writeCnt1; i++) {
+  for (size_t i = 0; i < write_cnt1; i++) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i;
     }
-    int iRet = streamer->add_impl(i, vec.data(), qmeta, ctx);
-    if (iRet != 0) {
-      ret = iRet;
+    int i_ret = streamer->add_impl(i, vec.data(), qmeta, ctx);
+    if (i_ret != 0) {
+      ret = i_ret;
     }
   }
   ASSERT_EQ(IndexError_IndexFull, ret);
@@ -1969,10 +1969,10 @@ TEST_F(HnswStreamerTest, TestCheckStats) {
   ASSERT_EQ(0u, stats.index_size() % ailego::MemoryHelper::PageSize());
   ASSERT_EQ(0U, stats.dumped_size());
   ASSERT_EQ(0U, stats.check_point());
-  auto createTime = stats.create_time();
-  auto updateTime = stats.update_time();
-  ASSERT_GT(createTime, 0UL);
-  ASSERT_EQ(createTime, updateTime);
+  auto create_time = stats.create_time();
+  auto update_time = stats.update_time();
+  ASSERT_GT(create_time, 0UL);
+  ASSERT_EQ(create_time, update_time);
 
   NumericalVector<float> vec(dim);
   auto ctx = streamer->create_context();
@@ -1996,8 +1996,8 @@ TEST_F(HnswStreamerTest, TestCheckStats) {
   ASSERT_GT(size3, size2);
   LOG_INFO("size1=%zu size2=%zu size3=%zu", size1, size2, size3);
 
-  uint64_t checkPoint = 23423UL;
-  streamer->flush(checkPoint);
+  uint64_t check_point = 23423UL;
+  streamer->flush(check_point);
   size_t size4 = stats.index_size();
   ASSERT_EQ(size3, size4);
   auto stats1 = streamer->stats();
@@ -2007,11 +2007,11 @@ TEST_F(HnswStreamerTest, TestCheckStats) {
   ASSERT_EQ(0U, stats1.discarded_count());
   ASSERT_GT(stats1.index_size(), 0U);
   ASSERT_EQ(0U, stats1.dumped_size());
-  ASSERT_EQ(checkPoint, stats1.check_point());
-  auto createTime1 = stats1.create_time();
-  auto updateTime1 = stats1.update_time();
-  ASSERT_GE(updateTime1, createTime1);
-  ASSERT_EQ(createTime, createTime1);
+  ASSERT_EQ(check_point, stats1.check_point());
+  auto create_time1 = stats1.create_time();
+  auto update_time1 = stats1.update_time();
+  ASSERT_GE(update_time1, create_time1);
+  ASSERT_EQ(create_time, create_time1);
   streamer->close();
 
   ASSERT_EQ(0, streamer->open(storage));
@@ -2025,14 +2025,14 @@ TEST_F(HnswStreamerTest, TestCheckStats) {
   ASSERT_EQ(0U, stats2.discarded_count());
   ASSERT_GT(stats1.index_size(), 0);
   ASSERT_EQ(0U, stats2.dumped_size());
-  ASSERT_EQ(checkPoint, stats2.check_point());
-  auto createTime2 = stats2.create_time();
-  auto updateTime2 = stats2.update_time();
-  ASSERT_EQ(createTime2, createTime1);
-  ASSERT_GE(updateTime2, updateTime1);
+  ASSERT_EQ(check_point, stats2.check_point());
+  auto create_time2 = stats2.create_time();
+  auto update_time2 = stats2.update_time();
+  ASSERT_EQ(create_time2, create_time1);
+  ASSERT_GE(update_time2, update_time1);
 
   sleep(1);
-  streamer->flush(checkPoint + 1);
+  streamer->flush(check_point + 1);
   ASSERT_NE(0, streamer->add_impl(0U, vec.data(), qmeta, ctx));
   auto &stats3 = streamer->stats();
   ASSERT_EQ(2U, stats3.revision_id());
@@ -2041,11 +2041,11 @@ TEST_F(HnswStreamerTest, TestCheckStats) {
   ASSERT_EQ(1U, stats3.discarded_count());
   ASSERT_EQ(stats2.index_size(), stats3.index_size());
   ASSERT_EQ(0U, stats3.dumped_size());
-  ASSERT_EQ(checkPoint + 1, stats3.check_point());
-  auto createTime3 = stats3.create_time();
-  auto updateTime3 = stats3.update_time();
-  ASSERT_EQ(createTime3, createTime1);
-  ASSERT_GT(updateTime3, updateTime2);
+  ASSERT_EQ(check_point + 1, stats3.check_point());
+  auto create_time3 = stats3.create_time();
+  auto update_time3 = stats3.update_time();
+  ASSERT_EQ(create_time3, create_time1);
+  ASSERT_GT(update_time3, update_time2);
 
   auto dpath = dir_ + "dumpIndex";
   auto dumper = IndexFactory::CreateDumper("FileDumper");
@@ -2157,7 +2157,7 @@ TEST_F(HnswStreamerTest, TestDumpIndexAndAdd) {
   ASSERT_NE(nullptr, ctx);
   int code = 0;
   std::atomic<bool> async_started{false};
-  auto addVector = [&](int a, int b, bool signal_start) {
+  auto add_vector = [&](int a, int b, bool signal_start) {
     int success = 0;
     if (signal_start) {
       async_started.store(true, std::memory_order_release);
@@ -2178,8 +2178,8 @@ TEST_F(HnswStreamerTest, TestDumpIndexAndAdd) {
     }
     std::cout << "addVector: " << success << " success" << std::endl;
   };
-  addVector(0, 2000, false);
-  auto t2 = std::async(std::launch::async, addVector, 2000, 3000, true);
+  add_vector(0, 2000, false);
+  auto t2 = std::async(std::launch::async, add_vector, 2000, 3000, true);
   auto path1 = dir_ + "dumpIndex1";
   auto dumper1 = IndexFactory::CreateDumper("FileDumper");
   ASSERT_NE(dumper1, nullptr);
@@ -2509,24 +2509,24 @@ TEST_F(HnswStreamerTest, TestBruteForceSetupInContext) {
   }
 
   size_t topk = 200;
-  [[maybe_unused]] uint64_t knnTotalTime = 0;
-  [[maybe_unused]] uint64_t linearTotalTime = 0;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  [[maybe_unused]] uint64_t knn_total_time = 0;
+  [[maybe_unused]] uint64_t linear_total_time = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
 
   bool set_bf_threshold = false;
   bool use_update = false;
 
   for (size_t i = 0; i < cnt; i++) {
-    auto linearCtx = streamer->create_context();
-    auto knnCtx = streamer->create_context();
+    auto linear_ctx = streamer->create_context();
+    auto knn_ctx = streamer->create_context();
 
-    ASSERT_TRUE(!!linearCtx);
-    ASSERT_TRUE(!!linearCtx);
+    ASSERT_TRUE(!!linear_ctx);
+    ASSERT_TRUE(!!linear_ctx);
 
-    linearCtx->set_topk(topk);
-    knnCtx->set_topk(topk);
+    linear_ctx->set_topk(topk);
+    knn_ctx->set_topk(topk);
 
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
@@ -2535,53 +2535,53 @@ TEST_F(HnswStreamerTest, TestBruteForceSetupInContext) {
 
     if (set_bf_threshold) {
       if (use_update) {
-        ailego::Params streamerParamsExtra;
+        ailego::Params streamer_params_extra;
 
-        streamerParamsExtra.set("proxima.hnsw.streamer.brute_force_threshold",
-                                cnt);
-        knnCtx->update(streamerParamsExtra);
+        streamer_params_extra.set("proxima.hnsw.streamer.brute_force_threshold",
+                                  cnt);
+        knn_ctx->update(streamer_params_extra);
       } else {
-        knnCtx->set_bruteforce_threshold(cnt);
+        knn_ctx->set_bruteforce_threshold(cnt);
       }
 
       use_update = !use_update;
     }
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
 
     auto t2 = ailego::Realtime::MicroSeconds();
 
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
     // auto t3 = ailego::Realtime::MicroSeconds();
 
     if (set_bf_threshold) {
-      linearTotalTime += t2 - t1;
+      linear_total_time += t2 - t1;
     } else {
-      knnTotalTime += t2 - t1;
+      knn_total_time += t2 - t1;
     }
 
     set_bf_threshold = !set_bf_threshold;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 1.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 1.0f / cnt;
   // float cost = linearTotalTime * 1.0f / knnTotalTime;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
@@ -2590,7 +2590,7 @@ TEST_F(HnswStreamerTest, TestBruteForceSetupInContext) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.95f);
+  EXPECT_GT(topk1_recall, 0.95f);
   // EXPECT_GT(cost, 2.0f);
 }
 
@@ -2655,16 +2655,16 @@ TEST_F(HnswStreamerTest, TestKnnSearchCosine) {
   }
 
   size_t query_cnt = 200U;
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  [[maybe_unused]] uint64_t knnTotalTime = 0;
-  [[maybe_unused]] uint64_t linearTotalTime = 0;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  [[maybe_unused]] uint64_t knn_total_time = 0;
+  [[maybe_unused]] uint64_t linear_total_time = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
 
 
   for (size_t i = 0; i < query_cnt; i++) {
@@ -2681,39 +2681,39 @@ TEST_F(HnswStreamerTest, TestKnnSearchCosine) {
     ASSERT_EQ(0, reformer->transform(vec.data(), qmeta, &new_query, &new_meta));
 
     auto t1 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knn_ctx));
     auto t2 = ailego::Realtime::MicroSeconds();
     ASSERT_EQ(0,
-              streamer->search_bf_impl(new_query.data(), new_meta, linearCtx));
+              streamer->search_bf_impl(new_query.data(), new_meta, linear_ctx));
     auto t3 = ailego::Realtime::MicroSeconds();
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
     // On platforms without SIMD (e.g., RISC-V), scalar FP rounding
     // differences may cause adjacent vectors with near-identical cosine
     // distances to swap in ranking. Allow top-1 to be within +/-1.
-    EXPECT_LE(std::abs(static_cast<int64_t>(linearResult[0].key()) -
+    EXPECT_LE(std::abs(static_cast<int64_t>(linear_result[0].key()) -
                        static_cast<int64_t>(i)),
               1);
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 1.0f / query_cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 1.0f / query_cnt;
   // float cost = linearTotalTime * 1.0f / knnTotalTime;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
@@ -2722,7 +2722,7 @@ TEST_F(HnswStreamerTest, TestKnnSearchCosine) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.90f);
+  EXPECT_GT(topk1_recall, 0.90f);
   // EXPECT_GT(cost, 2.0f);
 }
 
@@ -2772,42 +2772,42 @@ TEST_F(HnswStreamerTest, TestFetchVector) {
     ASSERT_FLOAT_EQ(vector_value, i);
   }
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
-  knnCtx->set_fetch_vector(true);
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
+  knn_ctx->set_fetch_vector(true);
 
   size_t query_cnt = 200U;
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
   for (size_t i = 0; i < query_cnt; i++) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i;
     }
 
     auto t1 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
     auto t2 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
     auto t3 = ailego::Realtime::MicroSeconds();
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
-    ASSERT_NE(knnResult[0].vector(), nullptr);
-    float vector_value = *((float *)(knnResult[0].vector()));
+    ASSERT_NE(knn_result[0].vector(), nullptr);
+    float vector_value = *((float *)(knn_result[0].vector()));
     ASSERT_FLOAT_EQ(vector_value, i);
   }
-  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
-  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
+  std::cout << "knnTotalTime: " << knn_total_time << std::endl;
+  std::cout << "linearTotalTime: " << linear_total_time << std::endl;
 }
 
 TEST_F(HnswStreamerTest, TestFetchVectorCosine) {
@@ -2886,17 +2886,17 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosine) {
     EXPECT_NEAR(vector_value, fixed_value + add_on, epsilon);
   }
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
-  linearCtx->set_fetch_vector(true);
-  knnCtx->set_fetch_vector(true);
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
+  linear_ctx->set_fetch_vector(true);
+  knn_ctx->set_fetch_vector(true);
 
   size_t query_cnt = 200U;
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
   for (size_t i = 0; i < query_cnt; i++) {
     float add_on = i * 10;
     for (size_t j = 0; j < dim; ++j) {
@@ -2911,39 +2911,39 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosine) {
     ASSERT_EQ(0, reformer->transform(vec.data(), qmeta, &new_query, &new_meta));
 
     auto t1 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knn_ctx));
     auto t2 = ailego::Realtime::MicroSeconds();
     ASSERT_EQ(0,
-              streamer->search_bf_impl(new_query.data(), new_meta, linearCtx));
+              streamer->search_bf_impl(new_query.data(), new_meta, linear_ctx));
     auto t3 = ailego::Realtime::MicroSeconds();
 
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
     // On platforms without SIMD (e.g., RISC-V), scalar FP rounding
     // differences may cause adjacent vectors with near-identical cosine
     // distances to swap in ranking. Allow top-1 to be within +/-1.
-    EXPECT_LE(std::abs(static_cast<int64_t>(linearResult[0].key()) -
+    EXPECT_LE(std::abs(static_cast<int64_t>(linear_result[0].key()) -
                        static_cast<int64_t>(i)),
               1);
 
-    ASSERT_NE(knnResult[0].vector(), nullptr);
+    ASSERT_NE(knn_result[0].vector(), nullptr);
 
     std::string denormalized_vec;
     denormalized_vec.resize(dim * sizeof(float));
-    reformer->revert(linearResult[0].vector(), new_meta, &denormalized_vec);
+    reformer->revert(linear_result[0].vector(), new_meta, &denormalized_vec);
 
-    float expected_add_on = linearResult[0].key() * 10;
+    float expected_add_on = linear_result[0].key() * 10;
     float vector_value = *(((float *)(denormalized_vec.data()) + dim - 1));
     EXPECT_NEAR(vector_value, fixed_value + expected_add_on, epsilon);
   }
-  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
-  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
+  std::cout << "knnTotalTime: " << knn_total_time << std::endl;
+  std::cout << "linearTotalTime: " << linear_total_time << std::endl;
 }
 
 TEST_F(HnswStreamerTest, TestFetchVectorCosineHalfFloatConverter) {
@@ -3031,17 +3031,17 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosineHalfFloatConverter) {
     EXPECT_NEAR(expected_vec_float, vector_value_float, epsilon);
   }
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
-  linearCtx->set_fetch_vector(true);
-  knnCtx->set_fetch_vector(true);
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
+  linear_ctx->set_fetch_vector(true);
+  knn_ctx->set_fetch_vector(true);
 
   size_t query_cnt = 200U;
   size_t topk = 30;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
 
   for (size_t i = 0; i < query_cnt; i++) {
     auto &vec = vecs[i];
@@ -3051,27 +3051,27 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosineHalfFloatConverter) {
     ASSERT_EQ(0, reformer->transform(vec.data(), qmeta, &new_query, &new_meta));
 
     auto t1 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knn_ctx));
     auto t2 = ailego::Realtime::MicroSeconds();
     ASSERT_EQ(0,
-              streamer->search_bf_impl(new_query.data(), new_meta, linearCtx));
+              streamer->search_bf_impl(new_query.data(), new_meta, linear_ctx));
     auto t3 = ailego::Realtime::MicroSeconds();
 
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
-    ASSERT_NE(knnResult[0].vector(), nullptr);
+    ASSERT_NE(knn_result[0].vector(), nullptr);
 
     std::string denormalized_vec;
     denormalized_vec.resize(dim * sizeof(uint16_t));
-    reformer->revert(linearResult[0].vector(), new_meta, &denormalized_vec);
+    reformer->revert(linear_result[0].vector(), new_meta, &denormalized_vec);
 
     uint16_t expected_vec_value = vec[dim - 1];
     uint16_t vector_value =
@@ -3083,8 +3083,8 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosineHalfFloatConverter) {
     EXPECT_NEAR(expected_vec_float, vector_value_float, epsilon);
   }
 
-  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
-  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
+  std::cout << "knnTotalTime: " << knn_total_time << std::endl;
+  std::cout << "linearTotalTime: " << linear_total_time << std::endl;
 }
 
 TEST_F(HnswStreamerTest, TestFetchVectorCosineFp16Converter) {
@@ -3170,17 +3170,17 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosineFp16Converter) {
     EXPECT_NEAR(expected_vec_value, vector_value, epsilon);
   }
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
-  linearCtx->set_fetch_vector(true);
-  knnCtx->set_fetch_vector(true);
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
+  linear_ctx->set_fetch_vector(true);
+  knn_ctx->set_fetch_vector(true);
 
   size_t query_cnt = 200U;
   size_t topk = 30;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
 
   for (size_t i = 0; i < query_cnt; i++) {
     auto &vec = vecs[i];
@@ -3190,27 +3190,27 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosineFp16Converter) {
     ASSERT_EQ(0, reformer->transform(vec.data(), qmeta, &new_query, &new_meta));
 
     auto t1 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knn_ctx));
     auto t2 = ailego::Realtime::MicroSeconds();
     ASSERT_EQ(0,
-              streamer->search_bf_impl(new_query.data(), new_meta, linearCtx));
+              streamer->search_bf_impl(new_query.data(), new_meta, linear_ctx));
     auto t3 = ailego::Realtime::MicroSeconds();
 
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
-    ASSERT_NE(knnResult[0].vector(), nullptr);
+    ASSERT_NE(knn_result[0].vector(), nullptr);
 
     std::string denormalized_vec;
     denormalized_vec.resize(dim * sizeof(float));
-    reformer->revert(linearResult[0].vector(), new_meta, &denormalized_vec);
+    reformer->revert(linear_result[0].vector(), new_meta, &denormalized_vec);
 
     float expected_vec_value = vec[dim - 1];
     float vector_value = *(((float *)(denormalized_vec.data()) + dim - 1));
@@ -3218,8 +3218,8 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosineFp16Converter) {
     EXPECT_NEAR(expected_vec_value, vector_value, epsilon);
   }
 
-  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
-  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
+  std::cout << "knnTotalTime: " << knn_total_time << std::endl;
+  std::cout << "linearTotalTime: " << linear_total_time << std::endl;
 }
 
 TEST_F(HnswStreamerTest, TestFetchVectorCosineInt8Converter) {
@@ -3299,17 +3299,17 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosineInt8Converter) {
     EXPECT_NEAR(vector_value, fixed_value + add_on, epsilon);
   }
 
-  auto linearCtx = streamer->create_context();
-  linearCtx->set_fetch_vector(true);
-  auto knnCtx = streamer->create_context();
-  knnCtx->set_fetch_vector(true);
+  auto linear_ctx = streamer->create_context();
+  linear_ctx->set_fetch_vector(true);
+  auto knn_ctx = streamer->create_context();
+  knn_ctx->set_fetch_vector(true);
 
   size_t query_cnt = 200U;
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
   for (size_t i = 0; i < query_cnt; i++) {
     float add_on = i * 10;
     for (size_t j = 0; j < dim; ++j) {
@@ -3324,35 +3324,35 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosineInt8Converter) {
     ASSERT_EQ(0, reformer->transform(vec.data(), qmeta, &new_query, &new_meta));
 
     auto t1 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knn_ctx));
     auto t2 = ailego::Realtime::MicroSeconds();
     ASSERT_EQ(0,
-              streamer->search_bf_impl(new_query.data(), new_meta, linearCtx));
+              streamer->search_bf_impl(new_query.data(), new_meta, linear_ctx));
     auto t3 = ailego::Realtime::MicroSeconds();
 
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
-    ASSERT_NE(knnResult[0].vector(), nullptr);
-    ASSERT_NE(linearResult[0].vector(), nullptr);
+    ASSERT_NE(knn_result[0].vector(), nullptr);
+    ASSERT_NE(linear_result[0].vector(), nullptr);
 
     std::string denormalized_vec;
     denormalized_vec.resize(dim * sizeof(float));
-    reformer->revert(linearResult[0].vector(), new_meta, &denormalized_vec);
+    reformer->revert(linear_result[0].vector(), new_meta, &denormalized_vec);
 
     float vector_value = *(((float *)(denormalized_vec.data()) + dim - 1));
     EXPECT_NEAR(vector_value, fixed_value + add_on, epsilon);
   }
 
-  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
-  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
+  std::cout << "knnTotalTime: " << knn_total_time << std::endl;
+  std::cout << "linearTotalTime: " << linear_total_time << std::endl;
 }
 
 TEST_F(HnswStreamerTest, TestFetchVectorCosineInt4Converter) {
@@ -3432,17 +3432,17 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosineInt4Converter) {
     EXPECT_NEAR(vector_value, fixed_value + add_on, epsilon);
   }
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
-  linearCtx->set_fetch_vector(true);
-  knnCtx->set_fetch_vector(true);
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
+  linear_ctx->set_fetch_vector(true);
+  knn_ctx->set_fetch_vector(true);
 
   size_t query_cnt = 100U;
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  uint64_t knnTotalTime = 0;
-  uint64_t linearTotalTime = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  uint64_t knn_total_time = 0;
+  uint64_t linear_total_time = 0;
   for (size_t i = 0; i < query_cnt; i++) {
     float add_on = i * 10;
     for (size_t j = 0; j < dim; ++j) {
@@ -3457,34 +3457,34 @@ TEST_F(HnswStreamerTest, TestFetchVectorCosineInt4Converter) {
     ASSERT_EQ(0, reformer->transform(vec.data(), qmeta, &new_query, &new_meta));
 
     auto t1 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knn_ctx));
     auto t2 = ailego::Realtime::MicroSeconds();
     ASSERT_EQ(0,
-              streamer->search_bf_impl(new_query.data(), new_meta, linearCtx));
+              streamer->search_bf_impl(new_query.data(), new_meta, linear_ctx));
     auto t3 = ailego::Realtime::MicroSeconds();
 
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
-    ASSERT_NE(knnResult[0].vector(), nullptr);
+    ASSERT_NE(knn_result[0].vector(), nullptr);
 
     std::string denormalized_vec;
     denormalized_vec.resize(dim * sizeof(float));
-    reformer->revert(linearResult[0].vector(), new_meta, &denormalized_vec);
+    reformer->revert(linear_result[0].vector(), new_meta, &denormalized_vec);
 
     float vector_value = *(((float *)(denormalized_vec.data()) + dim - 1));
     EXPECT_NEAR(vector_value, fixed_value + add_on, epsilon);
   }
 
-  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
-  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
+  std::cout << "knnTotalTime: " << knn_total_time << std::endl;
+  std::cout << "linearTotalTime: " << linear_total_time << std::endl;
 }
 
 TEST_F(HnswStreamerTest, TestRnnSearch) {
@@ -3740,7 +3740,7 @@ TEST_F(HnswStreamerTest, TestGroup) {
   size_t group_topk = 20;
   uint64_t total_time = 0;
 
-  auto groupbyFunc = [](uint64_t key) {
+  auto groupby_func = [](uint64_t key) {
     uint32_t group_id = key / 10 % 10;
     // std::cout << "key: " << key << ", group id: " << group_id << std::endl;
     return std::string("g_") + std::to_string(group_id);
@@ -3749,7 +3749,7 @@ TEST_F(HnswStreamerTest, TestGroup) {
   size_t group_num = 5;
 
   ctx->set_group_params(group_num, group_topk);
-  ctx->set_group_by(groupbyFunc);
+  ctx->set_group_by(groupby_func);
 
   size_t query_value = cnt / 2;
   for (size_t j = 0; j < dim; ++j) {
@@ -3782,7 +3782,7 @@ TEST_F(HnswStreamerTest, TestGroup) {
   }
 
   // do linear search by p_keys test
-  auto groupbyFuncLinear = [](uint64_t key) {
+  auto groupby_func_linear = [](uint64_t key) {
     uint32_t group_id = key % 10;
 
     return std::string("g_") + std::to_string(group_id);
@@ -3791,7 +3791,7 @@ TEST_F(HnswStreamerTest, TestGroup) {
   auto linear_pk_ctx = streamer->create_context();
 
   linear_pk_ctx->set_group_params(group_num, group_topk);
-  linear_pk_ctx->set_group_by(groupbyFuncLinear);
+  linear_pk_ctx->set_group_by(groupby_func_linear);
 
   std::vector<std::vector<uint64_t>> p_keys;
   p_keys.resize(1);
@@ -3855,7 +3855,7 @@ TEST_F(HnswStreamerTest, TestGroupNotEnoughNum) {
   size_t group_topk = 20;
   uint64_t total_time = 0;
 
-  auto groupbyFunc = [](uint64_t key) {
+  auto groupby_func = [](uint64_t key) {
     uint32_t group_id = key / 10 % 10;
     // std::cout << "key: " << key << ", group id: " << group_id << std::endl;
     return std::string("g_") + std::to_string(group_id);
@@ -3863,7 +3863,7 @@ TEST_F(HnswStreamerTest, TestGroupNotEnoughNum) {
 
   size_t group_num = 12;
   ctx->set_group_params(group_num, group_topk);
-  ctx->set_group_by(groupbyFunc);
+  ctx->set_group_by(groupby_func);
 
   size_t query_value = cnt / 2;
   for (size_t j = 0; j < dim; ++j) {
@@ -3932,7 +3932,7 @@ TEST_F(HnswStreamerTest, TestGroupInBruteforceSearch) {
   size_t group_topk = 20;
   uint64_t total_time = 0;
 
-  auto groupbyFunc = [](uint64_t key) {
+  auto groupby_func = [](uint64_t key) {
     uint32_t group_id = key / 10 % 10;
     // std::cout << "key: " << key << ", group id: " << group_id << std::endl;
     return std::string("g_") + std::to_string(group_id);
@@ -3940,7 +3940,7 @@ TEST_F(HnswStreamerTest, TestGroupInBruteforceSearch) {
 
   size_t group_num = 5;
   ctx->set_group_params(group_num, group_topk);
-  ctx->set_group_by(groupbyFunc);
+  ctx->set_group_by(groupby_func);
 
   size_t query_value = cnt / 2;
   for (size_t j = 0; j < dim; ++j) {
@@ -3994,8 +3994,8 @@ TEST_F(HnswStreamerTest, TestAddAndSearchWithID) {
   NumericalVector<float> vec(dim);
   size_t cnt = 20000U;
   auto ctx = streamer->create_context();
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   ASSERT_TRUE(!!ctx);
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
   for (size_t i = 0; i < cnt; i += 4) {
@@ -4015,65 +4015,65 @@ TEST_F(HnswStreamerTest, TestAddAndSearchWithID) {
   // streamer->print_debug_info();
 
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  [[maybe_unused]] uint64_t knnTotalTime = 0;
-  [[maybe_unused]] uint64_t linearTotalTime = 0;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  [[maybe_unused]] uint64_t knn_total_time = 0;
+  [[maybe_unused]] uint64_t linear_total_time = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
   for (size_t i = 0; i < cnt / 10; i += 2) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = i + 0.1f;
     }
     auto t1 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
     auto t2 = ailego::Realtime::MicroSeconds();
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
     auto t3 = ailego::Realtime::MicroSeconds();
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
 
     for (size_t j = 0; j < topk; ++j) {
-      ASSERT_NE(linearResult[j].key(), kInvalidKey);
-      ASSERT_NE(linearResult[j].index(), kInvalidKey);
-      auto linearVec = static_cast<const float *>(
-          streamer->get_vector_by_id(linearResult[j].index()));
+      ASSERT_NE(linear_result[j].key(), kInvalidKey);
+      ASSERT_NE(linear_result[j].index(), kInvalidKey);
+      auto linear_vec = static_cast<const float *>(
+          streamer->get_vector_by_id(linear_result[j].index()));
 
       for (size_t z = 0; z < dim; ++z) {
-        ASSERT_FLOAT_EQ(linearVec[z], linearResult[j].index());
+        ASSERT_FLOAT_EQ(linear_vec[z], linear_result[j].index());
       }
     }
     for (size_t j = 0; j < topk; ++j) {
-      ASSERT_NE(knnResult[j].key(), kInvalidKey);
-      ASSERT_NE(knnResult[j].index(), kInvalidKey);
-      auto knnVec = static_cast<const float *>(
-          streamer->get_vector_by_id(knnResult[j].index()));
+      ASSERT_NE(knn_result[j].key(), kInvalidKey);
+      ASSERT_NE(knn_result[j].index(), kInvalidKey);
+      auto knn_vec = static_cast<const float *>(
+          streamer->get_vector_by_id(knn_result[j].index()));
       for (size_t z = 0; z < dim; ++z) {
-        ASSERT_FLOAT_EQ(knnVec[z], knnResult[j].index());
+        ASSERT_FLOAT_EQ(knn_vec[z], knn_result[j].index());
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 100.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 100.0f / cnt;
   // float cost = linearTotalTime * 1.0f / knnTotalTime;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
@@ -4082,7 +4082,7 @@ TEST_F(HnswStreamerTest, TestAddAndSearchWithID) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.80f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
   // EXPECT_GT(cost, 2.0f);
 }
 
@@ -4138,34 +4138,34 @@ TEST_F(HnswStreamerTest, TestContiguousMemorySearch) {
   size_t topk = 50;
   NumericalVector<float> vec(dim);
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
-  auto linearCtx = searcher->create_context();
-  auto knnCtx = searcher->create_context();
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  int totalHits = 0;
-  int totalCnts = 0;
+  auto linear_ctx = searcher->create_context();
+  auto knn_ctx = searcher->create_context();
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  int total_hits = 0;
+  int total_cnts = 0;
   for (size_t i = 0; i < cnt; i++) {
     for (size_t j = 0; j < dim; ++j) {
       vec[j] = static_cast<float>(i) + 0.1f;
     }
-    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
+  float recall = total_hits * 1.0f / total_cnts;
   EXPECT_GT(recall, 0.90f);
 }
 
@@ -4199,23 +4199,23 @@ TEST_F(HnswStreamerTest, TestContiguousMultiThreadSearch) {
     ASSERT_EQ(0, builder->init(meta, build_params));
     ASSERT_EQ(0, builder->open(storage));
 
-    auto addVector = [&builder](int baseKey, size_t addCnt) {
+    auto add_vector = [&builder](int base_key, size_t add_cnt) {
       NumericalVector<float> vec(dim_mt);
       IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim_mt);
-      size_t succAdd = 0;
+      size_t succ_add = 0;
       auto ctx = builder->create_context();
-      for (size_t i = 0; i < addCnt; i++) {
+      for (size_t i = 0; i < add_cnt; i++) {
         for (size_t j = 0; j < dim_mt; ++j) {
-          vec[j] = static_cast<float>(i + baseKey);
+          vec[j] = static_cast<float>(i + base_key);
         }
-        succAdd += !builder->add_impl(baseKey + i, vec.data(), qmeta, ctx);
+        succ_add += !builder->add_impl(base_key + i, vec.data(), qmeta, ctx);
       }
       builder->flush(0UL);
-      return succAdd;
+      return succ_add;
     };
-    auto t1 = std::async(std::launch::async, addVector, 0, 1000);
-    auto t2 = std::async(std::launch::async, addVector, 1000, 1000);
-    auto t3 = std::async(std::launch::async, addVector, 2000, 1000);
+    auto t1 = std::async(std::launch::async, add_vector, 0, 1000);
+    auto t2 = std::async(std::launch::async, add_vector, 1000, 1000);
+    auto t3 = std::async(std::launch::async, add_vector, 2000, 1000);
     ASSERT_EQ(1000U, t1.get());
     ASSERT_EQ(1000U, t2.get());
     ASSERT_EQ(1000U, t3.get());
@@ -4256,41 +4256,41 @@ TEST_F(HnswStreamerTest, TestContiguousMultiThreadSearch) {
   // Multi-thread search on contiguous memory
   size_t topk = 100;
   size_t cnt = 3000;
-  auto knnSearch = [&]() {
+  auto knn_search = [&]() {
     NumericalVector<float> vec(dim_mt);
-    auto linearCtx = searcher->create_context();
-    auto knnCtx = searcher->create_context();
+    auto linear_ctx = searcher->create_context();
+    auto knn_ctx = searcher->create_context();
     IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim_mt);
-    linearCtx->set_topk(topk);
-    knnCtx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    linear_ctx->set_topk(topk);
+    knn_ctx->set_topk(topk);
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     for (size_t i = 0; i < cnt; i += 1) {
       for (size_t j = 0; j < dim_mt; ++j) {
         vec[j] = static_cast<float>(i) + 0.1f;
       }
-      ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
-      ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
-      auto &knnResult = knnCtx->result();
-      ASSERT_EQ(topk, knnResult.size());
-      auto &linearResult = linearCtx->result();
-      ASSERT_EQ(topk, linearResult.size());
-      ASSERT_EQ(i, linearResult[0].key());
+      ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
+      ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
+      auto &knn_result = knn_ctx->result();
+      ASSERT_EQ(topk, knn_result.size());
+      auto &linear_result = linear_ctx->result();
+      ASSERT_EQ(topk, linear_result.size());
+      ASSERT_EQ(i, linear_result[0].key());
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
-          if (linearResult[j].key() == knnResult[k].key()) {
-            totalHits++;
+          if (linear_result[j].key() == knn_result[k].key()) {
+            total_hits++;
             break;
           }
         }
       }
     }
-    ASSERT_TRUE((totalHits * 1.0f / totalCnts) > 0.80f);
+    ASSERT_TRUE((total_hits * 1.0f / total_cnts) > 0.80f);
   };
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
-  auto s3 = std::async(std::launch::async, knnSearch);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
+  auto s3 = std::async(std::launch::async, knn_search);
   s1.wait();
   s2.wait();
   s3.wait();
@@ -4375,10 +4375,10 @@ TEST_F(HnswStreamerTest, TestInt8WithRotate) {
   ASSERT_EQ(0, reformer2->load(storage2));
 
   // Search: verify knn results are non-empty
-  auto knnCtx = streamer2->create_context();
-  knnCtx->set_topk(kTopk);
-  auto linearCtx = streamer2->create_context();
-  linearCtx->set_topk(kTopk);
+  auto knn_ctx = streamer2->create_context();
+  knn_ctx->set_topk(kTopk);
+  auto linear_ctx = streamer2->create_context();
+  linear_ctx->set_topk(kTopk);
 
   NumericalVector<float> query(kTestDim);
   for (size_t j = 0; j < kTestDim; ++j) query[j] = dist(gen);
@@ -4387,12 +4387,12 @@ TEST_F(HnswStreamerTest, TestInt8WithRotate) {
   IndexQueryMeta new_qmeta;
   ASSERT_EQ(0,
             reformer2->transform(query.data(), qmeta, &new_query, &new_qmeta));
-  ASSERT_EQ(0, streamer2->search_impl(new_query.data(), new_qmeta, knnCtx));
+  ASSERT_EQ(0, streamer2->search_impl(new_query.data(), new_qmeta, knn_ctx));
   ASSERT_EQ(0,
-            streamer2->search_bf_impl(new_query.data(), new_qmeta, linearCtx));
+            streamer2->search_bf_impl(new_query.data(), new_qmeta, linear_ctx));
 
-  EXPECT_EQ(kTopk, knnCtx->result().size());
-  EXPECT_EQ(kTopk, linearCtx->result().size());
+  EXPECT_EQ(kTopk, knn_ctx->result().size());
+  EXPECT_EQ(kTopk, linear_ctx->result().size());
 }
 
 TEST_F(HnswStreamerTest, TestCompareFromOriginalVsBaseline) {
@@ -4450,51 +4450,51 @@ TEST_F(HnswStreamerTest, TestCompareFromOriginalVsBaseline) {
   ailego::Params stg_params;
 
   // === Build index A: from original (with provider) ===
-  IndexStreamer::Pointer streamerA =
+  IndexStreamer::Pointer streamer_a =
       IndexFactory::CreateStreamer("HnswStreamer");
-  ASSERT_TRUE(streamerA != nullptr);
-  ASSERT_EQ(0, streamerA->set_provider(provider, fp32_meta));
+  ASSERT_TRUE(streamer_a != nullptr);
+  ASSERT_EQ(0, streamer_a->set_provider(provider, fp32_meta));
 
-  auto storageA = IndexFactory::CreateStorage("MMapFileStorage");
-  ASSERT_EQ(0, storageA->init(stg_params));
-  ASSERT_EQ(0, storageA->open(dir_ + "compare_from_original.index", true));
-  ASSERT_EQ(0, streamerA->init(fp16_meta, params));
-  ASSERT_EQ(0, streamerA->open(storageA));
+  auto storage_a = IndexFactory::CreateStorage("MMapFileStorage");
+  ASSERT_EQ(0, storage_a->init(stg_params));
+  ASSERT_EQ(0, storage_a->open(dir_ + "compare_from_original.index", true));
+  ASSERT_EQ(0, streamer_a->init(fp16_meta, params));
+  ASSERT_EQ(0, streamer_a->open(storage_a));
 
-  auto ctxA = streamerA->create_context();
+  auto ctx_a = streamer_a->create_context();
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP16, dim);
   for (size_t i = 0; i < cnt; i++) {
-    ASSERT_EQ(0, streamerA->add_impl(i, stored[i].data(), qmeta, ctxA));
+    ASSERT_EQ(0, streamer_a->add_impl(i, stored[i].data(), qmeta, ctx_a));
   }
-  streamerA->flush(0UL);
+  streamer_a->flush(0UL);
 
   // === Build index B: baseline (no provider) ===
-  IndexStreamer::Pointer streamerB =
+  IndexStreamer::Pointer streamer_b =
       IndexFactory::CreateStreamer("HnswStreamer");
-  ASSERT_TRUE(streamerB != nullptr);
+  ASSERT_TRUE(streamer_b != nullptr);
 
-  auto storageB = IndexFactory::CreateStorage("MMapFileStorage");
-  ASSERT_EQ(0, storageB->init(stg_params));
-  ASSERT_EQ(0, storageB->open(dir_ + "compare_baseline.index", true));
-  ASSERT_EQ(0, streamerB->init(fp16_meta, params));
-  ASSERT_EQ(0, streamerB->open(storageB));
+  auto storage_b = IndexFactory::CreateStorage("MMapFileStorage");
+  ASSERT_EQ(0, storage_b->init(stg_params));
+  ASSERT_EQ(0, storage_b->open(dir_ + "compare_baseline.index", true));
+  ASSERT_EQ(0, streamer_b->init(fp16_meta, params));
+  ASSERT_EQ(0, streamer_b->open(storage_b));
 
-  auto ctxB = streamerB->create_context();
+  auto ctx_b = streamer_b->create_context();
   for (size_t i = 0; i < cnt; i++) {
-    ASSERT_EQ(0, streamerB->add_impl(i, stored[i].data(), qmeta, ctxB));
+    ASSERT_EQ(0, streamer_b->add_impl(i, stored[i].data(), qmeta, ctx_b));
   }
-  streamerB->flush(0UL);
+  streamer_b->flush(0UL);
 
   // === Search and compare ===
-  size_t queryCnt = 0;
-  int totalHitsA = 0, totalHitsB = 0;
-  int totalCnts = 0;
-  int topk1HitsA = 0, topk1HitsB = 0;
+  size_t query_cnt = 0;
+  int total_hits_a = 0, total_hits_b = 0;
+  int total_cnts = 0;
+  int topk1_hits_a = 0, topk1_hits_b = 0;
 
-  auto knnCtxA = streamerA->create_context();
-  auto knnCtxB = streamerB->create_context();
-  knnCtxA->set_topk(topk);
-  knnCtxB->set_topk(topk);
+  auto knn_ctx_a = streamer_a->create_context();
+  auto knn_ctx_b = streamer_b->create_context();
+  knn_ctx_a->set_topk(topk);
+  knn_ctx_b->set_topk(topk);
 
   //! queries are the original vectors perturbed a little, so the answer is
   //! not simply the query itself
@@ -4507,29 +4507,29 @@ TEST_F(HnswStreamerTest, TestCompareFromOriginalVsBaseline) {
     queries.push_back(std::move(q));
   }
 
-  std::vector<std::vector<uint64_t>> resultsA;
-  std::vector<std::vector<uint64_t>> resultsB;
+  std::vector<std::vector<uint64_t>> results_a;
+  std::vector<std::vector<uint64_t>> results_b;
   NumericalVector<uint16_t> fp16_query(dim);
   for (auto &q : queries) {
     for (size_t j = 0; j < dim; ++j) {
       fp16_query[j] = ailego::FloatHelper::ToFP16(q[j]);
     }
 
-    ASSERT_EQ(0, streamerA->search_impl(fp16_query.data(), qmeta, knnCtxA));
-    auto &resA = knnCtxA->result();
-    ASSERT_EQ(topk, resA.size());
-    std::vector<uint64_t> keysA(topk);
-    for (size_t k = 0; k < topk; ++k) keysA[k] = resA[k].key();
-    resultsA.push_back(std::move(keysA));
-
-    ASSERT_EQ(0, streamerB->search_impl(fp16_query.data(), qmeta, knnCtxB));
-    auto &resB = knnCtxB->result();
-    ASSERT_EQ(topk, resB.size());
-    std::vector<uint64_t> keysB(topk);
-    for (size_t k = 0; k < topk; ++k) keysB[k] = resB[k].key();
-    resultsB.push_back(std::move(keysB));
-
-    queryCnt++;
+    ASSERT_EQ(0, streamer_a->search_impl(fp16_query.data(), qmeta, knn_ctx_a));
+    auto &res_a = knn_ctx_a->result();
+    ASSERT_EQ(topk, res_a.size());
+    std::vector<uint64_t> keys_a(topk);
+    for (size_t k = 0; k < topk; ++k) keys_a[k] = res_a[k].key();
+    results_a.push_back(std::move(keys_a));
+
+    ASSERT_EQ(0, streamer_b->search_impl(fp16_query.data(), qmeta, knn_ctx_b));
+    auto &res_b = knn_ctx_b->result();
+    ASSERT_EQ(topk, res_b.size());
+    std::vector<uint64_t> keys_b(topk);
+    for (size_t k = 0; k < topk; ++k) keys_b[k] = res_b[k].key();
+    results_b.push_back(std::move(keys_b));
+
+    query_cnt++;
   }
 
   //! exhaustive ground truth in the original FP32 space
@@ -4550,27 +4550,27 @@ TEST_F(HnswStreamerTest, TestCompareFromOriginalVsBaseline) {
     for (size_t k = 0; k < topk; ++k) {
       gt.insert(dists[k].second);
     }
-    topk1HitsA += (resultsA[qi][0] == dists[0].second);
-    topk1HitsB += (resultsB[qi][0] == dists[0].second);
+    topk1_hits_a += (results_a[qi][0] == dists[0].second);
+    topk1_hits_b += (results_b[qi][0] == dists[0].second);
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
-      totalHitsA += gt.count(resultsA[qi][k]) > 0;
-      totalHitsB += gt.count(resultsB[qi][k]) > 0;
+      total_cnts++;
+      total_hits_a += gt.count(results_a[qi][k]) > 0;
+      total_hits_b += gt.count(results_b[qi][k]) > 0;
     }
   }
 
-  float recallA = totalHitsA * 1.0f / totalCnts;
-  float recallB = totalHitsB * 1.0f / totalCnts;
-  float topk1RecallA = topk1HitsA * 1.0f / queryCnt;
-  float topk1RecallB = topk1HitsB * 1.0f / queryCnt;
+  float recall_a = total_hits_a * 1.0f / total_cnts;
+  float recall_b = total_hits_b * 1.0f / total_cnts;
+  float topk1_recall_a = topk1_hits_a * 1.0f / query_cnt;
+  float topk1_recall_b = topk1_hits_b * 1.0f / query_cnt;
 
   printf("\n=== From-Original vs Baseline Comparison ===\n");
-  printf("From-Original: Recall@%zu=%.4f, Recall@1=%.4f\n", topk, recallA,
-         topk1RecallA);
-  printf("Baseline:      Recall@%zu=%.4f, Recall@1=%.4f\n", topk, recallB,
-         topk1RecallB);
+  printf("From-Original: Recall@%zu=%.4f, Recall@1=%.4f\n", topk, recall_a,
+         topk1_recall_a);
+  printf("Baseline:      Recall@%zu=%.4f, Recall@1=%.4f\n", topk, recall_b,
+         topk1_recall_b);
   printf("Delta (From-Original - Baseline): Recall@%zu=%+.4f, Recall@1=%+.4f\n",
-         topk, recallA - recallB, topk1RecallA - topk1RecallB);
+         topk, recall_a - recall_b, topk1_recall_a - topk1_recall_b);
   printf("============================================\n");
 
   //! Both graphs must be functional. Note that building from the original
@@ -4578,10 +4578,10 @@ TEST_F(HnswStreamerTest, TestCompareFromOriginalVsBaseline) {
   //! on the stored FP16 vectors, so a graph optimized for FP32 distances
   //! can even be slightly off. See bench/REPORT.md for measurements on a
   //! real dataset
-  EXPECT_GT(recallA, 0.90f);
-  EXPECT_GT(recallB, 0.90f);
-  EXPECT_GT(topk1RecallA, 0.90f);
-  EXPECT_GT(topk1RecallB, 0.90f);
+  EXPECT_GT(recall_a, 0.90f);
+  EXPECT_GT(recall_b, 0.90f);
+  EXPECT_GT(topk1_recall_a, 0.90f);
+  EXPECT_GT(topk1_recall_b, 0.90f);
 }
 
 }  // namespace core
diff --git a/tests/core/algorithm/hnsw_sparse/hnsw_sparse_streamer_test.cc b/tests/core/algorithm/hnsw_sparse/hnsw_sparse_streamer_test.cc
index 3d2efc18a..5f197b495 100644
--- a/tests/core/algorithm/hnsw_sparse/hnsw_sparse_streamer_test.cc
+++ b/tests/core/algorithm/hnsw_sparse/hnsw_sparse_streamer_test.cc
@@ -128,11 +128,11 @@ TEST_F(HnswSparseStreamerTest, TestGeneral) {
   auto ctx = streamer->create_context();
   ASSERT_TRUE(!!ctx);
 
-  auto linearCtx = streamer->create_context();
-  ASSERT_TRUE(!!linearCtx);
+  auto linear_ctx = streamer->create_context();
+  ASSERT_TRUE(!!linear_ctx);
 
-  auto knnCtx = streamer->create_context();
-  ASSERT_TRUE(!!knnCtx);
+  auto knn_ctx = streamer->create_context();
+  ASSERT_TRUE(!!knn_ctx);
 
   std::vector<NumericalVector<uint32_t>> sparse_indices_list;
   std::vector<NumericalVector<float>> sparse_vec_list;
@@ -150,15 +150,15 @@ TEST_F(HnswSparseStreamerTest, TestGeneral) {
 
   // streamer->print_debug_info();
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
-  [[maybe_unused]] uint64_t knnTotalTime = 0;
-  [[maybe_unused]] uint64_t linearTotalTime = 0;
+  [[maybe_unused]] uint64_t knn_total_time = 0;
+  [[maybe_unused]] uint64_t linear_total_time = 0;
 
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
 
   for (size_t i = 0; i < cnt; i += 100) {
     const auto &sparse_indices = sparse_indices_list[i];
@@ -167,41 +167,41 @@ TEST_F(HnswSparseStreamerTest, TestGeneral) {
     auto t1 = ailego::Realtime::MicroSeconds();
 
     ASSERT_EQ(0, streamer->search_impl(sparse_dim_count, sparse_indices.data(),
-                                       sparse_vec.data(), qmeta, knnCtx));
+                                       sparse_vec.data(), qmeta, knn_ctx));
 
     auto t2 = ailego::Realtime::MicroSeconds();
 
     ASSERT_EQ(0,
               streamer->search_bf_impl(sparse_dim_count, sparse_indices.data(),
-                                       sparse_vec.data(), qmeta, linearCtx));
+                                       sparse_vec.data(), qmeta, linear_ctx));
 
     auto t3 = ailego::Realtime::MicroSeconds();
 
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
     // std::cout << "i: " << i << std::endl;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 100.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 100.0f / cnt;
   // float cost = linearTotalTime * 1.0f / knnTotalTime;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
@@ -210,7 +210,7 @@ TEST_F(HnswSparseStreamerTest, TestGeneral) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.80f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
   // EXPECT_GT(cost, 2.0f);
 }
 
@@ -484,8 +484,8 @@ TEST_F(HnswSparseStreamerTest, TestOpenClose) {
   ASSERT_EQ(0, storage2->init(stg_params));
   ASSERT_EQ(0, storage2->open(dir_ + "TessOpenAndClose2", true));
   ASSERT_EQ(0, streamer->init(meta, params));
-  auto checkIter = [](size_t base, size_t total,
-                      IndexStreamer::Pointer &streamer) {
+  auto check_iter = [](size_t base, size_t total,
+                       IndexStreamer::Pointer &streamer) {
     auto provider = streamer->create_sparse_provider();
     auto iter = provider->create_iterator();
     ASSERT_TRUE(!!iter);
@@ -504,10 +504,10 @@ TEST_F(HnswSparseStreamerTest, TestOpenClose) {
     ASSERT_EQ(cnt, total);
   };
 
-  size_t testCnt = 200;
+  size_t test_cnt = 200;
   IndexQueryMeta qmeta(IndexMeta::MetaType::MT_SPARSE,
                        IndexMeta::DataType::DT_FP32);
-  for (size_t i = 0; i < testCnt; i += 2) {
+  for (size_t i = 0; i < test_cnt; i += 2) {
     float v1 = (float)i;
     ASSERT_EQ(0, streamer->open(storage1));
     auto ctx = streamer->create_context();
@@ -523,7 +523,7 @@ TEST_F(HnswSparseStreamerTest, TestOpenClose) {
     ASSERT_EQ(0, streamer->add_impl(i, sparse_dim_count, sparse_indices1.data(),
                                     sparse_velues1.data(), qmeta, ctx));
 
-    checkIter(0, i / 2 + 1, streamer);
+    check_iter(0, i / 2 + 1, streamer);
     ASSERT_EQ(0, streamer->flush(0UL));
     ASSERT_EQ(0, streamer->close());
 
@@ -541,7 +541,7 @@ TEST_F(HnswSparseStreamerTest, TestOpenClose) {
     ASSERT_EQ(
         0, streamer->add_impl(i + 1, sparse_dim_count, sparse_indices2.data(),
                               sparse_velues2.data(), qmeta, ctx));
-    checkIter(1, i / 2 + 1, streamer);
+    check_iter(1, i / 2 + 1, streamer);
     ASSERT_EQ(0, streamer->flush(0UL));
     ASSERT_EQ(0, streamer->close());
   }
@@ -558,8 +558,8 @@ TEST_F(HnswSparseStreamerTest, TestOpenClose) {
   ASSERT_EQ(0, streamer2->init(meta, params));
   ASSERT_EQ(0, streamer2->open(storage2));
 
-  checkIter(0, testCnt / 2, streamer1);
-  checkIter(1, testCnt / 2, streamer2);
+  check_iter(0, test_cnt / 2, streamer1);
+  check_iter(1, test_cnt / 2, streamer2);
 }
 
 TEST_F(HnswSparseStreamerTest, TestCreateIterator) {
@@ -579,7 +579,7 @@ TEST_F(HnswSparseStreamerTest, TestCreateIterator) {
   ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto checkIter = [](size_t total, IndexStreamer::Pointer &streamer) {
+  auto check_iter = [](size_t total, IndexStreamer::Pointer &streamer) {
     auto provider = streamer->create_sparse_provider();
     auto iter = provider->create_iterator();
     ASSERT_TRUE(!!iter);
@@ -611,13 +611,13 @@ TEST_F(HnswSparseStreamerTest, TestCreateIterator) {
 
     ASSERT_EQ(0, streamer->add_impl(i, sparse_dim_count, sparse_indices1.data(),
                                     sparse_velues1.data(), qmeta, ctx));
-    checkIter(i + 1, streamer);
+    check_iter(i + 1, streamer);
   }
 
   streamer->flush(0UL);
   streamer->close();
   ASSERT_EQ(0, streamer->open(storage));
-  checkIter(cnt, streamer);
+  check_iter(cnt, streamer);
 
   // check getVector
   auto provider = streamer->create_sparse_provider();
@@ -667,7 +667,7 @@ TEST_F(HnswSparseStreamerTest, TestForceFlush) {
   ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto checkIter = [](size_t total, IndexStreamer::Pointer &streamer) {
+  auto check_iter = [](size_t total, IndexStreamer::Pointer &streamer) {
     auto provider = streamer->create_sparse_provider();
     auto iter = provider->create_iterator();
     ASSERT_TRUE(!!iter);
@@ -704,7 +704,7 @@ TEST_F(HnswSparseStreamerTest, TestForceFlush) {
 
     ASSERT_EQ(0, streamer->add_impl(i, sparse_dim_count, sparse_indices.data(),
                                     sparse_velues.data(), qmeta, ctx));
-    checkIter(i + 1, streamer);
+    check_iter(i + 1, streamer);
   }
 
   streamer->flush(0UL);
@@ -716,7 +716,7 @@ TEST_F(HnswSparseStreamerTest, TestForceFlush) {
   ASSERT_EQ(0, storage->init(stg_params));
   ASSERT_EQ(0, storage->open(dir_ + "TestForceFlush", true));
   ASSERT_EQ(0, streamer->open(storage));
-  checkIter(cnt, streamer);
+  check_iter(cnt, streamer);
 
   // check getVector
   auto provider = streamer->create_sparse_provider();
@@ -762,31 +762,31 @@ TEST_F(HnswSparseStreamerTest, TestKnnMultiThread) {
   ASSERT_EQ(0, storage->open(dir_ + "TessKnnMultiThread", true));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto addVector = [&streamer](int baseKey, size_t addCnt) {
+  auto add_vector = [&streamer](int base_key, size_t add_cnt) {
     IndexQueryMeta qmeta(IndexMeta::MetaType::MT_SPARSE,
                          IndexMeta::DataType::DT_FP32);
-    size_t succAdd = 0;
+    size_t succ_add = 0;
     auto ctx = streamer->create_context();
-    for (size_t i = 0; i < addCnt; i++) {
+    for (size_t i = 0; i < add_cnt; i++) {
       NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
       NumericalVector<float> sparse_velues(sparse_dim_count);
 
       for (size_t j = 0; j < sparse_dim_count; ++j) {
         sparse_indices[j] = j * 20;
-        sparse_velues[j] = (float)i + baseKey;
+        sparse_velues[j] = (float)i + base_key;
       }
 
-      succAdd += !streamer->add_impl(baseKey + i, sparse_dim_count,
-                                     sparse_indices.data(),
-                                     sparse_velues.data(), qmeta, ctx);
+      succ_add += !streamer->add_impl(base_key + i, sparse_dim_count,
+                                      sparse_indices.data(),
+                                      sparse_velues.data(), qmeta, ctx);
     }
     streamer->flush(0UL);
-    return succAdd;
+    return succ_add;
   };
 
-  auto t2 = std::async(std::launch::async, addVector, 1000, 1000);
-  auto t3 = std::async(std::launch::async, addVector, 2000, 1000);
-  auto t1 = std::async(std::launch::async, addVector, 0, 1000);
+  auto t2 = std::async(std::launch::async, add_vector, 1000, 1000);
+  auto t3 = std::async(std::launch::async, add_vector, 2000, 1000);
+  auto t1 = std::async(std::launch::async, add_vector, 0, 1000);
   ASSERT_EQ(1000U, t1.get());
   ASSERT_EQ(1000U, t2.get());
   ASSERT_EQ(1000U, t3.get());
@@ -821,17 +821,17 @@ TEST_F(HnswSparseStreamerTest, TestKnnMultiThread) {
   // ====== multi thread search
   size_t topk = 10;
   size_t cnt = 3000;
-  auto knnSearch = [&]() {
-    auto linearCtx = streamer->create_context();
-    auto linearByPkeysCtx = streamer->create_context();
+  auto knn_search = [&]() {
+    auto linear_ctx = streamer->create_context();
+    auto linear_by_pkeys_ctx = streamer->create_context();
     auto ctx = streamer->create_context();
     IndexQueryMeta qmeta(IndexMeta::MetaType::MT_SPARSE,
                          IndexMeta::DataType::DT_FP32);
-    linearCtx->set_topk(topk);
-    linearByPkeysCtx->set_topk(topk);
+    linear_ctx->set_topk(topk);
+    linear_by_pkeys_ctx->set_topk(topk);
     ctx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     for (size_t i = 0; i < cnt; i += 1) {
       NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
       NumericalVector<float> sparse_velues(sparse_dim_count);
@@ -846,17 +846,18 @@ TEST_F(HnswSparseStreamerTest, TestKnnMultiThread) {
                                       sparse_velues.data(), qmeta, ctx));
       ASSERT_EQ(
           0, streamer->search_bf_impl(sparse_dim_count, sparse_indices.data(),
-                                      sparse_velues.data(), qmeta, linearCtx));
+                                      sparse_velues.data(), qmeta, linear_ctx));
       std::vector<std::vector<uint64_t>> p_keys = {{cnt - 1, cnt - 2, cnt - 3}};
-      ASSERT_EQ(0, streamer->search_bf_by_p_keys_impl(
-                       sparse_dim_count, sparse_indices.data(),
-                       sparse_velues.data(), p_keys, qmeta, linearByPkeysCtx));
+      ASSERT_EQ(
+          0, streamer->search_bf_by_p_keys_impl(
+                 sparse_dim_count, sparse_indices.data(), sparse_velues.data(),
+                 p_keys, qmeta, linear_by_pkeys_ctx));
       auto &r1 = ctx->result();
       ASSERT_EQ(topk, r1.size());
-      auto &r2 = linearCtx->result();
+      auto &r2 = linear_ctx->result();
       ASSERT_EQ(topk, r2.size());
       ASSERT_EQ(cnt - 1, r2[0].key());
-      auto &r3 = linearByPkeysCtx->result();
+      auto &r3 = linear_by_pkeys_ctx->result();
       ASSERT_EQ(std::min(topk, p_keys[0].size()), r3.size());
 #if 0
             printf("linear: %zd => %zd %zd %zd %zd %zd\n", i, r2[0].key,
@@ -865,21 +866,21 @@ TEST_F(HnswSparseStreamerTest, TestKnnMultiThread) {
                    r1[2].key, r1[3].key, r1[4].key);
 #endif
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
           if (r2[j].key() == r1[k].key()) {
-            totalHits++;
+            total_hits++;
             break;
           }
         }
       }
     }
-    printf("%f\n", totalHits * 1.0f / totalCnts);
-    ASSERT_TRUE((totalHits * 1.0f / totalCnts) > 0.80f);
+    printf("%f\n", total_hits * 1.0f / total_cnts);
+    ASSERT_TRUE((total_hits * 1.0f / total_cnts) > 0.80f);
   };
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
-  auto s3 = std::async(std::launch::async, knnSearch);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
+  auto s3 = std::async(std::launch::async, knn_search);
   s1.wait();
   s2.wait();
   s3.wait();
@@ -913,41 +914,41 @@ TEST_F(HnswSparseStreamerTest, TestKnnConcurrentAddAndSearch) {
   ASSERT_EQ(0, storage->open(dir_ + "TessKnnConcurrentAddAndSearch", true));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto addVector = [&streamer](int baseKey, size_t addCnt) {
+  auto add_vector = [&streamer](int base_key, size_t add_cnt) {
     IndexQueryMeta qmeta(IndexMeta::MetaType::MT_SPARSE,
                          IndexMeta::DataType::DT_FP32);
-    size_t succAdd = 0;
+    size_t succ_add = 0;
     auto ctx = streamer->create_context();
-    for (size_t i = 0; i < addCnt; i++) {
+    for (size_t i = 0; i < add_cnt; i++) {
       NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
       NumericalVector<float> sparse_velues(sparse_dim_count);
 
       for (size_t j = 0; j < sparse_dim_count; ++j) {
         sparse_indices[j] = j * 20;
-        sparse_velues[j] = (float)i + baseKey;
+        sparse_velues[j] = (float)i + base_key;
       }
 
-      succAdd += !streamer->add_impl(baseKey + i, sparse_dim_count,
-                                     sparse_indices.data(),
-                                     sparse_velues.data(), qmeta, ctx);
+      succ_add += !streamer->add_impl(base_key + i, sparse_dim_count,
+                                      sparse_indices.data(),
+                                      sparse_velues.data(), qmeta, ctx);
     }
     streamer->flush(0UL);
-    return succAdd;
+    return succ_add;
   };
 
-  auto knnSearch = [&]() {
+  auto knn_search = [&]() {
     size_t topk = 100;
     size_t cnt = 3000;
-    auto linearCtx = streamer->create_context();
-    auto linearByPkeysCtx = streamer->create_context();
+    auto linear_ctx = streamer->create_context();
+    auto linear_by_pkeys_ctx = streamer->create_context();
     auto ctx = streamer->create_context();
     IndexQueryMeta qmeta(IndexMeta::MetaType::MT_SPARSE,
                          IndexMeta::DataType::DT_FP32);
-    linearCtx->set_topk(topk);
-    linearByPkeysCtx->set_topk(topk);
+    linear_ctx->set_topk(topk);
+    linear_by_pkeys_ctx->set_topk(topk);
     ctx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     for (size_t i = 0; i < cnt; i += 1) {
       NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
       NumericalVector<float> sparse_velues(sparse_dim_count);
@@ -962,17 +963,18 @@ TEST_F(HnswSparseStreamerTest, TestKnnConcurrentAddAndSearch) {
                                       sparse_velues.data(), qmeta, ctx));
       ASSERT_EQ(
           0, streamer->search_bf_impl(sparse_dim_count, sparse_indices.data(),
-                                      sparse_velues.data(), qmeta, linearCtx));
+                                      sparse_velues.data(), qmeta, linear_ctx));
       std::vector<std::vector<uint64_t>> p_keys = {{0, 1, 2}};
-      ASSERT_EQ(0, streamer->search_bf_by_p_keys_impl(
-                       sparse_dim_count, sparse_indices.data(),
-                       sparse_velues.data(), p_keys, qmeta, linearByPkeysCtx));
+      ASSERT_EQ(
+          0, streamer->search_bf_by_p_keys_impl(
+                 sparse_dim_count, sparse_indices.data(), sparse_velues.data(),
+                 p_keys, qmeta, linear_by_pkeys_ctx));
       auto &r1 = ctx->result();
       ASSERT_EQ(topk, r1.size());
-      auto &r2 = linearCtx->result();
+      auto &r2 = linear_ctx->result();
       ASSERT_EQ(topk, r2.size());
       ASSERT_EQ(0, r2[0].key());
-      auto &r3 = linearByPkeysCtx->result();
+      auto &r3 = linear_by_pkeys_ctx->result();
       ASSERT_EQ(std::min(topk, p_keys[0].size()), r3.size());
 #if 0
             printf("linear: %zd => %zd %zd %zd %zd %zd\n", i, r2[0].key,
@@ -981,25 +983,25 @@ TEST_F(HnswSparseStreamerTest, TestKnnConcurrentAddAndSearch) {
                    r1[2].key, r1[3].key, r1[4].key);
 #endif
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
           if (r2[j].key() == r1[k].key()) {
-            totalHits++;
+            total_hits++;
             break;
           }
         }
       }
     }
-    printf("%f\n", totalHits * 1.0f / totalCnts);
-    ASSERT_TRUE((totalHits * 1.0f / totalCnts) > 0.80f);
+    printf("%f\n", total_hits * 1.0f / total_cnts);
+    ASSERT_TRUE((total_hits * 1.0f / total_cnts) > 0.80f);
   };
 
-  auto t0 = std::async(std::launch::async, addVector, 0, 1000);
+  auto t0 = std::async(std::launch::async, add_vector, 0, 1000);
   ASSERT_EQ(1000, t0.get());
-  auto t1 = std::async(std::launch::async, addVector, 1000, 1000);
-  auto t2 = std::async(std::launch::async, addVector, 2000, 1000);
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
+  auto t1 = std::async(std::launch::async, add_vector, 1000, 1000);
+  auto t2 = std::async(std::launch::async, add_vector, 2000, 1000);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
   ASSERT_EQ(1000, t1.get());
   ASSERT_EQ(1000, t2.get());
   s1.wait();
@@ -1167,13 +1169,13 @@ TEST_F(HnswSparseStreamerTest, TestFilter) {
   ASSERT_EQ(1, results[1].key());
   ASSERT_EQ(2, results[2].key());
 
-  auto filterFunc = [](uint64_t key) {
+  auto filter_func = [](uint64_t key) {
     if (key == 0UL || key == 3UL) {
       return true;
     }
     return false;
   };
-  ctx->set_filter(filterFunc);
+  ctx->set_filter(filter_func);
 
   // after set filter
   ASSERT_EQ(0, streamer->search_impl(sparse_dim_count, sparse_indices.data(),
@@ -1236,12 +1238,12 @@ TEST_F(HnswSparseStreamerTest, TestMaxIndexSize) {
     return;
   }
 
-  size_t writeCnt1 = 10000;
+  size_t write_cnt1 = 10000;
   IndexQueryMeta qmeta(IndexMeta::MetaType::MT_SPARSE,
                        IndexMeta::DataType::DT_FP32);
   auto ctx = streamer->create_context();
 
-  for (size_t i = 0; i < writeCnt1; ++i) {
+  for (size_t i = 0; i < write_cnt1; ++i) {
     NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
     NumericalVector<float> sparse_velues(sparse_dim_count);
 
@@ -1259,8 +1261,8 @@ TEST_F(HnswSparseStreamerTest, TestMaxIndexSize) {
   size_t increment = rss1 - rss0;
 
   size_t total_write =
-      writeCnt1 * sparse_dim_count * (sizeof(uint16_t) + sizeof(float)) +
-      writeCnt1 * 32 + writeCnt1 * 100 * 4;
+      write_cnt1 * sparse_dim_count * (sizeof(uint16_t) + sizeof(float)) +
+      write_cnt1 * 32 + write_cnt1 * 100 * 4;
 
   ASSERT_GT(total_write, increment * 0.8f);
   ASSERT_LT(total_write, increment * 1.2f);
@@ -1355,13 +1357,13 @@ TEST_F(HnswSparseStreamerTest, TestIndexSizeQuota) {
   ASSERT_EQ(0, streamer->init(meta, params));
   ASSERT_EQ(0, streamer->open(storage));
 
-  size_t writeCnt1 = 850;
+  size_t write_cnt1 = 850;
   int ret = 0;
   auto ctx = streamer->create_context();
   IndexQueryMeta qmeta(IndexMeta::MetaType::MT_SPARSE,
                        IndexMeta::DataType::DT_FP32);
 
-  for (size_t i = 0; i < writeCnt1; ++i) {
+  for (size_t i = 0; i < write_cnt1; ++i) {
     NumericalVector<uint32_t> sparse_indices(sparse_dim_count);
     NumericalVector<float> sparse_velues(sparse_dim_count);
 
@@ -1370,10 +1372,10 @@ TEST_F(HnswSparseStreamerTest, TestIndexSizeQuota) {
       sparse_velues[j] = i;
     }
 
-    int iRet = streamer->add_impl(i, sparse_dim_count, sparse_indices.data(),
-                                  sparse_velues.data(), qmeta, ctx);
-    if (iRet != 0) {
-      ret = iRet;
+    int i_ret = streamer->add_impl(i, sparse_dim_count, sparse_indices.data(),
+                                   sparse_velues.data(), qmeta, ctx);
+    if (i_ret != 0) {
+      ret = i_ret;
     }
   }
 
@@ -1502,10 +1504,10 @@ TEST_F(HnswSparseStreamerTest, TestCheckStats) {
   ASSERT_EQ(init_size, stats.index_size());
   ASSERT_EQ(0U, stats.dumped_size());
   ASSERT_EQ(0U, stats.check_point());
-  auto createTime = stats.create_time();
-  auto updateTime = stats.update_time();
-  ASSERT_GT(createTime, 0UL);
-  ASSERT_EQ(createTime, updateTime);
+  auto create_time = stats.create_time();
+  auto update_time = stats.update_time();
+  ASSERT_GT(create_time, 0UL);
+  ASSERT_EQ(create_time, update_time);
 
   auto ctx = streamer->create_context();
   ASSERT_NE(nullptr, ctx);
@@ -1538,8 +1540,8 @@ TEST_F(HnswSparseStreamerTest, TestCheckStats) {
   ASSERT_GT(size3, size2);
   LOG_INFO("size1=%zu size2=%zu size3=%zu", size1, size2, size3);
 
-  uint64_t checkPoint = 23423UL;
-  streamer->flush(checkPoint);
+  uint64_t check_point = 23423UL;
+  streamer->flush(check_point);
   size_t size4 = stats.index_size();
   ASSERT_EQ(size3, size4);
   auto stats1 = streamer->stats();
@@ -1549,11 +1551,11 @@ TEST_F(HnswSparseStreamerTest, TestCheckStats) {
   ASSERT_EQ(0U, stats1.discarded_count());
   ASSERT_GT(stats1.index_size(), 0U);
   ASSERT_EQ(0U, stats1.dumped_size());
-  ASSERT_EQ(checkPoint, stats1.check_point());
-  auto createTime1 = stats1.create_time();
-  auto updateTime1 = stats1.update_time();
-  ASSERT_GE(updateTime1, createTime1);
-  ASSERT_EQ(createTime, createTime1);
+  ASSERT_EQ(check_point, stats1.check_point());
+  auto create_time1 = stats1.create_time();
+  auto update_time1 = stats1.update_time();
+  ASSERT_GE(update_time1, create_time1);
+  ASSERT_EQ(create_time, create_time1);
   streamer->close();
 
   ASSERT_EQ(0, streamer->open(storage));
@@ -1571,14 +1573,14 @@ TEST_F(HnswSparseStreamerTest, TestCheckStats) {
   ASSERT_EQ(0U, stats2.discarded_count());
   ASSERT_GT(stats1.index_size(), 0);
   ASSERT_EQ(0U, stats2.dumped_size());
-  ASSERT_EQ(checkPoint, stats2.check_point());
-  auto createTime2 = stats2.create_time();
-  auto updateTime2 = stats2.update_time();
-  ASSERT_EQ(createTime2, createTime1);
-  ASSERT_GE(updateTime2, updateTime1);
+  ASSERT_EQ(check_point, stats2.check_point());
+  auto create_time2 = stats2.create_time();
+  auto update_time2 = stats2.update_time();
+  ASSERT_EQ(create_time2, create_time1);
+  ASSERT_GE(update_time2, update_time1);
 
   sleep(1);
-  streamer->flush(checkPoint + 1);
+  streamer->flush(check_point + 1);
 
   ASSERT_NE(0, streamer->add_impl(0U, sparse_dim_count, sparse_indices.data(),
                                   sparse_velues.data(), qmeta, ctx));
@@ -1590,11 +1592,11 @@ TEST_F(HnswSparseStreamerTest, TestCheckStats) {
   ASSERT_EQ(1U, stats3.discarded_count());
   ASSERT_EQ(stats2.index_size(), stats3.index_size());
   ASSERT_EQ(0U, stats3.dumped_size());
-  ASSERT_EQ(checkPoint + 1, stats3.check_point());
-  auto createTime3 = stats3.create_time();
-  auto updateTime3 = stats3.update_time();
-  ASSERT_EQ(createTime3, createTime1);
-  ASSERT_GT(updateTime3, updateTime2);
+  ASSERT_EQ(check_point + 1, stats3.check_point());
+  auto create_time3 = stats3.create_time();
+  auto update_time3 = stats3.update_time();
+  ASSERT_EQ(create_time3, create_time1);
+  ASSERT_GT(update_time3, update_time2);
 
   auto dpath = dir_ + "dumpIndex";
   auto dumper = IndexFactory::CreateDumper("FileDumper");
@@ -1729,7 +1731,7 @@ TEST_F(HnswSparseStreamerTest, TestDumpIndexAndAdd) {
   int code = 0;
   std::atomic<bool> async_started{false};
 
-  auto addVector = [&](int a, int b, bool signal_start) {
+  auto add_vector = [&](int a, int b, bool signal_start) {
     if (signal_start) {
       async_started.store(true, std::memory_order_release);
     }
@@ -1753,8 +1755,8 @@ TEST_F(HnswSparseStreamerTest, TestDumpIndexAndAdd) {
     }
   };
 
-  addVector(0, 2000, false);
-  auto t2 = std::async(std::launch::async, addVector, 2000, 3000, true);
+  add_vector(0, 2000, false);
+  auto t2 = std::async(std::launch::async, add_vector, 2000, 3000, true);
   auto path1 = dir_ + "dumpIndex1";
   auto dumper1 = IndexFactory::CreateDumper("FileDumper");
   ASSERT_NE(dumper1, nullptr);
@@ -2118,11 +2120,11 @@ TEST_F(HnswSparseStreamerTest, TestBruteForceSetupInContext) {
   }
 
   size_t topk = 20;
-  [[maybe_unused]] uint64_t knnTotalTime = 0;
-  [[maybe_unused]] uint64_t linearTotalTime = 0;
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  [[maybe_unused]] uint64_t knn_total_time = 0;
+  [[maybe_unused]] uint64_t linear_total_time = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
 
   bool set_bf_threshold = false;
   bool use_update = false;
@@ -2130,14 +2132,14 @@ TEST_F(HnswSparseStreamerTest, TestBruteForceSetupInContext) {
   size_t step = 50;
   for (size_t i = 0; i < cnt; i += step) {
     // for (size_t i = 0; i < cnt; i++) {
-    auto linearCtx = streamer->create_context();
-    auto knnCtx = streamer->create_context();
+    auto linear_ctx = streamer->create_context();
+    auto knn_ctx = streamer->create_context();
 
-    ASSERT_TRUE(!!linearCtx);
-    ASSERT_TRUE(!!knnCtx);
+    ASSERT_TRUE(!!linear_ctx);
+    ASSERT_TRUE(!!knn_ctx);
 
-    linearCtx->set_topk(topk);
-    knnCtx->set_topk(topk);
+    linear_ctx->set_topk(topk);
+    knn_ctx->set_topk(topk);
 
     NumericalVector<uint32_t> query_sparse_indices(sparse_dim_count);
     NumericalVector<float> query_sparse_velues(sparse_dim_count);
@@ -2150,57 +2152,57 @@ TEST_F(HnswSparseStreamerTest, TestBruteForceSetupInContext) {
 
     if (set_bf_threshold) {
       if (use_update) {
-        ailego::Params streamerParamsExtra;
+        ailego::Params streamer_params_extra;
 
-        streamerParamsExtra.set(
+        streamer_params_extra.set(
             "proxima.hnsw.sparse_streamer.brute_force_threshold", cnt);
-        knnCtx->update(streamerParamsExtra);
+        knn_ctx->update(streamer_params_extra);
       } else {
-        knnCtx->set_bruteforce_threshold(cnt);
+        knn_ctx->set_bruteforce_threshold(cnt);
       }
 
       use_update = !use_update;
     }
     ASSERT_EQ(
         0, streamer->search_impl(sparse_dim_count, query_sparse_indices.data(),
-                                 query_sparse_velues.data(), qmeta, knnCtx));
+                                 query_sparse_velues.data(), qmeta, knn_ctx));
 
     auto t2 = ailego::Realtime::MicroSeconds();
 
     ASSERT_EQ(0, streamer->search_bf_impl(
                      sparse_dim_count, query_sparse_indices.data(),
-                     query_sparse_velues.data(), qmeta, linearCtx));
+                     query_sparse_velues.data(), qmeta, linear_ctx));
 
     // auto t3 = ailego::Realtime::MicroSeconds();
 
     if (set_bf_threshold) {
-      linearTotalTime += t2 - t1;
+      linear_total_time += t2 - t1;
     } else {
-      knnTotalTime += t2 - t1;
+      knn_total_time += t2 - t1;
     }
 
     set_bf_threshold = !set_bf_threshold;
 
-    auto &knnResult = knnCtx->result();
+    auto &knn_result = knn_ctx->result();
     // ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += cnt - 1 == knnResult[0].key();
+    topk1_hits += cnt - 1 == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(cnt - 1, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(cnt - 1, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * step * 1.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * step * 1.0f / cnt;
   // float cost = linearTotalTime * 1.0f / knnTotalTime;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
@@ -2209,7 +2211,7 @@ TEST_F(HnswSparseStreamerTest, TestBruteForceSetupInContext) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.95f);
+  EXPECT_GT(topk1_recall, 0.95f);
   // EXPECT_GT(cost, 2.0f);
 }
 
@@ -2243,11 +2245,11 @@ TEST_F(HnswSparseStreamerTest, TestQueryFilteringRatio) {
   auto ctx = streamer->create_context();
   ASSERT_TRUE(!!ctx);
 
-  auto linearCtx = streamer->create_context();
-  ASSERT_TRUE(!!linearCtx);
+  auto linear_ctx = streamer->create_context();
+  ASSERT_TRUE(!!linear_ctx);
 
-  auto knnCtx = streamer->create_context();
-  ASSERT_TRUE(!!knnCtx);
+  auto knn_ctx = streamer->create_context();
+  ASSERT_TRUE(!!knn_ctx);
 
   std::vector<NumericalVector<uint32_t>> sparse_indices_list;
   std::vector<NumericalVector<float>> sparse_vec_list;
@@ -2265,15 +2267,15 @@ TEST_F(HnswSparseStreamerTest, TestQueryFilteringRatio) {
 
   // streamer->print_debug_info();
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
-  [[maybe_unused]] uint64_t knnTotalTime = 0;
-  [[maybe_unused]] uint64_t linearTotalTime = 0;
+  [[maybe_unused]] uint64_t knn_total_time = 0;
+  [[maybe_unused]] uint64_t linear_total_time = 0;
 
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
 
   size_t step = 100;
   for (size_t i = 0; i < cnt; i += step) {
@@ -2283,41 +2285,41 @@ TEST_F(HnswSparseStreamerTest, TestQueryFilteringRatio) {
     auto t1 = ailego::Realtime::MicroSeconds();
 
     ASSERT_EQ(0, streamer->search_impl(sparse_dim_count, sparse_indices.data(),
-                                       sparse_vec.data(), qmeta, knnCtx));
+                                       sparse_vec.data(), qmeta, knn_ctx));
 
     auto t2 = ailego::Realtime::MicroSeconds();
 
     ASSERT_EQ(0,
               streamer->search_bf_impl(sparse_dim_count, sparse_indices.data(),
-                                       sparse_vec.data(), qmeta, linearCtx));
+                                       sparse_vec.data(), qmeta, linear_ctx));
 
     auto t3 = ailego::Realtime::MicroSeconds();
 
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
     // std::cout << "i: " << i << std::endl;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * step * 1.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * step * 1.0f / cnt;
   // float cost = linearTotalTime * 1.0f / knnTotalTime;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
@@ -2326,7 +2328,7 @@ TEST_F(HnswSparseStreamerTest, TestQueryFilteringRatio) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.80f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
   // EXPECT_GT(cost, 2.0f);
 }
 
@@ -2359,11 +2361,11 @@ TEST_F(HnswSparseStreamerTest, TestAddAndSearchWithID) {
   auto ctx = streamer->create_context();
   ASSERT_TRUE(!!ctx);
 
-  auto linearCtx = streamer->create_context();
-  ASSERT_TRUE(!!linearCtx);
+  auto linear_ctx = streamer->create_context();
+  ASSERT_TRUE(!!linear_ctx);
 
-  auto knnCtx = streamer->create_context();
-  ASSERT_TRUE(!!knnCtx);
+  auto knn_ctx = streamer->create_context();
+  ASSERT_TRUE(!!knn_ctx);
 
   std::vector<NumericalVector<uint32_t>> sparse_indices_list;
   std::vector<NumericalVector<float>> sparse_vec_list;
@@ -2388,15 +2390,15 @@ TEST_F(HnswSparseStreamerTest, TestAddAndSearchWithID) {
 
   // streamer->print_debug_info();
   size_t topk = 200;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
 
-  [[maybe_unused]] uint64_t knnTotalTime = 0;
-  [[maybe_unused]] uint64_t linearTotalTime = 0;
+  [[maybe_unused]] uint64_t knn_total_time = 0;
+  [[maybe_unused]] uint64_t linear_total_time = 0;
 
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
 
   for (size_t i = 0; i < cnt / 100; i += 2) {
     const auto &sparse_indices = sparse_indices_list[i];
@@ -2405,34 +2407,34 @@ TEST_F(HnswSparseStreamerTest, TestAddAndSearchWithID) {
     auto t1 = ailego::Realtime::MicroSeconds();
 
     ASSERT_EQ(0, streamer->search_impl(sparse_dim_count, sparse_indices.data(),
-                                       sparse_vec.data(), qmeta, knnCtx));
+                                       sparse_vec.data(), qmeta, knn_ctx));
 
     auto t2 = ailego::Realtime::MicroSeconds();
 
     ASSERT_EQ(0,
               streamer->search_bf_impl(sparse_dim_count, sparse_indices.data(),
-                                       sparse_vec.data(), qmeta, linearCtx));
+                                       sparse_vec.data(), qmeta, linear_ctx));
 
     auto t3 = ailego::Realtime::MicroSeconds();
 
-    knnTotalTime += t2 - t1;
-    linearTotalTime += t3 - t2;
+    knn_total_time += t2 - t1;
+    linear_total_time += t3 - t2;
 
     // std::cout << "i: " << i << std::endl;
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
@@ -2449,27 +2451,26 @@ TEST_F(HnswSparseStreamerTest, TestAddAndSearchWithID) {
                            &sparse_indices_buffer, &sparse_values_buffer));
           ASSERT_EQ(sparse_dim_count, sparse_count);
 
-          const auto &_sparse_indices = sparse_indices_list[result[j].index()];
-          const auto &_sparse_vec = sparse_vec_list[result[j].index()];
+          const auto &sparse_indices = sparse_indices_list[result[j].index()];
+          const auto &sparse_vec = sparse_vec_list[result[j].index()];
           std::string original_sparse_values_buffer;
-          original_sparse_values_buffer.resize(_sparse_vec.size() *
+          original_sparse_values_buffer.resize(sparse_vec.size() *
                                                sizeof(float));
           memcpy((char *)original_sparse_values_buffer.data(),
-                 (char *)_sparse_vec.data(),
-                 _sparse_vec.size() * sizeof(float));
+                 (char *)sparse_vec.data(), sparse_vec.size() * sizeof(float));
 
-          ASSERT_EQ(sparse_indices_buffer, _sparse_indices);
+          ASSERT_EQ(sparse_indices_buffer, sparse_indices);
 
           ASSERT_EQ(sparse_values_buffer, original_sparse_values_buffer);
         }
       };
 
-      func(linearResult);
-      func(knnResult);
+      func(linear_result);
+      func(knn_result);
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 100.0f / (float(cnt) / 100);
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 100.0f / (float(cnt) / 100);
   // float cost = linearTotalTime * 1.0f / knnTotalTime;
 #if 0
     printf("knnTotalTime=%zd linearTotalTime=%zd totalHits=%d totalCnts=%d "
@@ -2478,7 +2479,7 @@ TEST_F(HnswSparseStreamerTest, TestAddAndSearchWithID) {
            topk1Recall, cost);
 #endif
   EXPECT_GT(recall, 0.80f);
-  EXPECT_GT(topk1Recall, 0.80f);
+  EXPECT_GT(topk1_recall, 0.80f);
   // EXPECT_GT(cost, 2.0f);
 }
 
diff --git a/tests/core/algorithm/ivf/ivf_searcher_test.cc b/tests/core/algorithm/ivf/ivf_searcher_test.cc
index bd4a868a6..8d20a1924 100644
--- a/tests/core/algorithm/ivf/ivf_searcher_test.cc
+++ b/tests/core/algorithm/ivf/ivf_searcher_test.cc
@@ -2856,8 +2856,8 @@ TEST_F(IVFSearcherTest, TestProvider) {
   // test searcher
   IndexSearcher::Pointer searcher = IndexFactory::CreateSearcher("IVFSearcher");
   ASSERT_NE(searcher, nullptr);
-  Params searcherParams;
-  ASSERT_EQ(0, searcher->init(searcherParams));
+  Params searcher_params;
+  ASSERT_EQ(0, searcher->init(searcher_params));
   auto container = IndexFactory::CreateStorage("FileReadStorage");
   ASSERT_EQ(0, container->open(path, false));
   ASSERT_EQ(0, searcher->load(container, IndexMetric::Pointer()));
@@ -2946,8 +2946,8 @@ TEST_F(IVFSearcherTest, TestProviderInt8) {
   // test searcher
   IndexSearcher::Pointer searcher = IndexFactory::CreateSearcher("IVFSearcher");
   ASSERT_NE(searcher, nullptr);
-  Params searcherParams;
-  ASSERT_EQ(0, searcher->init(searcherParams));
+  Params searcher_params;
+  ASSERT_EQ(0, searcher->init(searcher_params));
   auto container = IndexFactory::CreateStorage("FileReadStorage");
   ASSERT_EQ(0, container->open(path, false));
   ASSERT_EQ(0, searcher->load(container, IndexMetric::Pointer()));
@@ -3032,8 +3032,8 @@ TEST_F(IVFSearcherTest, TestSearcherReuse) {
   // test searcher
   IndexSearcher::Pointer searcher = IndexFactory::CreateSearcher("IVFSearcher");
   ASSERT_NE(searcher, nullptr);
-  Params searcherParams;
-  ASSERT_EQ(0, searcher->init(searcherParams));
+  Params searcher_params;
+  ASSERT_EQ(0, searcher->init(searcher_params));
   auto container = IndexFactory::CreateStorage("FileReadStorage");
   ASSERT_EQ(0, container->open(path1, false));
   ASSERT_EQ(0, searcher->load(container, IndexMetric::Pointer()));
@@ -3059,7 +3059,7 @@ TEST_F(IVFSearcherTest, TestSearcherReuse) {
 
   auto container2 = IndexFactory::CreateStorage("FileReadStorage");
   ASSERT_EQ(0, container2->open(path2, false));
-  ASSERT_EQ(0, searcher->init(searcherParams));
+  ASSERT_EQ(0, searcher->init(searcher_params));
   ASSERT_EQ(0, searcher->load(container2, IndexMetric::Pointer()));
 
   auto provider2 = searcher->create_provider();
@@ -3109,8 +3109,8 @@ TEST_F(IVFSearcherTest, TestInt8QuantizerWithL2) {
   // test searcher
   IndexSearcher::Pointer searcher = IndexFactory::CreateSearcher("IVFSearcher");
   ASSERT_NE(searcher, nullptr);
-  Params searcherParams;
-  ASSERT_EQ(0, searcher->init(searcherParams));
+  Params searcher_params;
+  ASSERT_EQ(0, searcher->init(searcher_params));
   auto container = IndexFactory::CreateStorage("FileReadStorage");
   ASSERT_EQ(0, container->open(path, false));
   ASSERT_EQ(0, searcher->load(container, IndexMetric::Pointer()));
diff --git a/tests/core/algorithm/vamana/vamana_fast_search_test.cc b/tests/core/algorithm/vamana/vamana_fast_search_test.cc
index 7250cf1c1..6eabd8cc7 100644
--- a/tests/core/algorithm/vamana/vamana_fast_search_test.cc
+++ b/tests/core/algorithm/vamana/vamana_fast_search_test.cc
@@ -41,8 +41,8 @@ class VamanaFastSearchTest : public testing::Test {
     test_util::RemoveTestPath(path_);
   }
 
-  void CreateGraph(const std::vector<float> &values,
-                   const std::vector<std::vector<node_id_t>> &rows) {
+  void create_graph(const std::vector<float> &values,
+                    const std::vector<std::vector<node_id_t>> &rows) {
     ASSERT_EQ(values.size(), rows.size());
     storage_ = IndexFactory::CreateStorage("MMapFileStorage");
     ASSERT_TRUE(storage_);
@@ -83,10 +83,10 @@ class VamanaFastSearchTest : public testing::Test {
     algorithm_ =
         std::make_unique<VamanaAlgorithm<VamanaContiguousStreamerEntity>>(
             *entity_);
-    MakeContext();
+    make_context();
   }
 
-  void MakeContext(std::optional<VisitFilter::Mode> mode = std::nullopt) {
+  void make_context(std::optional<VisitFilter::Mode> mode = std::nullopt) {
     context_ = std::make_unique<VamanaContext>(kDimension, metric_, entity_);
     if (mode) context_->set_filter_mode(*mode);
     context_->set_max_scan_num(10000);
@@ -103,7 +103,7 @@ class VamanaFastSearchTest : public testing::Test {
         });
   }
 
-  void Search(float value, uint32_t capacity) {
+  void search(float value, uint32_t capacity) {
     ASSERT_TRUE(context_);
     evaluated_.clear();
     context_->clear();
@@ -117,7 +117,7 @@ class VamanaFastSearchTest : public testing::Test {
     context_->topk_to_result();
   }
 
-  std::vector<std::pair<uint64_t, float>> Results() const {
+  std::vector<std::pair<uint64_t, float>> results() const {
     std::vector<std::pair<uint64_t, float>> result;
     for (const auto &doc : context_->result()) {
       result.emplace_back(doc.key(), doc.score());
@@ -138,7 +138,7 @@ class VamanaFastSearchTest : public testing::Test {
 };
 
 TEST_F(VamanaFastSearchTest, ContextDefaultsToBitmapAndAllowsExplicitOverride) {
-  CreateGraph({10, 2}, {{1}, {0}});
+  create_graph({10, 2}, {{1}, {0}});
   EXPECT_EQ(VisitFilter::BitMap, context_->visit_filter().get_mode());
   for (auto type :
        {VamanaContext::kBuilderContext, VamanaContext::kSearcherContext,
@@ -162,15 +162,15 @@ TEST_F(VamanaFastSearchTest, ContextDefaultsToBitmapAndAllowsExplicitOverride) {
 }
 
 TEST_F(VamanaFastSearchTest, LocalOptimumReusesRowThenPoolFindsBetterPoint) {
-  CreateGraph({10, 2, 3, 1}, {{1, 2}, {0, 2}, {3}, {}});
-  Search(0, 4);
+  create_graph({10, 2, 3, 1}, {{1, 2}, {0, 2}, {3}, {}});
+  search(0, 4);
   const std::vector<std::vector<node_id_t>> expected = {
       {0}, {1, 2}, {0, 2}, {3}};
   EXPECT_EQ(expected, evaluated_);
   EXPECT_EQ(6U, context_->get_scan_num());
-  const std::vector<std::pair<uint64_t, float>> results = {
+  const std::vector<std::pair<uint64_t, float>> expected_results = {
       {3, 1}, {1, 4}, {2, 9}, {0, 100}};
-  EXPECT_EQ(results, Results());
+  EXPECT_EQ(expected_results, results());
 }
 
 TEST_F(VamanaFastSearchTest, HundredStepCapRecomputesLandingRow) {
@@ -182,8 +182,8 @@ TEST_F(VamanaFastSearchTest, HundredStepCapRecomputesLandingRow) {
     if (i > 0) rows[i].push_back(i - 1);
     if (i + 1 < kCount) rows[i].push_back(i + 1);
   }
-  CreateGraph(values, rows);
-  Search(0, 1);
+  create_graph(values, rows);
+  search(0, 1);
   ASSERT_EQ(104U, evaluated_.size());
   EXPECT_EQ((std::vector<node_id_t>{98, 100}), evaluated_[100]);
   // Depth 100 stops at node 100, while the cached row belongs to node 99.
@@ -192,67 +192,67 @@ TEST_F(VamanaFastSearchTest, HundredStepCapRecomputesLandingRow) {
   EXPECT_EQ((std::vector<node_id_t>{102}), evaluated_[102]);
   EXPECT_EQ((std::vector<node_id_t>{103}), evaluated_[103]);
   EXPECT_EQ(204U, context_->get_scan_num());
-  EXPECT_EQ((std::vector<std::pair<uint64_t, float>>{{103, 1}}), Results());
+  EXPECT_EQ((std::vector<std::pair<uint64_t, float>>{{103, 1}}), results());
 }
 
 TEST_F(VamanaFastSearchTest, EqualDistanceStopsDescentWithoutLosingNeighbors) {
-  CreateGraph({2, 2, 1}, {{1}, {2}, {}});
-  Search(0, 3);
+  create_graph({2, 2, 1}, {{1}, {2}, {}});
+  search(0, 3);
   EXPECT_EQ(3U, context_->get_scan_num());
-  ASSERT_EQ(3U, Results().size());
-  EXPECT_EQ(2U, Results()[0].first);
-  EXPECT_EQ(1.0f, Results()[0].second);
+  ASSERT_EQ(3U, results().size());
+  EXPECT_EQ(2U, results()[0].first);
+  EXPECT_EQ(1.0f, results()[0].second);
 }
 
 TEST_F(VamanaFastSearchTest, DuplicateNeighborsAndReusedContextMatchFresh) {
-  CreateGraph({10, 2, 3, 1}, {{1, 1, 2}, {0, 2, 2, 1}, {3, 3}, {1, 1}});
-  Search(0, 4);
-  const auto expected = Results();
+  create_graph({10, 2, 3, 1}, {{1, 1, 2}, {0, 2, 2, 1}, {3, 3}, {1, 1}});
+  search(0, 4);
+  const auto expected = results();
   ASSERT_EQ(4U, expected.size());
   EXPECT_EQ(9U, context_->get_scan_num());
   const auto first_trace = evaluated_;
   for (uint32_t capacity : {1U, 4U, 2U, 4U}) {
-    Search(12, capacity);
-    const auto reused_result = Results();
+    search(12, capacity);
+    const auto reused_result = results();
     const auto reused_trace = evaluated_;
     auto reused_context = std::move(context_);
-    MakeContext();
-    Search(12, capacity);
-    EXPECT_EQ(reused_result, Results());
+    make_context();
+    search(12, capacity);
+    EXPECT_EQ(reused_result, results());
     EXPECT_EQ(reused_trace, evaluated_);
     context_ = std::move(reused_context);
-    Search(0, 4);
-    EXPECT_EQ(expected, Results());
+    search(0, 4);
+    EXPECT_EQ(expected, results());
     EXPECT_EQ(first_trace, evaluated_);
   }
 }
 
 TEST_F(VamanaFastSearchTest, EmptyNeighborRowKeepsTheEntryPoint) {
-  CreateGraph({0}, {{}});
-  Search(0, 1);
+  create_graph({0}, {{}});
+  search(0, 1);
   EXPECT_EQ((std::vector<std::vector<node_id_t>>{{0}}), evaluated_);
-  EXPECT_EQ((std::vector<std::pair<uint64_t, float>>{{0, 0}}), Results());
+  EXPECT_EQ((std::vector<std::pair<uint64_t, float>>{{0, 0}}), results());
 }
 
 TEST_F(VamanaFastSearchTest, ExactVisitModesPreserveResultsAndSearchTrace) {
-  CreateGraph({10, 2, 3, 1}, {{1, 1, 2}, {0, 2, 2, 1}, {3, 3}, {1, 1}});
+  create_graph({10, 2, 3, 1}, {{1, 1, 2}, {0, 2, 2, 1}, {3, 3}, {1, 1}});
   for (float query : {0.0f, 12.0f}) {
     for (uint32_t capacity : {1U, 4U}) {
-      MakeContext(VisitFilter::ByteMap);
-      Search(query, capacity);
-      const auto expected = Results();
+      make_context(VisitFilter::ByteMap);
+      search(query, capacity);
+      const auto expected = results();
       const auto expected_trace = evaluated_;
-      MakeContext(VisitFilter::BitMap);
-      Search(query, capacity);
-      EXPECT_EQ(expected, Results());
+      make_context(VisitFilter::BitMap);
+      search(query, capacity);
+      EXPECT_EQ(expected, results());
       EXPECT_EQ(expected_trace, evaluated_);
     }
   }
 }
 
 TEST_F(VamanaFastSearchTest, InvalidVisitFilterFailsSearchExplicitly) {
-  CreateGraph({10, 2, 3, 1}, {{1, 2}, {0, 2}, {3}, {}});
-  MakeContext(VisitFilter::Default);
+  create_graph({10, 2, 3, 1}, {{1, 2}, {0, 2}, {3}, {}});
+  make_context(VisitFilter::Default);
   context_->set_topk(4);
   context_->set_ef(4);
   std::array<float, kDimension> query{};
diff --git a/tests/core/algorithm/vamana/vamana_streamer_test.cc b/tests/core/algorithm/vamana/vamana_streamer_test.cc
index 52096ba19..08e62daac 100644
--- a/tests/core/algorithm/vamana/vamana_streamer_test.cc
+++ b/tests/core/algorithm/vamana/vamana_streamer_test.cc
@@ -65,7 +65,7 @@ class VamanaStreamerTest : public testing::Test {
   void SetUp() override;
   void TearDown() override;
 
-  IndexStreamer::Pointer CreateVamanaStreamer(
+  IndexStreamer::Pointer create_vamana_streamer(
       const ailego::Params &extra_params = ailego::Params());
 
   static std::string dir_;
@@ -125,20 +125,20 @@ class VamanaPrefetchContextTest : public testing::Test {
     metric_ = IndexFactory::CreateMetric("SquaredEuclidean");
     ASSERT_TRUE(metric_);
     ASSERT_EQ(0, metric_->init(meta, ailego::Params()));
-    entity_ = CreateEntity(960, 64);
+    entity_ = create_entity(960, 64);
     context_ =
         std::make_unique<VamanaContext>(meta.dimension(), metric_, entity_);
     ASSERT_EQ(0, context_->init(VamanaContext::kStreamerContext));
   }
 
-  VamanaEntity::Pointer CreateEntity(size_t vector_size, uint32_t max_degree) {
+  VamanaEntity::Pointer create_entity(size_t vector_size, uint32_t max_degree) {
     auto entity = std::make_shared<VamanaContiguousStreamerEntity>(stats_);
     entity->set_vector_size(vector_size);
     entity->set_max_degree(max_degree);
     return entity;
   }
 
-  void ExpectPrefetch(uint32_t offset, uint32_t lines) const {
+  void expect_prefetch(uint32_t offset, uint32_t lines) const {
     EXPECT_EQ(offset, context_->po());
     EXPECT_EQ(lines, context_->pl());
   }
@@ -155,7 +155,7 @@ TEST_F(VamanaPrefetchContextTest, UnchangedRequestsReuseResolvedValues) {
   params.set(PARAM_VAMANA_STREAMER_PL, core_interface::kDefaultPrefetchLines);
   // Matching the initial requested values must still resolve a fresh context.
   ASSERT_EQ(0, context_->update(params));
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
 
   // Change only the fixture's metadata, without publishing an entity refresh.
   // An unnecessary resolve would now produce 96/1 instead of the cached 48/2.
@@ -164,23 +164,23 @@ TEST_F(VamanaPrefetchContextTest, UnchangedRequestsReuseResolvedValues) {
   entity_->set_max_degree(96);
   for (int i = 0; i < 3; ++i) {
     ASSERT_EQ(0, context_->update(params));
-    ExpectPrefetch(48, 2);
+    expect_prefetch(48, 2);
   }
   ASSERT_EQ(0, context_->update(ailego::Params()));
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
   ailego::Params ef;
   ef.set(PARAM_VAMANA_STREAMER_EF, 123U);
   ASSERT_EQ(0, context_->update(ef));
   EXPECT_EQ(123U, context_->ef());
   EXPECT_EQ(123U, context_->search_heap().topk().limit());
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
 
   // A notified entity change must resolve even when requests are unchanged.
   ASSERT_EQ(
       0, context_->update_context(VamanaContext::kStreamerContext,
                                   IndexMeta(IndexMeta::DataType::DT_FP32, 16),
                                   metric_, entity_, 1));
-  ExpectPrefetch(96, 1);
+  expect_prefetch(96, 1);
 }
 
 TEST_F(VamanaPrefetchContextTest, UnchangedSettersKeepResolvedValues) {
@@ -190,9 +190,9 @@ TEST_F(VamanaPrefetchContextTest, UnchangedSettersKeepResolvedValues) {
   context_->set_po(core_interface::kDefaultPrefetchOffset);
   context_->set_pl(core_interface::kDefaultPrefetchLines);
   // Same requests must neither overwrite effective values nor invalidate them.
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
   context_->prepare_query_prefetch();
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
 }
 
 TEST_F(VamanaPrefetchContextTest, DirtyValuesResolveEvenForUnchangedRequests) {
@@ -203,7 +203,7 @@ TEST_F(VamanaPrefetchContextTest, DirtyValuesResolveEvenForUnchangedRequests) {
   ailego::Params params;
   params.set(PARAM_VAMANA_STREAMER_PL, 4U);
   ASSERT_EQ(0, context_->update(params));
-  ExpectPrefetch(24, 4);
+  expect_prefetch(24, 4);
 }
 
 TEST_F(VamanaPrefetchContextTest,
@@ -212,75 +212,76 @@ TEST_F(VamanaPrefetchContextTest,
   ailego::Params offset;
   offset.set(PARAM_VAMANA_STREAMER_PO, 48U);
   ASSERT_EQ(0, context_->update(offset));
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
 
   ailego::Params lines;
   lines.set(PARAM_VAMANA_STREAMER_PL, 4U);
   ASSERT_EQ(0, context_->update(lines));
-  ExpectPrefetch(48, 4);  // Manual PO stays 48 rather than becoming auto PO=24.
+  expect_prefetch(48,
+                  4);  // Manual PO stays 48 rather than becoming auto PO=24.
   offset.set(PARAM_VAMANA_STREAMER_PO, core_interface::kDefaultPrefetchOffset);
   ASSERT_EQ(0, context_->update(offset));
-  ExpectPrefetch(24, 4);
+  expect_prefetch(24, 4);
 }
 
 TEST_F(VamanaPrefetchContextTest, PartialUpdatesPreserveAutomaticOffset) {
   ASSERT_EQ(0, context_->update(ailego::Params()));
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
 
   ailego::Params lines;
   lines.set(PARAM_VAMANA_STREAMER_PL, 4U);
   ASSERT_EQ(0, context_->update(lines));
-  ExpectPrefetch(24, 4);
+  expect_prefetch(24, 4);
 
   ailego::Params ef;
   ef.set(PARAM_VAMANA_STREAMER_EF, 123U);
   ASSERT_EQ(0, context_->update(ef));
   EXPECT_EQ(123U, context_->ef());
-  ExpectPrefetch(24, 4);
+  expect_prefetch(24, 4);
   ASSERT_EQ(0, context_->update(ailego::Params()));
-  ExpectPrefetch(24, 4);
+  expect_prefetch(24, 4);
 
   lines.set(PARAM_VAMANA_STREAMER_PL, core_interface::kDefaultPrefetchLines);
   ASSERT_EQ(0, context_->update(lines));
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
 }
 
 TEST_F(VamanaPrefetchContextTest, PartialUpdatesPreserveManualFields) {
   ailego::Params offset;
   offset.set(PARAM_VAMANA_STREAMER_PO, 12U);
   ASSERT_EQ(0, context_->update(offset));
-  ExpectPrefetch(12, 2);
+  expect_prefetch(12, 2);
 
   ailego::Params lines;
   lines.set(PARAM_VAMANA_STREAMER_PL, 4U);
   ASSERT_EQ(0, context_->update(lines));
-  ExpectPrefetch(12, 4);
+  expect_prefetch(12, 4);
 
   offset.set(PARAM_VAMANA_STREAMER_PO, core_interface::kDefaultPrefetchOffset);
   ASSERT_EQ(0, context_->update(offset));
-  ExpectPrefetch(24, 4);
+  expect_prefetch(24, 4);
   lines.set(PARAM_VAMANA_STREAMER_PL, 1U);
   ASSERT_EQ(0, context_->update(lines));
-  ExpectPrefetch(64, 1);
+  expect_prefetch(64, 1);
 
   offset.set(PARAM_VAMANA_STREAMER_PO, 0U);
   ASSERT_EQ(0, context_->update(offset));
-  ExpectPrefetch(0, 1);
+  expect_prefetch(0, 1);
   lines.set(PARAM_VAMANA_STREAMER_PL, core_interface::kDefaultPrefetchLines);
   ASSERT_EQ(0, context_->update(lines));
-  ExpectPrefetch(0, 2);
+  expect_prefetch(0, 2);
 }
 
 TEST_F(VamanaPrefetchContextTest, ResolvesOnlyWhenPreparingAQuery) {
   // Streamer initialization is shared with add_node and two-pass construction.
-  ExpectPrefetch(8, 0);
+  expect_prefetch(8, 0);
   context_->prepare_query_prefetch();
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
   context_->clear();
   context_->prepare_query_prefetch();
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
 
-  VamanaContext search_context(240, metric_, CreateEntity(960, 64));
+  VamanaContext search_context(240, metric_, create_entity(960, 64));
   ASSERT_EQ(0, search_context.init(VamanaContext::kSearcherContext));
   EXPECT_EQ(48U, search_context.po());
   EXPECT_EQ(2U, search_context.pl());
@@ -291,49 +292,49 @@ TEST_F(VamanaPrefetchContextTest, SettersInvalidateResolvedValues) {
   context_->set_pl(4);
   EXPECT_EQ(4U, context_->pl());
   context_->prepare_query_prefetch();
-  ExpectPrefetch(24, 4);
+  expect_prefetch(24, 4);
 
   context_->set_po(12);
   EXPECT_EQ(12U, context_->po());
   ASSERT_EQ(0, context_->update(ailego::Params()));
-  ExpectPrefetch(12, 4);
+  expect_prefetch(12, 4);
 
   context_->set_po(core_interface::kDefaultPrefetchOffset);
   context_->set_pl(core_interface::kDefaultPrefetchLines);
   context_->prepare_query_prefetch();
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
 }
 
 TEST_F(VamanaPrefetchContextTest, EntityRefreshResolvesOriginalRequests) {
   context_->prepare_query_prefetch();
-  ExpectPrefetch(48, 2);
+  expect_prefetch(48, 2);
   ASSERT_EQ(
       0, context_->update_context(VamanaContext::kStreamerContext,
                                   IndexMeta(IndexMeta::DataType::DT_FP32, 16),
-                                  metric_, CreateEntity(64, 96), 1));
-  ExpectPrefetch(96, 1);
+                                  metric_, create_entity(64, 96), 1));
+  expect_prefetch(96, 1);
 
   // Preserve explicit requests too, not their schema-clamped effective values.
   ailego::Params params;
   params.set(PARAM_VAMANA_STREAMER_PO, 128U);
   params.set(PARAM_VAMANA_STREAMER_PL, 16U);
   ASSERT_EQ(0, context_->update(params));
-  ExpectPrefetch(96, 1);
+  expect_prefetch(96, 1);
   ASSERT_EQ(
       0, context_->update_context(VamanaContext::kStreamerContext,
                                   IndexMeta(IndexMeta::DataType::DT_FP32, 1024),
-                                  metric_, CreateEntity(4096, 128), 2));
-  ExpectPrefetch(128, 16);
+                                  metric_, create_entity(4096, 128), 2));
+  expect_prefetch(128, 16);
 }
 
 TEST_F(VamanaPrefetchContextTest, EntityRefreshKeepsBuildDefaultsUnresolved) {
   ASSERT_EQ(
       0, context_->update_context(VamanaContext::kStreamerContext,
                                   IndexMeta(IndexMeta::DataType::DT_FP32, 16),
-                                  metric_, CreateEntity(64, 96), 1));
-  ExpectPrefetch(8, 0);
+                                  metric_, create_entity(64, 96), 1));
+  expect_prefetch(8, 0);
   context_->prepare_query_prefetch();
-  ExpectPrefetch(96, 1);
+  expect_prefetch(96, 1);
 }
 
 std::string VamanaStreamerTest::dir_("vamana_streamer_test_dir/");
@@ -351,7 +352,7 @@ void VamanaStreamerTest::TearDown() {
   zvec::test_util::RemoveTestPath(dir_);
 }
 
-IndexStreamer::Pointer VamanaStreamerTest::CreateVamanaStreamer(
+IndexStreamer::Pointer VamanaStreamerTest::create_vamana_streamer(
     const ailego::Params &extra_params) {
   auto streamer = IndexFactory::CreateStreamer("VamanaStreamer");
   if (!streamer) return nullptr;
@@ -371,7 +372,7 @@ IndexStreamer::Pointer VamanaStreamerTest::CreateVamanaStreamer(
 }
 
 TEST_F(VamanaStreamerTest, TestAddVector) {
-  auto streamer = CreateVamanaStreamer();
+  auto streamer = create_vamana_streamer();
   ASSERT_NE(nullptr, streamer);
 
   auto storage = IndexFactory::CreateStorage("MMapFileStorage");
@@ -398,7 +399,7 @@ TEST_F(VamanaStreamerTest, TestAddVector) {
 }
 
 TEST_F(VamanaStreamerTest, TestLinearSearch) {
-  auto streamer = CreateVamanaStreamer();
+  auto streamer = create_vamana_streamer();
   ASSERT_NE(nullptr, streamer);
 
   auto storage = IndexFactory::CreateStorage("MMapFileStorage");
@@ -445,7 +446,7 @@ TEST_F(VamanaStreamerTest, TestLinearSearch) {
 }
 
 TEST_F(VamanaStreamerTest, TestKnnSearch) {
-  auto streamer = CreateVamanaStreamer();
+  auto streamer = create_vamana_streamer();
   ASSERT_NE(nullptr, streamer);
 
   ailego::Params stg_params;
@@ -466,47 +467,47 @@ TEST_F(VamanaStreamerTest, TestKnnSearch) {
     ASSERT_EQ(0, streamer->add_impl(i, vec.data(), qmeta, ctx));
   }
 
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
   size_t topk = 100;
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  int totalHits = 0;
-  int totalCnts = 0;
-  int topk1Hits = 0;
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  int total_hits = 0;
+  int total_cnts = 0;
+  int topk1_hits = 0;
   for (size_t i = 0; i < cnt; i++) {
     for (size_t j = 0; j < kDim; ++j) {
       vec[j] = static_cast<float>(i) + 0.1f;
     }
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
 
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    topk1Hits += i == knnResult[0].key();
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    topk1_hits += i == knn_result[0].key();
 
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
 
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
-  float topk1Recall = topk1Hits * 1.0f / cnt;
+  float recall = total_hits * 1.0f / total_cnts;
+  float topk1_recall = topk1_hits * 1.0f / cnt;
   EXPECT_GT(recall, 0.90f);
-  EXPECT_GT(topk1Recall, 0.95f);
+  EXPECT_GT(topk1_recall, 0.95f);
 }
 
 TEST_F(VamanaStreamerTest, TestOpenClose) {
-  auto streamer = CreateVamanaStreamer();
+  auto streamer = create_vamana_streamer();
   ASSERT_NE(nullptr, streamer);
 
   constexpr size_t dim_large = 128;
@@ -529,11 +530,11 @@ TEST_F(VamanaStreamerTest, TestOpenClose) {
   ASSERT_EQ(0, storage->open(dir_ + "TestOpenClose.index", true));
   ASSERT_EQ(0, streamer->open(storage));
 
-  size_t testCnt = 200;
+  size_t test_cnt = 200;
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim_large);
   auto ctx = streamer->create_context();
   ASSERT_TRUE(!!ctx);
-  for (size_t i = 0; i < testCnt; i++) {
+  for (size_t i = 0; i < test_cnt; i++) {
     std::vector<float> vec(dim_large);
     for (size_t d = 0; d < dim_large; ++d) {
       vec[d] = static_cast<float>(i);
@@ -558,7 +559,7 @@ TEST_F(VamanaStreamerTest, TestOpenClose) {
     total++;
     iter->next();
   }
-  ASSERT_EQ(testCnt, total);
+  ASSERT_EQ(test_cnt, total);
 }
 
 TEST_F(VamanaStreamerTest, TestKnnMultiThread) {
@@ -589,23 +590,23 @@ TEST_F(VamanaStreamerTest, TestKnnMultiThread) {
   ASSERT_EQ(0, storage->open(dir_ + "TestKnnMultiThread", true));
   ASSERT_EQ(0, streamer->open(storage));
 
-  auto addVector = [&streamer](int baseKey, size_t addCnt) {
+  auto add_vector = [&streamer](int base_key, size_t add_cnt) {
     NumericalVector<float> vec(dim);
     IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
-    size_t succAdd = 0;
+    size_t succ_add = 0;
     auto ctx = streamer->create_context();
-    for (size_t i = 0; i < addCnt; i++) {
+    for (size_t i = 0; i < add_cnt; i++) {
       for (size_t j = 0; j < dim; ++j) {
-        vec[j] = static_cast<float>(i + baseKey);
+        vec[j] = static_cast<float>(i + base_key);
       }
-      succAdd += !streamer->add_impl(baseKey + i, vec.data(), qmeta, ctx);
+      succ_add += !streamer->add_impl(base_key + i, vec.data(), qmeta, ctx);
     }
     streamer->flush(0UL);
-    return succAdd;
+    return succ_add;
   };
-  auto t1 = std::async(std::launch::async, addVector, 0, 1000);
-  auto t2 = std::async(std::launch::async, addVector, 1000, 1000);
-  auto t3 = std::async(std::launch::async, addVector, 2000, 1000);
+  auto t1 = std::async(std::launch::async, add_vector, 0, 1000);
+  auto t2 = std::async(std::launch::async, add_vector, 1000, 1000);
+  auto t3 = std::async(std::launch::async, add_vector, 2000, 1000);
   ASSERT_EQ(1000U, t1.get());
   ASSERT_EQ(1000U, t2.get());
   ASSERT_EQ(1000U, t3.get());
@@ -617,60 +618,60 @@ TEST_F(VamanaStreamerTest, TestKnnMultiThread) {
   auto iter = provider->create_iterator();
   ASSERT_TRUE(!!iter);
   size_t total = 0;
-  uint64_t minKey = 10000;
-  uint64_t maxKey = 0;
+  uint64_t min_key = 10000;
+  uint64_t max_key = 0;
   while (iter->is_valid()) {
     float *data = (float *)iter->data();
     for (size_t d = 0; d < dim; ++d) {
       ASSERT_FLOAT_EQ(static_cast<float>(iter->key()), data[d]);
     }
     total++;
-    minKey = std::min(minKey, iter->key());
-    maxKey = std::max(maxKey, iter->key());
+    min_key = std::min(min_key, iter->key());
+    max_key = std::max(max_key, iter->key());
     iter->next();
   }
   ASSERT_EQ(3000, total);
-  ASSERT_EQ(0, minKey);
-  ASSERT_EQ(2999, maxKey);
+  ASSERT_EQ(0, min_key);
+  ASSERT_EQ(2999, max_key);
 
   // Multi-thread search
   size_t topk = 100;
   size_t cnt = 3000;
-  auto knnSearch = [&]() {
+  auto knn_search = [&]() {
     NumericalVector<float> vec(dim);
-    auto linearCtx = streamer->create_context();
-    auto knnCtx = streamer->create_context();
+    auto linear_ctx = streamer->create_context();
+    auto knn_ctx = streamer->create_context();
     IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
-    linearCtx->set_topk(topk);
-    knnCtx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    linear_ctx->set_topk(topk);
+    knn_ctx->set_topk(topk);
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     for (size_t i = 0; i < cnt; i += 1) {
       for (size_t j = 0; j < dim; ++j) {
         vec[j] = static_cast<float>(i) + 0.1f;
       }
-      ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
-      ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
-      auto &knnResult = knnCtx->result();
-      ASSERT_EQ(topk, knnResult.size());
-      auto &linearResult = linearCtx->result();
-      ASSERT_EQ(topk, linearResult.size());
-      ASSERT_EQ(i, linearResult[0].key());
+      ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
+      ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
+      auto &knn_result = knn_ctx->result();
+      ASSERT_EQ(topk, knn_result.size());
+      auto &linear_result = linear_ctx->result();
+      ASSERT_EQ(topk, linear_result.size());
+      ASSERT_EQ(i, linear_result[0].key());
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
-          if (linearResult[j].key() == knnResult[k].key()) {
-            totalHits++;
+          if (linear_result[j].key() == knn_result[k].key()) {
+            total_hits++;
             break;
           }
         }
       }
     }
-    ASSERT_TRUE((totalHits * 1.0f / totalCnts) > 0.80f);
+    ASSERT_TRUE((total_hits * 1.0f / total_cnts) > 0.80f);
   };
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
-  auto s3 = std::async(std::launch::async, knnSearch);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
+  auto s3 = std::async(std::launch::async, knn_search);
   s1.wait();
   s2.wait();
   s3.wait();
@@ -680,7 +681,7 @@ TEST_F(VamanaStreamerTest, TestContiguousMemory) {
   ailego::Params extra;
   extra.set(PARAM_VAMANA_STREAMER_USE_CONTIGUOUS_MEMORY, true);
   extra.set(PARAM_VAMANA_STREAMER_BRUTE_FORCE_THRESHOLD, 2000U);
-  auto streamer = CreateVamanaStreamer(extra);
+  auto streamer = create_vamana_streamer(extra);
   ASSERT_NE(nullptr, streamer);
 
   auto storage = IndexFactory::CreateStorage("MMapFileStorage");
@@ -691,7 +692,7 @@ TEST_F(VamanaStreamerTest, TestContiguousMemory) {
 
   // First build with default mmap mode
   {
-    auto builder_streamer = CreateVamanaStreamer();
+    auto builder_streamer = create_vamana_streamer();
     ASSERT_NE(nullptr, builder_streamer);
     ASSERT_EQ(0, builder_streamer->open(storage));
     auto ctx = builder_streamer->create_context();
@@ -717,34 +718,34 @@ TEST_F(VamanaStreamerTest, TestContiguousMemory) {
   size_t topk = 50;
   NumericalVector<float> vec(kDim);
   IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, kDim);
-  auto linearCtx = streamer->create_context();
-  auto knnCtx = streamer->create_context();
-  linearCtx->set_topk(topk);
-  knnCtx->set_topk(topk);
-  int totalHits = 0;
-  int totalCnts = 0;
+  auto linear_ctx = streamer->create_context();
+  auto knn_ctx = streamer->create_context();
+  linear_ctx->set_topk(topk);
+  knn_ctx->set_topk(topk);
+  int total_hits = 0;
+  int total_cnts = 0;
   for (size_t i = 0; i < cnt; i++) {
     for (size_t j = 0; j < kDim; ++j) {
       vec[j] = static_cast<float>(i) + 0.1f;
     }
-    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knnCtx));
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linearCtx));
-    auto &knnResult = knnCtx->result();
-    ASSERT_EQ(topk, knnResult.size());
-    auto &linearResult = linearCtx->result();
-    ASSERT_EQ(topk, linearResult.size());
-    ASSERT_EQ(i, linearResult[0].key());
+    ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, knn_ctx));
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, linear_ctx));
+    auto &knn_result = knn_ctx->result();
+    ASSERT_EQ(topk, knn_result.size());
+    auto &linear_result = linear_ctx->result();
+    ASSERT_EQ(topk, linear_result.size());
+    ASSERT_EQ(i, linear_result[0].key());
     for (size_t k = 0; k < topk; ++k) {
-      totalCnts++;
+      total_cnts++;
       for (size_t j = 0; j < topk; ++j) {
-        if (linearResult[j].key() == knnResult[k].key()) {
-          totalHits++;
+        if (linear_result[j].key() == knn_result[k].key()) {
+          total_hits++;
           break;
         }
       }
     }
   }
-  float recall = totalHits * 1.0f / totalCnts;
+  float recall = total_hits * 1.0f / total_cnts;
   EXPECT_GT(recall, 0.90f);
 }
 
@@ -1137,7 +1138,7 @@ TEST_F(VamanaStreamerTest, TestContiguousPackedGraphTracksNeighborUpdates) {
   params.set(PARAM_VAMANA_STREAMER_MAX_DEGREE, kMaxDegree);
   params.set(PARAM_VAMANA_STREAMER_SEARCH_LIST_SIZE, kCount);
   params.set(PARAM_VAMANA_STREAMER_BRUTE_FORCE_THRESHOLD, 0U);
-  auto builder = CreateVamanaStreamer(params);
+  auto builder = create_vamana_streamer(params);
   ASSERT_TRUE(builder);
 
   auto storage = IndexFactory::CreateStorage("MMapFileStorage");
@@ -1250,48 +1251,48 @@ TEST_F(VamanaStreamerTest, TestContiguousMultiThreadSearch) {
 
   size_t topk = 50;
   size_t cnt = 3000;
-  auto knnSearch = [&]() {
+  auto knn_search = [&]() {
     NumericalVector<float> vec(dim);
-    auto linearCtx = searcher->create_context();
-    auto knnCtx = searcher->create_context();
+    auto linear_ctx = searcher->create_context();
+    auto knn_ctx = searcher->create_context();
     IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
-    linearCtx->set_topk(topk);
-    knnCtx->set_topk(topk);
-    size_t totalCnts = 0;
-    size_t totalHits = 0;
+    linear_ctx->set_topk(topk);
+    knn_ctx->set_topk(topk);
+    size_t total_cnts = 0;
+    size_t total_hits = 0;
     for (size_t i = 0; i < cnt; i++) {
       for (size_t j = 0; j < dim; ++j) {
         vec[j] = static_cast<float>(i) + 0.1f;
       }
-      ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
-      ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
-      auto &knnResult = knnCtx->result();
-      ASSERT_EQ(topk, knnResult.size());
-      auto &linearResult = linearCtx->result();
-      ASSERT_EQ(topk, linearResult.size());
-      ASSERT_EQ(i, linearResult[0].key());
+      ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knn_ctx));
+      ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linear_ctx));
+      auto &knn_result = knn_ctx->result();
+      ASSERT_EQ(topk, knn_result.size());
+      auto &linear_result = linear_ctx->result();
+      ASSERT_EQ(topk, linear_result.size());
+      ASSERT_EQ(i, linear_result[0].key());
       for (size_t k = 0; k < topk; ++k) {
-        totalCnts++;
+        total_cnts++;
         for (size_t j = 0; j < topk; ++j) {
-          if (linearResult[j].key() == knnResult[k].key()) {
-            totalHits++;
+          if (linear_result[j].key() == knn_result[k].key()) {
+            total_hits++;
             break;
           }
         }
       }
     }
-    ASSERT_TRUE((totalHits * 1.0f / totalCnts) > 0.80f);
+    ASSERT_TRUE((total_hits * 1.0f / total_cnts) > 0.80f);
   };
-  auto s1 = std::async(std::launch::async, knnSearch);
-  auto s2 = std::async(std::launch::async, knnSearch);
-  auto s3 = std::async(std::launch::async, knnSearch);
+  auto s1 = std::async(std::launch::async, knn_search);
+  auto s2 = std::async(std::launch::async, knn_search);
+  auto s3 = std::async(std::launch::async, knn_search);
   s1.wait();
   s2.wait();
   s3.wait();
 }
 
 TEST_F(VamanaStreamerTest, TestProvider) {
-  auto streamer = CreateVamanaStreamer();
+  auto streamer = create_vamana_streamer();
   ASSERT_NE(nullptr, streamer);
 
   auto storage = IndexFactory::CreateStorage("MMapFileStorage");
@@ -1332,7 +1333,7 @@ TEST_F(VamanaStreamerTest, TestProvider) {
 }
 
 TEST_F(VamanaStreamerTest, TestAddAndSearch) {
-  auto streamer = CreateVamanaStreamer();
+  auto streamer = create_vamana_streamer();
   ASSERT_NE(nullptr, streamer);
 
   auto storage = IndexFactory::CreateStorage("MMapFileStorage");
@@ -1360,13 +1361,13 @@ TEST_F(VamanaStreamerTest, TestAddAndSearch) {
     // Search for recently added vectors
     size_t current_cnt = (batch + 1) * 200;
     size_t topk = std::min(current_cnt, (size_t)10);
-    auto searchCtx = streamer->create_context();
-    searchCtx->set_topk(topk);
+    auto search_ctx = streamer->create_context();
+    search_ctx->set_topk(topk);
     for (size_t j = 0; j < kDim; ++j) {
       vec[j] = static_cast<float>(base);
     }
-    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, searchCtx));
-    auto &result = searchCtx->result();
+    ASSERT_EQ(0, streamer->search_bf_impl(vec.data(), qmeta, search_ctx));
+    auto &result = search_ctx->result();
     ASSERT_EQ(topk, result.size());
     ASSERT_EQ(base, result[0].key());
   }
@@ -1413,7 +1414,7 @@ TEST_F(VamanaStreamerTest, TestKnnConcurrentAddAndSearch) {
   std::atomic<bool> stop_search{false};
 
   // Concurrent add
-  auto addFuture = std::async(std::launch::async, [&]() {
+  auto add_future = std::async(std::launch::async, [&]() {
     auto ctx = streamer->create_context();
     IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
     NumericalVector<float> vec(dim);
@@ -1427,7 +1428,7 @@ TEST_F(VamanaStreamerTest, TestKnnConcurrentAddAndSearch) {
   });
 
   // Concurrent search
-  auto searchFuture = std::async(std::launch::async, [&]() {
+  auto search_future = std::async(std::launch::async, [&]() {
     auto ctx = streamer->create_context();
     IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
     NumericalVector<float> vec(dim);
@@ -1443,8 +1444,8 @@ TEST_F(VamanaStreamerTest, TestKnnConcurrentAddAndSearch) {
     }
   });
 
-  addFuture.wait();
-  searchFuture.wait();
+  add_future.wait();
+  search_future.wait();
 }
 
 // Test concurrent build (parallel add_impl) which was crashing due to
@@ -1520,7 +1521,7 @@ TEST_F(VamanaStreamerTest, TestConcurrentBuild) {
 }
 
 TEST_F(VamanaStreamerTest, TestBruteForceByPrimaryKeysHonorsFilter) {
-  auto streamer = CreateVamanaStreamer();
+  auto streamer = create_vamana_streamer();
   ASSERT_TRUE(streamer);
   auto storage = IndexFactory::CreateStorage("MMapFileStorage");
   ASSERT_TRUE(storage);
@@ -1714,10 +1715,10 @@ TEST_F(VamanaStreamerTest, TestInt8WithRotate) {
   ASSERT_EQ(0, reformer2->load(storage2));
 
   // Search: verify knn results are non-empty
-  auto knnCtx = streamer2->create_context();
-  knnCtx->set_topk(kTopk);
-  auto linearCtx = streamer2->create_context();
-  linearCtx->set_topk(kTopk);
+  auto knn_ctx = streamer2->create_context();
+  knn_ctx->set_topk(kTopk);
+  auto linear_ctx = streamer2->create_context();
+  linear_ctx->set_topk(kTopk);
 
   NumericalVector<float> query(kTestDim);
   for (size_t j = 0; j < kTestDim; ++j) query[j] = dist(gen);
@@ -1726,12 +1727,12 @@ TEST_F(VamanaStreamerTest, TestInt8WithRotate) {
   IndexQueryMeta new_qmeta;
   ASSERT_EQ(0,
             reformer2->transform(query.data(), qmeta, &new_query, &new_qmeta));
-  ASSERT_EQ(0, streamer2->search_impl(new_query.data(), new_qmeta, knnCtx));
+  ASSERT_EQ(0, streamer2->search_impl(new_query.data(), new_qmeta, knn_ctx));
   ASSERT_EQ(0,
-            streamer2->search_bf_impl(new_query.data(), new_qmeta, linearCtx));
+            streamer2->search_bf_impl(new_query.data(), new_qmeta, linear_ctx));
 
-  EXPECT_EQ(kTopk, knnCtx->result().size());
-  EXPECT_EQ(kTopk, linearCtx->result().size());
+  EXPECT_EQ(kTopk, knn_ctx->result().size());
+  EXPECT_EQ(kTopk, linear_ctx->result().size());
 }
 
 }  // namespace core
diff --git a/tests/core/interface/index_group_by_test.cc b/tests/core/interface/index_group_by_test.cc
index 2c3982452..37f0e1f24 100644
--- a/tests/core/interface/index_group_by_test.cc
+++ b/tests/core/interface/index_group_by_test.cc
@@ -240,11 +240,11 @@ BaseIndexQueryParam::Pointer DiskAnnQuery(bool fetch_vector = false,
 
 class GroupByInterfaceTest : public ::testing::Test {
  protected:
-  void RunOk(const GroupByCase &test_case) {
+  void run_ok(const GroupByCase &test_case) {
     Run(test_case, /*expect_error=*/false);
   }
 
-  void RunRejected(const GroupByCase &test_case) {
+  void run_rejected(const GroupByCase &test_case) {
     Run(test_case, /*expect_error=*/true);
   }
 
@@ -261,14 +261,15 @@ class GroupByInterfaceTest : public ::testing::Test {
     zvec::test_util::RemoveTestFiles(index_name + "*");
     zvec::test_util::RemoveTestFiles(source_index_name + "*");
 
-    auto source = IndexFactory::CreateAndInitIndex(*FlatSourceParam(test_case));
+    auto source =
+        IndexFactory::CreateAndInitIndex(*flat_source_param(test_case));
     ASSERT_NE(nullptr, source) << test_case.name;
     ASSERT_EQ(0, source->open(source_index_name,
                               {StorageOptions::StorageType::kMMAP, true}))
         << test_case.name;
 
     for (uint32_t i = 0; i < kNumDocs; ++i) {
-      AddDoc(source, i, test_case);
+      add_doc(source, i, test_case);
     }
     ASSERT_EQ(0, source->train()) << test_case.name;
 
@@ -291,7 +292,7 @@ class GroupByInterfaceTest : public ::testing::Test {
       query_param->refiner_param->scale_factor_ = 1.0f;
       query_param->refiner_param->reference_index = source;
     }
-    auto query = MakeQuery(test_case);
+    auto query = make_query(test_case);
 
     SearchResult result;
     const int ret = index->search(query.data, query_param, &result);
@@ -303,7 +304,7 @@ class GroupByInterfaceTest : public ::testing::Test {
       }
     } else {
       ASSERT_EQ(0, ret) << test_case.name;
-      AssertGroupedResult(result, query_param, test_case);
+      assert_grouped_result(result, query_param, test_case);
     }
 
     ASSERT_EQ(0, index->close()) << test_case.name;
@@ -312,15 +313,15 @@ class GroupByInterfaceTest : public ::testing::Test {
     zvec::test_util::RemoveTestFiles(source_index_name + "*");
   }
 
-  BaseIndexParam::Pointer FlatSourceParam(const GroupByCase &test_case) {
+  BaseIndexParam::Pointer flat_source_param(const GroupByCase &test_case) {
     if (test_case.is_sparse) {
       return SparseFlatParam();
     }
     return DenseFlatParam(test_case.dimension);
   }
 
-  void AddDoc(const Index::Pointer &index, uint32_t key,
-              const GroupByCase &test_case) {
+  void add_doc(const Index::Pointer &index, uint32_t key,
+               const GroupByCase &test_case) {
     std::vector<float> values(test_case.dimension, static_cast<float>(key));
     if (test_case.is_sparse) {
       std::vector<uint32_t> indices(test_case.dimension);
@@ -334,7 +335,7 @@ class GroupByInterfaceTest : public ::testing::Test {
     ASSERT_EQ(0, index->add(data, key)) << key;
   }
 
-  QueryHolder MakeQuery(const GroupByCase &test_case) {
+  QueryHolder make_query(const GroupByCase &test_case) {
     QueryHolder holder;
     holder.values.assign(test_case.dimension, 1.0f);
     if (test_case.is_sparse) {
@@ -348,9 +349,9 @@ class GroupByInterfaceTest : public ::testing::Test {
     return holder;
   }
 
-  void AssertGroupedResult(const SearchResult &result,
-                           const BaseIndexQueryParam::Pointer &query_param,
-                           const GroupByCase &test_case) {
+  void assert_grouped_result(const SearchResult &result,
+                             const BaseIndexQueryParam::Pointer &query_param,
+                             const GroupByCase &test_case) {
     ASSERT_TRUE(result.doc_list_.empty());
     ASSERT_EQ(kNumGroups, result.group_doc_list_.size());
 
@@ -386,14 +387,15 @@ class GroupByInterfaceTest : public ::testing::Test {
       return;
     }
     if (test_case.is_sparse) {
-      AssertSparseVectorsFetched(result, test_case.dimension);
+      assert_sparse_vectors_fetched(result, test_case.dimension);
     } else {
-      AssertDenseVectorsFetched(result, test_case.dimension, test_case.name);
+      assert_dense_vectors_fetched(result, test_case.dimension, test_case.name);
     }
   }
 
-  void AssertDenseVectorsFetched(const SearchResult &result, uint32_t dimension,
-                                 const std::string &case_name = "") {
+  void assert_dense_vectors_fetched(const SearchResult &result,
+                                    uint32_t dimension,
+                                    const std::string &case_name = "") {
     const bool has_reverted = !result.group_reverted_vector_list_.empty();
     if (has_reverted) {
       ASSERT_EQ(result.group_doc_list_.size(),
@@ -431,8 +433,8 @@ class GroupByInterfaceTest : public ::testing::Test {
     }
   }
 
-  void AssertSparseVectorsFetched(const SearchResult &result,
-                                  uint32_t dimension) {
+  void assert_sparse_vectors_fetched(const SearchResult &result,
+                                     uint32_t dimension) {
     const bool has_reverted =
         !result.group_reverted_sparse_values_list_.empty();
     if (has_reverted) {
@@ -530,7 +532,7 @@ TEST_F(GroupByInterfaceTest, Dense) {
   };
 
   for (const auto &test_case : cases) {
-    RunOk(test_case);
+    run_ok(test_case);
   }
 }
 
@@ -552,7 +554,7 @@ TEST_F(GroupByInterfaceTest, Sparse) {
   };
 
   for (const auto &test_case : cases) {
-    RunOk(test_case);
+    run_ok(test_case);
   }
 }
 
@@ -615,7 +617,7 @@ TEST_F(GroupByInterfaceTest, UnsupportedIndexTypes) {
   };
 
   for (const auto &test_case : cases) {
-    RunRejected(test_case);
+    run_rejected(test_case);
   }
 }
 
diff --git a/tests/core/interface/index_interface_test.cc b/tests/core/interface/index_interface_test.cc
index 5d7381346..8f204e73b 100644
--- a/tests/core/interface/index_interface_test.cc
+++ b/tests/core/interface/index_interface_test.cc
@@ -64,8 +64,8 @@ std::string ReadIndexBytesForTest(const std::string &path) {
 
 class TestableIVFIndex : public IVFIndex {
  public:
-  int CreateAndInitStreamerForTest(const BaseIndexParam &param) {
-    return CreateAndInitStreamer(param);
+  int create_and_init_streamer_for_test(const BaseIndexParam &param) {
+    return create_and_init_streamer(param);
   }
 
   const zvec::ailego::Params &proxima_index_params() const {
@@ -75,14 +75,14 @@ class TestableIVFIndex : public IVFIndex {
 
 class TestableHNSWIndex : public HNSWIndex {
  public:
-  int GetCoarseSearchTopk(const BaseIndexQueryParam::Pointer &param) {
+  int get_coarse_search_topk(const BaseIndexQueryParam::Pointer &param) {
     return _get_coarse_search_topk(param);
   }
 };
 
 class TestableVamanaIndex : public VamanaIndex {
  public:
-  int GetCoarseSearchTopk(const BaseIndexQueryParam::Pointer &param) {
+  int get_coarse_search_topk(const BaseIndexQueryParam::Pointer &param) {
     return _get_coarse_search_topk(param);
   }
 };
@@ -108,12 +108,12 @@ TEST(IndexInterface, GraphRefineKeepsLegacyDefaultCandidateCount) {
   TestableHNSWIndex hnsw;
   TestableVamanaIndex vamana;
 
-  EXPECT_EQ(kHnswEf, hnsw.GetCoarseSearchTopk(hnsw_param));
-  EXPECT_EQ(kVamanaEf, vamana.GetCoarseSearchTopk(vamana_param));
+  EXPECT_EQ(kHnswEf, hnsw.get_coarse_search_topk(hnsw_param));
+  EXPECT_EQ(kVamanaEf, vamana.get_coarse_search_topk(vamana_param));
 
   refiner->scale_factor_ = 2.0f;
-  EXPECT_EQ(kTopk * 2, hnsw.GetCoarseSearchTopk(hnsw_param));
-  EXPECT_EQ(kTopk * 2, vamana.GetCoarseSearchTopk(vamana_param));
+  EXPECT_EQ(kTopk * 2, hnsw.get_coarse_search_topk(hnsw_param));
+  EXPECT_EQ(kTopk * 2, vamana.get_coarse_search_topk(vamana_param));
 }
 
 TEST(IndexInterface, IVFPropagatesIterationCountToClusterParams) {
@@ -126,7 +126,7 @@ TEST(IndexInterface, IVFPropagatesIterationCountToClusterParams) {
                    .with_n_iters(37)
                    .build();
 
-  ASSERT_EQ(0, index.CreateAndInitStreamerForTest(*param));
+  ASSERT_EQ(0, index.create_and_init_streamer_for_test(*param));
 
   zvec::ailego::Params cluster_params;
   ASSERT_TRUE(index.proxima_index_params().get(
@@ -254,11 +254,11 @@ TEST(IndexInterface, IvfRabitqSearchIgnoresFetchVector) {
 
 class ReformerInspectableHNSWIndex : public HNSWIndex {
  public:
-  int InitForTest(const BaseIndexParam &param) {
-    return Init(param);
+  int init_for_test(const BaseIndexParam &param) {
+    return init(param);
   }
 
-  int TransformForTest(const std::vector<float> &query) const {
+  int transform_for_test(const std::vector<float> &query) const {
     if (!reformer_) {
       return zvec::core::IndexError_Uninitialized;
     }
@@ -501,14 +501,14 @@ TEST(IndexInterface, ReopenRestoresUniformReformer) {
             .with_quantizer_param(QuantizerParam(test_case.quantizer_type))
             .build();
     ReformerInspectableHNSWIndex index;
-    ASSERT_EQ(0, index.InitForTest(*param));
+    ASSERT_EQ(0, index.init_for_test(*param));
 
     const std::vector<float> query(kDimension, 1.0f);
-    ASSERT_NE(0, index.TransformForTest(query));
+    ASSERT_NE(0, index.transform_for_test(query));
     ASSERT_EQ(0, index.open(test_case.index_name,
                             {StorageOptions::StorageType::kMMAP,
                              /*create_new=*/false, /*read_only=*/true}));
-    EXPECT_EQ(0, index.TransformForTest(query));
+    EXPECT_EQ(0, index.transform_for_test(query));
     ASSERT_EQ(0, index.close());
 
     zvec::test_util::RemoveTestFiles(test_case.index_name);
@@ -1504,7 +1504,7 @@ class InspectableIVFIndex : public IVFIndex {
   int initialize(const BaseIndexParam &param, uint32_t train_sample_count = 0) {
     proxima_index_params_.set(zvec::core::PARAM_IVF_BUILDER_TRAIN_SAMPLE_COUNT,
                               train_sample_count);
-    return Init(param);
+    return init(param);
   }
   std::weak_ptr<zvec::core::IndexBuilder> build_state() const {
     return builder_;
@@ -3888,13 +3888,13 @@ TEST(IndexInterface, HNSWRabitqGeneral) {
     }
     ASSERT_TRUE(holder->emplace(i, vec));
   }
-  std::shared_ptr<IndexMeta> index_meta_ptr_;
-  index_meta_ptr_.reset(
-      new (std::nothrow) IndexMeta(IndexMeta::DataType::DT_FP32, kDimension));
-  index_meta_ptr_->set_metric("SquaredEuclidean", 0, Params());
+  std::shared_ptr<IndexMeta> index_meta_ptr;
+  index_meta_ptr.reset(new (std::nothrow)
+                           IndexMeta(IndexMeta::DataType::DT_FP32, kDimension));
+  index_meta_ptr->set_metric("SquaredEuclidean", 0, Params());
 
   RabitqConverter converter;
-  converter.init(*index_meta_ptr_, Params());
+  converter.init(*index_meta_ptr, Params());
   ASSERT_EQ(converter.train(holder), 0);
   std::shared_ptr<IndexReformer> index_reformer;
   ASSERT_EQ(converter.to_reformer(&index_reformer), 0);
@@ -3937,7 +3937,7 @@ TEST(IndexInterface, HNSWRabitqGeneral) {
   RabitqConverter converter2;
   Params converter2_params;
   converter2_params.set(PARAM_RABITQ_TOTAL_BITS, 2u);
-  converter2.init(*index_meta_ptr_, converter2_params);
+  converter2.init(*index_meta_ptr, converter2_params);
   ASSERT_EQ(converter2.train(holder), 0);
   std::shared_ptr<IndexReformer> index_reformer2;
   ASSERT_EQ(converter2.to_reformer(&index_reformer2), 0);
diff --git a/tests/core/metric/quantized_integer_metric_test.cc b/tests/core/metric/quantized_integer_metric_test.cc
index 7e018e3ee..57541fcd4 100644
--- a/tests/core/metric/quantized_integer_metric_test.cc
+++ b/tests/core/metric/quantized_integer_metric_test.cc
@@ -45,12 +45,12 @@ static IndexHolder::Pointer GetHolder(
   return holder;
 }
 
-static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src, size_t M,
-                                   size_t N) {
-  for (size_t n = 0; n < N * M; n++) {
-    size_t i = n / N;
-    size_t j = n % N;
-    dst[n] = src[M * j + i];
+static inline void MatrixTranspose(uint32_t *dst, const uint32_t *src,
+                                   size_t num_rows, size_t num_cols) {
+  for (size_t n = 0; n < num_cols * num_rows; n++) {
+    size_t i = n / num_cols;
+    size_t j = n % num_cols;
+    dst[n] = src[num_rows * j + i];
   }
 }
 
@@ -76,35 +76,35 @@ TEST(QuantizedIntegerMetric, General) {
   std::uniform_real_distribution<float> dist(-1.0, 1.0);
   const size_t DIMENSION = 21;
   ailego::NumericalVector<float> x(DIMENSION);
-  ailego::NumericalVector<float> X(DIMENSION);
+  ailego::NumericalVector<float> xt(DIMENSION);
   ailego::NumericalVector<float> y(DIMENSION);
-  ailego::NumericalVector<float> Y(DIMENSION);
+  ailego::NumericalVector<float> yt(DIMENSION);
   float xa = dist(gen);
   float xb = dist(gen);
   float ya = dist(gen);
   float yb = dist(gen);
   float x2 = 0, x1 = 0, y2 = 0, y1 = 0;
-  float X2 = 0;
+  float xt2 = 0;
   float xx2 = 0;
   for (size_t j = 0; j < DIMENSION; ++j) {
     x[j] = dist(gen);
     printf("%f ", x[j]);
-    X[j] = x[j] * xa + xb;
+    xt[j] = x[j] * xa + xb;
     x1 += x[j];
-    X2 += X[j] * X[j];
+    xt2 += xt[j] * xt[j];
     xx2 += x[j] * x[j];
   }
   printf("\n");
 
   for (size_t j = 0; j < DIMENSION; ++j) {
     y[j] = dist(gen);
-    Y[j] = y[j] * ya + yb;
+    yt[j] = y[j] * ya + yb;
     y1 += y[j];
     printf("%f ", y[j]);
   }
   printf("\n");
 
-  auto v1 = ailego::Distance::SquaredEuclidean(X.data(), Y.data(), DIMENSION);
+  auto v1 = ailego::Distance::SquaredEuclidean(xt.data(), yt.data(), DIMENSION);
   auto ip = ailego::Distance::InnerProduct(x.data(), y.data(), DIMENSION);
   ailego::SquaredNorm2Matrix<float, 1>::Compute(x.data(), DIMENSION, &x2);
   ailego::SquaredNorm2Matrix<float, 1>::Compute(y.data(), DIMENSION, &y2);
@@ -121,23 +121,23 @@ TEST(QuantizedIntegerMetric, General) {
   printf(
       "x=%f y=%f X=%f Y=%f, xa=%f xb=%f ya=%f yb=%f, x2=%f y2=%f x1=%f y1=%f "
       "ip=%f\n",
-      x[0], y[0], X[0], Y[0], xa, xb, ya, yb, x2, y2, x1, y1, ip);
+      x[0], y[0], xt[0], yt[0], xa, xb, ya, yb, x2, y2, x1, y1, ip);
   printf("v1=%f v2=%f v3=%f\n", v1, v2, v3);
 
-  auto IP = ailego::Distance::InnerProduct(X.data(), Y.data(), DIMENSION);
+  auto ip_t = ailego::Distance::InnerProduct(xt.data(), yt.data(), DIMENSION);
   auto v = xa * ya * ip + xb * ya * y1 + xa * yb * x1 + xb * yb * DIMENSION;
-  printf("V=%f %f\n", IP, v);
+  printf("V=%f %f\n", ip_t, v);
 
   printf("=========\n");
   float mips;
   ailego::MipsSquaredEuclideanDistanceMatrix<float, 1, 1>::Compute(
-      X.data(), Y.data(), DIMENSION, 0.0, &mips);
+      xt.data(), yt.data(), DIMENSION, 0.0, &mips);
   printf("u2=%f v2=%f\n", x2, y2);
   float uu2 = xa * xa * x2 + 2 * xa * xb * x1 + xb * xb * DIMENSION;
   float vv2 = ya * ya * y2 + 2 * ya * yb * y1 + yb * yb * DIMENSION;
   float v7 = 2.0 - 2.0 * v / std::max(uu2, vv2);
   printf("mips=%f v7=%f\n", mips, v7);
-  printf("X2=%f uu2=%f xx2=%f x2=%f\n", X2, uu2, xx2, x2);
+  printf("X2=%f uu2=%f xx2=%f x2=%f\n", xt2, uu2, xx2, x2);
 }
 
 TEST(QuantizedIntegerMetric, TestInt8SquaredEuclidean) {
diff --git a/tests/core/utility/buffer_storage_write_test.cc b/tests/core/utility/buffer_storage_write_test.cc
index 1cdae4d71..f8fd5660d 100644
--- a/tests/core/utility/buffer_storage_write_test.cc
+++ b/tests/core/utility/buffer_storage_write_test.cc
@@ -48,7 +48,7 @@ class BufferStorageWriteTest : public ::testing::Test {
   }
 
   // Open BufferStorage in writable mode (create_if_missing=true)
-  IndexStorage::Pointer OpenWritable() {
+  IndexStorage::Pointer open_writable() {
     auto storage = IndexFactory::CreateStorage("BufferStorage");
     if (!storage) return nullptr;
     ailego::Params params;
@@ -58,7 +58,7 @@ class BufferStorageWriteTest : public ::testing::Test {
   }
 
   // Open BufferStorage in read-only mode
-  IndexStorage::Pointer OpenReadOnly() {
+  IndexStorage::Pointer open_read_only() {
     auto storage = IndexFactory::CreateStorage("BufferStorage");
     if (!storage) return nullptr;
     ailego::Params params;
@@ -75,7 +75,7 @@ class BufferStorageWriteTest : public ::testing::Test {
 // Test: Create new index via BufferStorage, append segment, write data, read
 // back
 TEST_F(BufferStorageWriteTest, WriteBasicCreateAndWrite) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 4096));
@@ -97,7 +97,7 @@ TEST_F(BufferStorageWriteTest, WriteBasicCreateAndWrite) {
 
 // Test: Write at non-zero offset within the segment
 TEST_F(BufferStorageWriteTest, WriteAtNonZeroOffset) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 8192));
@@ -129,7 +129,7 @@ TEST_F(BufferStorageWriteTest, WriteAtNonZeroOffset) {
 
 // Test: Write to multiple independent segments
 TEST_F(BufferStorageWriteTest, WriteMultipleSegments) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg_a", 4096));
@@ -167,7 +167,7 @@ TEST_F(BufferStorageWriteTest, WriteMultipleSegments) {
 
 // Test: Overwrite existing data at the same offset
 TEST_F(BufferStorageWriteTest, WriteOverwrite) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 4096));
@@ -189,7 +189,7 @@ TEST_F(BufferStorageWriteTest, WriteOverwrite) {
 }
 
 TEST_F(BufferStorageWriteTest, WriteBatchSamePagePersists) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("batch_seg", 8192));
@@ -219,7 +219,7 @@ TEST_F(BufferStorageWriteTest, WriteBatchSamePagePersists) {
   EXPECT_EQ(payload, got_payload);
 
   ASSERT_EQ(0, storage->close());
-  storage = OpenReadOnly();
+  storage = open_read_only();
   ASSERT_TRUE(storage);
   segment = storage->get("batch_seg");
   ASSERT_TRUE(segment);
@@ -238,7 +238,7 @@ TEST_F(BufferStorageWriteTest, WriteBatchSamePagePersists) {
 
 // Test: Write exceeding segment capacity returns 0
 TEST_F(BufferStorageWriteTest, WriteExceedsCapacity) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   // Append a small segment (page-aligned, so at least 4096 bytes capacity)
@@ -262,7 +262,7 @@ TEST_F(BufferStorageWriteTest, WriteExceedsCapacity) {
 
 // Test: Write with zero length (edge case)
 TEST_F(BufferStorageWriteTest, WriteZeroLength) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 4096));
@@ -283,7 +283,7 @@ TEST_F(BufferStorageWriteTest, WriteFlushReopenVerify) {
   std::string data = "Persistent data that survives close/reopen";
 
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("persist_seg", 8192));
     auto seg = storage->get("persist_seg");
@@ -295,7 +295,7 @@ TEST_F(BufferStorageWriteTest, WriteFlushReopenVerify) {
 
   // Reopen in read-only mode and verify
   {
-    auto storage = OpenReadOnly();
+    auto storage = open_read_only();
     ASSERT_TRUE(storage);
     auto seg = storage->get("persist_seg");
     ASSERT_TRUE(seg);
@@ -314,7 +314,7 @@ TEST_F(BufferStorageWriteTest, WriteMultipleFlushCycles) {
   std::string data2 = "second_write_longer";
 
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg1", 4096));
     auto seg = storage->get("seg1");
@@ -332,7 +332,7 @@ TEST_F(BufferStorageWriteTest, WriteMultipleFlushCycles) {
 
   // Verify persistence
   {
-    auto storage = OpenReadOnly();
+    auto storage = open_read_only();
     ASSERT_TRUE(storage);
     auto seg = storage->get("seg1");
     ASSERT_TRUE(seg);
@@ -354,7 +354,7 @@ TEST_F(BufferStorageWriteTest, WriteCloseWithoutExplicitFlush) {
   std::string data = "should_persist_on_close";
 
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg1", 4096));
     auto seg = storage->get("seg1");
@@ -365,7 +365,7 @@ TEST_F(BufferStorageWriteTest, WriteCloseWithoutExplicitFlush) {
   }
 
   {
-    auto storage = OpenReadOnly();
+    auto storage = open_read_only();
     ASSERT_TRUE(storage);
     auto seg = storage->get("seg1");
     ASSERT_TRUE(seg);
@@ -382,7 +382,7 @@ TEST_F(BufferStorageWriteTest, WriteCloseWithoutExplicitFlush) {
 TEST_F(BufferStorageWriteTest, WriteReadOnlyNoOp) {
   // First create an index file with a segment
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg1", 4096));
     auto seg = storage->get("seg1");
@@ -395,7 +395,7 @@ TEST_F(BufferStorageWriteTest, WriteReadOnlyNoOp) {
 
   // Open read-only and attempt write
   {
-    auto storage = OpenReadOnly();
+    auto storage = open_read_only();
     ASSERT_TRUE(storage);
     auto seg = storage->get("seg1");
     ASSERT_TRUE(seg);
@@ -417,7 +417,7 @@ TEST_F(BufferStorageWriteTest, WriteReadOnlyNoOp) {
 
 // Test: Resize increases data_size without writing
 TEST_F(BufferStorageWriteTest, ResizeGrow) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 4096));
@@ -435,7 +435,7 @@ TEST_F(BufferStorageWriteTest, ResizeGrow) {
 
 // Test: Resize shrinks data_size
 TEST_F(BufferStorageWriteTest, ResizeShrink) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 4096));
@@ -457,7 +457,7 @@ TEST_F(BufferStorageWriteTest, ResizeShrink) {
 
 // Test: Resize beyond capacity is clamped
 TEST_F(BufferStorageWriteTest, ResizeBeyondCapacityClamped) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 4096));
@@ -477,7 +477,7 @@ TEST_F(BufferStorageWriteTest, ResizeBeyondCapacityClamped) {
 
 // Test: update_data_crc reflects in data_crc() getter
 TEST_F(BufferStorageWriteTest, UpdateDataCrc) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 4096));
@@ -495,7 +495,7 @@ TEST_F(BufferStorageWriteTest, UpdateDataCrc) {
 TEST_F(BufferStorageWriteTest, UpdateDataCrcPersistence) {
   uint32_t crc_val = 0x12345678;
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg1", 4096));
     auto seg = storage->get("seg1");
@@ -508,7 +508,7 @@ TEST_F(BufferStorageWriteTest, UpdateDataCrcPersistence) {
   }
 
   {
-    auto storage = OpenReadOnly();
+    auto storage = open_read_only();
     ASSERT_TRUE(storage);
     auto seg = storage->get("seg1");
     ASSERT_TRUE(seg);
@@ -521,7 +521,7 @@ TEST_F(BufferStorageWriteTest, UpdateDataCrcPersistence) {
 
 // Test: Multiple threads writing to different segments concurrently
 TEST_F(BufferStorageWriteTest, ConcurrentWriteDifferentSegments) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   const int kNumSegments = 8;
@@ -570,7 +570,7 @@ TEST_F(BufferStorageWriteTest, ConcurrentWriteDifferentSegments) {
 
 // Test: Multiple threads writing to the same segment at different offsets
 TEST_F(BufferStorageWriteTest, ConcurrentWriteSameSegment) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   // Need large enough segment for all threads
@@ -616,7 +616,7 @@ TEST_F(BufferStorageWriteTest, ConcurrentWriteSameSegment) {
 
 // Test: Concurrent writers + flush (simulates real workload)
 TEST_F(BufferStorageWriteTest, ConcurrentWriteWithFlush) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 65536));
@@ -662,7 +662,7 @@ TEST_F(BufferStorageWriteTest, ConcurrentWriteWithFlush) {
 
 // Test: Append multiple segments then write to each
 TEST_F(BufferStorageWriteTest, AppendThenWriteSequence) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   for (int i = 0; i < 5; ++i) {
@@ -691,7 +691,7 @@ TEST_F(BufferStorageWriteTest, AppendThenWriteSequence) {
 
 // Test: Write to a segment, append another, write to both, verify all
 TEST_F(BufferStorageWriteTest, InterleavedAppendAndWrite) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   // Append and write first segment
@@ -731,7 +731,7 @@ TEST_F(BufferStorageWriteTest, InterleavedAppendAndWrite) {
 
 // Test: Fill entire segment capacity with data
 TEST_F(BufferStorageWriteTest, WriteLargeBuffer) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   // Request 16KB segment (will be page-aligned)
@@ -766,7 +766,7 @@ TEST_F(BufferStorageWriteTest, WriteLargeBufferPersistence) {
   }
 
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("large_seg", kSize));
     auto seg = storage->get("large_seg");
@@ -776,7 +776,7 @@ TEST_F(BufferStorageWriteTest, WriteLargeBufferPersistence) {
   }
 
   {
-    auto storage = OpenReadOnly();
+    auto storage = open_read_only();
     ASSERT_TRUE(storage);
     auto seg = storage->get("large_seg");
     ASSERT_TRUE(seg);
@@ -793,7 +793,7 @@ TEST_F(BufferStorageWriteTest, WriteLargeBufferPersistence) {
 
 // Test: refresh() updates checkpoint and marks dirty
 TEST_F(BufferStorageWriteTest, RefreshCheckpoint) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
   ASSERT_EQ(0, storage->append("seg1", 4096));
 
@@ -815,7 +815,7 @@ TEST_F(BufferStorageWriteTest, RefreshCheckpoint) {
 
 // Test: Appending a duplicate segment ID returns error
 TEST_F(BufferStorageWriteTest, AppendDuplicateSegment) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("dup_seg", 4096));
@@ -827,7 +827,7 @@ TEST_F(BufferStorageWriteTest, AppendDuplicateSegment) {
 
 // Test: Appending a zero-size segment returns error
 TEST_F(BufferStorageWriteTest, AppendZeroSize) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   EXPECT_NE(0, storage->append("zero_seg", 0));
@@ -844,7 +844,7 @@ TEST_F(BufferStorageWriteTest, AppendZeroSize) {
 // observed after all writers quiesce (individual unsynchronized reads during
 // concurrent writes may appear torn, which is expected).
 TEST_F(BufferStorageWriteTest, CR_DataSizePaddingSizeInvariant) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 8192));
@@ -884,7 +884,7 @@ TEST_F(BufferStorageWriteTest, CR_DataSizePaddingSizeInvariant) {
 // The invariant is verified after all threads stop (reads without meta_mtx_
 // during concurrent mutation may observe a torn pair, which is expected).
 TEST_F(BufferStorageWriteTest, CR_ConcurrentWriteAndResize) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 8192));
@@ -933,7 +933,7 @@ TEST_F(BufferStorageWriteTest, CR_ChainSplitAllSegmentsAccessible) {
       50;  // Enough to trigger chain split with default 4096 meta capacity
 
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
 
     for (int i = 0; i < kNumSegments; ++i) {
@@ -953,7 +953,7 @@ TEST_F(BufferStorageWriteTest, CR_ChainSplitAllSegmentsAccessible) {
 
   // Reopen and verify ALL segments are present and readable
   {
-    auto storage = OpenReadOnly();
+    auto storage = open_read_only();
     ASSERT_TRUE(storage);
     for (int i = 0; i < kNumSegments; ++i) {
       std::string name = "chain_seg_" + std::to_string(i);
@@ -977,7 +977,7 @@ TEST_F(BufferStorageWriteTest, CR_MultipleInstancesSameThread) {
   std::string path2 = file_path_ + "_second";
   ailego::File::Delete(path2);
 
-  auto storage1 = OpenWritable();
+  auto storage1 = open_writable();
   ASSERT_TRUE(storage1);
 
   // Open a second independent BufferStorage instance
@@ -1019,7 +1019,7 @@ TEST_F(BufferStorageWriteTest, CR_MultipleInstancesSameThread) {
 // then read back via both fetch() and read(MemoryBlock&) to verify the
 // cross-page buffer allocation path. (Tests fix for UAF in cross-page read.)
 TEST_F(BufferStorageWriteTest, CR_CrossPageWriteAndRead) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   // Segment large enough to span multiple pages
@@ -1054,7 +1054,7 @@ TEST_F(BufferStorageWriteTest, CR_CrossPageWriteAndRead) {
 }
 
 TEST_F(BufferStorageWriteTest, ImmutableReadPinsWritablePageWithoutCopy) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("immutable_read_seg", 8192));
@@ -1093,7 +1093,7 @@ TEST_F(BufferStorageWriteTest, ImmutableReadPinsWritablePageWithoutCopy) {
 }
 
 TEST_F(BufferStorageWriteTest, ImmutableReadCopiesCrossPageRange) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   const size_t page_size = ailego::kVectorPageSize;
@@ -1121,7 +1121,7 @@ TEST_F(BufferStorageWriteTest, ImmutableReadCopiesCrossPageRange) {
 }
 
 TEST_F(BufferStorageWriteTest, ImmutableFallbackPreservesUnflushedPrefix) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
   const size_t page_size = ailego::kVectorPageSize;
   ASSERT_EQ(0, storage->append("dirty_fallback", 3 * page_size));
@@ -1160,7 +1160,7 @@ TEST_F(BufferStorageWriteTest, ImmutableFallbackPreservesUnflushedPrefix) {
 }
 
 TEST_F(BufferStorageWriteTest, ImmutableBatchReadUsesWritableCache) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
   const size_t page_size = ailego::kVectorPageSize;
   ASSERT_EQ(0, storage->append("immutable_batch", 3 * page_size));
@@ -1201,7 +1201,7 @@ TEST_F(BufferStorageWriteTest, ImmutableBatchReadUsesWritableCache) {
 TEST_F(BufferStorageWriteTest, ReadOnlyBatchFallsBackWhenPinsExceedBudget) {
   constexpr size_t kSegmentBytes = 68UL * 1024UL * 1024UL;
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("batch_pressure", kSegmentBytes));
     auto segment = storage->get("batch_pressure");
@@ -1212,7 +1212,7 @@ TEST_F(BufferStorageWriteTest, ReadOnlyBatchFallsBackWhenPinsExceedBudget) {
     ASSERT_EQ(0, storage->close());
   }
 
-  auto storage = OpenReadOnly();
+  auto storage = open_read_only();
   ASSERT_TRUE(storage);
   auto segment = storage->get("batch_pressure");
   ASSERT_TRUE(segment);
@@ -1272,7 +1272,7 @@ TEST_F(BufferStorageWriteTest, ReadOnlyBatchFallsBackWhenPinsExceedBudget) {
 TEST_F(BufferStorageWriteTest, ReadOnlyBatchPreservesSharedCacheReserve) {
   constexpr size_t kSegmentBytes = 64UL * 1024UL * 1024UL;
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("batch_reserve", kSegmentBytes));
     auto segment = storage->get("batch_reserve");
@@ -1283,7 +1283,7 @@ TEST_F(BufferStorageWriteTest, ReadOnlyBatchPreservesSharedCacheReserve) {
     ASSERT_EQ(0, storage->close());
   }
 
-  auto storage = OpenReadOnly();
+  auto storage = open_read_only();
   ASSERT_TRUE(storage);
   auto segment = storage->get("batch_reserve");
   ASSERT_TRUE(segment);
@@ -1317,7 +1317,7 @@ TEST_F(BufferStorageWriteTest, ReadOnlyBatchPreservesSharedCacheReserve) {
 // pinned page. Retaining a separate 4K-aligned snapshot for every read grows
 // memory until close() and makes long Optimize workloads consume gigabytes.
 TEST_F(BufferStorageWriteTest, CR_WritableLegacyPointerReadReusesCachedPage) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("legacy_pointer_seg", 8192));
@@ -1357,7 +1357,7 @@ TEST_F(BufferStorageWriteTest, CR_DirtyFlagNotLostAfterFlush) {
   std::string late_data = "late_write_after_flush";
 
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg1", 4096));
     auto seg = storage->get("seg1");
@@ -1377,7 +1377,7 @@ TEST_F(BufferStorageWriteTest, CR_DirtyFlagNotLostAfterFlush) {
 
   // Reopen and verify the late write persisted
   {
-    auto storage = OpenReadOnly();
+    auto storage = open_read_only();
     ASSERT_TRUE(storage);
     auto seg = storage->get("seg1");
     ASSERT_TRUE(seg);
@@ -1393,7 +1393,7 @@ TEST_F(BufferStorageWriteTest, CR_DirtyFlagNotLostAfterFlush) {
 // races. All writes that return successfully MUST be visible after final
 // close+reopen.
 TEST_F(BufferStorageWriteTest, CR_ConcurrentFlushWriteDirtyFlagStress) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 65536));
@@ -1446,7 +1446,7 @@ TEST_F(BufferStorageWriteTest, CR_ConcurrentFlushWriteDirtyFlagStress) {
 // append must still work correctly AFTER the append (unordered_map address
 // stability guarantee). This tests the fix for reserve()-based invalidation.
 TEST_F(BufferStorageWriteTest, CR_PointerStabilityAcrossAppend) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg_first", 4096));
@@ -1480,7 +1480,7 @@ TEST_F(BufferStorageWriteTest, CR_PointerStabilityAcrossAppend) {
 // update_data_crc concurrent with write: CRC update must be serialized
 // with data_size changes via meta_mtx_. Invariant verified post-quiescence.
 TEST_F(BufferStorageWriteTest, CR_ConcurrentWriteAndCrcUpdate) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
 
   ASSERT_EQ(0, storage->append("seg1", 8192));
@@ -1524,7 +1524,7 @@ TEST_F(BufferStorageWriteTest, CR_ConcurrentWriteAndCrcUpdate) {
 }
 
 TEST_F(BufferStorageWriteTest, CR_ConcurrentSamePageReadSeesWholeWrite) {
-  auto storage = OpenWritable();
+  auto storage = open_writable();
   ASSERT_TRUE(storage);
   ASSERT_EQ(0, storage->append("seg1", 2 * ailego::kVectorPageSize));
   auto seg = storage->get("seg1");
@@ -1575,7 +1575,7 @@ TEST_F(BufferStorageWriteTest, CR_ConcurrentSamePageReadSeesWholeWrite) {
 TEST_F(BufferStorageWriteTest, CR_MemoryBlockOutlivesReadOnlyStorage) {
   const std::string expected = "lifetime";
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg1", 4096));
     auto seg = storage->get("seg1");
@@ -1587,7 +1587,7 @@ TEST_F(BufferStorageWriteTest, CR_MemoryBlockOutlivesReadOnlyStorage) {
 
   IndexStorage::MemoryBlock block;
   {
-    auto storage = OpenReadOnly();
+    auto storage = open_read_only();
     ASSERT_TRUE(storage);
     auto seg = storage->get("seg1");
     ASSERT_TRUE(seg);
@@ -1604,7 +1604,7 @@ TEST_F(BufferStorageWriteTest, CR_MemoryBlockOutlivesReadOnlyStorage) {
 TEST_F(BufferStorageWriteTest, CR_BorrowedReadAvoidsOwningHandle) {
   const std::string expected = "borrowed";
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg1", 4096));
     auto seg = storage->get("seg1");
@@ -1614,7 +1614,7 @@ TEST_F(BufferStorageWriteTest, CR_BorrowedReadAvoidsOwningHandle) {
     ASSERT_EQ(0, storage->close());
   }
 
-  auto storage = OpenReadOnly();
+  auto storage = open_read_only();
   ASSERT_TRUE(storage);
   auto seg = storage->get("seg1");
   ASSERT_TRUE(seg);
@@ -1632,7 +1632,7 @@ TEST_F(BufferStorageWriteTest, CR_BorrowedReadAvoidsOwningHandle) {
 TEST_F(BufferStorageWriteTest, BorrowedReadUsesOneColdPageLoadSequence) {
   const std::string expected = "borrowed pressure fallback";
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg1", 4096));
     auto segment = storage->get("seg1");
@@ -1643,7 +1643,7 @@ TEST_F(BufferStorageWriteTest, BorrowedReadUsesOneColdPageLoadSequence) {
     ASSERT_EQ(0, storage->close());
   }
 
-  auto storage = OpenReadOnly();
+  auto storage = open_read_only();
   ASSERT_TRUE(storage);
   auto segment = storage->get("seg1");
   ASSERT_TRUE(segment);
@@ -1668,7 +1668,7 @@ TEST_F(BufferStorageWriteTest, BorrowedReadUsesOneColdPageLoadSequence) {
 TEST_F(BufferStorageWriteTest, ReadOnlyPrefetchPreservesCachePriority) {
   const size_t page_size = ailego::kVectorPageSize;
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("hot", 3 * page_size));
     auto segment = storage->get("hot");
@@ -1678,7 +1678,7 @@ TEST_F(BufferStorageWriteTest, ReadOnlyPrefetchPreservesCachePriority) {
     ASSERT_EQ(0, storage->close());
   }
 
-  auto storage = OpenReadOnly();
+  auto storage = open_read_only();
   ASSERT_TRUE(storage);
   auto segment = storage->get("hot");
   ASSERT_TRUE(segment);
@@ -1721,7 +1721,7 @@ TEST_F(BufferStorageWriteTest, BatchBorrowedReadAcrossSegments) {
   }
 
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg_a", payload_a.size()));
     ASSERT_EQ(0, storage->append("seg_b", payload_b.size()));
@@ -1737,7 +1737,7 @@ TEST_F(BufferStorageWriteTest, BatchBorrowedReadAcrossSegments) {
     ASSERT_EQ(0, storage->close());
   }
 
-  auto storage = OpenReadOnly();
+  auto storage = open_read_only();
   ASSERT_TRUE(storage);
   auto seg_a = storage->get("seg_a");
   auto seg_b = storage->get("seg_b");
@@ -1786,7 +1786,7 @@ TEST_F(BufferStorageWriteTest, BatchBorrowedReadAcrossSegments) {
 TEST_F(BufferStorageWriteTest, CR_ReadOnlyMetadataPressureFallsBackToBypass) {
   const std::string expected = "bypass";
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg1", 4096));
     auto seg = storage->get("seg1");
@@ -1799,7 +1799,7 @@ TEST_F(BufferStorageWriteTest, CR_ReadOnlyMetadataPressureFallsBackToBypass) {
   auto &pool = ailego::MemoryLimitPool::get_instance();
   ASSERT_EQ(0, pool.init(ailego::kVectorPageSize));
   {
-    auto storage = OpenReadOnly();
+    auto storage = open_read_only();
     ASSERT_TRUE(storage);
     auto seg = storage->get("seg1");
     ASSERT_TRUE(seg);
@@ -1819,7 +1819,7 @@ TEST_F(BufferStorageWriteTest, BatchScratchResultsSurviveLaterBatches) {
     payload[i] = static_cast<char>((i * 17 + i / page_size * 31) % 251);
   }
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg", payload.size()));
     auto segment = storage->get("seg");
@@ -1832,7 +1832,7 @@ TEST_F(BufferStorageWriteTest, BatchScratchResultsSurviveLaterBatches) {
 
   // Exercise both the read-only batch and writable immutable batch paths.
   for (bool immutable : {false, true}) {
-    auto storage = immutable ? OpenWritable() : OpenReadOnly();
+    auto storage = immutable ? open_writable() : open_read_only();
     ASSERT_TRUE(storage);
     auto segment = storage->get("seg");
     ASSERT_TRUE(segment);
@@ -1889,7 +1889,7 @@ TEST_F(BufferStorageWriteTest, BatchScratchResultsSurviveLaterBatches) {
                              larger.data(), page_size + 256));
 
     // The cached arena is thread-local, so another storage shares the cache.
-    auto other_storage = OpenReadOnly();
+    auto other_storage = open_read_only();
     ASSERT_TRUE(other_storage);
     auto other_segment = other_storage->get("seg");
     ASSERT_TRUE(other_segment);
@@ -1921,7 +1921,7 @@ TEST_F(BufferStorageWriteTest, BatchScratchResultsSurviveReadingThreadExit) {
   const size_t page_size = ailego::kVectorPageSize;
   std::vector<char> payload(3 * page_size, 't');
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg", payload.size()));
     auto segment = storage->get("seg");
@@ -1931,7 +1931,7 @@ TEST_F(BufferStorageWriteTest, BatchScratchResultsSurviveReadingThreadExit) {
     ASSERT_EQ(0, storage->flush());
     ASSERT_EQ(0, storage->close());
   }
-  auto storage = OpenReadOnly();
+  auto storage = open_read_only();
   ASSERT_TRUE(storage);
   auto segment = storage->get("seg");
   ASSERT_TRUE(segment);
@@ -1958,7 +1958,7 @@ TEST_F(BufferStorageWriteTest, OversizedBatchScratchKeepsOwnedFallback) {
   const size_t length = (2UL << 20) + 128;
   std::vector<char> payload(length + 2 * ailego::kVectorPageSize, 'f');
   {
-    auto storage = OpenWritable();
+    auto storage = open_writable();
     ASSERT_TRUE(storage);
     ASSERT_EQ(0, storage->append("seg", payload.size()));
     auto segment = storage->get("seg");
@@ -1968,7 +1968,7 @@ TEST_F(BufferStorageWriteTest, OversizedBatchScratchKeepsOwnedFallback) {
     ASSERT_EQ(0, storage->flush());
     ASSERT_EQ(0, storage->close());
   }
-  auto storage = OpenReadOnly();
+  auto storage = open_read_only();
   ASSERT_TRUE(storage);
   auto segment = storage->get("seg");
   ASSERT_TRUE(segment);
diff --git a/tests/db/collection_test.cc b/tests/db/collection_test.cc
index a67788af4..bac870203 100644
--- a/tests/db/collection_test.cc
+++ b/tests/db/collection_test.cc
@@ -80,7 +80,7 @@ class CollectionTest : public ::testing::Test {
     ailego::FileHelper::RemoveDirectory("demo");
   }
 
-  CollectionSchema MakeSchema(const std::string &name = "x",
+  CollectionSchema make_schema(const std::string &name = "x",
                               const std::string &field = "value") {
     CollectionSchema schema(name);
     EXPECT_TRUE(schema
@@ -90,20 +90,20 @@ class CollectionTest : public ::testing::Test {
     return schema;
   }
 
-  void Create(const CollectionSchema &schema) {
+  void create(const CollectionSchema &schema) {
     auto result = Collection::CreateAndOpen(col_path, schema, options_);
     ASSERT_TRUE(result.has_value()) << result.error().message();
     collection_ = std::move(result).value();
   }
 
-  void Reopen() {
+  void reopen() {
     collection_.reset();
     auto result = Collection::Open(col_path, options_);
     ASSERT_TRUE(result.has_value()) << result.error().message();
     collection_ = std::move(result).value();
   }
 
-  Doc MakeDoc(const std::string &id, int32_t value,
+  Doc make_doc(const std::string &id, int32_t value,
               const std::string &field = "value") {
     Doc doc;
     doc.set_pk(id);
@@ -111,7 +111,7 @@ class CollectionTest : public ::testing::Test {
     return doc;
   }
 
-  void ExpectWrite(const Result<WriteResults> &result, size_t count) {
+  void expect_write(const Result<WriteResults> &result, size_t count) {
     ASSERT_TRUE(result.has_value()) << result.error().message();
     ASSERT_EQ(result.value().size(), count);
     for (const auto &status : result.value()) {
@@ -119,7 +119,7 @@ class CollectionTest : public ::testing::Test {
     }
   }
 
-  void ExpectValue(const std::string &id, int32_t expected,
+  void expect_value(const std::string &id, int32_t expected,
                    const std::string &field = "value") {
     auto result = collection_->fetch({id});
     ASSERT_TRUE(result.has_value()) << result.error().message();
@@ -167,7 +167,7 @@ class DirectoryWriteBlockerForTest {
         probe_file << "probe";
         probe_file.close();
         fs::remove(probe_path, ec);
-        Restore();
+        restore();
         skip_reason_ = "Directory permissions do not block writes";
         return;
       }
@@ -175,7 +175,7 @@ class DirectoryWriteBlockerForTest {
   }
 
   ~DirectoryWriteBlockerForTest() {
-    Restore();
+    restore();
   }
 
   bool enabled() const {
@@ -186,7 +186,7 @@ class DirectoryWriteBlockerForTest {
     return skip_reason_;
   }
 
-  void Restore() {
+  void restore() {
     if (enabled_) {
       std::error_code ec;
       std::filesystem::permissions(dir_path_, original_perms_,
@@ -389,16 +389,16 @@ TEST_F(CollectionTest, Feature_CreateAndOpen_NameBoundaries) {
   for (const auto &name : std::vector<std::string>{
            "x", "xy", u8"集", std::string(253, 'n') + u8"集"}) {
     SCOPED_TRACE(name);
-    ASSERT_NO_FATAL_FAILURE(Create(MakeSchema(name)));
-    std::vector<Doc> docs{MakeDoc("id", 1)};
-    ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->insert(docs), 1));
+    ASSERT_NO_FATAL_FAILURE(create(make_schema(name)));
+    std::vector<Doc> docs{make_doc("id", 1)};
+    ASSERT_NO_FATAL_FAILURE(expect_write(collection_->insert(docs), 1));
     auto status = collection_->flush();
     ASSERT_TRUE(status.ok()) << status.message();
-    ASSERT_NO_FATAL_FAILURE(Reopen());
+    ASSERT_NO_FATAL_FAILURE(reopen());
     auto schema = collection_->schema();
     ASSERT_TRUE(schema.has_value()) << schema.error().message();
     EXPECT_EQ(schema.value().name(), name);
-    ASSERT_NO_FATAL_FAILURE(ExpectValue("id", 1));
+    ASSERT_NO_FATAL_FAILURE(expect_value("id", 1));
     status = collection_->destroy();
     ASSERT_TRUE(status.ok()) << status.message();
     collection_.reset();
@@ -407,7 +407,7 @@ TEST_F(CollectionTest, Feature_CreateAndOpen_NameBoundaries) {
 
 TEST_F(CollectionTest, Feature_CreateAndOpen_InvalidSchema) {
   auto result = Collection::CreateAndOpen(
-      col_path, MakeSchema("x", "_zvec_uid_"), options_);
+      col_path, make_schema("x", "_zvec_uid_"), options_);
   ASSERT_FALSE(result.has_value());
   EXPECT_EQ(result.error().code(), StatusCode::INVALID_ARGUMENT);
   EXPECT_NE(result.error().message().find("is reserved"), std::string::npos);
@@ -602,14 +602,14 @@ TEST_F(CollectionTest, Feature_CreateAndOpen_MultiThread) {
 }
 
 TEST_F(CollectionTest, Feature_Write_InvalidIdRejectsWholeBatch) {
-  ASSERT_NO_FATAL_FAILURE(Create(MakeSchema()));
-  std::vector<Doc> initial{MakeDoc("existing", 1)};
-  ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->insert(initial), 1));
+  ASSERT_NO_FATAL_FAILURE(create(make_schema()));
+  std::vector<Doc> initial{make_doc("existing", 1)};
+  ASSERT_NO_FATAL_FAILURE(expect_write(collection_->insert(initial), 1));
   for (int operation = 0; operation < 3; ++operation) {
     SCOPED_TRACE(operation);
     const std::string first_id = operation == 0 ? "new:id" : "existing";
-    std::vector<Doc> batch{MakeDoc(first_id, 99),
-                           MakeDoc(std::string("bad\0id", 6), 100)};
+    std::vector<Doc> batch{make_doc(first_id, 99),
+                           make_doc(std::string("bad\0id", 6), 100)};
     auto result = operation == 0   ? collection_->insert(batch)
                   : operation == 1 ? collection_->update(batch)
                                    : collection_->upsert(batch);
@@ -620,14 +620,14 @@ TEST_F(CollectionTest, Feature_Write_InvalidIdRejectsWholeBatch) {
               std::string::npos);
     EXPECT_NE(result.error().message().find("id[bad\\0id]"), std::string::npos);
     EXPECT_EQ(result.error().message().find("offset"), std::string::npos);
-    ASSERT_NO_FATAL_FAILURE(ExpectValue("existing", 1));
+    ASSERT_NO_FATAL_FAILURE(expect_value("existing", 1));
     auto missing = collection_->fetch({"new:id"});
     ASSERT_TRUE(missing.has_value()) << missing.error().message();
     ASSERT_EQ(missing.value().size(), 1u);
     EXPECT_EQ(missing.value().at("new:id"), nullptr);
   }
-  ASSERT_NO_FATAL_FAILURE(Reopen());
-  ASSERT_NO_FATAL_FAILURE(ExpectValue("existing", 1));
+  ASSERT_NO_FATAL_FAILURE(reopen());
+  ASSERT_NO_FATAL_FAILURE(expect_value("existing", 1));
   EXPECT_EQ(collection_->stats().value().doc_count, 1u);
 }
 
@@ -666,7 +666,7 @@ TEST_F(CollectionTest, Feature_Write_Batch_Validate) {
 
 TEST_F(CollectionTest, Feature_Write_Utf8IdsAndReopen) {
   const std::string name = u8"测试 集合/v1";
-  ASSERT_NO_FATAL_FAILURE(Create(MakeSchema(name)));
+  ASSERT_NO_FATAL_FAILURE(create(make_schema(name)));
   const std::vector<std::string> ids = {
       "user:123",  "https://example.com/document/42",
       u8"订单-😀", std::string(1021, 'i') + u8"中",
@@ -676,19 +676,19 @@ TEST_F(CollectionTest, Feature_Write_Utf8IdsAndReopen) {
       "DOC"};
   std::vector<Doc> docs;
   for (size_t i = 0; i < ids.size(); ++i) {
-    docs.push_back(MakeDoc(ids[i], static_cast<int32_t>(i)));
+    docs.push_back(make_doc(ids[i], static_cast<int32_t>(i)));
   }
-  ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->insert(docs), docs.size()));
+  ASSERT_NO_FATAL_FAILURE(expect_write(collection_->insert(docs), docs.size()));
 
-  std::vector<Doc> updates{MakeDoc(ids[0], 100)};
-  ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->update(updates), 1));
-  std::vector<Doc> upserts{MakeDoc(ids[3], 103), MakeDoc(u8"新增:文档", 200)};
-  ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->upsert(upserts), 2));
-  ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->delete_({ids[1]}), 1));
+  std::vector<Doc> updates{make_doc(ids[0], 100)};
+  ASSERT_NO_FATAL_FAILURE(expect_write(collection_->update(updates), 1));
+  std::vector<Doc> upserts{make_doc(ids[3], 103), make_doc(u8"新增:文档", 200)};
+  ASSERT_NO_FATAL_FAILURE(expect_write(collection_->upsert(upserts), 2));
+  ASSERT_NO_FATAL_FAILURE(expect_write(collection_->delete_({ids[1]}), 1));
 
   auto flush_status = collection_->flush();
   ASSERT_TRUE(flush_status.ok()) << flush_status.message();
-  ASSERT_NO_FATAL_FAILURE(Reopen());
+  ASSERT_NO_FATAL_FAILURE(reopen());
   auto schema = collection_->schema();
   ASSERT_TRUE(schema.has_value()) << schema.error().message();
   EXPECT_EQ(schema.value().name(), name);
@@ -699,9 +699,9 @@ TEST_F(CollectionTest, Feature_Write_Utf8IdsAndReopen) {
     int32_t expected = static_cast<int32_t>(i);
     if (i == 0) expected = 100;
     if (i == 3) expected = 103;
-    ASSERT_NO_FATAL_FAILURE(ExpectValue(ids[i], expected));
+    ASSERT_NO_FATAL_FAILURE(expect_value(ids[i], expected));
   }
-  ASSERT_NO_FATAL_FAILURE(ExpectValue(u8"新增:文档", 200));
+  ASSERT_NO_FATAL_FAILURE(expect_value(u8"新增:文档", 200));
   auto deleted = collection_->fetch({ids[1]});
   ASSERT_TRUE(deleted.has_value()) << deleted.error().message();
   ASSERT_EQ(deleted.value().size(), 1u);
@@ -1761,7 +1761,7 @@ TEST_F(CollectionTest, Feature_Update_Empty) {
 }
 
 TEST_F(CollectionTest, Feature_FetchAndDelete_InvalidIdsRemainMissing) {
-  ASSERT_NO_FATAL_FAILURE(Create(MakeSchema()));
+  ASSERT_NO_FATAL_FAILURE(create(make_schema()));
   // These are invalid for a new document, but lookup must retain its existing
   // missing-key behavior rather than introducing input validation errors.
   const std::vector<std::string> absent_ids{"", std::string("bad\0id", 6),
@@ -2904,7 +2904,7 @@ TEST_F(CollectionTest,
   }
 
   auto s = collection->drop_index("int32");
-  write_blocker.Restore();
+  write_blocker.restore();
   ASSERT_FALSE(s.ok());
 
   collection.reset();
@@ -4608,7 +4608,7 @@ TEST_F(CollectionTest, Feature_Query_MaximumLengthFieldNames) {
     const std::string scalar = "s" + std::string(63, 'a');
     const std::string second_scalar = scalar.substr(0, 63) + "b";
     const std::string vector = "v" + std::string(63, 'b');
-    auto schema = MakeSchema("x", scalar);
+    auto schema = make_schema("x", scalar);
     ASSERT_TRUE(schema
                     .add_field(std::make_shared<FieldSchema>(
                         second_scalar, DataType::INT32, false))
@@ -4618,13 +4618,13 @@ TEST_F(CollectionTest, Feature_Query_MaximumLengthFieldNames) {
                         vector, DataType::VECTOR_FP32, 4, false,
                         std::make_shared<FlatIndexParams>(MetricType::L2)))
                     .ok());
-    ASSERT_NO_FATAL_FAILURE(Create(schema));
+    ASSERT_NO_FATAL_FAILURE(create(schema));
     const std::vector<float> values{1.0f, 2.0f, 3.0f, 4.0f};
-    Doc doc = MakeDoc(u8"文档:1", 42, scalar);
+    Doc doc = make_doc(u8"文档:1", 42, scalar);
     ASSERT_TRUE(doc.set<int32_t>(second_scalar, 7));
     ASSERT_TRUE(doc.set<std::vector<float>>(vector, values));
     std::vector<Doc> docs{doc};
-    ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->insert(docs), 1));
+    ASSERT_NO_FATAL_FAILURE(expect_write(collection_->insert(docs), 1));
     auto status = collection_->flush();
     ASSERT_TRUE(status.ok()) << status.message();
     status = collection_->create_index(scalar,
@@ -4636,7 +4636,7 @@ TEST_F(CollectionTest, Feature_Query_MaximumLengthFieldNames) {
     status = collection_->create_index(second_scalar,
                                        std::make_shared<InvertIndexParams>());
     ASSERT_TRUE(status.ok()) << status.message();
-    ASSERT_NO_FATAL_FAILURE(Reopen());
+    ASSERT_NO_FATAL_FAILURE(reopen());
 
     // Fetch supplies the query vector, covering lookup by a newly allowed ID.
     auto fetched = collection_->fetch({doc.pk()});
@@ -5476,7 +5476,7 @@ TEST_F(CollectionTest, Feature_MultiQuery_CallbackReranker) {
 TEST_F(CollectionTest, Feature_GroupByQuery) {}
 
 TEST_F(CollectionTest, Feature_ColumnDDL_DuplicateNamesKeepData) {
-  auto schema = MakeSchema();
+  auto schema = make_schema();
   ASSERT_TRUE(schema
                   .add_field(std::make_shared<FieldSchema>(
                       "other", DataType::INT32, true))
@@ -5485,10 +5485,10 @@ TEST_F(CollectionTest, Feature_ColumnDDL_DuplicateNamesKeepData) {
                   .add_field(std::make_shared<FieldSchema>(
                       "embedding", DataType::VECTOR_FP32, 4, true))
                   .ok());
-  ASSERT_NO_FATAL_FAILURE(Create(schema));
-  std::vector<Doc> docs{MakeDoc("id", 42)};
+  ASSERT_NO_FATAL_FAILURE(create(schema));
+  std::vector<Doc> docs{make_doc("id", 42)};
   ASSERT_TRUE(docs[0].set<std::vector<float>>("embedding", {1, 2, 3, 4}));
-  ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->insert(docs), 1));
+  ASSERT_NO_FATAL_FAILURE(expect_write(collection_->insert(docs), 1));
   const auto before = collection_->schema().value();
   for (const std::string name : {"other", "embedding"}) {
     SCOPED_TRACE(name);
@@ -5503,17 +5503,17 @@ TEST_F(CollectionTest, Feature_ColumnDDL_DuplicateNamesKeepData) {
     EXPECT_EQ(status.code(), StatusCode::ALREADY_EXISTS);
     EXPECT_NE(status.message().find("already exists"), std::string::npos);
     EXPECT_EQ(collection_->schema().value(), before);
-    ASSERT_NO_FATAL_FAILURE(ExpectValue("id", 42));
+    ASSERT_NO_FATAL_FAILURE(expect_value("id", 42));
   }
-  ASSERT_NO_FATAL_FAILURE(Reopen());
+  ASSERT_NO_FATAL_FAILURE(reopen());
   EXPECT_EQ(collection_->schema().value(), before);
-  ASSERT_NO_FATAL_FAILURE(ExpectValue("id", 42));
+  ASSERT_NO_FATAL_FAILURE(expect_value("id", 42));
 }
 
 TEST_F(CollectionTest, Feature_ColumnDDL_ReservedNamesKeepData) {
-  ASSERT_NO_FATAL_FAILURE(Create(MakeSchema()));
-  std::vector<Doc> docs{MakeDoc("id", 42)};
-  ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->insert(docs), 1));
+  ASSERT_NO_FATAL_FAILURE(create(make_schema()));
+  std::vector<Doc> docs{make_doc("id", 42)};
+  ASSERT_NO_FATAL_FAILURE(expect_write(collection_->insert(docs), 1));
   const auto before = collection_->schema().value();
   const std::string name = "_zvec_uid_";
   auto status = collection_->add_column(
@@ -5528,10 +5528,10 @@ TEST_F(CollectionTest, Feature_ColumnDDL_ReservedNamesKeepData) {
   EXPECT_EQ(status.code(), StatusCode::INVALID_ARGUMENT);
   EXPECT_NE(status.message().find("is reserved"), std::string::npos);
   EXPECT_EQ(collection_->schema().value(), before);
-  ASSERT_NO_FATAL_FAILURE(ExpectValue("id", 42));
-  ASSERT_NO_FATAL_FAILURE(Reopen());
+  ASSERT_NO_FATAL_FAILURE(expect_value("id", 42));
+  ASSERT_NO_FATAL_FAILURE(reopen());
   EXPECT_EQ(collection_->schema().value(), before);
-  ASSERT_NO_FATAL_FAILURE(ExpectValue("id", 42));
+  ASSERT_NO_FATAL_FAILURE(expect_value("id", 42));
 }
 
 TEST_F(CollectionTest, Feature_ColumnDDL_FieldCountLimits) {
@@ -5542,7 +5542,7 @@ TEST_F(CollectionTest, Feature_ColumnDDL_FieldCountLimits) {
                         "f" + std::to_string(i), DataType::INT32, true))
                     .ok());
   }
-  ASSERT_NO_FATAL_FAILURE(Create(schema));
+  ASSERT_NO_FATAL_FAILURE(create(schema));
   auto status = collection_->add_column(
       std::make_shared<FieldSchema>("excess", DataType::INT32, true), "");
   EXPECT_EQ(status.code(), StatusCode::INVALID_ARGUMENT);
@@ -5553,22 +5553,22 @@ TEST_F(CollectionTest, Feature_ColumnDDL_FieldCountLimits) {
   ASSERT_TRUE(status.ok()) << status.message();
   collection_.reset();
 
-  ASSERT_NO_FATAL_FAILURE(Create(MakeSchema()));
-  std::vector<Doc> docs{MakeDoc("id", 42)};
-  ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->insert(docs), 1));
+  ASSERT_NO_FATAL_FAILURE(create(make_schema()));
+  std::vector<Doc> docs{make_doc("id", 42)};
+  ASSERT_NO_FATAL_FAILURE(expect_write(collection_->insert(docs), 1));
   status = collection_->drop_column("value");
   EXPECT_EQ(status.code(), StatusCode::INVALID_ARGUMENT);
   EXPECT_NE(status.message().find("last field"), std::string::npos);
-  ASSERT_NO_FATAL_FAILURE(ExpectValue("id", 42));
-  ASSERT_NO_FATAL_FAILURE(Reopen());
+  ASSERT_NO_FATAL_FAILURE(expect_value("id", 42));
+  ASSERT_NO_FATAL_FAILURE(reopen());
   EXPECT_TRUE(collection_->schema().value().has_field("value"));
-  ASSERT_NO_FATAL_FAILURE(ExpectValue("id", 42));
+  ASSERT_NO_FATAL_FAILURE(expect_value("id", 42));
 }
 
 TEST_F(CollectionTest, Feature_ColumnDDL_CopiesCallerSchema) {
-  ASSERT_NO_FATAL_FAILURE(Create(MakeSchema()));
-  std::vector<Doc> initial{MakeDoc("original", 1)};
-  ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->insert(initial), 1));
+  ASSERT_NO_FATAL_FAILURE(create(make_schema()));
+  std::vector<Doc> initial{make_doc("original", 1)};
+  ASSERT_NO_FATAL_FAILURE(expect_write(collection_->insert(initial), 1));
   auto added = std::make_shared<FieldSchema>("extra", DataType::INT32, true);
   auto status = collection_->add_column(added, "");
   ASSERT_TRUE(status.ok()) << status.message();
@@ -5581,10 +5581,10 @@ TEST_F(CollectionTest, Feature_ColumnDDL_CopiesCallerSchema) {
   EXPECT_EQ(current.get_field("extra")->data_type(), DataType::INT32);
   EXPECT_TRUE(current.get_field("extra")->nullable());
   EXPECT_FALSE(current.has_field("bad name"));
-  Doc doc = MakeDoc("new", 2);
+  Doc doc = make_doc("new", 2);
   ASSERT_TRUE(doc.set<int32_t>("extra", 7));
   std::vector<Doc> docs{doc};
-  ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->insert(docs), 1));
+  ASSERT_NO_FATAL_FAILURE(expect_write(collection_->insert(docs), 1));
 
   auto altered = std::make_shared<FieldSchema>("extra", DataType::INT64, true);
   status = collection_->alter_column("extra", "", altered);
@@ -5595,9 +5595,9 @@ TEST_F(CollectionTest, Feature_ColumnDDL_CopiesCallerSchema) {
   ASSERT_TRUE(current.has_field("extra"));
   EXPECT_EQ(current.get_field("extra")->data_type(), DataType::INT64);
   EXPECT_FALSE(current.has_field("another bad name"));
-  ASSERT_NO_FATAL_FAILURE(Reopen());
-  ASSERT_NO_FATAL_FAILURE(ExpectValue("original", 1));
-  ASSERT_NO_FATAL_FAILURE(ExpectValue("new", 2));
+  ASSERT_NO_FATAL_FAILURE(reopen());
+  ASSERT_NO_FATAL_FAILURE(expect_value("original", 1));
+  ASSERT_NO_FATAL_FAILURE(expect_value("new", 2));
   auto fetched = collection_->fetch({"new"});
   ASSERT_TRUE(fetched.has_value()) << fetched.error().message();
   ASSERT_NE(fetched.value().at("new"), nullptr);
@@ -5828,9 +5828,9 @@ TEST_F(CollectionTest, Feature_DropColumn_General) {
 }
 
 TEST_F(CollectionTest, Feature_AlterColumn_InvalidNameKeepsData) {
-  ASSERT_NO_FATAL_FAILURE(Create(MakeSchema()));
-  std::vector<Doc> docs{MakeDoc("id", 42)};
-  ASSERT_NO_FATAL_FAILURE(ExpectWrite(collection_->insert(docs), 1));
+  ASSERT_NO_FATAL_FAILURE(create(make_schema()));
+  std::vector<Doc> docs{make_doc("id", 42)};
+  ASSERT_NO_FATAL_FAILURE(expect_write(collection_->insert(docs), 1));
   const auto before = collection_->schema().value();
   for (const auto &name : std::vector<std::string>{
            "user name", "../value", u8"字段", std::string(65, 'f')}) {
@@ -5840,19 +5840,19 @@ TEST_F(CollectionTest, Feature_AlterColumn_InvalidNameKeepsData) {
     EXPECT_EQ(status.message().find("Invalid schema:"), 0u);
     EXPECT_EQ(status.message().find("offset"), std::string::npos);
     EXPECT_EQ(collection_->schema().value(), before);
-    ASSERT_NO_FATAL_FAILURE(ExpectValue("id", 42));
+    ASSERT_NO_FATAL_FAILURE(expect_value("id", 42));
   }
-  ASSERT_NO_FATAL_FAILURE(Reopen());
+  ASSERT_NO_FATAL_FAILURE(reopen());
   EXPECT_EQ(collection_->schema().value(), before);
-  ASSERT_NO_FATAL_FAILURE(ExpectValue("id", 42));
+  ASSERT_NO_FATAL_FAILURE(expect_value("id", 42));
 
   const std::string renamed(64, 'r');
   auto status = collection_->alter_column("value", renamed);
   ASSERT_TRUE(status.ok()) << status.message();
-  ASSERT_NO_FATAL_FAILURE(Reopen());
+  ASSERT_NO_FATAL_FAILURE(reopen());
   EXPECT_FALSE(collection_->schema().value().has_field("value"));
   EXPECT_TRUE(collection_->schema().value().has_field(renamed));
-  ASSERT_NO_FATAL_FAILURE(ExpectValue("id", 42, renamed));
+  ASSERT_NO_FATAL_FAILURE(expect_value("id", 42, renamed));
 }
 
 TEST_F(CollectionTest, Feature_AlterColumn_General) {
@@ -7639,7 +7639,7 @@ TEST_F(CollectionTest, Feature_DropFtsIndex_FailureKeepsPersistedOldSchema) {
   }
 
   auto s = col->drop_index("content");
-  write_blocker.Restore();
+  write_blocker.restore();
   ASSERT_FALSE(s.ok());
 
   col.reset();
diff --git a/tests/db/common/cgroup_util_test.cc b/tests/db/common/cgroup_util_test.cc
index e011f8c6b..88e8e8905 100644
--- a/tests/db/common/cgroup_util_test.cc
+++ b/tests/db/common/cgroup_util_test.cc
@@ -20,26 +20,26 @@ using namespace zvec;
 TEST(CgroupUtil, ParseCpuMaxQuota) {
   int cpu_cores = 0;
 
-  ASSERT_TRUE(CgroupUtil::parseCpuMax("100000 100000", &cpu_cores));
+  ASSERT_TRUE(CgroupUtil::parse_cpu_max("100000 100000", &cpu_cores));
   EXPECT_EQ(1, cpu_cores);
 
-  ASSERT_TRUE(CgroupUtil::parseCpuMax("150000 100000\n", &cpu_cores));
+  ASSERT_TRUE(CgroupUtil::parse_cpu_max("150000 100000\n", &cpu_cores));
   EXPECT_EQ(2, cpu_cores);
 
-  ASSERT_TRUE(CgroupUtil::parseCpuMax("400000 100000", &cpu_cores));
+  ASSERT_TRUE(CgroupUtil::parse_cpu_max("400000 100000", &cpu_cores));
   EXPECT_EQ(4, cpu_cores);
 }
 
 TEST(CgroupUtil, ParseCpuMaxUnlimitedOrInvalid) {
   int cpu_cores = 7;
 
-  EXPECT_FALSE(CgroupUtil::parseCpuMax("max 100000", &cpu_cores));
-  EXPECT_FALSE(CgroupUtil::parseCpuMax("100000/100000", &cpu_cores));
-  EXPECT_FALSE(CgroupUtil::parseCpuMax("100000 0", &cpu_cores));
-  EXPECT_FALSE(CgroupUtil::parseCpuMax("0 100000", &cpu_cores));
-  EXPECT_FALSE(CgroupUtil::parseCpuMax("100000 100000 trailing", &cpu_cores));
-  EXPECT_FALSE(CgroupUtil::parseCpuMax("invalid", &cpu_cores));
-  EXPECT_FALSE(CgroupUtil::parseCpuMax("100000 100000", nullptr));
+  EXPECT_FALSE(CgroupUtil::parse_cpu_max("max 100000", &cpu_cores));
+  EXPECT_FALSE(CgroupUtil::parse_cpu_max("100000/100000", &cpu_cores));
+  EXPECT_FALSE(CgroupUtil::parse_cpu_max("100000 0", &cpu_cores));
+  EXPECT_FALSE(CgroupUtil::parse_cpu_max("0 100000", &cpu_cores));
+  EXPECT_FALSE(CgroupUtil::parse_cpu_max("100000 100000 trailing", &cpu_cores));
+  EXPECT_FALSE(CgroupUtil::parse_cpu_max("invalid", &cpu_cores));
+  EXPECT_FALSE(CgroupUtil::parse_cpu_max("100000 100000", nullptr));
 
   EXPECT_EQ(7, cpu_cores);
 }
diff --git a/tests/db/crash_recovery/optimize_recovery_test.cc b/tests/db/crash_recovery/optimize_recovery_test.cc
index 4d053fa30..90ce7f846 100644
--- a/tests/db/crash_recovery/optimize_recovery_test.cc
+++ b/tests/db/crash_recovery/optimize_recovery_test.cc
@@ -37,10 +37,10 @@ typedef HANDLE pid_t;
 namespace zvec {
 
 
-static std::string optimizer_bin_;
-const std::string collection_name_{"optimize_recovery_test"};
-const std::string dir_path_{"optimize_recovery_test_db"};
-const zvec::CollectionOptions options_{false, true, 256 * 1024};
+static std::string optimizer_bin;
+const std::string collection_name{"optimize_recovery_test"};
+const std::string dir_path{"optimize_recovery_test_db"};
+const zvec::CollectionOptions options{false, true, 256 * 1024};
 const int batch_size{50};
 const int num_batches{1000};
 
@@ -54,7 +54,7 @@ void ExecuteOptimizer(const std::string &path, int kill_after_seconds = -1) {
   bool should_crash = kill_after_seconds >= 0;
 
 #ifdef _WIN32
-  std::string cmd_str = optimizer_bin_ + " --path " + path;
+  std::string cmd_str = optimizer_bin + " --path " + path;
 
   STARTUPINFOA si = {sizeof(si)};
   PROCESS_INFORMATION pi;
@@ -93,7 +93,7 @@ void ExecuteOptimizer(const std::string &path, int kill_after_seconds = -1) {
 
   if (pid == 0) {
     char arg_path[] = "--path";
-    char *args[] = {const_cast<char *>(optimizer_bin_.c_str()), arg_path,
+    char *args[] = {const_cast<char *>(optimizer_bin.c_str()), arg_path,
                     const_cast<char *>(path.c_str()), nullptr};
     execvp(args[0], args);
     perror("execvp failed");
@@ -132,7 +132,7 @@ class OptimizeRecoveryTest : public ::testing::Test {
  protected:
   void SetUp() override {
     zvec::test_util::RemoveTestPath("./optimize_recovery_test_db");
-    ASSERT_NO_THROW(optimizer_bin_ = LocateOptimizeGenerator());
+    ASSERT_NO_THROW(optimizer_bin = LocateOptimizeGenerator());
   }
 
   void TearDown() override {
@@ -143,8 +143,8 @@ class OptimizeRecoveryTest : public ::testing::Test {
 
 TEST_F(OptimizeRecoveryTest, CrashDuringOptimize) {
   {  // Create a collection and insert some documents
-    auto schema = CreateTestSchema(collection_name_);
-    auto result = Collection::CreateAndOpen(dir_path_, *schema, options_);
+    auto schema = CreateTestSchema(collection_name);
+    auto result = Collection::CreateAndOpen(dir_path, *schema, options);
     ASSERT_TRUE(result.has_value());
     auto collection = result.value();
 
@@ -164,10 +164,10 @@ TEST_F(OptimizeRecoveryTest, CrashDuringOptimize) {
     collection.reset();
   }
 
-  RunOptimizerAndCrash(dir_path_, 4);
+  RunOptimizerAndCrash(dir_path, 4);
 
   {  // Open the collection and verify data integrity
-    auto result = Collection::Open(dir_path_, options_);
+    auto result = Collection::Open(dir_path, options);
     ASSERT_TRUE(result.has_value())
         << "Failed to reopen collection after crash. "
            "Recovery mechanism may be broken.";
@@ -220,10 +220,10 @@ TEST_F(OptimizeRecoveryTest, CrashDuringOptimize) {
     collection.reset();
   }
 
-  RunOptimizer(dir_path_);
+  RunOptimizer(dir_path);
 
   // Open the collection and verify data integrity
-  auto result = Collection::Open(dir_path_, options_);
+  auto result = Collection::Open(dir_path, options);
   ASSERT_TRUE(result.has_value()) << "Failed to reopen collection after crash. "
                                      "Recovery mechanism may be broken.";
   auto collection = result.value();
diff --git a/tests/db/crash_recovery/write_recovery_test.cc b/tests/db/crash_recovery/write_recovery_test.cc
index 614fb71ea..b4d784697 100644
--- a/tests/db/crash_recovery/write_recovery_test.cc
+++ b/tests/db/crash_recovery/write_recovery_test.cc
@@ -41,10 +41,10 @@ typedef HANDLE pid_t;
 namespace zvec {
 
 
-static std::string data_generator_bin_;
-const std::string collection_name_{"write_recovery_test"};
-const std::string dir_path_{"write_recovery_test_db"};
-const zvec::CollectionOptions options_{false, true, 256 * 1024};
+static std::string data_generator_bin;
+const std::string collection_name{"write_recovery_test"};
+const std::string dir_path{"write_recovery_test_db"};
+const zvec::CollectionOptions options{false, true, 256 * 1024};
 
 
 static std::string LocateDataGenerator() {
@@ -64,7 +64,7 @@ void ExecuteProcess(const std::string &start, const std::string &end,
 
 #ifdef _WIN32
   // 1. Build the command line string with quotes to handle paths with spaces
-  std::string cmd_str = data_generator_bin_ + " --path " + dir_path_ +
+  std::string cmd_str = data_generator_bin + " --path " + dir_path +
                         " --start " + start + " --end " + end + " --op " + op +
                         " --version " + version;
 
@@ -107,9 +107,9 @@ void ExecuteProcess(const std::string &start, const std::string &end,
 
   if (pid == 0) {  // Child process
     // Use a vector to manage arguments cleanly
-    std::vector<const char *> args = {data_generator_bin_.c_str(),
+    std::vector<const char *> args = {data_generator_bin.c_str(),
                                       "--path",
-                                      dir_path_.c_str(),
+                                      dir_path.c_str(),
                                       "--start",
                                       start.c_str(),
                                       "--end",
@@ -156,7 +156,7 @@ class CrashRecoveryTest : public ::testing::Test {
  protected:
   void SetUp() override {
     zvec::test_util::RemoveTestPath("./write_recovery_test_db");
-    ASSERT_NO_THROW(data_generator_bin_ = LocateDataGenerator());
+    ASSERT_NO_THROW(data_generator_bin = LocateDataGenerator());
   }
 
   void TearDown() override {
@@ -182,7 +182,7 @@ TEST_F(CrashRecoveryTest, Utf8AndLongIdsRecoverFromUnflushedWal) {
           std::_Exit(1);
         }
         auto created =
-            Collection::CreateAndOpen(dir_path_, schema, CollectionOptions{});
+            Collection::CreateAndOpen(dir_path, schema, CollectionOptions{});
         if (!created.has_value()) std::_Exit(2);
         auto collection = std::move(created).value();
         std::vector<Doc> docs;
@@ -201,7 +201,7 @@ TEST_F(CrashRecoveryTest, Utf8AndLongIdsRecoverFromUnflushedWal) {
       },
       ::testing::ExitedWithCode(0), "");
 
-  auto opened = Collection::Open(dir_path_, CollectionOptions{});
+  auto opened = Collection::Open(dir_path, CollectionOptions{});
   ASSERT_TRUE(opened.has_value()) << opened.error().message();
   auto collection = std::move(opened).value();
   EXPECT_EQ(collection->schema().value().name(), u8"恢复 集合");
@@ -218,22 +218,22 @@ TEST_F(CrashRecoveryTest, Utf8AndLongIdsRecoverFromUnflushedWal) {
   auto status = collection->flush();
   ASSERT_TRUE(status.ok()) << status.message();
   collection.reset();
-  auto reopened = Collection::Open(dir_path_, CollectionOptions{});
+  auto reopened = Collection::Open(dir_path, CollectionOptions{});
   ASSERT_TRUE(reopened.has_value()) << reopened.error().message();
   EXPECT_EQ(reopened.value()->stats().value().doc_count, ids.size());
 }
 
 TEST_F(CrashRecoveryTest, BasicInsertAndReopen) {
   {
-    auto schema = CreateTestSchema(collection_name_);
-    auto result = Collection::CreateAndOpen(dir_path_, *schema, options_);
+    auto schema = CreateTestSchema(collection_name);
+    auto result = Collection::CreateAndOpen(dir_path, *schema, options);
     ASSERT_TRUE(result.has_value()) << result.error().message();
     auto collection = result.value();
     collection.reset();
   }
 
   RunGenerator("0", "5000", "insert", "0");
-  auto result = Collection::Open(dir_path_, options_);
+  auto result = Collection::Open(dir_path, options);
   ASSERT_TRUE(result.has_value());
   auto collection = result.value();
   ASSERT_EQ(collection->stats().value().doc_count, 5000)
@@ -243,8 +243,8 @@ TEST_F(CrashRecoveryTest, BasicInsertAndReopen) {
 
 TEST_F(CrashRecoveryTest, CrashRecoveryDuringInsertion) {
   {
-    auto schema = CreateTestSchema(collection_name_);
-    auto result = Collection::CreateAndOpen(dir_path_, *schema, options_);
+    auto schema = CreateTestSchema(collection_name);
+    auto result = Collection::CreateAndOpen(dir_path, *schema, options);
     ASSERT_TRUE(result.has_value()) << result.error().message();
     auto collection = result.value();
     collection.reset();
@@ -252,7 +252,7 @@ TEST_F(CrashRecoveryTest, CrashRecoveryDuringInsertion) {
 
   RunGeneratorAndCrash("0", "10000", "insert", "0", 5);
 
-  auto result = Collection::Open(dir_path_, options_);
+  auto result = Collection::Open(dir_path, options);
   ASSERT_TRUE(result.has_value()) << "Failed to reopen collection after crash. "
                                      "Recovery mechanism may be broken.";
   auto collection = result.value();
@@ -282,8 +282,8 @@ TEST_F(CrashRecoveryTest, CrashRecoveryDuringInsertion) {
 
 TEST_F(CrashRecoveryTest, OptimizeAfterCrashRecoveryPersistsReplayedData) {
   {
-    auto schema = CreateTestSchema(collection_name_);
-    auto result = Collection::CreateAndOpen(dir_path_, *schema, options_);
+    auto schema = CreateTestSchema(collection_name);
+    auto result = Collection::CreateAndOpen(dir_path, *schema, options);
     ASSERT_TRUE(result.has_value()) << result.error().message();
   }
 
@@ -291,7 +291,7 @@ TEST_F(CrashRecoveryTest, OptimizeAfterCrashRecoveryPersistsReplayedData) {
 
   uint64_t recovered_doc_count = 0;
   {
-    auto result = Collection::Open(dir_path_, options_);
+    auto result = Collection::Open(dir_path, options);
     ASSERT_TRUE(result.has_value())
         << "Failed to reopen collection after crash recovery";
     auto collection = result.value();
@@ -305,7 +305,7 @@ TEST_F(CrashRecoveryTest, OptimizeAfterCrashRecoveryPersistsReplayedData) {
     ASSERT_EQ(collection->stats().value().doc_count, recovered_doc_count);
   }
 
-  auto result = Collection::Open(dir_path_, options_);
+  auto result = Collection::Open(dir_path, options);
   ASSERT_TRUE(result.has_value())
       << "Failed to reopen collection after optimizing recovered data";
   ASSERT_EQ(result.value()->stats().value().doc_count, recovered_doc_count)
@@ -315,8 +315,8 @@ TEST_F(CrashRecoveryTest, OptimizeAfterCrashRecoveryPersistsReplayedData) {
 
 TEST_F(CrashRecoveryTest, CrashRecoveryDuringUpsert) {
   {
-    auto schema = CreateTestSchema(collection_name_);
-    auto result = Collection::CreateAndOpen(dir_path_, *schema, options_);
+    auto schema = CreateTestSchema(collection_name);
+    auto result = Collection::CreateAndOpen(dir_path, *schema, options);
     ASSERT_TRUE(result.has_value()) << result.error().message();
     auto collection = result.value();
     collection.reset();
@@ -324,7 +324,7 @@ TEST_F(CrashRecoveryTest, CrashRecoveryDuringUpsert) {
 
   RunGenerator("0", "5000", "insert", "0");
   {
-    auto result = Collection::Open(dir_path_, options_);
+    auto result = Collection::Open(dir_path, options);
     ASSERT_TRUE(result.has_value()) << result.error().message();
     auto collection = result.value();
     ASSERT_EQ(collection->stats().value().doc_count, 5000)
@@ -333,7 +333,7 @@ TEST_F(CrashRecoveryTest, CrashRecoveryDuringUpsert) {
 
   RunGeneratorAndCrash("4500", "20000", "upsert", "1", 5);
 
-  auto result = Collection::Open(dir_path_, options_);
+  auto result = Collection::Open(dir_path, options);
   ASSERT_TRUE(result.has_value()) << "Failed to reopen collection after crash. "
                                      "Recovery mechanism may be broken.";
   auto collection = result.value();
@@ -368,8 +368,8 @@ TEST_F(CrashRecoveryTest, CrashRecoveryDuringUpsert) {
 
 TEST_F(CrashRecoveryTest, CrashRecoveryDuringUpdate) {
   {
-    auto schema = CreateTestSchema(collection_name_);
-    auto result = Collection::CreateAndOpen(dir_path_, *schema, options_);
+    auto schema = CreateTestSchema(collection_name);
+    auto result = Collection::CreateAndOpen(dir_path, *schema, options);
     ASSERT_TRUE(result.has_value()) << result.error().message();
     auto collection = result.value();
     collection.reset();
@@ -377,7 +377,7 @@ TEST_F(CrashRecoveryTest, CrashRecoveryDuringUpdate) {
 
   RunGenerator("0", "18000", "upsert", "0");
   {
-    auto result = Collection::Open(dir_path_, options_);
+    auto result = Collection::Open(dir_path, options);
     ASSERT_TRUE(result.has_value()) << result.error().message();
     auto collection = result.value();
     ASSERT_EQ(collection->stats().value().doc_count, 18000)
@@ -386,7 +386,7 @@ TEST_F(CrashRecoveryTest, CrashRecoveryDuringUpdate) {
 
   RunGeneratorAndCrash("3000", "15000", "update", "3", 4);
 
-  auto result = Collection::Open(dir_path_, options_);
+  auto result = Collection::Open(dir_path, options);
   ASSERT_TRUE(result.has_value()) << "Failed to reopen collection after crash. "
                                      "Recovery mechanism may be broken.";
   auto collection = result.value();
@@ -456,8 +456,8 @@ TEST_F(CrashRecoveryTest, CrashRecoveryDuringUpdate) {
 
 TEST_F(CrashRecoveryTest, CrashRecoveryDuringDelete) {
   {
-    auto schema = CreateTestSchema(collection_name_);
-    auto result = Collection::CreateAndOpen(dir_path_, *schema, options_);
+    auto schema = CreateTestSchema(collection_name);
+    auto result = Collection::CreateAndOpen(dir_path, *schema, options);
     ASSERT_TRUE(result.has_value()) << result.error().message();
     auto collection = result.value();
     collection.reset();
@@ -465,7 +465,7 @@ TEST_F(CrashRecoveryTest, CrashRecoveryDuringDelete) {
 
   RunGenerator("0", "18000", "insert", "0");
   {
-    auto result = Collection::Open(dir_path_, options_);
+    auto result = Collection::Open(dir_path, options);
     ASSERT_TRUE(result.has_value()) << result.error().message();
     auto collection = result.value();
     ASSERT_EQ(collection->stats().value().doc_count, 18000)
@@ -474,7 +474,7 @@ TEST_F(CrashRecoveryTest, CrashRecoveryDuringDelete) {
 
   RunGeneratorAndCrash("3000", "15000", "delete", "0", 4);
 
-  auto result = Collection::Open(dir_path_, options_);
+  auto result = Collection::Open(dir_path, options);
   ASSERT_TRUE(result.has_value()) << "Failed to reopen collection after crash. "
                                      "Recovery mechanism may be broken.";
   auto collection = result.value();
diff --git a/tests/db/index/column/fts_column/fts_rocksdb_reducer_test.cc b/tests/db/index/column/fts_column/fts_rocksdb_reducer_test.cc
index 851112c21..c988cd555 100644
--- a/tests/db/index/column/fts_column/fts_rocksdb_reducer_test.cc
+++ b/tests/db/index/column/fts_column/fts_rocksdb_reducer_test.cc
@@ -242,7 +242,7 @@ class FtsRocksdbReducerTest : public ::testing::Test {
     zvec::FileHelper::RemoveDirectory(kTestDir);
   }
 
-  std::unique_ptr<FtsColumnIndexer> MakeSrc0Indexer() {
+  std::unique_ptr<FtsColumnIndexer> make_src0_indexer() {
     auto field_meta = MakeWhitespaceFieldMeta(kFieldName);
     auto indexer = std::make_unique<FtsColumnIndexer>();
     EXPECT_TRUE(indexer
@@ -254,7 +254,7 @@ class FtsRocksdbReducerTest : public ::testing::Test {
   }
 
   // Create and open a FtsColumnIndexer for src1 (doc_ids start at offset)
-  std::unique_ptr<FtsColumnIndexer> MakeSrc1Indexer() {
+  std::unique_ptr<FtsColumnIndexer> make_src1_indexer() {
     auto field_meta = MakeWhitespaceFieldMeta(kFieldName);
     auto indexer = std::make_unique<FtsColumnIndexer>();
     EXPECT_TRUE(indexer
@@ -267,7 +267,7 @@ class FtsRocksdbReducerTest : public ::testing::Test {
 
   // Open a FtsColumnIndexer (read-only) on the merged destination store.
   // Side CFs are nullptr — immutable/reducer stores no longer contain them.
-  std::unique_ptr<FtsColumnIndexer> MakeDstReader() {
+  std::unique_ptr<FtsColumnIndexer> make_dst_reader() {
     auto reader = std::make_unique<FtsColumnIndexer>();
     EXPECT_TRUE(reader
                     ->open_reader(kFieldName, &dst_db_, dst_postings_,
@@ -279,7 +279,7 @@ class FtsRocksdbReducerTest : public ::testing::Test {
   }
 
   // Initialize a reducer targeting the destination store
-  FtsRocksdbReducer MakeReducer() {
+  FtsRocksdbReducer make_reducer() {
     FtsRocksdbReducer reducer;
     EXPECT_TRUE(reducer
                     .init(kFieldName, &dst_db_, dst_postings_, dst_positions_,
@@ -334,7 +334,7 @@ TEST_F(FtsRocksdbReducerTest, FeedFailsBeforeInit) {
 }
 
 TEST_F(FtsRocksdbReducerTest, FeedAcceptsGapBetweenGlobalDocIdRanges) {
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
 
   FtsSegmentStats stats0 = MakeSegmentStats(0, 2);
   EXPECT_TRUE(reducer.feed(stats0, &src0_db_, src0_postings_, src0_positions_)
@@ -348,7 +348,7 @@ TEST_F(FtsRocksdbReducerTest, FeedAcceptsGapBetweenGlobalDocIdRanges) {
 }
 
 TEST_F(FtsRocksdbReducerTest, FeedFailsWithOverlappingGlobalDocIdRanges) {
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
 
   FtsSegmentStats stats0 = MakeSegmentStats(0, 2);
   EXPECT_TRUE(reducer.feed(stats0, &src0_db_, src0_postings_, src0_positions_)
@@ -363,12 +363,12 @@ TEST_F(FtsRocksdbReducerTest, FeedAcceptsEmptySegmentAsNoop) {
   // Empty segments (doc_count == 0) silently contribute nothing — the
   // surrounding non-empty segments still get their ordering validated
   // against each other, as if the empty one wasn't there.
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(), {{0, "hello world"}, {1, "foo"}, {2, "bar"}});
-  auto indexer1 = MakeSrc1Indexer();
+  auto indexer1 = make_src1_indexer();
   InsertDocs(indexer1.get(), {{0, "baz"}});
 
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
 
   FtsSegmentStats stats0 = MakeSegmentStats(0, 2);
   ASSERT_TRUE(reducer.feed(stats0, &src0_db_, src0_postings_, src0_positions_)
@@ -391,7 +391,7 @@ TEST_F(FtsRocksdbReducerTest, FeedAcceptsEmptySegmentAsNoop) {
 
   ASSERT_TRUE(reducer.reduce(NoDeleteFilter()).has_value());
 
-  auto reader = MakeDstReader();
+  auto reader = make_dst_reader();
   std::vector<FtsResult> results;
   ASSERT_TRUE(search_str_ok(*reader, "hello", 10, &results));
   EXPECT_EQ(results.size(), 1u);
@@ -409,18 +409,18 @@ TEST_F(FtsRocksdbReducerTest, FeedAcceptsEmptySegmentAsNoop) {
 
 TEST_F(FtsRocksdbReducerTest, SingleSegmentMergeNoDeletes) {
   // Segment 0: doc_ids 0..2
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(),
              {{0, "hello world"}, {1, "hello foo"}, {2, "bar"}});
 
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
   FtsSegmentStats stats0 = MakeSegmentStats(0, 2);
   ASSERT_TRUE(reducer.feed(stats0, &src0_db_, src0_postings_, src0_positions_)
                   .has_value());
   ASSERT_TRUE(reducer.reduce(NoDeleteFilter()).has_value());
 
   // Verify: search "hello" should return doc_ids 0 and 1
-  auto reader = MakeDstReader();
+  auto reader = make_dst_reader();
   std::vector<FtsResult> results;
   ASSERT_TRUE(search_str_ok(*reader, "hello", 10, &results));
   EXPECT_EQ(results.size(), 2u);
@@ -447,11 +447,11 @@ TEST_F(FtsRocksdbReducerTest, SingleSegmentMergeNoDeletes) {
 
 TEST_F(FtsRocksdbReducerTest, SingleSegmentMergeWithDeletes) {
   // Segment 0: doc_ids 0..2
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(),
              {{0, "hello world"}, {1, "hello foo"}, {2, "bar"}});
 
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
   FtsSegmentStats stats0 = MakeSegmentStats(0, 2);
   ASSERT_TRUE(reducer.feed(stats0, &src0_db_, src0_postings_, src0_positions_)
                   .has_value());
@@ -460,7 +460,7 @@ TEST_F(FtsRocksdbReducerTest, SingleSegmentMergeWithDeletes) {
   // doc_ids; surviving global {1,2} get dense ranks {0,1}.
   ASSERT_TRUE(reducer.reduce(DeleteFilter({0})).has_value());
 
-  auto reader = MakeDstReader();
+  auto reader = make_dst_reader();
   std::vector<FtsResult> results;
 
   // "hello" survived in global doc 1 → dense doc_id 0.
@@ -480,15 +480,15 @@ TEST_F(FtsRocksdbReducerTest, SingleSegmentMergeWithDeletes) {
 
 TEST_F(FtsRocksdbReducerTest, TwoSegmentsMergeDocIdRemapping) {
   // Segment 0: GLOBAL doc_ids 0..2
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(),
              {{0, "hello world"}, {1, "hello baz"}, {2, "foo bar"}});
 
   // Segment 1: GLOBAL doc_ids 3..3 (stored as LOCAL 0 in src1 RocksDB)
-  auto indexer1 = MakeSrc1Indexer();
+  auto indexer1 = make_src1_indexer();
   InsertDocs(indexer1.get(), {{0, "hello qux"}});
 
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
 
   FtsSegmentStats stats0 = MakeSegmentStats(0, 2);
   ASSERT_TRUE(reducer.feed(stats0, &src0_db_, src0_postings_, src0_positions_)
@@ -503,7 +503,7 @@ TEST_F(FtsRocksdbReducerTest, TwoSegmentsMergeDocIdRemapping) {
   // Dst segment starts at GLOBAL doc_id 0 (covers 0..3); reader returns
   // GLOBAL doc_ids by adding start_doc_id back to local doc_ids stored in
   // the merged dst RocksDB.
-  auto reader = MakeDstReader();
+  auto reader = make_dst_reader();
   std::vector<FtsResult> results;
 
   // "hello" appears in global doc_ids 0, 1 (seg0) and 3 (seg1)
@@ -540,14 +540,14 @@ TEST_F(FtsRocksdbReducerTest, TwoSegmentsMergeDocIdRemapping) {
 
 TEST_F(FtsRocksdbReducerTest, TwoSegmentsMergeDeleteFromSecondSegment) {
   // Segment 0: GLOBAL doc_ids 0..1
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(), {{0, "hello world"}, {1, "foo bar"}});
 
   // Segment 1: GLOBAL doc_ids 2..3 (stored as LOCAL 0..1 in src1 RocksDB)
-  auto indexer1 = MakeSrc1Indexer();
+  auto indexer1 = make_src1_indexer();
   InsertDocs(indexer1.get(), {{0, "hello baz"}, {1, "qux"}});
 
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
 
   FtsSegmentStats stats0 = MakeSegmentStats(0, 1);
   ASSERT_TRUE(reducer.feed(stats0, &src0_db_, src0_postings_, src0_positions_)
@@ -561,7 +561,7 @@ TEST_F(FtsRocksdbReducerTest, TwoSegmentsMergeDeleteFromSecondSegment) {
   // input scan order are global {0, 1, 3}, getting dense ranks {0, 1, 2}.
   ASSERT_TRUE(reducer.reduce(DeleteFilter({2})).has_value());
 
-  auto reader = MakeDstReader();
+  auto reader = make_dst_reader();
   std::vector<FtsResult> results;
 
   // "hello" survived in global doc 0 → dense rank 0.
@@ -581,17 +581,17 @@ TEST_F(FtsRocksdbReducerTest, TwoSegmentsMergeDeleteFromSecondSegment) {
 // ============================================================
 
 TEST_F(FtsRocksdbReducerTest, MergedResultsHavePositiveScores) {
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(),
              {{0, "hello world"}, {1, "hello foo"}, {2, "bar baz"}});
 
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
   FtsSegmentStats stats0 = MakeSegmentStats(0, 2);
   ASSERT_TRUE(reducer.feed(stats0, &src0_db_, src0_postings_, src0_positions_)
                   .has_value());
   ASSERT_TRUE(reducer.reduce(NoDeleteFilter()).has_value());
 
-  auto reader = MakeDstReader();
+  auto reader = make_dst_reader();
   std::vector<FtsResult> results;
   ASSERT_TRUE(search_str_ok(*reader, "hello", 10, &results));
   ASSERT_EQ(results.size(), 2u);
@@ -607,7 +607,7 @@ TEST_F(FtsRocksdbReducerTest, MergedResultsHavePositiveScores) {
 // ============================================================
 
 TEST_F(FtsRocksdbReducerTest, ReduceFailsBeforeFeed) {
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
   EXPECT_FALSE(reducer.reduce(NoDeleteFilter()).has_value());
 }
 
@@ -616,9 +616,9 @@ TEST_F(FtsRocksdbReducerTest, ReduceFailsBeforeFeed) {
 // ============================================================
 
 TEST_F(FtsRocksdbReducerTest, CleanupResetsState) {
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
 
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(), {{0, "hello"}, {1, "world"}});
 
   FtsSegmentStats stats0 = MakeSegmentStats(0, 1);
@@ -636,11 +636,11 @@ TEST_F(FtsRocksdbReducerTest, CleanupResetsState) {
 // ============================================================
 
 TEST_F(FtsRocksdbReducerTest, ReduceProducesBitPackedFormat) {
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(),
              {{0, "hello world"}, {1, "hello foo"}, {2, "bar baz"}});
 
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
   FtsSegmentStats stats0 = MakeSegmentStats(0, 2);
   ASSERT_TRUE(reducer.feed(stats0, &src0_db_, src0_postings_, src0_positions_)
                   .has_value());
@@ -679,14 +679,14 @@ TEST_F(FtsRocksdbReducerTest, ReduceProducesBitPackedFormat) {
 
 TEST_F(FtsRocksdbReducerTest, TwoSegmentMergeBitPackedCorrectness) {
   // Segment 0: GLOBAL doc_ids 0..1
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(), {{0, "hello world"}, {1, "foo bar"}});
 
   // Segment 1: GLOBAL doc_ids 2..3 (stored as LOCAL 0..1 in src1 RocksDB)
-  auto indexer1 = MakeSrc1Indexer();
+  auto indexer1 = make_src1_indexer();
   InsertDocs(indexer1.get(), {{0, "hello baz"}, {1, "qux"}});
 
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
 
   FtsSegmentStats stats0 = MakeSegmentStats(0, 1);
   ASSERT_TRUE(reducer.feed(stats0, &src0_db_, src0_postings_, src0_positions_)
@@ -715,7 +715,7 @@ TEST_F(FtsRocksdbReducerTest, TwoSegmentMergeBitPackedCorrectness) {
   EXPECT_EQ(iter.next_doc(), fts::BitPackedPostingIterator::NO_MORE_DOCS);
 
   // Verify search still works correctly via FtsColumnIndexer
-  auto reader = MakeDstReader();
+  auto reader = make_dst_reader();
   std::vector<FtsResult> results;
   ASSERT_TRUE(search_str_ok(*reader, "hello", 10, &results));
   EXPECT_EQ(results.size(), 2u);
@@ -738,7 +738,7 @@ TEST_F(FtsRocksdbReducerTest, MergeTwoBitPackedSegments) {
 
   // Mid0: reduce src0 -> mid0 (produces BitPacked postings)
   {
-    auto indexer0 = MakeSrc0Indexer();
+    auto indexer0 = make_src0_indexer();
     InsertDocs(indexer0.get(),
                {{0, "hello world"}, {1, "hello foo"}, {2, "bar"}});
 
@@ -772,7 +772,7 @@ TEST_F(FtsRocksdbReducerTest, MergeTwoBitPackedSegments) {
 
   // Mid1: reduce src1 -> mid1 (produces BitPacked postings)
   {
-    auto indexer1 = MakeSrc1Indexer();
+    auto indexer1 = make_src1_indexer();
     InsertDocs(indexer1.get(), {{0, "hello baz"}, {1, "qux bar"}});
 
     RocksdbContext mid1_db;
@@ -814,7 +814,7 @@ TEST_F(FtsRocksdbReducerTest, MergeTwoBitPackedSegments) {
   auto *mid0_positions = mid0_db.get_cf(kPositionsCf);
   auto *mid1_postings = mid1_db.get_cf(kPostingsCf);
   auto *mid1_positions = mid1_db.get_cf(kPositionsCf);
-  FtsRocksdbReducer final_reducer = MakeReducer();
+  FtsRocksdbReducer final_reducer = make_reducer();
   // mid0 has doc_ids 0..2, mid1 has doc_ids 3..4
   ASSERT_TRUE(
       final_reducer
@@ -862,7 +862,7 @@ TEST_F(FtsRocksdbReducerTest, MergeTwoBitPackedSegments) {
   EXPECT_EQ(bar_iter.next_doc(), fts::BitPackedPostingIterator::NO_MORE_DOCS);
 
   // Verify search via FtsColumnIndexer still works
-  auto reader = MakeDstReader();
+  auto reader = make_dst_reader();
   std::vector<FtsResult> results;
   ASSERT_TRUE(search_str_ok(*reader, "hello", 10, &results));
   EXPECT_EQ(results.size(), 3u);
@@ -902,7 +902,7 @@ TEST_F(FtsRocksdbReducerTest, MergeTwoBitPackedSegments) {
 TEST_F(FtsRocksdbReducerTest, ReducerHandlesBitpackedConvertedSrcSegments) {
   // ----- src0: insert + flush + convert (the helper already calls convert)
   // -----
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(), {
                                  {0, "hello world"},
                                  {1, "hello foo"},
@@ -933,7 +933,7 @@ TEST_F(FtsRocksdbReducerTest, ReducerHandlesBitpackedConvertedSrcSegments) {
   }
 
   // ----- src1: insert + flush + convert -----
-  auto indexer1 = MakeSrc1Indexer();
+  auto indexer1 = make_src1_indexer();
   InsertDocs(indexer1.get(), {
                                  {0, "hello qux"},
                                  {1, "qux quux"},
@@ -941,7 +941,7 @@ TEST_F(FtsRocksdbReducerTest, ReducerHandlesBitpackedConvertedSrcSegments) {
 
   // ----- Reduce -----
   // src0 covers GLOBAL [0, 2], src1 covers GLOBAL [3, 4] (consecutive).
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
   ASSERT_TRUE(reducer
                   .feed(MakeSegmentStats(0, 2), &src0_db_, src0_postings_,
                         src0_positions_)
@@ -956,7 +956,7 @@ TEST_F(FtsRocksdbReducerTest, ReducerHandlesBitpackedConvertedSrcSegments) {
   // After reduce, dst postings get re-written to BitPacked again by the
   // reducer's existing convert_postings_to_bitpacked step, so this exercises
   // the full BitPacked-in / BitPacked-out path.
-  auto reader = MakeDstReader();
+  auto reader = make_dst_reader();
 
   // "hello" appears in src0 doc 0 (global 0), src0 doc 1 (global 1),
   // src1 doc 0 (global 3) -> 3 hits.
@@ -992,7 +992,7 @@ TEST_F(FtsRocksdbReducerTest, ReducerHandlesBitpackedConvertedSrcSegments) {
 TEST_F(FtsRocksdbReducerTest, ReduceWithEmptySideCFsProducesBitPacked) {
   // InsertDocs() already calls convert_postings_to_bitpacked(), so by the
   // time we reach reduce() the src $TF / $MAX_TF / $DOC_LEN CFs are empty.
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(), {{0, "alpha beta gamma"},
                               {1, "alpha alpha gamma"},
                               {2, "delta epsilon"}});
@@ -1013,7 +1013,7 @@ TEST_F(FtsRocksdbReducerTest, ReduceWithEmptySideCFsProducesBitPacked) {
     EXPECT_FALSE(it3->Valid());
   }
 
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
   ASSERT_TRUE(reducer
                   .feed(MakeSegmentStats(0, 2), &src0_db_, src0_postings_,
                         src0_positions_)
@@ -1057,7 +1057,7 @@ TEST_F(FtsRocksdbReducerTest, ReduceWithEmptySideCFsProducesBitPacked) {
 
   // dst no longer has side CFs ($TF/$MAX_TF/$DOC_LEN) — they are dropped
   // at dump time. Verify search still works end-to-end.
-  auto reader = MakeDstReader();
+  auto reader = make_dst_reader();
   std::vector<FtsResult> results;
   ASSERT_TRUE(search_str_ok(*reader, "alpha", 10, &results));
   EXPECT_EQ(results.size(), 2u);
@@ -1073,14 +1073,14 @@ TEST_F(FtsRocksdbReducerTest, ReduceWithEmptySideCFsProducesBitPacked) {
 
 TEST_F(FtsRocksdbReducerTest, MultiSegmentBM25StatsAreAccumulatedCorrectly) {
   // src0: 2 docs, doc_len 3 + 2 = 5 tokens
-  auto indexer0 = MakeSrc0Indexer();
+  auto indexer0 = make_src0_indexer();
   InsertDocs(indexer0.get(), {{0, "alpha beta gamma"}, {1, "alpha beta"}});
 
   // src1: 2 docs, doc_len 4 + 1 = 5 tokens
-  auto indexer1 = MakeSrc1Indexer();
+  auto indexer1 = make_src1_indexer();
   InsertDocs(indexer1.get(), {{0, "alpha gamma delta epsilon"}, {1, "alpha"}});
 
-  FtsRocksdbReducer reducer = MakeReducer();
+  FtsRocksdbReducer reducer = make_reducer();
   ASSERT_TRUE(reducer
                   .feed(MakeSegmentStats(0, 1), &src0_db_, src0_postings_,
                         src0_positions_)
diff --git a/tests/db/index/column/vector_column_group_by_test.cc b/tests/db/index/column/vector_column_group_by_test.cc
index c0b41b374..ce2f89a65 100644
--- a/tests/db/index/column/vector_column_group_by_test.cc
+++ b/tests/db/index/column/vector_column_group_by_test.cc
@@ -74,7 +74,7 @@ std::vector<uint64_t> AllPks() {
 
 class CapturingVectorColumnIndexer : public VectorColumnIndexer {
  public:
-  Result<IndexResults::Ptr> Search(
+  Result<IndexResults::Ptr> search(
       const vector_column_params::VectorData &,
       const vector_column_params::QueryParams &query_params) override {
     search_called = true;
@@ -95,10 +95,10 @@ class CapturingVectorColumnIndexer : public VectorColumnIndexer {
 
 class GroupByIndexerTest : public ::testing::Test {
  protected:
-  void RunOk(const GroupByCase &tc) {
+  void run_ok(const GroupByCase &tc) {
     Run(tc, /*expect_error=*/false);
   }
-  void RunRejected(const GroupByCase &tc) {
+  void run_rejected(const GroupByCase &tc) {
     Run(tc, /*expect_error=*/true);
   }
 
@@ -125,7 +125,7 @@ class GroupByIndexerTest : public ::testing::Test {
     QueryHolder holder = MakeQuery(tc);
     vector_column_params::QueryParams qp = MakeQueryParams(tc);
 
-    auto results = indexer->Search(holder.data, qp);
+    auto results = indexer->search(holder.data, qp);
 
     if (expect_error) {
       ASSERT_FALSE(results.has_value())
@@ -135,7 +135,7 @@ class GroupByIndexerTest : public ::testing::Test {
       AssertGroupedResult(results.value().get(), tc);
     }
 
-    indexer->Close();
+    indexer->close();
     zvec::test_util::RemoveTestFiles(path);
   }
 
@@ -151,7 +151,7 @@ class GroupByIndexerTest : public ::testing::Test {
   static VectorColumnIndexer::Ptr OpenIndexer(const GroupByCase &tc,
                                               const std::string &path) {
     auto indexer = std::make_shared<VectorColumnIndexer>(path, MakeSchema(tc));
-    if (!indexer->Open(vector_column_params::ReadOptions{true, true}).ok()) {
+    if (!indexer->open(vector_column_params::ReadOptions{true, true}).ok()) {
       return nullptr;
     }
     return indexer;
@@ -170,12 +170,12 @@ class GroupByIndexerTest : public ::testing::Test {
         vector_column_params::SparseVector sv{kGbSparseCount, indices.data(),
                                               values.data()};
         ASSERT_TRUE(
-            indexer->Insert(vector_column_params::VectorData{sv}, i).ok());
+            indexer->insert(vector_column_params::VectorData{sv}, i).ok());
       } else {
         std::vector<float> vec(tc.dimension, static_cast<float>(i));
         vector_column_params::DenseVector dv{vec.data()};
         ASSERT_TRUE(
-            indexer->Insert(vector_column_params::VectorData{dv}, i).ok());
+            indexer->insert(vector_column_params::VectorData{dv}, i).ok());
       }
     }
   }
@@ -306,7 +306,7 @@ TEST_F(GroupByIndexerTest, Dense) {
   };
 
   for (const auto &tc : cases) {
-    RunOk(tc);
+    run_ok(tc);
   }
 }
 
@@ -324,15 +324,15 @@ TEST_F(GroupByIndexerTest, CombinedSortsGroupsBeforeTruncating) {
 
   auto block0 = std::make_shared<VectorColumnIndexer>(block0_path, schema);
   auto block1 = std::make_shared<VectorColumnIndexer>(block1_path, schema);
-  ASSERT_TRUE(block0->Open(vector_column_params::ReadOptions{true, true}).ok());
-  ASSERT_TRUE(block1->Open(vector_column_params::ReadOptions{true, true}).ok());
+  ASSERT_TRUE(block0->open(vector_column_params::ReadOptions{true, true}).ok());
+  ASSERT_TRUE(block1->open(vector_column_params::ReadOptions{true, true}).ok());
 
   auto insert_dense = [](const VectorColumnIndexer::Ptr &indexer,
                          uint32_t doc_id, float value) {
     std::vector<float> vec(kGbDimension, value);
     vector_column_params::DenseVector dense{vec.data()};
     ASSERT_TRUE(
-        indexer->Insert(vector_column_params::VectorData{dense}, doc_id).ok());
+        indexer->insert(vector_column_params::VectorData{dense}, doc_id).ok());
   };
   insert_dense(block0, 0, 0.0f);
   insert_dense(block0, 1, 1.0f);
@@ -355,7 +355,7 @@ TEST_F(GroupByIndexerTest, CombinedSortsGroupsBeforeTruncating) {
   query_params.group_by = MakeSegmentGroupByParams(/*group_topk=*/1,
                                                    /*group_count=*/1);
 
-  auto results = combined.Search(vector_column_params::VectorData{dense_query},
+  auto results = combined.search(vector_column_params::VectorData{dense_query},
                                  query_params);
   ASSERT_TRUE(results.has_value());
   auto *group_results =
@@ -367,8 +367,8 @@ TEST_F(GroupByIndexerTest, CombinedSortsGroupsBeforeTruncating) {
   ASSERT_EQ(3u, group_results->groups()[0].docs()[0].key());
   ASSERT_FLOAT_EQ(44.0f, group_results->groups()[0].docs()[0].score());
 
-  ASSERT_TRUE(block0->Close().ok());
-  ASSERT_TRUE(block1->Close().ok());
+  ASSERT_TRUE(block0->close().ok());
+  ASSERT_TRUE(block1->close().ok());
   zvec::test_util::RemoveTestFiles(block0_path);
   zvec::test_util::RemoveTestFiles(block1_path);
 }
@@ -392,7 +392,7 @@ TEST_F(GroupByIndexerTest, CombinedSupportsIvfRabitqRefiner) {
   query_params.query_params =
       std::make_shared<IvfRabitqQueryParams>(4, 0.0f, false, true, 3.5f);
 
-  auto result = combined.Search(
+  auto result = combined.search(
       vector_column_params::VectorData{
           vector_column_params::DenseVector{query.data()}},
       query_params);
@@ -414,7 +414,7 @@ TEST_F(GroupByIndexerTest, Sparse) {
   };
 
   for (const auto &tc : cases) {
-    RunOk(tc);
+    run_ok(tc);
   }
 }
 
@@ -430,7 +430,7 @@ TEST_F(GroupByIndexerTest, UnsupportedIndexTypes) {
   };
 
   for (const auto &tc : cases) {
-    RunRejected(tc);
+    run_rejected(tc);
   }
 }
 
diff --git a/tests/db/index/column/vector_column_indexer_test.cc b/tests/db/index/column/vector_column_indexer_test.cc
index b0bfd9c81..3111c4a9b 100644
--- a/tests/db/index/column/vector_column_indexer_test.cc
+++ b/tests/db/index/column/vector_column_indexer_test.cc
@@ -73,7 +73,7 @@ TEST(VectorColumnIndexerTest, General) {
 
     // 2. open
     ASSERT_TRUE(
-        indexer->Open(vector_column_params::ReadOptions{true, true}).ok());
+        indexer->open(vector_column_params::ReadOptions{true, true}).ok());
 
     {
       // can't use `DenseVector{std::vector<float>{1.0f, 2.0f, 3.0f}.data()}}`,
@@ -83,14 +83,14 @@ TEST(VectorColumnIndexerTest, General) {
       // 3. add data
       auto data = vector_column_params::VectorData{
           vector_column_params::DenseVector{vector.data()}};
-      ASSERT_TRUE(indexer->Insert(data, kDocId).ok());
+      ASSERT_TRUE(indexer->insert(data, kDocId).ok());
     }
 
     {
       auto vector = std::vector<float>{1.0f, 2000.0f, 3.0f, 0};
       // 1 * 1 + 2 * 2000 + 3 * 3 = 12006
       ASSERT_TRUE(indexer
-                      ->Insert(
+                      ->insert(
                           vector_column_params::VectorData{
                               vector_column_params::DenseVector{vector.data()}},
                           kDocId + 10)
@@ -101,7 +101,7 @@ TEST(VectorColumnIndexerTest, General) {
       auto vector = std::vector<float>{1.0f, 0, 3.0f, 0};
       // 1 * 1 + 2 * 0 + 3 * 3 = 10
       ASSERT_TRUE(indexer
-                      ->Insert(
+                      ->insert(
                           vector_column_params::VectorData{
                               vector_column_params::DenseVector{vector.data()}},
                           kDocId + 10)
@@ -109,7 +109,7 @@ TEST(VectorColumnIndexerTest, General) {
     }
 
     // 5. fetch
-    auto fetched_data = indexer->Fetch(kDocId);
+    auto fetched_data = indexer->fetch(kDocId);
     ASSERT_TRUE(fetched_data);
     const float *dense_vector = reinterpret_cast<const float *>(
         std::get<vector_column_params::DenseVectorBuffer>(
@@ -129,7 +129,7 @@ TEST(VectorColumnIndexerTest, General) {
     indexer_query_params.filter = nullptr;
     indexer_query_params.fetch_vector = true;
     indexer_query_params.query_params = query_params;
-    auto results = indexer->Search(query, indexer_query_params);
+    auto results = indexer->search(query, indexer_query_params);
     ASSERT_TRUE(results.has_value());
 
     auto vector_results =
@@ -170,7 +170,7 @@ TEST(VectorColumnIndexerTest, General) {
       ASSERT_TRUE(vector_results->reverted_sparse_values_list().empty());
     }
 
-    indexer->Close();
+    indexer->close();
 
     zvec::test_util::RemoveTestFiles(index_file_path);
   };
@@ -224,7 +224,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeFP16) {
 
     // 2. open
     ASSERT_TRUE(
-        indexer->Open(vector_column_params::ReadOptions{true, true}).ok());
+        indexer->open(vector_column_params::ReadOptions{true, true}).ok());
 
     {
       // can't use `DenseVector{std::vector<float>{1.0f, 2.0f, 3.0f}.data()}}`,
@@ -238,7 +238,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeFP16) {
       // 3. add data
       auto data = vector_column_params::VectorData{
           vector_column_params::DenseVector{vector.data()}};
-      ASSERT_TRUE(indexer->Insert(data, kDocId).ok());
+      ASSERT_TRUE(indexer->insert(data, kDocId).ok());
     }
 
     {
@@ -249,7 +249,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeFP16) {
       auto vector = buffer;
       // 1 * 1 + 2 * 2000 + 3 * 3 = 12006
       ASSERT_TRUE(indexer
-                      ->Insert(
+                      ->insert(
                           vector_column_params::VectorData{
                               vector_column_params::DenseVector{vector.data()}},
                           kDocId + 10)
@@ -264,7 +264,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeFP16) {
       auto vector = buffer;
       // 1 * 1 + 2 * 0 + 3 * 3 = 10
       ASSERT_TRUE(indexer
-                      ->Insert(
+                      ->insert(
                           vector_column_params::VectorData{
                               vector_column_params::DenseVector{vector.data()}},
                           kDocId + 10)
@@ -272,7 +272,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeFP16) {
     }
     // 5. fetch
     {
-      auto fetched_data = indexer->Fetch(kDocId);
+      auto fetched_data = indexer->fetch(kDocId);
       ASSERT_TRUE(fetched_data);
       const uint16_t *dense_vector = reinterpret_cast<const uint16_t *>(
           std::get<vector_column_params::DenseVectorBuffer>(
@@ -284,7 +284,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeFP16) {
       ASSERT_NEAR(ailego::FloatHelper::ToFP32(dense_vector[3]), 0, 0.1);
     }
     {
-      auto fetched_data = indexer->Fetch(kDocId + 10);
+      auto fetched_data = indexer->fetch(kDocId + 10);
       ASSERT_TRUE(fetched_data);
       const uint16_t *dense_vector = reinterpret_cast<const uint16_t *>(
           std::get<vector_column_params::DenseVectorBuffer>(
@@ -310,7 +310,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeFP16) {
     indexer_query_params.filter = nullptr;
     indexer_query_params.fetch_vector = true;
     indexer_query_params.query_params = query_params;
-    auto results = indexer->Search(query, indexer_query_params);
+    auto results = indexer->search(query, indexer_query_params);
     ASSERT_TRUE(results.has_value());
 
     auto vector_results =
@@ -351,7 +351,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeFP16) {
       ASSERT_TRUE(vector_results->reverted_sparse_values_list().empty());
     }
 
-    indexer->Close();
+    indexer->close();
 
     zvec::test_util::RemoveTestFiles(index_file_path);
   };
@@ -379,7 +379,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeINT8) {
 
     // 2. open
     ASSERT_TRUE(
-        indexer->Open(vector_column_params::ReadOptions{true, true}).ok());
+        indexer->open(vector_column_params::ReadOptions{true, true}).ok());
 
     {
       // can't use `DenseVector{std::vector<float>{1.0f, 2.0f, 3.0f}.data()}}`,
@@ -389,14 +389,14 @@ TEST(VectorColumnIndexerTest, DenseDataTypeINT8) {
       // 3. add data
       auto data = vector_column_params::VectorData{
           vector_column_params::DenseVector{vector.data()}};
-      ASSERT_TRUE(indexer->Insert(data, kDocId).ok());
+      ASSERT_TRUE(indexer->insert(data, kDocId).ok());
     }
 
     {
       auto vector = std::vector<uint8_t>{1, 200, 3, 0};
       // 1 * 1 + 2 * 2000 + 3 * 3 = 12006
       ASSERT_TRUE(indexer
-                      ->Insert(
+                      ->insert(
                           vector_column_params::VectorData{
                               vector_column_params::DenseVector{vector.data()}},
                           kDocId + 10)
@@ -407,7 +407,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeINT8) {
       auto vector = std::vector<uint8_t>{1, 0, 3, 0};
       // 1 * 1 + 2 * 0 + 3 * 3 = 10
       ASSERT_TRUE(indexer
-                      ->Insert(
+                      ->insert(
                           vector_column_params::VectorData{
                               vector_column_params::DenseVector{vector.data()}},
                           kDocId + 10)
@@ -415,7 +415,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeINT8) {
     }
     // 5. fetch
     {
-      auto fetched_data = indexer->Fetch(kDocId);
+      auto fetched_data = indexer->fetch(kDocId);
       ASSERT_TRUE(fetched_data);
       const uint8_t *dense_vector = reinterpret_cast<const uint8_t *>(
           std::get<vector_column_params::DenseVectorBuffer>(
@@ -427,7 +427,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeINT8) {
       ASSERT_NEAR(dense_vector[3], 0, 0.1);
     }
     {
-      auto fetched_data = indexer->Fetch(kDocId + 10);
+      auto fetched_data = indexer->fetch(kDocId + 10);
       ASSERT_TRUE(fetched_data);
       const uint8_t *dense_vector = reinterpret_cast<const uint8_t *>(
           std::get<vector_column_params::DenseVectorBuffer>(
@@ -448,7 +448,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeINT8) {
     indexer_query_params.filter = nullptr;
     indexer_query_params.fetch_vector = true;
     indexer_query_params.query_params = query_params;
-    auto results = indexer->Search(query, indexer_query_params);
+    auto results = indexer->search(query, indexer_query_params);
     ASSERT_TRUE(results.has_value());
 
     auto vector_results =
@@ -489,7 +489,7 @@ TEST(VectorColumnIndexerTest, DenseDataTypeINT8) {
       ASSERT_TRUE(vector_results->reverted_sparse_values_list().empty());
     }
 
-    indexer->Close();
+    indexer->close();
 
     zvec::test_util::RemoveTestFiles(index_file_path);
   };
@@ -516,7 +516,7 @@ TEST(VectorColumnIndexerTest, SparseGeneral) {
     ASSERT_TRUE(indexer);
 
     // open
-    if (auto ret = indexer->Open(vector_column_params::ReadOptions{true, true});
+    if (auto ret = indexer->open(vector_column_params::ReadOptions{true, true});
         !ret.ok()) {
       std::cout << ret.message() << std::endl;
       ASSERT_TRUE(false);
@@ -531,10 +531,10 @@ TEST(VectorColumnIndexerTest, SparseGeneral) {
     vector_column_params::SparseVector vector{kSparseCount, indices.data(),
                                               values.data()};
     ASSERT_TRUE(
-        indexer->Insert(vector_column_params::VectorData{vector}, kDocId).ok());
+        indexer->insert(vector_column_params::VectorData{vector}, kDocId).ok());
 
     // fetch
-    auto fetched_data = indexer->Fetch(kDocId);
+    auto fetched_data = indexer->fetch(kDocId);
     ASSERT_TRUE(fetched_data.has_value());
     auto fetched_sparse_vector =
         std::get<vector_column_params::SparseVectorBuffer>(
@@ -556,7 +556,7 @@ TEST(VectorColumnIndexerTest, SparseGeneral) {
     query_params.topk = 10;
     query_params.filter = nullptr;
     query_params.fetch_vector = true;
-    auto results = indexer->Search(query, query_params);
+    auto results = indexer->search(query, query_params);
     ASSERT_TRUE(results.has_value());
 
     auto vector_results =
@@ -599,7 +599,7 @@ TEST(VectorColumnIndexerTest, SparseGeneral) {
       }
     }
 
-    indexer->Close();
+    indexer->close();
 
     zvec::test_util::RemoveTestFiles(index_file_path);
   };
@@ -626,7 +626,7 @@ TEST(VectorColumnIndexerTest, SparseDataTypeFP16) {
     ASSERT_TRUE(indexer);
 
     // open
-    if (auto ret = indexer->Open(vector_column_params::ReadOptions{true, true});
+    if (auto ret = indexer->open(vector_column_params::ReadOptions{true, true});
         !ret.ok()) {
       std::cout << ret.message() << std::endl;
       ASSERT_TRUE(false);
@@ -645,10 +645,10 @@ TEST(VectorColumnIndexerTest, SparseDataTypeFP16) {
     vector_column_params::SparseVector vector{kSparseCount, indices.data(),
                                               values.data()};
     ASSERT_TRUE(
-        indexer->Insert(vector_column_params::VectorData{vector}, kDocId).ok());
+        indexer->insert(vector_column_params::VectorData{vector}, kDocId).ok());
 
     // fetch
-    auto fetched_data = indexer->Fetch(kDocId);
+    auto fetched_data = indexer->fetch(kDocId);
     ASSERT_TRUE(fetched_data.has_value());
     auto fetched_sparse_vector =
         std::get<vector_column_params::SparseVectorBuffer>(
@@ -670,7 +670,7 @@ TEST(VectorColumnIndexerTest, SparseDataTypeFP16) {
     query_params.topk = 10;
     query_params.filter = nullptr;
     query_params.fetch_vector = true;
-    auto results = indexer->Search(query, query_params);
+    auto results = indexer->search(query, query_params);
     ASSERT_TRUE(results.has_value());
 
     auto vector_results =
@@ -713,7 +713,7 @@ TEST(VectorColumnIndexerTest, SparseDataTypeFP16) {
       }
     }
 
-    indexer->Close();
+    indexer->close();
 
     zvec::test_util::RemoveTestFiles(index_file_path);
   };
@@ -738,7 +738,7 @@ TEST(VectorColumnIndexerTest, Merge) {
         index_name, FieldSchema("test", DataType::VECTOR_FP32, kDimension,
                                 false, index_params));
     if (indexer == nullptr ||
-        !indexer->Open(vector_column_params::ReadOptions{true, true}).ok()) {
+        !indexer->open(vector_column_params::ReadOptions{true, true}).ok()) {
       return nullptr;
     }
     return indexer;
@@ -757,15 +757,15 @@ TEST(VectorColumnIndexerTest, Merge) {
     vector[2] = 123.0f;
     auto vector_data = vector_column_params::VectorData{
         vector_column_params::DenseVector{vector.data()}};
-    ASSERT_TRUE(indexer1->Insert(vector_data, 0).ok());
+    ASSERT_TRUE(indexer1->insert(vector_data, 0).ok());
 
     vector[1] = 2.0f;
-    ASSERT_TRUE(indexer2->Insert(vector_data, 0).ok());
+    ASSERT_TRUE(indexer2->insert(vector_data, 0).ok());
     vector[1] = 3.0f;
-    ASSERT_TRUE(indexer2->Insert(vector_data, 1).ok());
+    ASSERT_TRUE(indexer2->insert(vector_data, 1).ok());
 
     {
-      auto fetched_data = indexer1->Fetch(0);
+      auto fetched_data = indexer1->fetch(0);
       ASSERT_TRUE(fetched_data.has_value());
       const float *fetched_vector = reinterpret_cast<const float *>(
           std::get<vector_column_params::DenseVectorBuffer>(
@@ -775,7 +775,7 @@ TEST(VectorColumnIndexerTest, Merge) {
       ASSERT_NEAR(123.0f, fetched_vector[2], 0.1);
     }
     {
-      auto fetched_data = indexer2->Fetch(0);
+      auto fetched_data = indexer2->fetch(0);
       ASSERT_TRUE(fetched_data.has_value());
       const float *fetched_vector = reinterpret_cast<const float *>(
           std::get<vector_column_params::DenseVectorBuffer>(
@@ -785,7 +785,7 @@ TEST(VectorColumnIndexerTest, Merge) {
       ASSERT_NEAR(123.0f, fetched_vector[2], 0.1);
     }
     {
-      auto fetched_data = indexer2->Fetch(1);
+      auto fetched_data = indexer2->fetch(1);
       ASSERT_TRUE(fetched_data.has_value());
       const float *fetched_vector = reinterpret_cast<const float *>(
           std::get<vector_column_params::DenseVectorBuffer>(
@@ -798,9 +798,9 @@ TEST(VectorColumnIndexerTest, Merge) {
     {  // test reduce
       auto indexer3 = create_indexer_func(param3, index_name + "3");
       ASSERT_NE(nullptr, indexer3);
-      ASSERT_TRUE(indexer3->Merge({indexer1, indexer2}, nullptr).ok());
+      ASSERT_TRUE(indexer3->merge({indexer1, indexer2}, nullptr).ok());
       {
-        auto fetched_data = indexer3->Fetch(0);
+        auto fetched_data = indexer3->fetch(0);
         ASSERT_TRUE(fetched_data.has_value());
         const float *fetched_vector = reinterpret_cast<const float *>(
             std::get<vector_column_params::DenseVectorBuffer>(
@@ -810,7 +810,7 @@ TEST(VectorColumnIndexerTest, Merge) {
         ASSERT_NEAR(123.0f, fetched_vector[2], 0.1);
       }
       {
-        auto fetched_data = indexer3->Fetch(1);
+        auto fetched_data = indexer3->fetch(1);
         ASSERT_TRUE(fetched_data.has_value());
         const float *fetched_vector = reinterpret_cast<const float *>(
             std::get<vector_column_params::DenseVectorBuffer>(
@@ -819,7 +819,7 @@ TEST(VectorColumnIndexerTest, Merge) {
         ASSERT_NEAR(2.0f, fetched_vector[1], 0.1);
         ASSERT_NEAR(123.0f, fetched_vector[2], 0.1);
       }
-      indexer3->Close();
+      indexer3->close();
       del_index_file_func(index_name + "3");
     }
 
@@ -828,11 +828,11 @@ TEST(VectorColumnIndexerTest, Merge) {
       ASSERT_NE(nullptr, indexer3);
       auto filter = std::make_shared<EasyIndexFilter>(
           [](uint64_t key) { return key == 0; });
-      ASSERT_TRUE(indexer3->Merge({indexer1, indexer2}, filter).ok());
+      ASSERT_TRUE(indexer3->merge({indexer1, indexer2}, filter).ok());
       // 0.0 -> x ; 1.0 -> 0 ; 1.1 -> 1
       ASSERT_TRUE(indexer3->doc_count() == 2);
       {
-        auto fetched_data = indexer3->Fetch(0);
+        auto fetched_data = indexer3->fetch(0);
         ASSERT_TRUE(fetched_data.has_value());
         const float *fetched_vector = reinterpret_cast<const float *>(
             std::get<vector_column_params::DenseVectorBuffer>(
@@ -850,7 +850,7 @@ TEST(VectorColumnIndexerTest, Merge) {
         query_params.topk = 10;
         query_params.filter = nullptr;
         query_params.fetch_vector = true;
-        auto results = indexer2->Search(query, query_params);
+        auto results = indexer2->search(query, query_params);
         ASSERT_TRUE(results.has_value());
         auto vector_results =
             dynamic_cast<VectorIndexResults *>(results.value().get());
@@ -894,7 +894,7 @@ TEST(VectorColumnIndexerTest, Merge) {
         }
       }
 
-      indexer3->Close();
+      indexer3->close();
       del_index_file_func(index_name + "3");
     }
 
@@ -903,10 +903,10 @@ TEST(VectorColumnIndexerTest, Merge) {
       ASSERT_NE(nullptr, indexer3);
       auto filter = std::make_shared<EasyIndexFilter>(
           [](uint64_t key) { return key == 0; });
-      ASSERT_TRUE(indexer3->Merge({indexer1, indexer2}, filter, {3}).ok());
+      ASSERT_TRUE(indexer3->merge({indexer1, indexer2}, filter, {3}).ok());
 
       {
-        auto fetched_data = indexer3->Fetch(0);
+        auto fetched_data = indexer3->fetch(0);
         ASSERT_TRUE(fetched_data.has_value());
         const float *fetched_vector = reinterpret_cast<const float *>(
             std::get<vector_column_params::DenseVectorBuffer>(
@@ -915,13 +915,13 @@ TEST(VectorColumnIndexerTest, Merge) {
         ASSERT_NEAR(2.0f, fetched_vector[1], 0.1);
         ASSERT_NEAR(123.0f, fetched_vector[2], 0.1);
       }
-      indexer3->Close();
+      indexer3->close();
       del_index_file_func(index_name + "3");
     }
 
 
-    indexer1->Close();
-    indexer2->Close();
+    indexer1->close();
+    indexer2->close();
     del_index_file_func(index_name + "1");
     del_index_file_func(index_name + "2");
   };
@@ -1006,7 +1006,7 @@ TEST(VectorColumnIndexerTest, SparseMerge) {
         index_name,
         FieldSchema("test", DataType::SPARSE_VECTOR_FP32, false, index_params));
     if (indexer == nullptr ||
-        !indexer->Open(vector_column_params::ReadOptions{true, true}).ok()) {
+        !indexer->open(vector_column_params::ReadOptions{true, true}).ok()) {
       return nullptr;
     }
     return indexer;
@@ -1029,15 +1029,15 @@ TEST(VectorColumnIndexerTest, SparseMerge) {
     vector_column_params::SparseVector vector{kSparseCount, indices.data(),
                                               values.data()};
     auto vector_data = vector_column_params::VectorData{vector};
-    ASSERT_TRUE(indexer1->Insert(vector_data, 0).ok());
+    ASSERT_TRUE(indexer1->insert(vector_data, 0).ok());
 
     values[1] = 2.0f;
-    ASSERT_TRUE(indexer2->Insert(vector_data, 0).ok());
+    ASSERT_TRUE(indexer2->insert(vector_data, 0).ok());
     values[1] = 3.0f;
-    ASSERT_TRUE(indexer2->Insert(vector_data, 1).ok());
+    ASSERT_TRUE(indexer2->insert(vector_data, 1).ok());
 
     {
-      auto fetched_data = indexer1->Fetch(0);
+      auto fetched_data = indexer1->fetch(0);
       ASSERT_TRUE(fetched_data.has_value());
       auto fetched_sparse_vector =
           std::get<vector_column_params::SparseVectorBuffer>(
@@ -1058,7 +1058,7 @@ TEST(VectorColumnIndexerTest, SparseMerge) {
       ASSERT_EQ(2.0f, fetched_values[2]);
     }
     {
-      auto fetched_data = indexer2->Fetch(0);
+      auto fetched_data = indexer2->fetch(0);
       ASSERT_TRUE(fetched_data.has_value());
       auto fetched_sparse_vector =
           std::get<vector_column_params::SparseVectorBuffer>(
@@ -1079,7 +1079,7 @@ TEST(VectorColumnIndexerTest, SparseMerge) {
       ASSERT_EQ(2.0f, fetched_values[2]);
     }
     {
-      auto fetched_data = indexer2->Fetch(1);
+      auto fetched_data = indexer2->fetch(1);
       ASSERT_TRUE(fetched_data.has_value());
       auto fetched_sparse_vector =
           std::get<vector_column_params::SparseVectorBuffer>(
@@ -1103,9 +1103,9 @@ TEST(VectorColumnIndexerTest, SparseMerge) {
     {  // test reduce
       auto indexer3 = create_indexer_func(param3, index_name + "3");
       ASSERT_NE(nullptr, indexer3);
-      ASSERT_TRUE(indexer3->Merge({indexer1, indexer2}, nullptr).ok());
+      ASSERT_TRUE(indexer3->merge({indexer1, indexer2}, nullptr).ok());
       {
-        auto fetched_data = indexer3->Fetch(0);
+        auto fetched_data = indexer3->fetch(0);
         ASSERT_TRUE(fetched_data.has_value());
         auto fetched_sparse_vector =
             std::get<vector_column_params::SparseVectorBuffer>(
@@ -1126,7 +1126,7 @@ TEST(VectorColumnIndexerTest, SparseMerge) {
         ASSERT_EQ(2.0f, fetched_values[2]);
       }
       {
-        auto fetched_data = indexer3->Fetch(1);
+        auto fetched_data = indexer3->fetch(1);
         ASSERT_TRUE(fetched_data.has_value());
         auto fetched_sparse_vector =
             std::get<vector_column_params::SparseVectorBuffer>(
@@ -1146,7 +1146,7 @@ TEST(VectorColumnIndexerTest, SparseMerge) {
         ASSERT_EQ(2.0f, fetched_values[1]);
         ASSERT_EQ(2.0f, fetched_values[2]);
       }
-      indexer3->Close();
+      indexer3->close();
       del_index_file_func(index_name + "3");
     }
 
@@ -1155,9 +1155,9 @@ TEST(VectorColumnIndexerTest, SparseMerge) {
       ASSERT_NE(nullptr, indexer3);
       auto filter = std::make_shared<EasyIndexFilter>(
           [](uint64_t key) { return key == 0; });
-      ASSERT_TRUE(indexer3->Merge({indexer1, indexer2}, filter).ok());
+      ASSERT_TRUE(indexer3->merge({indexer1, indexer2}, filter).ok());
       {
-        auto fetched_data = indexer3->Fetch(0);
+        auto fetched_data = indexer3->fetch(0);
         ASSERT_TRUE(fetched_data.has_value());
         auto fetched_sparse_vector =
             std::get<vector_column_params::SparseVectorBuffer>(
@@ -1177,7 +1177,7 @@ TEST(VectorColumnIndexerTest, SparseMerge) {
         ASSERT_EQ(2.0f, fetched_values[1]);
         ASSERT_EQ(2.0f, fetched_values[2]);
       }
-      indexer3->Close();
+      indexer3->close();
       del_index_file_func(index_name + "3");
     }
 
@@ -1186,9 +1186,9 @@ TEST(VectorColumnIndexerTest, SparseMerge) {
       ASSERT_NE(nullptr, indexer3);
       auto filter = std::make_shared<EasyIndexFilter>(
           [](uint64_t key) { return key == 0; });
-      ASSERT_TRUE(indexer3->Merge({indexer1, indexer2}, filter, {3}).ok());
+      ASSERT_TRUE(indexer3->merge({indexer1, indexer2}, filter, {3}).ok());
       {
-        auto fetched_data = indexer3->Fetch(0);
+        auto fetched_data = indexer3->fetch(0);
         ASSERT_TRUE(fetched_data.has_value());
         auto fetched_sparse_vector =
             std::get<vector_column_params::SparseVectorBuffer>(
@@ -1208,13 +1208,13 @@ TEST(VectorColumnIndexerTest, SparseMerge) {
         ASSERT_EQ(2.0f, fetched_values[1]);
         ASSERT_EQ(2.0f, fetched_values[2]);
       }
-      indexer3->Close();
+      indexer3->close();
       del_index_file_func(index_name + "3");
     }
 
 
-    indexer1->Close();
-    indexer2->Close();
+    indexer1->close();
+    indexer2->close();
     del_index_file_func(index_name + "1");
     del_index_file_func(index_name + "2");
   };
@@ -1281,7 +1281,7 @@ TEST(VectorColumnIndexerTest, BfPks) {
 
     // 2. open
     ASSERT_TRUE(
-        indexer->Open(vector_column_params::ReadOptions{true, true}).ok());
+        indexer->open(vector_column_params::ReadOptions{true, true}).ok());
 
     auto vector1 = std::vector<float>{1.0f, 2.0f, 3.0f};
     auto vector2 = std::vector<float>{4.0f, 5.0f, 6.0f};
@@ -1289,11 +1289,11 @@ TEST(VectorColumnIndexerTest, BfPks) {
     // 3. add data
     auto data1 = vector_column_params::VectorData{
         vector_column_params::DenseVector{vector1.data()}};
-    ASSERT_TRUE(indexer->Insert(data1, 1).ok());
+    ASSERT_TRUE(indexer->insert(data1, 1).ok());
 
     auto data2 = vector_column_params::VectorData{
         vector_column_params::DenseVector{vector2.data()}};
-    ASSERT_TRUE(indexer->Insert(data2, 2).ok());
+    ASSERT_TRUE(indexer->insert(data2, 2).ok());
 
     {
       auto bf_pks = std::vector<uint64_t>{1};
@@ -1305,7 +1305,7 @@ TEST(VectorColumnIndexerTest, BfPks) {
       query_params.filter = nullptr;
       query_params.fetch_vector = true;
       query_params.bf_pks = {bf_pks};
-      auto results = indexer->Search(query, query_params);
+      auto results = indexer->search(query, query_params);
       ASSERT_TRUE(results.has_value());
 
       auto vector_results =
@@ -1334,7 +1334,7 @@ TEST(VectorColumnIndexerTest, BfPks) {
       query_params.filter = nullptr;
       query_params.fetch_vector = true;
       query_params.bf_pks = {bf_pks};
-      auto results = indexer->Search(query, query_params);
+      auto results = indexer->search(query, query_params);
       ASSERT_TRUE(results.has_value());
 
       auto vector_results =
@@ -1363,7 +1363,7 @@ TEST(VectorColumnIndexerTest, BfPks) {
       query_params.filter = nullptr;
       query_params.fetch_vector = true;
       query_params.bf_pks = {bf_pks};
-      auto results = indexer->Search(query, query_params);
+      auto results = indexer->search(query, query_params);
       ASSERT_TRUE(results.has_value());
 
       auto vector_results =
@@ -1382,7 +1382,7 @@ TEST(VectorColumnIndexerTest, BfPks) {
       }
     }
 
-    indexer->Close();
+    indexer->close();
 
     zvec::test_util::RemoveTestFiles(index_file_path);
   };
@@ -1580,7 +1580,7 @@ TEST(VectorColumnIndexerTest, CosineGeneral) {
         FieldSchema("test", data_type, kDim, false, index_params));
     ASSERT_TRUE(indexer);
 
-    if (auto ret = indexer->Open(vector_column_params::ReadOptions{true, true});
+    if (auto ret = indexer->open(vector_column_params::ReadOptions{true, true});
         !ret.ok()) {
       LOG_ERROR("Failed to open indexer: %s", ret.message().c_str());
       return;
@@ -1592,12 +1592,12 @@ TEST(VectorColumnIndexerTest, CosineGeneral) {
       // print_dense_vector(buffer.data.data(), kDim, data_type);
       auto data = vector_column_params::VectorData{
           vector_column_params::DenseVector{buffer.data.data()}};
-      ASSERT_TRUE(indexer->Insert(data, i).ok());
+      ASSERT_TRUE(indexer->insert(data, i).ok());
     }
 
     // fetch
     for (int i = 0; i < kCount; ++i) {
-      auto fetched_data = indexer->Fetch(i);
+      auto fetched_data = indexer->fetch(i);
       ASSERT_TRUE(fetched_data);
       ASSERT_TRUE(compare_dense_vector(
           create_dense_vector(kDim, data_type, i, kCount, 0.1f),
@@ -1611,14 +1611,14 @@ TEST(VectorColumnIndexerTest, CosineGeneral) {
       auto buffer = create_dense_vector(kDim, data_type, i, kCount, 0.3f);
       auto data = vector_column_params::VectorData{
           vector_column_params::DenseVector{buffer.data.data()}};
-      auto _t = std::make_shared<zvec::HnswQueryParams>(100);
-      _t->set_is_linear(true);
+      auto t = std::make_shared<zvec::HnswQueryParams>(100);
+      t->set_is_linear(true);
       vector_column_params::QueryParams query_params;
       query_params.topk = kTopk;
       query_params.filter = nullptr;
       query_params.fetch_vector = true;
-      query_params.query_params = _t;
-      auto results = indexer->Search(data, query_params);
+      query_params.query_params = t;
+      auto results = indexer->search(data, query_params);
       ASSERT_TRUE(results.has_value());
       auto vector_results =
           dynamic_cast<VectorIndexResults *>(results.value().get());
@@ -1652,7 +1652,7 @@ TEST(VectorColumnIndexerTest, CosineGeneral) {
             fetched_vector.data, data_type));
       }
     }
-    indexer->Destroy();
+    indexer->destroy();
   };
 
   LOG_INFO("Test FlatIndexParams(MetricType::COSINE), VECTOR_FP32");
@@ -1801,20 +1801,20 @@ TEST(VectorColumnIndexerTest, Score) {
         FieldSchema("test", DataType::VECTOR_FP32, 3, false, index_params));
     ASSERT_TRUE(indexer);
 
-    if (auto ret = indexer->Open(vector_column_params::ReadOptions{true, true});
+    if (auto ret = indexer->open(vector_column_params::ReadOptions{true, true});
         !ret.ok()) {
       LOG_ERROR("Failed to open indexer: %s", ret.message().c_str());
       ASSERT_TRUE(false);
     }
 
     ASSERT_TRUE(indexer
-                    ->Insert(
+                    ->insert(
                         vector_column_params::VectorData{
                             vector_column_params::DenseVector{vector1.data()}},
                         kDocId1)
                     .ok());
     ASSERT_TRUE(indexer
-                    ->Insert(
+                    ->insert(
                         vector_column_params::VectorData{
                             vector_column_params::DenseVector{vector2.data()}},
                         kDocId2)
@@ -1826,13 +1826,13 @@ TEST(VectorColumnIndexerTest, Score) {
     query_params.topk = kTopk;
     query_params.filter = nullptr;
     query_params.fetch_vector = true;
-    auto results = indexer->Search(query, query_params);
+    auto results = indexer->search(query, query_params);
     ASSERT_TRUE(results.has_value());
 
     check_score(dynamic_cast<VectorIndexResults *>(results.value().get()),
                 metric_type);
 
-    indexer->Destroy();
+    indexer->destroy();
   };
 
   auto sparse_func = [&](const std::shared_ptr<VectorIndexParams>
@@ -1843,7 +1843,7 @@ TEST(VectorColumnIndexerTest, Score) {
         FieldSchema("test", DataType::SPARSE_VECTOR_FP32, false, index_params));
     ASSERT_TRUE(indexer);
 
-    if (auto ret = indexer->Open(vector_column_params::ReadOptions{true, true});
+    if (auto ret = indexer->open(vector_column_params::ReadOptions{true, true});
         !ret.ok()) {
       LOG_ERROR("Failed to open indexer: %s", ret.message().c_str());
       ASSERT_TRUE(false);
@@ -1851,7 +1851,7 @@ TEST(VectorColumnIndexerTest, Score) {
 
     ASSERT_TRUE(
         indexer
-            ->Insert(
+            ->insert(
                 vector_column_params::VectorData{
                     vector_column_params::SparseVector{
                         3,
@@ -1861,7 +1861,7 @@ TEST(VectorColumnIndexerTest, Score) {
             .ok());
     ASSERT_TRUE(
         indexer
-            ->Insert(
+            ->insert(
                 vector_column_params::VectorData{
                     vector_column_params::SparseVector{
                         3,
@@ -1878,12 +1878,12 @@ TEST(VectorColumnIndexerTest, Score) {
     query_params.topk = 10;
     query_params.filter = nullptr;
     query_params.fetch_vector = true;
-    auto results = indexer->Search(query, query_params);
+    auto results = indexer->search(query, query_params);
     ASSERT_TRUE(results.has_value());
 
     check_score(dynamic_cast<VectorIndexResults *>(results.value().get()),
                 metric_type);
-    indexer->Destroy();
+    indexer->destroy();
   };
 
   LOG_INFO("Test DenseVector, MetricType::IP");
@@ -1940,29 +1940,29 @@ TEST(VectorColumnIndexerTest, Failure) {
     ASSERT_TRUE(indexer);
 
     // Test Flush on unopened indexer
-    auto flush_result = indexer->Flush();
+    auto flush_result = indexer->flush();
     ASSERT_FALSE(flush_result.ok());
     ASSERT_EQ(flush_result.message(), "Index not opened");
 
     // Test Close on unopened indexer
-    auto close_result = indexer->Close();
+    auto close_result = indexer->close();
     ASSERT_FALSE(close_result.ok());
     ASSERT_EQ(close_result.message(), "Index not opened");
 
     // Test Destroy on unopened indexer
-    auto destroy_result = indexer->Destroy();
+    auto destroy_result = indexer->destroy();
     ASSERT_FALSE(destroy_result.ok());
     ASSERT_EQ(destroy_result.message(), "Index not opened");
 
     // Test Insert on unopened indexer
     auto data = vector_column_params::VectorData{
         vector_column_params::DenseVector{vector.data()}};
-    auto insert_result = indexer->Insert(data, kDocId);
+    auto insert_result = indexer->insert(data, kDocId);
     ASSERT_FALSE(insert_result.ok());
     ASSERT_EQ(insert_result.message(), "Index not opened");
 
     // Test Fetch on unopened indexer
-    auto fetch_result = indexer->Fetch(kDocId);
+    auto fetch_result = indexer->fetch(kDocId);
     ASSERT_FALSE(fetch_result.has_value());
     ASSERT_EQ(fetch_result.error().message(), "Index not opened");
 
@@ -1973,12 +1973,12 @@ TEST(VectorColumnIndexerTest, Failure) {
     query_params.topk = 10;
     query_params.filter = nullptr;
     query_params.fetch_vector = false;
-    auto search_result = indexer->Search(query, query_params);
+    auto search_result = indexer->search(query, query_params);
     ASSERT_FALSE(search_result.has_value());
     ASSERT_EQ(search_result.error().message(), "Index not opened");
 
     // Test Merge on unopened indexer
-    auto merge_result = indexer->Merge({}, nullptr);
+    auto merge_result = indexer->merge({}, nullptr);
     ASSERT_FALSE(merge_result.ok());
     ASSERT_EQ(merge_result.message(), "Index not opened");
   }
@@ -1993,7 +1993,7 @@ TEST(VectorColumnIndexerTest, Failure) {
     ASSERT_TRUE(indexer);
 
     auto open_result =
-        indexer->Open(vector_column_params::ReadOptions{true, true});
+        indexer->open(vector_column_params::ReadOptions{true, true});
     ASSERT_FALSE(open_result.ok());
     ASSERT_EQ(open_result.message(), "Engine name not supported");
   }
@@ -2007,7 +2007,7 @@ TEST(VectorColumnIndexerTest, Failure) {
     ASSERT_TRUE(indexer);
 
     auto open_result =
-        indexer->Open(vector_column_params::ReadOptions{true, true});
+        indexer->open(vector_column_params::ReadOptions{true, true});
     ASSERT_FALSE(open_result.ok());
     ASSERT_EQ(open_result.message(), "field_schema.index_params nullptr");
   }
@@ -2024,7 +2024,7 @@ TEST(VectorColumnIndexerTest, Failure) {
     ASSERT_TRUE(indexer);
 
     auto open_result =
-        indexer->Open(vector_column_params::ReadOptions{true, true});
+        indexer->open(vector_column_params::ReadOptions{true, true});
     ASSERT_FALSE(open_result.ok());
     ASSERT_EQ(open_result.message(),
               "failed to build index param: unsupported data type");
@@ -2040,7 +2040,7 @@ TEST(VectorColumnIndexerTest, Failure) {
     ASSERT_TRUE(indexer);
 
     auto open_result =
-        indexer->Open(vector_column_params::ReadOptions{true, true});
+        indexer->open(vector_column_params::ReadOptions{true, true});
     ASSERT_FALSE(open_result.ok());
     ASSERT_EQ(open_result.message(),
               "failed to build index param: unsupported metric type");
@@ -2059,7 +2059,7 @@ TEST(VectorColumnIndexerTest, Failure) {
     ASSERT_TRUE(indexer);
 
     auto open_result =
-        indexer->Open(vector_column_params::ReadOptions{true, true});
+        indexer->open(vector_column_params::ReadOptions{true, true});
     ASSERT_FALSE(open_result.ok());
     ASSERT_EQ(open_result.message(),
               "failed to build index param: unsupported quantize type");
@@ -2098,12 +2098,12 @@ TEST(VectorColumnIndexerTest, Failure) {
     ASSERT_TRUE(indexer);
 
     ASSERT_TRUE(
-        indexer->Open(vector_column_params::ReadOptions{true, true}).ok());
+        indexer->open(vector_column_params::ReadOptions{true, true}).ok());
 
     // Insert some data first
     auto data = vector_column_params::VectorData{
         vector_column_params::DenseVector{vector.data()}};
-    ASSERT_TRUE(indexer->Insert(data, kDocId).ok());
+    ASSERT_TRUE(indexer->insert(data, kDocId).ok());
 
     // Test search with bf_pks size > 1
     auto query = vector_column_params::VectorData{
@@ -2116,12 +2116,12 @@ TEST(VectorColumnIndexerTest, Failure) {
     query_params.fetch_vector = false;
     query_params.bf_pks = {bf_pks1, bf_pks2};
 
-    auto search_result = indexer->Search(query, query_params);
+    auto search_result = indexer->search(query, query_params);
     ASSERT_FALSE(search_result.has_value());
     ASSERT_EQ(search_result.error().message(),
               "bf_pks size > 1 is not supported");
 
-    indexer->Destroy();
+    indexer->destroy();
   }
 
   // Test case 9: Invalid field schema for query param conversion
@@ -2132,7 +2132,7 @@ TEST(VectorColumnIndexerTest, Failure) {
     ASSERT_TRUE(indexer);
 
     ASSERT_FALSE(
-        indexer->Open(vector_column_params::ReadOptions{true, true}).ok());
+        indexer->open(vector_column_params::ReadOptions{true, true}).ok());
   }
 
   // Test case 10: use_mmap = false
@@ -2144,14 +2144,14 @@ TEST(VectorColumnIndexerTest, Failure) {
                     std::make_shared<FlatIndexParams>(MetricType::IP)));
     ASSERT_TRUE(indexer);
     ASSERT_TRUE(
-        indexer->Open(vector_column_params::ReadOptions{true, true, false})
+        indexer->open(vector_column_params::ReadOptions{true, true, false})
             .ok());
     // Insert some data first
     auto data = vector_column_params::VectorData{
         vector_column_params::DenseVector{vector.data()}};
-    ASSERT_TRUE(indexer->Insert(data, kDocId).ok());
-    ASSERT_TRUE(indexer->Flush().ok());
-    ASSERT_TRUE(indexer->Close().ok());
+    ASSERT_TRUE(indexer->insert(data, kDocId).ok());
+    ASSERT_TRUE(indexer->flush().ok());
+    ASSERT_TRUE(indexer->close().ok());
     {
       auto indexer = std::make_shared<VectorColumnIndexer>(
           index_file_path,
@@ -2159,9 +2159,9 @@ TEST(VectorColumnIndexerTest, Failure) {
                       std::make_shared<FlatIndexParams>(MetricType::IP)));
       ASSERT_TRUE(indexer);
       auto open_result =
-          indexer->Open(vector_column_params::ReadOptions{false, false, true});
+          indexer->open(vector_column_params::ReadOptions{false, false, true});
       ASSERT_TRUE(open_result.ok());
-      indexer->Destroy();
+      indexer->destroy();
     }
   }
 
@@ -2175,16 +2175,16 @@ TEST(VectorColumnIndexerTest, Failure) {
 
     // First open should succeed
     auto open_result1 =
-        indexer->Open(vector_column_params::ReadOptions{true, true});
+        indexer->open(vector_column_params::ReadOptions{true, true});
     ASSERT_TRUE(open_result1.ok());
 
     // Second open should fail
     auto open_result2 =
-        indexer->Open(vector_column_params::ReadOptions{true, true});
+        indexer->open(vector_column_params::ReadOptions{true, true});
     ASSERT_FALSE(open_result2.ok());
     ASSERT_EQ(open_result2.message(), "Index already opened");
 
-    indexer->Destroy();
+    indexer->destroy();
   }
 
   // Test case 12: Test doc_count() on unopened indexer
@@ -2208,13 +2208,13 @@ TEST(VectorColumnIndexerTest, Failure) {
     ASSERT_TRUE(indexer);
 
     ASSERT_TRUE(
-        indexer->Open(vector_column_params::ReadOptions{true, true}).ok());
+        indexer->open(vector_column_params::ReadOptions{true, true}).ok());
 
     // Merge with empty indexers list should succeed
-    auto merge_result = indexer->Merge({}, nullptr);
+    auto merge_result = indexer->merge({}, nullptr);
     ASSERT_TRUE(merge_result.ok());
 
-    indexer->Destroy();
+    indexer->destroy();
   }
 
   // Test case 14: Test Merge with same index file path (should be skipped)
@@ -2226,18 +2226,18 @@ TEST(VectorColumnIndexerTest, Failure) {
     ASSERT_TRUE(indexer1);
 
     ASSERT_TRUE(
-        indexer1->Open(vector_column_params::ReadOptions{true, true}).ok());
+        indexer1->open(vector_column_params::ReadOptions{true, true}).ok());
 
     // Insert some data
     auto data = vector_column_params::VectorData{
         vector_column_params::DenseVector{vector.data()}};
-    ASSERT_TRUE(indexer1->Insert(data, kDocId).ok());
+    ASSERT_TRUE(indexer1->insert(data, kDocId).ok());
 
     // Merge with itself (same index file path) should succeed (skipped)
-    auto merge_result = indexer1->Merge({indexer1}, nullptr);
+    auto merge_result = indexer1->merge({indexer1}, nullptr);
     ASSERT_TRUE(merge_result.ok());
 
-    indexer1->Destroy();
+    indexer1->destroy();
   }
 
   // Test case 15: Test Fetch with non-existent doc_id
@@ -2249,15 +2249,15 @@ TEST(VectorColumnIndexerTest, Failure) {
     ASSERT_TRUE(indexer);
 
     ASSERT_TRUE(
-        indexer->Open(vector_column_params::ReadOptions{true, true}).ok());
+        indexer->open(vector_column_params::ReadOptions{true, true}).ok());
 
     // Fetch non-existent doc_id should fail
-    auto fetch_result = indexer->Fetch(99999);
+    auto fetch_result = indexer->fetch(99999);
     ASSERT_FALSE(fetch_result.has_value());
     ASSERT_EQ(fetch_result.error().message(),
               "Failed to fetch vector from index");
 
-    indexer->Destroy();
+    indexer->destroy();
   }
 
   // // Test case 16: Test Search with invalid query params (unsupported index
@@ -2329,7 +2329,7 @@ TEST(VectorColumnIndexerTest, CosineMerge) {
         index_name, FieldSchema("test", DataType::VECTOR_FP32, kDimension,
                                 false, index_params));
     if (indexer == nullptr ||
-        !indexer->Open(vector_column_params::ReadOptions{true, true}).ok()) {
+        !indexer->open(vector_column_params::ReadOptions{true, true}).ok()) {
       return nullptr;
     }
     return indexer;
@@ -2348,15 +2348,15 @@ TEST(VectorColumnIndexerTest, CosineMerge) {
     vector[2] = 123.0f;
     auto vector_data = vector_column_params::VectorData{
         vector_column_params::DenseVector{vector.data()}};
-    ASSERT_TRUE(indexer1->Insert(vector_data, 0).ok());
+    ASSERT_TRUE(indexer1->insert(vector_data, 0).ok());
 
     vector[1] = 2.0f;
-    ASSERT_TRUE(indexer2->Insert(vector_data, 0).ok());
+    ASSERT_TRUE(indexer2->insert(vector_data, 0).ok());
     vector[1] = 3.0f;
-    ASSERT_TRUE(indexer2->Insert(vector_data, 1).ok());
+    ASSERT_TRUE(indexer2->insert(vector_data, 1).ok());
 
     {
-      auto fetched_data = indexer1->Fetch(0);
+      auto fetched_data = indexer1->fetch(0);
       ASSERT_TRUE(fetched_data.has_value());
       const float *fetched_vector = reinterpret_cast<const float *>(
           std::get<vector_column_params::DenseVectorBuffer>(
@@ -2369,7 +2369,7 @@ TEST(VectorColumnIndexerTest, CosineMerge) {
       ASSERT_TRUE(fetched_vector[2] - 123.0f < 1);
     }
     {
-      auto fetched_data = indexer2->Fetch(0);
+      auto fetched_data = indexer2->fetch(0);
       ASSERT_TRUE(fetched_data.has_value());
       const float *fetched_vector = reinterpret_cast<const float *>(
           std::get<vector_column_params::DenseVectorBuffer>(
@@ -2382,7 +2382,7 @@ TEST(VectorColumnIndexerTest, CosineMerge) {
       ASSERT_TRUE(fetched_vector[2] - 123.0f < 1);
     }
     {
-      auto fetched_data = indexer2->Fetch(1);
+      auto fetched_data = indexer2->fetch(1);
       ASSERT_TRUE(fetched_data.has_value());
       const float *fetched_vector = reinterpret_cast<const float *>(
           std::get<vector_column_params::DenseVectorBuffer>(
@@ -2436,11 +2436,11 @@ TEST(VectorColumnIndexerTest, CosineMerge) {
       ASSERT_NE(nullptr, indexer3);
       auto filter = std::make_shared<EasyIndexFilter>(
           [](uint64_t key) { return key == 0; });
-      ASSERT_TRUE(indexer3->Merge({indexer1, indexer2}, filter).ok());
+      ASSERT_TRUE(indexer3->merge({indexer1, indexer2}, filter).ok());
       // 0.0 -> x ; 1.0 -> 0 ; 1.1 -> 1
       ASSERT_TRUE(indexer3->doc_count() == 2);
       {
-        auto fetched_data = indexer3->Fetch(0);
+        auto fetched_data = indexer3->fetch(0);
         ASSERT_TRUE(fetched_data.has_value());
         const float *fetched_vector = reinterpret_cast<const float *>(
             std::get<vector_column_params::DenseVectorBuffer>(
@@ -2462,7 +2462,7 @@ TEST(VectorColumnIndexerTest, CosineMerge) {
         query_params.topk = 10;
         query_params.filter = nullptr;
         query_params.fetch_vector = true;
-        auto results = indexer2->Search(query, query_params);
+        auto results = indexer2->search(query, query_params);
         ASSERT_TRUE(results.has_value());
         auto vector_results =
             dynamic_cast<VectorIndexResults *>(results.value().get());
@@ -2508,7 +2508,7 @@ TEST(VectorColumnIndexerTest, CosineMerge) {
         // ASSERT_TRUE(vector_results->docs()[0].key() == 1);
       }
 
-      indexer3->Close();
+      indexer3->close();
       del_index_file_func(index_name + "3");
     }
     //
@@ -2538,8 +2538,8 @@ TEST(VectorColumnIndexerTest, CosineMerge) {
     // }
 
 
-    indexer1->Close();
-    indexer2->Close();
+    indexer1->close();
+    indexer2->close();
     del_index_file_func(index_name + "1");
     del_index_file_func(index_name + "2");
   };
@@ -2583,7 +2583,7 @@ TEST(VectorColumnIndexerTest, Refiner) {
         index_file_path,
         FieldSchema("test", data_type, kDim, false, index_params));
     if (indexer == nullptr ||
-        !indexer->Open(vector_column_params::ReadOptions{true, true}).ok()) {
+        !indexer->open(vector_column_params::ReadOptions{true, true}).ok()) {
       return nullptr;
     }
     return indexer;
@@ -2608,8 +2608,8 @@ TEST(VectorColumnIndexerTest, Refiner) {
       // print_dense_vector(buffer.data.data(), kDim, data_type);
       auto data = vector_column_params::VectorData{
           vector_column_params::DenseVector{buffer.data.data()}};
-      ASSERT_TRUE(indexer->Insert(data, i).ok());
-      ASSERT_TRUE(reference_indexer->Insert(data, i).ok());
+      ASSERT_TRUE(indexer->insert(data, i).ok());
+      ASSERT_TRUE(reference_indexer->insert(data, i).ok());
     }
 
     // query
@@ -2626,7 +2626,7 @@ TEST(VectorColumnIndexerTest, Refiner) {
       query_params.refiner_param =
           std::make_shared<vector_column_params::RefinerParam>(
               vector_column_params::RefinerParam{10, reference_indexer});
-      auto results = indexer->Search(data, query_params);
+      auto results = indexer->search(data, query_params);
       ASSERT_TRUE(results.has_value());
       auto vector_results =
           dynamic_cast<VectorIndexResults *>(results.value().get());
@@ -2637,7 +2637,7 @@ TEST(VectorColumnIndexerTest, Refiner) {
       LOG_INFO("query_vector:%s",
                print_dense_vector(buffer.data.data(), kDim, data_type).c_str());
     }
-    indexer->Destroy();
+    indexer->destroy();
   };
 
   LOG_INFO(
diff --git a/tests/db/index/common/manifest_codec_golden_test.cc b/tests/db/index/common/manifest_codec_golden_test.cc
index 329f6199e..081348607 100644
--- a/tests/db/index/common/manifest_codec_golden_test.cc
+++ b/tests/db/index/common/manifest_codec_golden_test.cc
@@ -1087,9 +1087,9 @@ TEST(ManifestCodecGolden, UnknownFieldsAreIgnored) {
   std::string with_unknown = Golden(kGoldenSimple);
   {
     pbwire::Writer w(&with_unknown);
-    w.PutVarint(99, 12345);               // unknown varint field
-    w.PutMessage(100, std::string("x"));  // unknown length-delimited field
-    w.PutFloat(101, 2.5f);                // unknown fixed32 field
+    w.put_varint(99, 12345);               // unknown varint field
+    w.put_message(100, std::string("x"));  // unknown length-delimited field
+    w.put_float(101, 2.5f);                // unknown fixed32 field
   }
 
   ManifestData data;
@@ -1115,7 +1115,7 @@ TEST(ManifestCodecGolden, CorruptInputIsRejected) {
   std::string bad_len;
   {
     pbwire::Writer w(&bad_len);
-    w.PutMessage(2, std::string("payload"));
+    w.put_message(2, std::string("payload"));
   }
   bad_len[1] = static_cast<char>(0x7F);  // overlong length
   ManifestData data;
@@ -1139,7 +1139,7 @@ TEST(ManifestCodecGolden, WireReaderRejectsGroups) {
     std::string buf;
     buf.push_back(static_cast<char>((1 << 3) | type));
     pbwire::Reader r(buf);
-    EXPECT_FALSE(r.Next());
+    EXPECT_FALSE(r.next());
     EXPECT_FALSE(r.ok());
   }
 }
diff --git a/tests/db/index/common/pb_wire_test.cc b/tests/db/index/common/pb_wire_test.cc
index 85716830e..2e69a68d1 100644
--- a/tests/db/index/common/pb_wire_test.cc
+++ b/tests/db/index/common/pb_wire_test.cc
@@ -38,15 +38,15 @@ TEST(PbWireWriterTest, VarintRoundTrip) {
   for (const auto &test_case : cases) {
     std::string buf;
     Writer writer(&buf);
-    writer.PutVarint(1, test_case.value);
+    writer.put_varint(1, test_case.value);
     EXPECT_EQ(buf.size(), test_case.encoded_size);
 
     Reader reader(buf);
-    ASSERT_TRUE(reader.Next());
+    ASSERT_TRUE(reader.next());
     EXPECT_EQ(reader.field(), 1u);
     EXPECT_EQ(reader.wire_type(), kVarint);
     EXPECT_EQ(reader.varint(), test_case.value);
-    EXPECT_FALSE(reader.Next());
+    EXPECT_FALSE(reader.next());
     EXPECT_TRUE(reader.ok());
   }
 }
@@ -54,7 +54,7 @@ TEST(PbWireWriterTest, VarintRoundTrip) {
 TEST(PbWireWriterTest, VarintByteLayoutMatchesProtobuf) {
   std::string buf;
   Writer writer(&buf);
-  writer.PutVarint(1, 300);
+  writer.put_varint(1, 300);
   // Tag: field 1 with wire type 0; varint 300 encodes as 0xAC 0x02.
   const std::string expected("\x08\xAC\x02", 3);
   EXPECT_EQ(buf, expected);
@@ -63,71 +63,71 @@ TEST(PbWireWriterTest, VarintByteLayoutMatchesProtobuf) {
 TEST(PbWireWriterTest, DefaultValuesAreSkipped) {
   std::string buf;
   Writer writer(&buf);
-  writer.PutVarint(1, 0);
-  writer.PutBool(2, false);
-  writer.PutFloat(3, 0.0f);
-  writer.PutString(4, "");
+  writer.put_varint(1, 0);
+  writer.put_bool(2, false);
+  writer.put_float(3, 0.0f);
+  writer.put_string(4, "");
   EXPECT_TRUE(buf.empty());
 }
 
 TEST(PbWireWriterTest, BoolRoundTrip) {
   std::string buf;
   Writer writer(&buf);
-  writer.PutBool(7, true);
+  writer.put_bool(7, true);
 
   Reader reader(buf);
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.field(), 7u);
   EXPECT_EQ(reader.wire_type(), kVarint);
   EXPECT_TRUE(reader.bool_value());
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_TRUE(reader.ok());
 }
 
 TEST(PbWireWriterTest, FloatRoundTrip) {
   std::string buf;
   Writer writer(&buf);
-  writer.PutFloat(5, 3.5f);
-  writer.PutFloat(6, -1.25f);
+  writer.put_float(5, 3.5f);
+  writer.put_float(6, -1.25f);
 
   Reader reader(buf);
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.field(), 5u);
   EXPECT_EQ(reader.wire_type(), kFixed32);
   EXPECT_FLOAT_EQ(reader.float_value(), 3.5f);
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.field(), 6u);
   EXPECT_EQ(reader.wire_type(), kFixed32);
   EXPECT_FLOAT_EQ(reader.float_value(), -1.25f);
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_TRUE(reader.ok());
 }
 
 TEST(PbWireWriterTest, StringRoundTrip) {
   std::string buf;
   Writer writer(&buf);
-  writer.PutString(2, "manifest");
+  writer.put_string(2, "manifest");
 
   Reader reader(buf);
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.field(), 2u);
   EXPECT_EQ(reader.wire_type(), kLenDelim);
   EXPECT_EQ(reader.bytes(), std::string_view("manifest"));
   EXPECT_EQ(reader.string_value(), "manifest");
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_TRUE(reader.ok());
 }
 
 TEST(PbWireWriterTest, AddStringWritesEmptyElements) {
   std::string buf;
   Writer writer(&buf);
-  writer.AddString(2, "");
+  writer.add_string(2, "");
   // Tag for field 2 with wire type 2, followed by a zero length.
   const std::string expected("\x12\x00", 2);
   EXPECT_EQ(buf, expected);
 
   Reader reader(buf);
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.field(), 2u);
   EXPECT_EQ(reader.wire_type(), kLenDelim);
   EXPECT_TRUE(reader.bytes().empty());
@@ -137,7 +137,7 @@ TEST(PbWireWriterTest, AddStringWritesEmptyElements) {
 TEST(PbWireWriterTest, PutMessageWritesEmptyPayload) {
   std::string buf;
   Writer writer(&buf);
-  writer.PutMessage(3, "");
+  writer.put_message(3, "");
   // An empty but present sub-message is a zero-length field.
   const std::string expected("\x1A\x00", 2);
   EXPECT_EQ(buf, expected);
@@ -146,21 +146,21 @@ TEST(PbWireWriterTest, PutMessageWritesEmptyPayload) {
 TEST(PbWireWriterTest, MultipleFieldsInOrder) {
   std::string buf;
   Writer writer(&buf);
-  writer.PutVarint(1, 42);
-  writer.PutString(2, "zvec");
-  writer.PutBool(3, true);
+  writer.put_varint(1, 42);
+  writer.put_string(2, "zvec");
+  writer.put_bool(3, true);
 
   Reader reader(buf);
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.field(), 1u);
   EXPECT_EQ(reader.uint32_value(), 42u);
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.field(), 2u);
   EXPECT_EQ(reader.string_value(), "zvec");
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.field(), 3u);
   EXPECT_TRUE(reader.bool_value());
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_TRUE(reader.ok());
 }
 
@@ -168,33 +168,33 @@ TEST(PbWireWriterTest, Int32AndUint32ValueInterpretation) {
   std::string buf;
   Writer writer(&buf);
   // 0xFFFFFFFF is -1 when interpreted as an int32.
-  writer.PutVarint(1, 0xFFFFFFFFULL);
+  writer.put_varint(1, 0xFFFFFFFFULL);
   // Larger than 32 bits: uint32_value keeps the low 32 bits.
-  writer.PutVarint(2, 0x1FFFFFFFFULL);
+  writer.put_varint(2, 0x1FFFFFFFFULL);
 
   Reader reader(buf);
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.int32_value(), -1);
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.uint32_value(), 0xFFFFFFFFu);
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_TRUE(reader.ok());
 }
 
 TEST(PbWireReaderTest, EmptyBufferEndsImmediately) {
   const std::string_view empty;
   Reader reader(empty);
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_TRUE(reader.ok());
 }
 
 TEST(PbWireReaderTest, CharSizeConstructorWorks) {
   const std::string buf("\x08\x2A", 2);
   Reader reader(buf.data(), buf.size());
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.field(), 1u);
   EXPECT_EQ(reader.uint32_value(), 42u);
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_TRUE(reader.ok());
 }
 
@@ -202,11 +202,11 @@ TEST(PbWireReaderTest, Fixed64IsAccepted) {
   // Tag for field 1 with wire type 1, followed by 8 little-endian bytes.
   const std::string buf("\x09\x01\x02\x03\x04\x05\x06\x07\x08", 9);
   Reader reader(buf);
-  ASSERT_TRUE(reader.Next());
+  ASSERT_TRUE(reader.next());
   EXPECT_EQ(reader.field(), 1u);
   EXPECT_EQ(reader.wire_type(), kFixed64);
   EXPECT_EQ(reader.varint(), 0x0807060504030201ULL);
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_TRUE(reader.ok());
 }
 
@@ -214,7 +214,7 @@ TEST(PbWireReaderTest, TruncatedVarintFails) {
   // Continuation bit set, then end of buffer.
   const std::string buf("\x08\x80", 2);
   Reader reader(buf);
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_FALSE(reader.ok());
 }
 
@@ -222,21 +222,21 @@ TEST(PbWireReaderTest, OverlongVarintFails) {
   // Ten bytes that all carry the continuation bit would need an eleventh.
   const std::string buf(10, '\xFF');
   Reader reader(buf);
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_FALSE(reader.ok());
 }
 
 TEST(PbWireReaderTest, TruncatedFixed32Fails) {
   const std::string buf("\x0D\x01\x02", 3);
   Reader reader(buf);
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_FALSE(reader.ok());
 }
 
 TEST(PbWireReaderTest, TruncatedFixed64Fails) {
   const std::string buf("\x09\x01\x02\x03", 4);
   Reader reader(buf);
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_FALSE(reader.ok());
 }
 
@@ -247,14 +247,14 @@ TEST(PbWireReaderTest, TruncatedLengthDelimitedFails) {
       "ab",
       4);
   Reader reader(buf);
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_FALSE(reader.ok());
 }
 
 TEST(PbWireReaderTest, TruncatedLengthVarintFails) {
   const std::string buf("\x12\x80", 2);
   Reader reader(buf);
-  EXPECT_FALSE(reader.Next());
+  EXPECT_FALSE(reader.next());
   EXPECT_FALSE(reader.ok());
 }
 
@@ -262,7 +262,7 @@ TEST(PbWireReaderTest, FieldNumberZeroFails) {
   // A tag whose field number is 0 is illegal in protobuf.
   const std::string zero_tag(1, '\x00');
   Reader zero_reader(zero_tag);
-  EXPECT_FALSE(zero_reader.Next());
+  EXPECT_FALSE(zero_reader.next());
   EXPECT_FALSE(zero_reader.ok());
 }
 
@@ -271,7 +271,7 @@ TEST(PbWireReaderTest, GroupAndUnknownWireTypesFail) {
   for (const char tag : {'\x0B', '\x0C', '\x0E', '\x0F'}) {
     const std::string buf(&tag, 1);
     Reader reader(buf);
-    EXPECT_FALSE(reader.Next()) << "wire tag " << static_cast<int>(tag);
+    EXPECT_FALSE(reader.next()) << "wire tag " << static_cast<int>(tag);
     EXPECT_FALSE(reader.ok()) << "wire tag " << static_cast<int>(tag);
   }
 }
diff --git a/tests/db/index/segment/segment_helper_test.cc b/tests/db/index/segment/segment_helper_test.cc
index b21bf505b..4a5c25d9a 100644
--- a/tests/db/index/segment/segment_helper_test.cc
+++ b/tests/db/index/segment/segment_helper_test.cc
@@ -77,12 +77,12 @@ class SegmentHelperTest : public testing::Test {
   }
 
  public:
-  std::string GetColPath() {
+  std::string get_col_path() {
     return col_path;
   }
 
  protected:
-  VersionManager::Ptr CreateVersionManager(const CollectionSchema &schema) {
+  VersionManager::Ptr create_version_manager(const CollectionSchema &schema) {
     Version version;
     version.set_schema(schema);
     auto vm = VersionManager::Create(col_path, version);
@@ -92,7 +92,7 @@ class SegmentHelperTest : public testing::Test {
     return vm.value();
   }
 
-  SegmentOptions WriteOptions() const {
+  SegmentOptions write_options() const {
     return SegmentOptions{false, true, DEFAULT_MAX_BUFFER_SIZE};
   }
 
@@ -103,12 +103,12 @@ class SegmentHelperTest : public testing::Test {
 
   // Execute a CompactTask end-to-end: build it, run it, move the tmp segment
   // dir into place, and reopen the output segment in read-only mode.
-  CompactResult RunCompactAndOpen(CollectionSchema::Ptr schema,
-                                  std::vector<Segment::Ptr> segments,
-                                  SegmentID output_segment_id,
-                                  IndexFilter::Ptr filter,
-                                  const VersionManager::Ptr &version_manager,
-                                  int concurrency = 1) {
+  CompactResult run_compact_and_open(CollectionSchema::Ptr schema,
+                                     std::vector<Segment::Ptr> segments,
+                                     SegmentID output_segment_id,
+                                     IndexFilter::Ptr filter,
+                                     const VersionManager::Ptr &version_manager,
+                                     int concurrency = 1) {
     const bool forward_use_parquet = false;
     CompactTask task(col_path, schema, std::move(segments), output_segment_id,
                      std::move(filter), forward_use_parquet, concurrency);
@@ -148,22 +148,22 @@ class SegmentHelperTest : public testing::Test {
 
 TEST_F(SegmentHelperTest, CompactTask_General) {
   auto schema = test::TestHelper::CreateNormalSchema(false, col_name);
-  auto version_manager = CreateVersionManager(*schema);
-  auto write_options = WriteOptions();
+  auto version_manager = create_version_manager(*schema);
+  auto seg_options = write_options();
 
   auto seg1 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 0, 0, id_map, delete_store, version_manager,
-      write_options, 0, 1000);
+      seg_options, 0, 1000);
   ASSERT_TRUE(seg1 != nullptr);
   ASSERT_TRUE(seg1->flush().ok());
   auto seg2 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 1, 1000, id_map, delete_store, version_manager,
-      write_options, 1000, 1000);
+      seg_options, 1000, 1000);
   ASSERT_TRUE(seg2 != nullptr);
   ASSERT_TRUE(seg2->flush().ok());
 
   SegmentID output_segment_id = 2;
-  auto [compact_task, seg3] = RunCompactAndOpen(
+  auto [compact_task, seg3] = run_compact_and_open(
       schema, {seg1, seg2}, output_segment_id, nullptr, version_manager);
 
   ASSERT_NE(seg3, nullptr);
@@ -174,7 +174,7 @@ TEST_F(SegmentHelperTest, CompactTask_General) {
   ASSERT_EQ(seg3->doc_count(), seg1->doc_count() + seg2->doc_count());
 
   for (uint64_t i = 0; i < seg3->doc_count(); i++) {
-    auto doc = seg3->Fetch(i);
+    auto doc = seg3->fetch(i);
     ASSERT_NE(doc, nullptr);
     auto expect_doc = test::TestHelper::CreateDoc(i, *schema);
     ASSERT_EQ(*doc, expect_doc);
@@ -186,22 +186,22 @@ TEST_F(SegmentHelperTest, CompactTask_General) {
 
 TEST_F(SegmentHelperTest, CompactTask_ScalarIndex) {
   auto schema = test::TestHelper::CreateSchemaWithScalarIndex(false);
-  auto version_manager = CreateVersionManager(*schema);
-  auto write_options = WriteOptions();
+  auto version_manager = create_version_manager(*schema);
+  auto seg_options = write_options();
 
   auto seg1 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 0, 0, id_map, delete_store, version_manager,
-      write_options, 0, 1000);
+      seg_options, 0, 1000);
   ASSERT_TRUE(seg1 != nullptr);
   ASSERT_TRUE(seg1->flush().ok());
   auto seg2 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 1, 1000, id_map, delete_store, version_manager,
-      write_options, 1000, 1000);
+      seg_options, 1000, 1000);
   ASSERT_TRUE(seg2 != nullptr);
   ASSERT_TRUE(seg2->flush().ok());
 
   SegmentID output_segment_id = 2;
-  auto [compact_task, seg3] = RunCompactAndOpen(
+  auto [compact_task, seg3] = run_compact_and_open(
       schema, {seg1, seg2}, output_segment_id, nullptr, version_manager);
 
   ASSERT_NE(seg3, nullptr);
@@ -212,7 +212,7 @@ TEST_F(SegmentHelperTest, CompactTask_ScalarIndex) {
   ASSERT_EQ(seg3->doc_count(), seg1->doc_count() + seg2->doc_count());
 
   for (uint64_t i = 0; i < seg3->doc_count(); i++) {
-    auto doc = seg3->Fetch(i);
+    auto doc = seg3->fetch(i);
     ASSERT_NE(doc, nullptr);
     auto expect_doc = test::TestHelper::CreateDoc(i, *schema);
     ASSERT_EQ(*doc, expect_doc);
@@ -224,22 +224,22 @@ TEST_F(SegmentHelperTest, CompactTask_ScalarIndex) {
 
 TEST_F(SegmentHelperTest, CompactTask_VectorIndex) {
   auto schema = test::TestHelper::CreateSchemaWithVectorIndex();
-  auto version_manager = CreateVersionManager(*schema);
-  auto write_options = WriteOptions();
+  auto version_manager = create_version_manager(*schema);
+  auto seg_options = write_options();
 
   auto seg1 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 0, 0, id_map, delete_store, version_manager,
-      write_options, 0, 1000);
+      seg_options, 0, 1000);
   ASSERT_TRUE(seg1 != nullptr);
   ASSERT_TRUE(seg1->flush().ok());
   auto seg2 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 1, 1000, id_map, delete_store, version_manager,
-      write_options, 1000, 1000);
+      seg_options, 1000, 1000);
   ASSERT_TRUE(seg2 != nullptr);
   ASSERT_TRUE(seg2->flush().ok());
 
   SegmentID output_segment_id = 2;
-  auto [compact_task, seg3] = RunCompactAndOpen(
+  auto [compact_task, seg3] = run_compact_and_open(
       schema, {seg1, seg2}, output_segment_id, nullptr, version_manager);
 
   ASSERT_NE(seg3, nullptr);
@@ -250,7 +250,7 @@ TEST_F(SegmentHelperTest, CompactTask_VectorIndex) {
   ASSERT_EQ(seg3->doc_count(), seg1->doc_count() + seg2->doc_count());
 
   for (uint64_t i = 0; i < seg3->doc_count(); i++) {
-    auto doc = seg3->Fetch(i);
+    auto doc = seg3->fetch(i);
     ASSERT_NE(doc, nullptr);
     auto expect_doc = test::TestHelper::CreateDoc(i, *schema);
     ASSERT_EQ(*doc, expect_doc);
@@ -262,8 +262,8 @@ TEST_F(SegmentHelperTest, CompactTask_VectorIndex) {
 
 TEST_F(SegmentHelperTest, CompactTask_MultipleSegments) {
   auto schema = test::TestHelper::CreateNormalSchema(false, col_name);
-  auto version_manager = CreateVersionManager(*schema);
-  auto write_options = WriteOptions();
+  auto version_manager = create_version_manager(*schema);
+  auto seg_options = write_options();
 
   std::vector<Segment::Ptr> input_segs;
   const int seg_count = 10;
@@ -271,15 +271,14 @@ TEST_F(SegmentHelperTest, CompactTask_MultipleSegments) {
   for (int i = 0; i < seg_count; i++) {
     auto seg = test::TestHelper::CreateSegmentWithDoc(
         col_path, *schema, i, i * doc_count_per_seg, id_map, delete_store,
-        version_manager, write_options, i * doc_count_per_seg,
-        doc_count_per_seg);
+        version_manager, seg_options, i * doc_count_per_seg, doc_count_per_seg);
     ASSERT_TRUE(seg != nullptr);
     ASSERT_TRUE(seg->flush().ok());
     input_segs.push_back(seg);
   }
 
   SegmentID output_segment_id = seg_count;
-  auto [compact_task, seg3] = RunCompactAndOpen(
+  auto [compact_task, seg3] = run_compact_and_open(
       schema, input_segs, output_segment_id, nullptr, version_manager);
 
   ASSERT_NE(seg3, nullptr);
@@ -290,7 +289,7 @@ TEST_F(SegmentHelperTest, CompactTask_MultipleSegments) {
   ASSERT_EQ(seg3->doc_count(), seg_count * doc_count_per_seg);
 
   for (uint64_t i = 0; i < seg3->doc_count(); i++) {
-    auto doc = seg3->Fetch(i);
+    auto doc = seg3->fetch(i);
     ASSERT_NE(doc, nullptr);
     auto expect_doc = test::TestHelper::CreateDoc(i, *schema);
     ASSERT_EQ(*doc, expect_doc);
@@ -299,12 +298,12 @@ TEST_F(SegmentHelperTest, CompactTask_MultipleSegments) {
 
 TEST_F(SegmentHelperTest, CompactTask_Filter) {
   auto schema = test::TestHelper::CreateNormalSchema(false, col_name);
-  auto version_manager = CreateVersionManager(*schema);
-  auto write_options = WriteOptions();
+  auto version_manager = create_version_manager(*schema);
+  auto seg_options = write_options();
 
   auto seg1 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 0, 0, id_map, delete_store, version_manager,
-      write_options, 0, 1000);
+      seg_options, 0, 1000);
   ASSERT_TRUE(seg1 != nullptr);
   ASSERT_TRUE(seg1->flush().ok());
 
@@ -312,7 +311,7 @@ TEST_F(SegmentHelperTest, CompactTask_Filter) {
       [](uint64_t id) -> bool { return id < 10; });
 
   SegmentID output_segment_id = 1;
-  auto [compact_task, seg2] = RunCompactAndOpen(
+  auto [compact_task, seg2] = run_compact_and_open(
       schema, {seg1}, output_segment_id, filter, version_manager);
 
   ASSERT_NE(seg2, nullptr);
@@ -327,12 +326,12 @@ TEST_F(SegmentHelperTest, CompactTask_Filter) {
 
 TEST_F(SegmentHelperTest, CompactTask_FilterAll) {
   auto schema = test::TestHelper::CreateNormalSchema(false, col_name);
-  auto version_manager = CreateVersionManager(*schema);
-  auto write_options = WriteOptions();
+  auto version_manager = create_version_manager(*schema);
+  auto seg_options = write_options();
 
   auto seg1 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 0, 0, id_map, delete_store, version_manager,
-      write_options, 0, 1000);
+      seg_options, 0, 1000);
   ASSERT_TRUE(seg1 != nullptr);
   ASSERT_TRUE(seg1->flush().ok());
 
@@ -340,7 +339,7 @@ TEST_F(SegmentHelperTest, CompactTask_FilterAll) {
       [](uint64_t /*id*/) -> bool { return true; });
 
   SegmentID output_segment_id = 1;
-  auto [compact_task, output_segment] = RunCompactAndOpen(
+  auto [compact_task, output_segment] = run_compact_and_open(
       schema, {seg1}, output_segment_id, filter, version_manager);
 
   ASSERT_EQ(compact_task.output_segment_meta_, nullptr);
@@ -363,7 +362,7 @@ TEST_F(SegmentHelperTest, CreateVectorIndexTask_AllFields) {
 
   // Create a segment
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      GetColPath(), *schema, 0, 0, id_map, delete_store, version_manager,
+      get_col_path(), *schema, 0, 0, id_map, delete_store, version_manager,
       SegmentOptions{false, true, DEFAULT_MAX_BUFFER_SIZE}, 0, 1000);
   ASSERT_TRUE(segment != nullptr);
   ASSERT_TRUE(segment->dump().ok());
@@ -422,7 +421,7 @@ TEST_F(SegmentHelperTest, CreateVectorIndexTask_SingleField) {
 
   // Create a segment
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      GetColPath(), *schema, 0, 0, id_map, delete_store, version_manager,
+      get_col_path(), *schema, 0, 0, id_map, delete_store, version_manager,
       SegmentOptions{false, true, DEFAULT_MAX_BUFFER_SIZE}, 0, 1000);
   ASSERT_TRUE(segment != nullptr);
   ASSERT_TRUE(segment->dump().ok());
@@ -464,18 +463,18 @@ TEST_F(SegmentHelperTest, CreateVectorIndexTask_SingleField) {
 
 TEST_F(SegmentHelperTest, CompactTask_VectorIndexThreeSegmentsRegression) {
   auto schema = test::TestHelper::CreateSchemaWithVectorIndex();
-  auto version_manager = CreateVersionManager(*schema);
-  auto write_options = WriteOptions();
+  auto version_manager = create_version_manager(*schema);
+  auto seg_options = write_options();
 
   auto seg1 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 0, 0, id_map, delete_store, version_manager,
-      write_options, 0, 300);
+      seg_options, 0, 300);
   auto seg2 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 1, 300, id_map, delete_store, version_manager,
-      write_options, 300, 300);
+      seg_options, 300, 300);
   auto seg3 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 2, 600, id_map, delete_store, version_manager,
-      write_options, 600, 300);
+      seg_options, 600, 300);
   ASSERT_TRUE(seg1 != nullptr);
   ASSERT_TRUE(seg2 != nullptr);
   ASSERT_TRUE(seg3 != nullptr);
@@ -483,13 +482,13 @@ TEST_F(SegmentHelperTest, CompactTask_VectorIndexThreeSegmentsRegression) {
   ASSERT_TRUE(seg2->flush().ok());
   ASSERT_TRUE(seg3->flush().ok());
 
-  auto [compact_task, output_segment] = RunCompactAndOpen(
+  auto [compact_task, output_segment] = run_compact_and_open(
       schema, {seg1, seg2, seg3}, 3, nullptr, version_manager);
 
   ASSERT_NE(output_segment, nullptr);
   ASSERT_EQ(output_segment->doc_count(), 900);
-  ASSERT_NE(output_segment->Fetch(0), nullptr);
-  ASSERT_NE(output_segment->Fetch(899), nullptr);
+  ASSERT_NE(output_segment->fetch(0), nullptr);
+  ASSERT_NE(output_segment->fetch(899), nullptr);
 }
 
 TEST_F(SegmentHelperTest,
@@ -498,18 +497,18 @@ TEST_F(SegmentHelperTest,
       false, col_name,
       std::make_shared<HnswIndexParams>(MetricType::IP, 16, 20,
                                         QuantizeType::FP16));
-  auto version_manager = CreateVersionManager(*schema);
-  auto write_options = WriteOptions();
+  auto version_manager = create_version_manager(*schema);
+  auto seg_options = write_options();
 
   auto seg1 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 0, 0, id_map, delete_store, version_manager,
-      write_options, 0, 300);
+      seg_options, 0, 300);
   auto seg2 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 1, 300, id_map, delete_store, version_manager,
-      write_options, 300, 300);
+      seg_options, 300, 300);
   auto seg3 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 2, 600, id_map, delete_store, version_manager,
-      write_options, 600, 300);
+      seg_options, 600, 300);
   ASSERT_TRUE(seg1 != nullptr);
   ASSERT_TRUE(seg2 != nullptr);
   ASSERT_TRUE(seg3 != nullptr);
@@ -520,13 +519,13 @@ TEST_F(SegmentHelperTest,
   ASSERT_GT(seg2->get_quant_vector_indexer("dense_fp32").size(), 0u);
   ASSERT_GT(seg3->get_quant_vector_indexer("dense_fp32").size(), 0u);
 
-  auto [compact_task, output_segment] = RunCompactAndOpen(
+  auto [compact_task, output_segment] = run_compact_and_open(
       schema, {seg1, seg2, seg3}, 3, nullptr, version_manager);
 
   ASSERT_NE(output_segment, nullptr);
   ASSERT_EQ(output_segment->doc_count(), 900);
-  ASSERT_NE(output_segment->Fetch(0), nullptr);
-  ASSERT_NE(output_segment->Fetch(899), nullptr);
+  ASSERT_NE(output_segment->fetch(0), nullptr);
+  ASSERT_NE(output_segment->fetch(899), nullptr);
   ASSERT_GT(output_segment->get_vector_indexer("dense_fp32").size(), 0u);
   ASSERT_GT(output_segment->get_quant_vector_indexer("dense_fp32").size(), 0u);
 }
@@ -538,13 +537,13 @@ TEST_F(SegmentHelperTest, QuantizedIvfClosesRawFlatBeforeBuildingIndex) {
       std::make_shared<IVFIndexParams>(MetricType::L2, 4, 2, false,
                                        QuantizeType::FP16));
   schema->add_field(field);
-  auto version_manager = CreateVersionManager(*schema);
+  auto version_manager = create_version_manager(*schema);
   auto seg1 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 0, 0, id_map, delete_store, version_manager,
-      WriteOptions(), 0, 32);
+      write_options(), 0, 32);
   auto seg2 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 1, 32, id_map, delete_store, version_manager,
-      WriteOptions(), 32, 32);
+      write_options(), 32, 32);
   ASSERT_NE(seg1, nullptr);
   ASSERT_NE(seg2, nullptr);
   ASSERT_TRUE(seg1->flush().ok());
@@ -614,10 +613,10 @@ TEST_F(SegmentHelperTest, QuantizedIvfClosesRawFlatBeforeBuildingIndex) {
     raw_field->set_index_params(
         std::make_shared<FlatIndexParams>(MetricType::L2));
     VectorColumnIndexer raw(raw_path, *raw_field);
-    ASSERT_TRUE(raw.Open({true, false, true}).ok());
+    ASSERT_TRUE(raw.open({true, false, true}).ok());
     EXPECT_EQ(raw.doc_count(), 64);
     for (uint32_t id : {0U, 31U, 32U, 63U}) {
-      auto fetched = raw.Fetch(id);
+      auto fetched = raw.fetch(id);
       ASSERT_TRUE(fetched.has_value());
       const auto &bytes = std::get<vector_column_params::DenseVectorBuffer>(
                               fetched->vector_buffer)
@@ -626,15 +625,15 @@ TEST_F(SegmentHelperTest, QuantizedIvfClosesRawFlatBeforeBuildingIndex) {
       EXPECT_EQ(bytes,
                 std::string(reinterpret_cast<const char *>(expected.data()),
                             expected.size() * sizeof(float)));
-      EXPECT_NE((id < 32 ? seg1 : seg2)->Fetch(id), nullptr);
+      EXPECT_NE((id < 32 ? seg1 : seg2)->fetch(id), nullptr);
     }
-    EXPECT_TRUE(raw.Close().ok());
+    EXPECT_TRUE(raw.close().ok());
     if (!fail_quantized_dump) {
       ASSERT_EQ(blocks.size(), 2);
       VectorColumnIndexer quantized(quantized_path, *field);
-      ASSERT_TRUE(quantized.Open({true, false, true}).ok());
+      ASSERT_TRUE(quantized.open({true, false, true}).ok());
       EXPECT_EQ(quantized.doc_count(), 64);
-      EXPECT_TRUE(quantized.Close().ok());
+      EXPECT_TRUE(quantized.close().ok());
     }
   }
 }
@@ -664,10 +663,10 @@ class SegmentCompactReuseTest
   // Run CreateVectorIndexTask on `segment` for `column` with `index_params`,
   // then reload the segment so its in-memory indexer reflects the new index
   // (matching collection.cc's post-optimize reload path).
-  void OptimizeSegmentToVectorIndex(const Segment::Ptr &segment,
-                                    const CollectionSchema &schema,
-                                    const std::string &column,
-                                    const IndexParams::Ptr &index_params) {
+  void optimize_segment_to_vector_index(const Segment::Ptr &segment,
+                                        const CollectionSchema &schema,
+                                        const std::string &column,
+                                        const IndexParams::Ptr &index_params) {
     CreateVectorIndexTask task(segment, column, index_params, 1);
     auto segment_task = SegmentTask::CreateCreateVectorIndexTask(task);
     ASSERT_NE(segment_task, nullptr);
@@ -697,7 +696,7 @@ class SegmentCompactReuseTest
     qp.query_params = query_params;
     vector_column_params::VectorData data{
         vector_column_params::DenseVector{qvec.data()}};
-    auto results = indexer->Search(data, qp);
+    auto results = indexer->search(data, qp);
     EXPECT_TRUE(results.has_value());
     if (!results.has_value()) return {};
     auto vec_res = dynamic_cast<VectorIndexResults *>(results.value().get());
@@ -764,8 +763,8 @@ TEST_P(SegmentCompactReuseTest, OptimizedSegmentsReuseFirstIndexer) {
   const auto &param = GetParam();
   auto schema = test::TestHelper::CreateSchemaWithVectorIndex(
       false, col_name, param.vector_index_params);
-  auto version_manager = CreateVersionManager(*schema);
-  auto write_options = WriteOptions();
+  auto version_manager = create_version_manager(*schema);
+  auto seg_options = write_options();
 
   constexpr int kSegCount = 3;
   constexpr int kDocsPerSeg = 300;
@@ -775,7 +774,7 @@ TEST_P(SegmentCompactReuseTest, OptimizedSegmentsReuseFirstIndexer) {
   for (int i = 0; i < kSegCount; i++) {
     auto seg = test::TestHelper::CreateSegmentWithDoc(
         col_path, *schema, i, i * kDocsPerSeg, id_map, delete_store,
-        version_manager, write_options, i * kDocsPerSeg, kDocsPerSeg);
+        version_manager, seg_options, i * kDocsPerSeg, kDocsPerSeg);
     ASSERT_NE(seg, nullptr);
     ASSERT_TRUE(seg->flush().ok());
     segs.push_back(seg);
@@ -814,8 +813,8 @@ TEST_P(SegmentCompactReuseTest, OptimizedSegmentsReuseFirstIndexer) {
   // Optimize seg[0]'s vector fields to the parametric index type, mimicking
   // the lifecycle the compact path exercises.
   for (const auto &vf : schema->vector_fields()) {
-    OptimizeSegmentToVectorIndex(segs[0], *schema, vf->name(),
-                                 vf->index_params());
+    optimize_segment_to_vector_index(segs[0], *schema, vf->name(),
+                                     vf->index_params());
   }
 
   // For quantized index types (e.g. HNSW_RABITQ) the built index lives in
@@ -833,12 +832,12 @@ TEST_P(SegmentCompactReuseTest, OptimizedSegmentsReuseFirstIndexer) {
   }
 
   auto [compact_task, output_segment] =
-      RunCompactAndOpen(schema, segs, kSegCount, nullptr, version_manager);
+      run_compact_and_open(schema, segs, kSegCount, nullptr, version_manager);
 
   ASSERT_NE(output_segment, nullptr);
   ASSERT_EQ(output_segment->doc_count(), kSegCount * kDocsPerSeg);
-  ASSERT_NE(output_segment->Fetch(0), nullptr);
-  ASSERT_NE(output_segment->Fetch(kSegCount * kDocsPerSeg - 1), nullptr);
+  ASSERT_NE(output_segment->fetch(0), nullptr);
+  ASSERT_NE(output_segment->fetch(kSegCount * kDocsPerSeg - 1), nullptr);
 
   auto out_indexers =
       quantized ? output_segment->get_quant_vector_indexer("dense_fp32")
@@ -905,15 +904,15 @@ INSTANTIATE_TEST_SUITE_P(
 
 TEST_F(SegmentHelperTest, CompactTask_FilterMultiSegmentsRegression) {
   auto schema = test::TestHelper::CreateSchemaWithVectorIndex();
-  auto version_manager = CreateVersionManager(*schema);
-  auto write_options = WriteOptions();
+  auto version_manager = create_version_manager(*schema);
+  auto seg_options = write_options();
 
   auto seg1 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 0, 0, id_map, delete_store, version_manager,
-      write_options, 0, 400);
+      seg_options, 0, 400);
   auto seg2 = test::TestHelper::CreateSegmentWithDoc(
       col_path, *schema, 1, 400, id_map, delete_store, version_manager,
-      write_options, 400, 400);
+      seg_options, 400, 400);
   ASSERT_TRUE(seg1 != nullptr);
   ASSERT_TRUE(seg2 != nullptr);
   ASSERT_TRUE(seg1->flush().ok());
@@ -923,7 +922,7 @@ TEST_F(SegmentHelperTest, CompactTask_FilterMultiSegmentsRegression) {
       [](uint64_t id) -> bool { return id < 100 || (id >= 400 && id < 450); });
 
   auto [compact_task, output_segment] =
-      RunCompactAndOpen(schema, {seg1, seg2}, 2, filter, version_manager);
+      run_compact_and_open(schema, {seg1, seg2}, 2, filter, version_manager);
 
   ASSERT_NE(output_segment, nullptr);
   ASSERT_EQ(output_segment->doc_count(), 650);
diff --git a/tests/db/index/segment/segment_test.cc b/tests/db/index/segment/segment_test.cc
index 9582d2bf3..b966b41f5 100644
--- a/tests/db/index/segment/segment_test.cc
+++ b/tests/db/index/segment/segment_test.cc
@@ -35,16 +35,16 @@
 #include "db/index/common/id_map.h"
 #include "db/index/common/version_manager.h"
 #include "db/index/storage/wal/wal_file.h"
-#include "segment_test_fixture.h"
 #include "utils/utils.h"
 #include "zvec/db/options.h"
+#include "segment_test_fixture.h"
 
 using namespace zvec;
 
 TEST_P(SegmentTest, EmptySchema) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 0);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 0);
   ASSERT_TRUE(segment != nullptr);
   EXPECT_EQ(segment->id(), 0);
 
@@ -56,8 +56,8 @@ TEST_P(SegmentTest, General) {
   options_.max_buffer_size_ = 1 * 1024;
 
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 25);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 25);
   ASSERT_TRUE(segment != nullptr);
 
   auto combined_reader = segment->scan({LOCAL_ROW_ID, "id", "name", "age"});
@@ -106,13 +106,13 @@ TEST_P(SegmentTest, General) {
 
 TEST_P(SegmentTest, InsertMoreData) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 0);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 0);
   ASSERT_TRUE(segment != nullptr);
 
-  uint64_t MAX_DOC = 1000;
+  uint64_t max_doc = 1000;
   auto start = std::chrono::system_clock::now();
-  test::TestHelper::SegmentInsertDoc(segment, *schema_, 0, MAX_DOC);
+  test::TestHelper::SegmentInsertDoc(segment, *schema_, 0, max_doc);
   auto end = std::chrono::system_clock::now();
   auto cost = std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
                   .count();
@@ -128,7 +128,7 @@ TEST_P(SegmentTest, InsertMoreData) {
     total_doc += batch->num_rows();
   }
 
-  EXPECT_EQ(total_doc, MAX_DOC);
+  EXPECT_EQ(total_doc, max_doc);
 }
 
 TEST_P(SegmentTest, InsertScalarTypes) {
@@ -137,14 +137,14 @@ TEST_P(SegmentTest, InsertScalarTypes) {
 
   auto invert_params = std::make_shared<InvertIndexParams>(false);
   schema_->add_field(std::make_shared<FieldSchema>("binary", DataType::BINARY,
-                                                  false, invert_params));
+                                                   false, invert_params));
 
   schema_->add_field(std::make_shared<FieldSchema>(
       "array_binary", DataType::ARRAY_BINARY, false, invert_params));
 
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 }
 
@@ -167,8 +167,8 @@ TEST_P(SegmentTest, InsertVectorTypes) {
   {
     Version v = version_manager_->get_current_version();
     auto result =
-        Segment::Open(col_path_, *tmp_schema, *v.writing_segment_meta(), id_map_,
-                      delete_store_, version_manager_, options_);
+        Segment::Open(col_path_, *tmp_schema, *v.writing_segment_meta(),
+                      id_map_, delete_store_, version_manager_, options_);
     ASSERT_TRUE(result.has_value());
     auto segment = result.value();
 
@@ -179,11 +179,11 @@ TEST_P(SegmentTest, InsertVectorTypes) {
 
 TEST_P(SegmentTest, FetchByGlobalDocID) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 1);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 1);
   ASSERT_TRUE(segment != nullptr);
 
-  auto ret_doc = segment->Fetch(0);
+  auto ret_doc = segment->fetch(0);
   EXPECT_TRUE(ret_doc != nullptr);
   EXPECT_EQ(ret_doc->doc_id(), 0);
   EXPECT_EQ(ret_doc->pk(), "pk_0");
@@ -192,8 +192,8 @@ TEST_P(SegmentTest, FetchByGlobalDocID) {
 TEST_P(SegmentTest, FetchSingleRow) {
   int doc_count = 10;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   auto func = [&](int index) -> void {
@@ -219,8 +219,8 @@ TEST_P(SegmentTest, FetchSingleRowWithPersistStore) {
   int doc_count = 1000;
   {
     auto segment = test::TestHelper::CreateSegmentWithDoc(
-        col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-        0, doc_count);
+        col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+        options_, 0, doc_count);
     ASSERT_TRUE(segment != nullptr);
   }
 
@@ -229,9 +229,9 @@ TEST_P(SegmentTest, FetchSingleRowWithPersistStore) {
     Version v = version_manager_->get_current_version();
     SegmentOptions open_options;
     open_options.read_only_ = false;
-    auto result = Segment::Open(col_path_, *schema_, *v.writing_segment_meta(),
-                                id_map_, delete_store_, version_manager_,
-                                open_options);
+    auto result =
+        Segment::Open(col_path_, *schema_, *v.writing_segment_meta(), id_map_,
+                      delete_store_, version_manager_, open_options);
     ASSERT_TRUE(result.has_value());
     auto segment = result.value();
 
@@ -259,8 +259,8 @@ TEST_P(SegmentTest, FetchSingleRowWithPersistStore) {
 
 TEST_P(SegmentTest, FetchSingleRowWithUserID) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 
   ExecBatchPtr batch = segment->fetch({USER_ID, "id", "name"}, 2);
@@ -276,8 +276,8 @@ TEST_P(SegmentTest, FetchSingleRowWithUserID) {
 
 TEST_P(SegmentTest, FetchSingleRowWithGlobalDocID) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 
   ExecBatchPtr batch = segment->fetch({GLOBAL_DOC_ID, "id", "name"}, 4);
@@ -293,8 +293,8 @@ TEST_P(SegmentTest, FetchSingleRowWithGlobalDocID) {
 
 TEST_P(SegmentTest, FetchSingleRowWithNegativeIndex) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 
   ExecBatchPtr batch = segment->fetch({"id", "name"}, -1);
@@ -303,8 +303,8 @@ TEST_P(SegmentTest, FetchSingleRowWithNegativeIndex) {
 
 TEST_P(SegmentTest, FetchSingleRowWithOutOfRangeIndex) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 
   ExecBatchPtr batch = segment->fetch({"id", "name"}, 15);
@@ -313,8 +313,8 @@ TEST_P(SegmentTest, FetchSingleRowWithOutOfRangeIndex) {
 
 TEST_P(SegmentTest, FetchSingleRowWithInvalidColumn) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 
   ExecBatchPtr batch = segment->fetch({"id", "invalid_column"}, 0);
@@ -323,8 +323,8 @@ TEST_P(SegmentTest, FetchSingleRowWithInvalidColumn) {
 
 TEST_P(SegmentTest, FetchSingleRowWithEmptyColumns) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 
   ExecBatchPtr batch = segment->fetch({}, 0);
@@ -333,8 +333,8 @@ TEST_P(SegmentTest, FetchSingleRowWithEmptyColumns) {
 
 TEST_P(SegmentTest, FetchSingleRowFromEmptySegment) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 0);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 0);
   ASSERT_TRUE(segment != nullptr);
 
   ExecBatchPtr batch = segment->fetch({"id", "name"}, 0);
@@ -343,8 +343,8 @@ TEST_P(SegmentTest, FetchSingleRowFromEmptySegment) {
 
 TEST_P(SegmentTest, FetchSingleRowWithBinaryFields) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 
   ExecBatchPtr batch = segment->fetch({"binary", "array_binary"}, 1);
@@ -368,8 +368,8 @@ TEST_P(SegmentTest, Recover) {
   int doc_count = 100;
   {
     auto segment = test::TestHelper::CreateSegmentWithDoc(
-        col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-        0, doc_count);
+        col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+        options_, 0, doc_count);
     ASSERT_TRUE(segment != nullptr);
   }
 
@@ -378,17 +378,17 @@ TEST_P(SegmentTest, Recover) {
     Version v = version_manager_->get_current_version();
     auto writing_block_id =
         v.writing_segment_meta()->writing_forward_block_->id();
-    auto wal_file = FileHelper::MakeWalPath(col_path_, 0, writing_block_id);
+    auto wal_path = FileHelper::MakeWalPath(col_path_, 0, writing_block_id);
     WalOptions wal_option{0, true};
-    WalFilePtr wal_file_;
-    WalFile::CreateAndOpen(wal_file, wal_option, &wal_file_);
-    ASSERT_TRUE(wal_file_ != nullptr);
+    WalFilePtr wal_file;
+    WalFile::CreateAndOpen(wal_path, wal_option, &wal_file);
+    ASSERT_TRUE(wal_file != nullptr);
 
     for (int i = doc_count; i < doc_count + 100; i++) {
       Doc doc = test::TestHelper::CreateDoc(i, *schema_);
       doc.set_operator(Operator::INSERT);
       std::vector<uint8_t> buf = doc.serialize();
-      auto ret = wal_file_->append(std::string(buf.begin(), buf.end()));
+      auto ret = wal_file->append(std::string(buf.begin(), buf.end()));
       ASSERT_EQ(ret, 0);
     }
 
@@ -397,7 +397,7 @@ TEST_P(SegmentTest, Recover) {
       doc.set_doc_id(i);  // global doc id
       doc.set_operator(Operator::UPDATE);
       std::vector<uint8_t> buf = doc.serialize();
-      auto ret = wal_file_->append(std::string(buf.begin(), buf.end()));
+      auto ret = wal_file->append(std::string(buf.begin(), buf.end()));
       ASSERT_EQ(ret, 0);
     }
 
@@ -405,7 +405,7 @@ TEST_P(SegmentTest, Recover) {
       Doc doc = test::TestHelper::CreateDoc(i, *schema_);
       doc.set_operator(Operator::UPSERT);
       std::vector<uint8_t> buf = doc.serialize();
-      auto ret = wal_file_->append(std::string(buf.begin(), buf.end()));
+      auto ret = wal_file->append(std::string(buf.begin(), buf.end()));
       ASSERT_EQ(ret, 0);
     }
 
@@ -414,7 +414,7 @@ TEST_P(SegmentTest, Recover) {
       doc.set_doc_id(i + 300);  // global doc id
       doc.set_operator(Operator::DELETE);
       std::vector<uint8_t> buf = doc.serialize();
-      auto ret = wal_file_->append(std::string(buf.begin(), buf.end()));
+      auto ret = wal_file->append(std::string(buf.begin(), buf.end()));
       ASSERT_EQ(ret, 0);
     }
   }
@@ -424,9 +424,9 @@ TEST_P(SegmentTest, Recover) {
     Version v = version_manager_->get_current_version();
     SegmentOptions open_options;
     open_options.read_only_ = false;
-    auto result = Segment::Open(col_path_, *schema_, *v.writing_segment_meta(),
-                                id_map_, delete_store_, version_manager_,
-                                open_options);
+    auto result =
+        Segment::Open(col_path_, *schema_, *v.writing_segment_meta(), id_map_,
+                      delete_store_, version_manager_, open_options);
     ASSERT_TRUE(result.has_value());
     auto segment = result.value();
 
@@ -452,8 +452,8 @@ TEST_P(SegmentTest, Recover) {
 
 TEST_P(SegmentTest, UpdateDoc) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 
   // before update
@@ -466,7 +466,7 @@ TEST_P(SegmentTest, UpdateDoc) {
   update_doc.set<uint32_t>("age", 99);
 
   // Update the document
-  auto status = segment->Update(update_doc);
+  auto status = segment->update(update_doc);
   EXPECT_TRUE(status.ok()) << "Update failed: " << status.message();
 
   // after update
@@ -475,7 +475,7 @@ TEST_P(SegmentTest, UpdateDoc) {
 
   // Fetch the updated document and verify changes
   // Note: The parameter here is the internal global_doc_id, not user-specified
-  auto ret_doc = segment->Fetch(10);
+  auto ret_doc = segment->fetch(10);
   EXPECT_TRUE(ret_doc != nullptr);
   EXPECT_EQ(ret_doc->get<std::string>("name"), "updated_name");
   EXPECT_EQ(ret_doc->get<uint32_t>("age"), 99);
@@ -484,8 +484,8 @@ TEST_P(SegmentTest, UpdateDoc) {
 TEST_P(SegmentTest, UpdateDocBatch) {
   int doc_count = 10;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
   // before update
   uint64_t count = segment->doc_count(delete_store_->make_filter());
@@ -495,7 +495,7 @@ TEST_P(SegmentTest, UpdateDocBatch) {
   for (int i = 0; i < doc_count; i++) {
     Doc update_doc = test::TestHelper::CreateDoc(i, *schema_);
     // Update the document
-    auto status = segment->Update(update_doc);
+    auto status = segment->update(update_doc);
     EXPECT_TRUE(status.ok()) << "Update failed: " << status.message();
   }
 
@@ -505,7 +505,7 @@ TEST_P(SegmentTest, UpdateDocBatch) {
 
   // Fetch the updated document and verify changes
   // Note: The parameter here is the internal global_doc_id, not user-specified
-  auto ret_doc = segment->Fetch(doc_count * 2 - 1);
+  auto ret_doc = segment->fetch(doc_count * 2 - 1);
   EXPECT_TRUE(ret_doc != nullptr);
   EXPECT_EQ(ret_doc->get<std::string>("name"),
             "value_" + std::to_string(doc_count - 1));
@@ -513,8 +513,8 @@ TEST_P(SegmentTest, UpdateDocBatch) {
 
 TEST_P(SegmentTest, DeleteDoc) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 
   // before update
@@ -541,8 +541,8 @@ TEST_P(SegmentTest, DeleteDoc) {
 TEST_P(SegmentTest, DeleteBatch) {
   int doc_count = 10;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   // before update
@@ -562,8 +562,8 @@ TEST_P(SegmentTest, DeleteBatch) {
 
 TEST_P(SegmentTest, UpsertDoc) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 5);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 5);
   ASSERT_TRUE(segment != nullptr);
 
   // before update
@@ -573,7 +573,7 @@ TEST_P(SegmentTest, UpsertDoc) {
   // Upsert an existing document
   Doc upsert_doc1 = test::TestHelper::CreateDoc(3, *schema_);
   upsert_doc1.set<std::string>("name", "upserted_name");
-  auto status = segment->Upsert(upsert_doc1);
+  auto status = segment->upsert(upsert_doc1);
   EXPECT_TRUE(status.ok()) << "Upsert existing doc failed: "
                            << status.message();
 
@@ -581,21 +581,21 @@ TEST_P(SegmentTest, UpsertDoc) {
   EXPECT_EQ(count, 5);
 
   // Verify the update
-  auto ret_doc = segment->Fetch(5);
+  auto ret_doc = segment->fetch(5);
   EXPECT_TRUE(ret_doc != nullptr);
   EXPECT_EQ(ret_doc->get<std::string>("name"), "upserted_name");
 
   // Upsert a new document
   Doc upsert_doc2 = test::TestHelper::CreateDoc(6, *schema_);
   upsert_doc2.set<std::string>("name", "new_upserted_doc");
-  status = segment->Upsert(upsert_doc2);
+  status = segment->upsert(upsert_doc2);
   EXPECT_TRUE(status.ok()) << "Upsert new doc failed: " << status.message();
 
   count = segment->doc_count(delete_store_->make_filter());
   EXPECT_EQ(count, 6);
 
   // Verify the new document was inserted
-  ret_doc = segment->Fetch(6);
+  ret_doc = segment->fetch(6);
   EXPECT_TRUE(ret_doc != nullptr);
   EXPECT_EQ(ret_doc->get<std::string>("name"), "new_upserted_doc");
 }
@@ -603,8 +603,8 @@ TEST_P(SegmentTest, UpsertDoc) {
 TEST_P(SegmentTest, UpsertDocBatch) {
   int doc_count = 10;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   // before update
@@ -615,7 +615,7 @@ TEST_P(SegmentTest, UpsertDocBatch) {
     // Upsert existing document
     Doc upsert_doc1 = test::TestHelper::CreateDoc(i, *schema_);
     upsert_doc1.set<std::string>("name", "upserted_name" + std::to_string(i));
-    auto status = segment->Upsert(upsert_doc1);
+    auto status = segment->upsert(upsert_doc1);
     EXPECT_TRUE(status.ok())
         << "Upsert existing doc failed: " << status.message();
 
@@ -623,7 +623,7 @@ TEST_P(SegmentTest, UpsertDocBatch) {
     Doc upsert_doc2 = test::TestHelper::CreateDoc(doc_count + i, *schema_);
     upsert_doc2.set<std::string>("name",
                                  "new_upserted_doc" + std::to_string(i));
-    status = segment->Upsert(upsert_doc2);
+    status = segment->upsert(upsert_doc2);
     EXPECT_TRUE(status.ok()) << "Upsert new doc failed: " << status.message();
   }
 
@@ -633,13 +633,13 @@ TEST_P(SegmentTest, UpsertDocBatch) {
   int incr_idx = 0;
   for (int i = doc_count; i < doc_count + doc_count * 2; i += 2) {
     // Verify the update
-    auto ret_doc = segment->Fetch(i);
+    auto ret_doc = segment->fetch(i);
     EXPECT_TRUE(ret_doc != nullptr);
     EXPECT_EQ(ret_doc->get<std::string>("name"),
               "upserted_name" + std::to_string(incr_idx));
 
     // Verify the new document was inserted
-    ret_doc = segment->Fetch(i + 1);
+    ret_doc = segment->fetch(i + 1);
     EXPECT_EQ(ret_doc->get<std::string>("name"),
               "new_upserted_doc" + std::to_string(incr_idx));
     incr_idx++;
@@ -648,8 +648,8 @@ TEST_P(SegmentTest, UpsertDocBatch) {
 
 TEST_P(SegmentTest, Flush) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 100);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 100);
   ASSERT_TRUE(segment != nullptr);
 
   // Flush the segment
@@ -659,8 +659,8 @@ TEST_P(SegmentTest, Flush) {
 
 TEST_P(SegmentTest, FlushAfterInsert) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 100);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 100);
   ASSERT_TRUE(segment != nullptr);
 
   // Flush the segment
@@ -672,7 +672,7 @@ TEST_P(SegmentTest, FlushAfterInsert) {
   ASSERT_EQ(segment->doc_count(), 150);
 
   for (int i = 0; i < 150; i++) {
-    auto ret_doc = segment->Fetch(i);
+    auto ret_doc = segment->fetch(i);
     EXPECT_TRUE(ret_doc != nullptr);
 
     Doc verify_doc = test::TestHelper::CreateDoc(i, *schema_);
@@ -686,8 +686,8 @@ TEST_P(SegmentTest, FlushAfterInsert) {
 
 TEST_P(SegmentTest, Dump) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 100);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 100);
   ASSERT_TRUE(segment != nullptr);
 
   // Dump the segment
@@ -701,8 +701,8 @@ TEST_P(SegmentTest, Dump) {
 
 TEST_P(SegmentTest, DocCount) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 50);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 50);
   ASSERT_TRUE(segment != nullptr);
 
   // Get document count
@@ -760,23 +760,23 @@ TEST_P(SegmentTest, CombinedVectorColumnIndexer) {
   options_.max_buffer_size_ = 10 * 1024;
 
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 0);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 0);
   ASSERT_TRUE(segment != nullptr);
 
 
-  uint64_t MAX_DOC = 1000;
-  test::TestHelper::SegmentInsertDoc(segment, *schema_, 0, MAX_DOC);
+  uint64_t max_doc = 1000;
+  test::TestHelper::SegmentInsertDoc(segment, *schema_, 0, max_doc);
 
   Doc new_doc = test::TestHelper::CreateDoc(1000, *schema_);
-  auto status = segment->Insert(new_doc);
+  auto status = segment->insert(new_doc);
   ASSERT_TRUE(status.ok());
 
   auto combined_indexer = segment->get_combined_vector_indexer("dense_fp32");
   ASSERT_TRUE(combined_indexer != nullptr);
 
   // fetch
-  auto fetched_data = combined_indexer->Fetch(1000);
+  auto fetched_data = combined_indexer->fetch(1000);
   ASSERT_TRUE(fetched_data);
   const float *dense_vector = reinterpret_cast<const float *>(
       std::get<vector_column_params::DenseVectorBuffer>(
@@ -799,7 +799,7 @@ TEST_P(SegmentTest, CombinedVectorColumnIndexer) {
   query_params.topk = 10;
   query_params.filter = nullptr;
   query_params.fetch_vector = false;
-  auto results = combined_indexer->Search(query, query_params);
+  auto results = combined_indexer->search(query, query_params);
   ASSERT_TRUE(results.has_value());
 
   auto vector_results =
@@ -830,11 +830,11 @@ TEST_P(SegmentTest, CombinedVectorColumnIndexerWithQuantVectorIndex) {
   ASSERT_TRUE(segment != nullptr);
 
 
-  uint64_t MAX_DOC = 1000;
-  test::TestHelper::SegmentInsertDoc(segment, *schema_, 0, MAX_DOC);
+  uint64_t max_doc = 1000;
+  test::TestHelper::SegmentInsertDoc(segment, *schema_, 0, max_doc);
 
   Doc new_doc = test::TestHelper::CreateDoc(1000, *schema_);
-  auto status = segment->Insert(new_doc);
+  auto status = segment->insert(new_doc);
   ASSERT_TRUE(status.ok());
 
   auto combined_indexer =
@@ -842,7 +842,7 @@ TEST_P(SegmentTest, CombinedVectorColumnIndexerWithQuantVectorIndex) {
   ASSERT_TRUE(combined_indexer != nullptr);
 
   // fetch
-  auto fetched_data = combined_indexer->Fetch(1000);
+  auto fetched_data = combined_indexer->fetch(1000);
   ASSERT_TRUE(fetched_data);
   const float *dense_vector = reinterpret_cast<const float *>(
       std::get<vector_column_params::DenseVectorBuffer>(
@@ -869,7 +869,7 @@ TEST_P(SegmentTest, CombinedVectorColumnIndexerWithQuantVectorIndex) {
       std::make_shared<zvec::QueryParams>(IndexType::HNSW);
   query_params.query_params->set_is_using_refiner(true);
 
-  auto results = combined_indexer->Search(query, query_params);
+  auto results = combined_indexer->search(query, query_params);
   ASSERT_TRUE(results.has_value());
 
   auto vector_results =
@@ -898,8 +898,8 @@ TEST_P(SegmentTest, CombinedVectorColumnIndexerQueryWithPks) {
   ASSERT_TRUE(segment != nullptr);
 
 
-  uint64_t MAX_DOC = 1000;
-  test::TestHelper::SegmentInsertDoc(segment, *schema_, 0, MAX_DOC);
+  uint64_t max_doc = 1000;
+  test::TestHelper::SegmentInsertDoc(segment, *schema_, 0, max_doc);
 
   auto combined_indexer = segment->get_combined_vector_indexer("dense_fp32");
   ASSERT_TRUE(combined_indexer != nullptr);
@@ -922,7 +922,7 @@ TEST_P(SegmentTest, CombinedVectorColumnIndexerQueryWithPks) {
       std::make_shared<zvec::QueryParams>(IndexType::HNSW);
   query_params.bf_pks = bf_pks;
 
-  auto results = combined_indexer->Search(query, query_params);
+  auto results = combined_indexer->search(query, query_params);
   ASSERT_TRUE(results.has_value());
 
   auto vector_results =
@@ -947,8 +947,8 @@ TEST_P(SegmentTest, CombinedVectorColumnIndexerQueryWithPks) {
 
 TEST_P(SegmentTest, ConcurrentInsertOperations) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 0);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 0);
   ASSERT_TRUE(segment != nullptr);
 
   const int num_threads = 4;
@@ -961,7 +961,7 @@ TEST_P(SegmentTest, ConcurrentInsertOperations) {
       for (int i = 0; i < docs_per_thread; ++i) {
         int doc_id = t * docs_per_thread + i;
         Doc doc = test::TestHelper::CreateDoc(doc_id, *schema_);
-        auto status = segment->Insert(doc);
+        auto status = segment->insert(doc);
         EXPECT_TRUE(status.ok())
             << "Thread " << t << " insert failed for doc " << doc_id;
       }
@@ -980,8 +980,8 @@ TEST_P(SegmentTest, ConcurrentInsertOperations) {
 
 TEST_P(SegmentTest, ConcurrentMixedOperations) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 100);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 100);
   ASSERT_TRUE(segment != nullptr);
 
   std::vector<std::thread> threads;
@@ -990,7 +990,7 @@ TEST_P(SegmentTest, ConcurrentMixedOperations) {
   threads.emplace_back([&]() {
     for (int i = 100; i < 120; ++i) {
       Doc doc = test::TestHelper::CreateDoc(i, *schema_);
-      auto status = segment->Insert(doc);
+      auto status = segment->insert(doc);
       EXPECT_TRUE(status.ok() || status.code() == StatusCode::ALREADY_EXISTS);
     }
   });
@@ -1000,7 +1000,7 @@ TEST_P(SegmentTest, ConcurrentMixedOperations) {
     for (int i = 0; i < 50; i += 5) {
       Doc doc = test::TestHelper::CreateDoc(i, *schema_);
       doc.set<std::string>("name", "updated_concurrent_" + std::to_string(i));
-      auto status = segment->Update(doc);
+      auto status = segment->update(doc);
       EXPECT_TRUE(status.ok() || status.code() == StatusCode::NOT_FOUND);
     }
   });
@@ -1022,12 +1022,12 @@ TEST_P(SegmentTest, ConcurrentMixedOperations) {
 // corner cases
 TEST_P(SegmentTest, DuplicateInsert) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 0);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 0);
   ASSERT_TRUE(segment != nullptr);
 
   Doc doc1 = test::TestHelper::CreateDoc(0, *schema_);
-  auto status1 = segment->Insert(doc1);
+  auto status1 = segment->insert(doc1);
   EXPECT_TRUE(status1.ok()) << "First insert failed: " << status1.message();
 
   auto meta = segment->meta();
@@ -1037,22 +1037,22 @@ TEST_P(SegmentTest, DuplicateInsert) {
   EXPECT_EQ(mem_block.min_doc_id_, 0);
   EXPECT_EQ(mem_block.max_doc_id_, 0);
 
-  auto doc = segment->Fetch(0);
+  auto doc = segment->fetch(0);
   EXPECT_TRUE(doc != nullptr);
   EXPECT_EQ(*doc, doc1);
 
-  auto status2 = segment->Insert(doc1);
+  auto status2 = segment->insert(doc1);
   EXPECT_FALSE(status2.ok()) << "Duplicate insert should fail";
 
-  auto fetched_doc = segment->Fetch(0);
+  auto fetched_doc = segment->fetch(0);
   ASSERT_TRUE(fetched_doc != nullptr);
   EXPECT_NE(fetched_doc->get<std::string>("name").value(), "duplicate_name");
 }
 
 TEST_P(SegmentTest, DuplicateDelete) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 5);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 5);
   ASSERT_TRUE(segment != nullptr);
 
   auto status1 = segment->Delete("pk_2");
@@ -1068,8 +1068,8 @@ TEST_P(SegmentTest, DuplicateDelete) {
 
 TEST_P(SegmentTest, DeleteNonExistentDoc) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 5);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 5);
   ASSERT_TRUE(segment != nullptr);
 
   auto status1 = segment->Delete("pk_999");
@@ -1078,27 +1078,27 @@ TEST_P(SegmentTest, DeleteNonExistentDoc) {
 
 TEST_P(SegmentTest, UpdateNonExistentDoc) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 5);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 5);
   ASSERT_TRUE(segment != nullptr);
 
   Doc doc = test::TestHelper::CreateDoc(999, *schema_);
   doc.set<std::string>("name", "non_existent_doc");
 
-  auto status = segment->Update(doc);
+  auto status = segment->update(doc);
   EXPECT_FALSE(status.ok()) << "Update non-existent doc should fail";
 }
 
 TEST_P(SegmentTest, UpsertNonExistentDoc) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 5);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 5);
   ASSERT_TRUE(segment != nullptr);
 
   Doc doc = test::TestHelper::CreateDoc(999, *schema_);
   doc.set<std::string>("name", "new_upserted_doc");
 
-  auto status = segment->Upsert(doc);
+  auto status = segment->upsert(doc);
   EXPECT_TRUE(status.ok()) << "Upsert non-existent doc should succeed: "
                            << status.message();
 
@@ -1109,8 +1109,8 @@ TEST_P(SegmentTest, UpsertNonExistentDoc) {
 
 TEST_P(SegmentTest, ScanWithEmptyColumns) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 5);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 5);
   ASSERT_TRUE(segment != nullptr);
 
   auto reader = segment->scan({});
@@ -1119,8 +1119,8 @@ TEST_P(SegmentTest, ScanWithEmptyColumns) {
 
 TEST_P(SegmentTest, ScanWithInvalidColumns) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 
   // Try to scan with invalid column name
@@ -1130,18 +1130,18 @@ TEST_P(SegmentTest, ScanWithInvalidColumns) {
 
 TEST_P(SegmentTest, FetchNonExistentDoc) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 5);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 5);
   ASSERT_TRUE(segment != nullptr);
 
-  auto doc = segment->Fetch(999);
+  auto doc = segment->fetch(999);
   EXPECT_TRUE(doc == nullptr) << "Fetch non-existent doc should return nullptr";
 }
 
 TEST_P(SegmentTest, FetchWithInvalidSegmentDocIDs) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 5);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 5);
   ASSERT_TRUE(segment != nullptr);
 
   std::vector<int> invalid_segment_doc_ids = {999, 1000};
@@ -1152,8 +1152,8 @@ TEST_P(SegmentTest, FetchWithInvalidSegmentDocIDs) {
 
 TEST_P(SegmentTest, FetchWithInvalidColumns) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 10);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 10);
   ASSERT_TRUE(segment != nullptr);
 
   // Try to fetch with invalid column name
@@ -1166,20 +1166,20 @@ TEST_P(SegmentTest, InsertEmptyDocWithNullableSchema) {
   auto nullable_schema = test::TestHelper::CreateNormalSchema(true, col_name_);
 
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *nullable_schema, 0, 0, id_map_, delete_store_, version_manager_,
-      options_, 0, 0);
+      col_path_, *nullable_schema, 0, 0, id_map_, delete_store_,
+      version_manager_, options_, 0, 0);
   ASSERT_TRUE(segment != nullptr);
 
   Doc empty_doc;
   empty_doc.set_pk("pk_empty");
-  auto status = segment->Insert(empty_doc);
+  auto status = segment->insert(empty_doc);
   EXPECT_TRUE(status.ok());
 }
 
 TEST_P(SegmentTest, MultipleDuplicateDeletes) {
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, 5);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, 5);
   ASSERT_TRUE(segment != nullptr);
 
   auto status1 = segment->Delete("pk_1");
@@ -1202,8 +1202,8 @@ TEST_P(SegmentTest, FetchWithTwoVectorFields) {
 
   int doc_count = 1000;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
   segment.reset();
   version_manager_.reset();
@@ -1248,7 +1248,7 @@ TEST_P(SegmentTest, FetchWithTwoVectorFields) {
 
   for (int i = 0; i < doc_count + incr_doc_count; i++) {
     auto expect_doc = test::TestHelper::CreateDoc(i, *schema_);
-    auto ret_doc = segment->Fetch(i);
+    auto ret_doc = segment->fetch(i);
     if (*ret_doc != expect_doc) {
       std::cout << "   ret_doc: " << ret_doc->to_string() << std::endl;
       std::cout << "expect_doc: " << expect_doc.to_string() << std::endl;
@@ -1262,8 +1262,8 @@ TEST_P(SegmentTest, FetchPerf) {
   int doc_count = 1000;
   options_.max_buffer_size_ = 100 * 1024;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   segment->dump();
@@ -1367,8 +1367,8 @@ TEST_P(SegmentTest, AddColumn) {
   options_.max_buffer_size_ = 10 * 1024 * 1024;
   int doc_count = 1000;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   auto s = segment->add_column(
@@ -1487,7 +1487,7 @@ TEST_P(SegmentTest, AddColumn) {
     auto check_doc = [&](int doc_count) {
       for (int i = 0; i < doc_count; i++) {
         auto expect_doc = test::TestHelper::CreateDoc(i, new_schema);
-        auto doc = segment->Fetch(i);
+        auto doc = segment->fetch(i);
         ASSERT_EQ(doc->pk(), expect_doc.pk());
 
         // column in same persist block
@@ -1600,8 +1600,8 @@ TEST_P(SegmentTest, AddNullableColumnWithoutExpressionMultiBlock) {
   options_.max_buffer_size_ = 1 * 1024;
   int doc_count = 100;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   segment->dump();
@@ -1674,9 +1674,8 @@ TEST_P(SegmentTest, AddNullableColumnWithoutExpressionMultiBlock) {
     auto field_schema =
         std::make_shared<FieldSchema>(nullable_col_name, data_type, true);
     s = segment->add_column(field_schema, "", AddColumnOptions());
-    ASSERT_TRUE(s.ok())
-        << "Failed to add nullable column " << nullable_col_name << ": "
-        << s.message();
+    ASSERT_TRUE(s.ok()) << "Failed to add nullable column " << nullable_col_name
+                        << ": " << s.message();
 
     auto combined_reader =
         segment->scan({"id", "name", "age", nullable_col_name});
@@ -1699,8 +1698,8 @@ TEST_P(SegmentTest, AddColumnWithExpressionMultiBlock) {
   options_.max_buffer_size_ = 1 * 1024;
   int doc_count = 100;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   segment->dump();
@@ -1807,8 +1806,8 @@ TEST_P(SegmentTest, AlterColumnMultiBlock) {
   options_.max_buffer_size_ = 1 * 1024;
   int doc_count = 100;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   segment->dump();
@@ -1891,8 +1890,8 @@ TEST_P(SegmentTest, DropColumnMultiBlock) {
   options_.max_buffer_size_ = 1 * 1024;
   int doc_count = 100;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   segment->dump();
@@ -1978,8 +1977,8 @@ TEST_P(SegmentTest, AddNullableThenAlterDropMultiBlock) {
   options_.max_buffer_size_ = 1 * 1024;
   int doc_count = 100;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   segment->dump();
@@ -2087,8 +2086,8 @@ TEST_P(SegmentTest, AlterColumn) {
   // create segment
   int doc_count = 1000;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   auto s = segment->alter_column(
@@ -2203,8 +2202,8 @@ TEST_P(SegmentTest, DropColumn) {
   // create segment
   int doc_count = 1000;
   auto segment = test::TestHelper::CreateSegmentWithDoc(
-      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_, options_,
-      0, doc_count);
+      col_path_, *schema_, 0, 0, id_map_, delete_store_, version_manager_,
+      options_, 0, doc_count);
   ASSERT_TRUE(segment != nullptr);
 
   auto s = segment->drop_column("int32");
diff --git a/tests/db/index/segment/segment_test_fixture.h b/tests/db/index/segment/segment_test_fixture.h
index 140f930b9..248009503 100644
--- a/tests/db/index/segment/segment_test_fixture.h
+++ b/tests/db/index/segment/segment_test_fixture.h
@@ -87,7 +87,7 @@ class SegmentTest : public testing::TestWithParam<bool> {
   }
 
  public:
-  std::string GetColPath() {
+  std::string get_col_path() {
     return col_path_;
   }
 
diff --git a/tests/db/index/storage/arrow_ipc_writer_test.cc b/tests/db/index/storage/arrow_ipc_writer_test.cc
index ad9743170..a99b8ca17 100644
--- a/tests/db/index/storage/arrow_ipc_writer_test.cc
+++ b/tests/db/index/storage/arrow_ipc_writer_test.cc
@@ -105,13 +105,13 @@ TEST(ArrowIpcWriter, General) {
             << std::endl;
 
   // 读取文件
-  std::shared_ptr<arrow::io::RandomAccessFile> output_file_;
+  std::shared_ptr<arrow::io::RandomAccessFile> output_file;
   std::string output_file_path_cp;
-  auto as = CreateRandomAccessFileByUri(output_file_path, &output_file_,
+  auto as = CreateRandomAccessFileByUri(output_file_path, &output_file,
                                         &output_file_path_cp);
   ASSERT_TRUE(as.ok());
 
-  auto result = arrow::ipc::RecordBatchFileReader::Open(output_file_);
+  auto result = arrow::ipc::RecordBatchFileReader::Open(output_file);
   ASSERT_TRUE(result.ok());
 
   auto reader = std::move(result).ValueOrDie();
diff --git a/tests/db/index/storage/bufferpool_store_test.cc b/tests/db/index/storage/bufferpool_store_test.cc
index 3ea9024c1..524e4ebb5 100644
--- a/tests/db/index/storage/bufferpool_store_test.cc
+++ b/tests/db/index/storage/bufferpool_store_test.cc
@@ -48,7 +48,7 @@ class BufferPoolStoreTest : public testing::Test {
 
 TEST_F(BufferPoolStoreTest, ParquetFetch) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   TablePtr table = store->fetch({"id", "name", "score"}, {0, 1, 2});
   ASSERT_TRUE(table != nullptr);
   EXPECT_EQ(table->num_rows(), 3);
@@ -57,7 +57,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetch) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchWithSelectColumns) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   TablePtr table = store->fetch({"id", "name"}, {0, 1, 2});
   ASSERT_TRUE(table != nullptr);
   EXPECT_EQ(table->num_rows(), 3);
@@ -66,7 +66,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchWithSelectColumns) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchWithUID) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   auto table = store->fetch({USER_ID, "id", "name"}, {0, 1, 2});
   ASSERT_TRUE(table != nullptr);
   EXPECT_EQ(table->num_rows(), 3);
@@ -75,7 +75,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchWithUID) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchWithGlobalDocID) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   auto table = store->fetch({GLOBAL_DOC_ID, "id", "name"}, {0, 1, 2});
   ASSERT_TRUE(table != nullptr);
   EXPECT_EQ(table->num_rows(), 3);
@@ -84,14 +84,14 @@ TEST_F(BufferPoolStoreTest, ParquetFetchWithGlobalDocID) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchWitEmptyColumns) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   TablePtr table = store->fetch({}, std::vector<int>{});
   EXPECT_EQ(table, nullptr);
 }
 
 TEST_F(BufferPoolStoreTest, ParquetFetchWitEmptyIndices) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   TablePtr table = store->fetch({"id", "name"}, std::vector<int>{});
   ASSERT_TRUE(table != nullptr);
   EXPECT_EQ(table->num_rows(), 0);
@@ -100,7 +100,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchWitEmptyIndices) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchWithMoreIndices) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   TablePtr table = store->fetch({"id"}, {0, 1, 2, 3, 6, 2, 1, 7});
   ASSERT_TRUE(table != nullptr);
   EXPECT_EQ(table->num_rows(), 8);
@@ -109,14 +109,14 @@ TEST_F(BufferPoolStoreTest, ParquetFetchWithMoreIndices) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchWithInvalidIndices) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   TablePtr table = store->fetch({"id"}, {0, 1, 30});
   ASSERT_TRUE(table == nullptr);
 }
 
 TEST_F(BufferPoolStoreTest, ParquetFetchCheckOrderWithLocalRowIDMiddle) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   TablePtr table =
       store->fetch({"id", "name", LOCAL_ROW_ID, "score"}, {0, 3, 6, 1, 0});
   ASSERT_TRUE(table != nullptr);
@@ -144,7 +144,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchCheckOrderWithLocalRowIDMiddle) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchCheckOrderWithLocalRowIDEnd) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   TablePtr table =
       store->fetch({"id", "name", "score", LOCAL_ROW_ID}, {0, 3, 6, 1, 0});
   ASSERT_TRUE(table != nullptr);
@@ -172,7 +172,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchCheckOrderWithLocalRowIDEnd) {
 
 TEST_F(BufferPoolStoreTest, ParquetScan) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   auto reader = store->scan({"id", "name", "score"});
   int batch_count = 0;
   int total_rows = 0;
@@ -194,7 +194,7 @@ TEST_F(BufferPoolStoreTest, ParquetScan) {
 
 TEST_F(BufferPoolStoreTest, ParquetScanWithSelectColumns) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   auto reader = store->scan({"id", "name"});
   int batch_count = 0;
   int total_rows = 0;
@@ -216,7 +216,7 @@ TEST_F(BufferPoolStoreTest, ParquetScanWithSelectColumns) {
 
 TEST_F(BufferPoolStoreTest, ParquetScanWithInvalidColumn) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   auto reader = store->scan({"id", "unknown_column"});
   ASSERT_TRUE(reader == nullptr);
 }
@@ -224,7 +224,7 @@ TEST_F(BufferPoolStoreTest, ParquetScanWithInvalidColumn) {
 
 TEST_F(BufferPoolStoreTest, ParquetScanWithUserID) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   auto reader = store->scan({USER_ID, "id", "name", "score"});
   int batch_count = 0;
   int total_rows = 0;
@@ -246,7 +246,7 @@ TEST_F(BufferPoolStoreTest, ParquetScanWithUserID) {
 
 TEST_F(BufferPoolStoreTest, ParquetScanWithGlobalDocID) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   auto reader = store->scan({GLOBAL_DOC_ID, "id", "name", "score"});
   int batch_count = 0;
   int total_rows = 0;
@@ -268,7 +268,7 @@ TEST_F(BufferPoolStoreTest, ParquetScanWithGlobalDocID) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchSingleRow) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   ExecBatchPtr batch = store->fetch({"id", "name", "score"}, 0);
   ASSERT_TRUE(batch != nullptr);
@@ -284,7 +284,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchSingleRow) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchSpecificRow) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   ExecBatchPtr batch = store->fetch({"id", "name", "score"}, 3);
   ASSERT_TRUE(batch != nullptr);
@@ -300,7 +300,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchSpecificRow) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithUserID) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   ExecBatchPtr batch = store->fetch({USER_ID, "id", "name"}, 1);
   ASSERT_TRUE(batch != nullptr);
@@ -315,7 +315,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithUserID) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithGlobalDocID) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   ExecBatchPtr batch = store->fetch({GLOBAL_DOC_ID, "id", "name"}, 4);
   ASSERT_TRUE(batch != nullptr);
@@ -330,7 +330,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithGlobalDocID) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithNegativeIndex) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   ExecBatchPtr batch = store->fetch({"id", "name"}, -1);
   EXPECT_EQ(batch, nullptr);
@@ -338,7 +338,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithNegativeIndex) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithOutOfRangeIndex) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   ExecBatchPtr batch = store->fetch({"id", "name"}, 15);
   EXPECT_EQ(batch, nullptr);
@@ -346,7 +346,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithOutOfRangeIndex) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithInvalidColumn) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   ExecBatchPtr batch = store->fetch({"id", "invalid_column"}, 0);
   EXPECT_EQ(batch, nullptr);
@@ -354,7 +354,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithInvalidColumn) {
 
 TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithEmptyColumns) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   ExecBatchPtr batch = store->fetch({}, 0);
   EXPECT_EQ(batch, nullptr);
@@ -362,7 +362,7 @@ TEST_F(BufferPoolStoreTest, ParquetFetchSingleRowWithEmptyColumns) {
 
 TEST_F(BufferPoolStoreTest, AllDataTypeFetchSingleRow) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   ExecBatchPtr batch = store->fetch({"id", "list_int32"}, 2);
   ASSERT_TRUE(batch != nullptr);
@@ -391,7 +391,7 @@ TEST_F(BufferPoolStoreTest, AllDataTypeFetchSingleRow) {
 
 TEST_F(BufferPoolStoreTest, AllDataType) {
   auto mmap_store = std::make_shared<BufferPoolForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
 
   std::vector<std::string> columns = {"id", "list_int32"};
   std::vector<int> indices = {0, 3, 6, 1, 0};
@@ -436,6 +436,6 @@ TEST_F(BufferPoolStoreTest, DeleteDestructs) {
 TEST_F(BufferPoolStoreTest, PhysicSchema) {
   auto store = std::make_shared<BufferPoolForwardStore>(parquet_path);
   ASSERT_NE(store, nullptr);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
   EXPECT_NE(store->physic_schema(), nullptr);
 }
diff --git a/tests/db/index/storage/mem_store_test.cc b/tests/db/index/storage/mem_store_test.cc
index d8ca52bc1..ee4d820e2 100644
--- a/tests/db/index/storage/mem_store_test.cc
+++ b/tests/db/index/storage/mem_store_test.cc
@@ -81,7 +81,7 @@ class MemStoreTest : public testing::Test {
     schema_ = GetCollectionSchema();
     store_ = std::make_shared<MemForwardStore>(schema_, "./scalar.block.0",
                                                FileFormat::IPC);
-    EXPECT_TRUE(store_->Open().ok());
+    EXPECT_TRUE(store_->open().ok());
   }
 
   void TearDown() override {
@@ -100,12 +100,12 @@ class MemStoreTest : public testing::Test {
 TEST_F(MemStoreTest, ConstructorTest) {
   auto schema = GetCollectionSchema();
   MemForwardStore store(schema, "./scalar.block.0", FileFormat::IPC);
-  EXPECT_TRUE(store.Open().ok());
+  EXPECT_TRUE(store.open().ok());
 }
 
 // Test open method
 TEST_F(MemStoreTest, OpenTest) {
-  EXPECT_TRUE(store_->Open().ok());
+  EXPECT_TRUE(store_->open().ok());
 }
 
 // Test insert method with valid data
@@ -136,7 +136,7 @@ TEST_F(MemStoreTest, InsertNullableData) {
                               "id", DataType::UINT64, true, nullptr)));
   MemForwardStore::Ptr store = std::make_shared<MemForwardStore>(
       schema, "./scalar.block.0", FileFormat::IPC);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   uint64_t doc_id = 0;
   Doc doc = CreateDoc(doc_id);
@@ -158,13 +158,13 @@ TEST_F(MemStoreTest, convertToBuilder) {
   uint64_t doc_id = 0;
   Doc doc = CreateDoc(doc_id);
   EXPECT_EQ(store_->insert(doc), Status::OK());
-  auto rb_builder = store_->createBuilder();
-  auto result = store_->convertToBuilder(rb_builder);
+  auto rb_builder = store_->create_builder();
+  auto result = store_->convert_to_builder(rb_builder);
   EXPECT_TRUE(result.ok());
   EXPECT_EQ(store_->num_rows(), 1);
 
   // re convert to builder
-  result = store_->convertToBuilder(rb_builder);
+  result = store_->convert_to_builder(rb_builder);
   EXPECT_TRUE(result.ok());
   EXPECT_EQ(store_->num_rows(), 1);
 }
@@ -177,7 +177,7 @@ TEST_F(MemStoreTest, convertToBuilderWithNullableData) {
                               "id", DataType::UINT64, true, nullptr)));
   MemForwardStore::Ptr store = std::make_shared<MemForwardStore>(
       schema, "./scalar.block.0", FileFormat::IPC);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   for (size_t i = 0; i < 10; i++) {
     uint64_t doc_id = 0;
@@ -188,8 +188,8 @@ TEST_F(MemStoreTest, convertToBuilderWithNullableData) {
     EXPECT_EQ(store->insert(doc), Status::OK());
   }
 
-  auto rb_builder = store_->createBuilder();
-  auto result = store_->convertToBuilder(rb_builder);
+  auto rb_builder = store_->create_builder();
+  auto result = store_->convert_to_builder(rb_builder);
   EXPECT_TRUE(result.ok());
 
   EXPECT_EQ(store->num_rows(), 10);
@@ -201,14 +201,14 @@ TEST_F(MemStoreTest, ConvertToRecordBatch) {
   Doc doc = CreateDoc(doc_id);
   EXPECT_EQ(store_->insert(doc), Status::OK());
 
-  auto result = store_->convertToRecordBatch();
+  auto result = store_->convert_to_record_batch();
   EXPECT_TRUE(result.ok());
   EXPECT_NE(result.ValueOrDie(), nullptr);
   auto rb = result.ValueOrDie();
   EXPECT_EQ(rb->num_rows(), 1);
 
   // re convert to record batch
-  result = store_->convertToRecordBatch();
+  result = store_->convert_to_record_batch();
   EXPECT_TRUE(result.ok());
   EXPECT_NE(result.ValueOrDie(), nullptr);
   rb = result.ValueOrDie();
@@ -223,7 +223,7 @@ TEST_F(MemStoreTest, ConvertToTable) {
 
   std::vector<std::string> columns = {};
 
-  auto result = store_->convertToTable(columns, {});
+  auto result = store_->convert_to_table(columns, {});
   EXPECT_TRUE(result.ok());
   EXPECT_NE(result.ValueOrDie(), nullptr);
   auto table = result.ValueOrDie();
@@ -231,7 +231,7 @@ TEST_F(MemStoreTest, ConvertToTable) {
   EXPECT_EQ(table->num_columns(), 2 + 4);
 
   // re convert to table
-  result = store_->convertToTable(columns, {});
+  result = store_->convert_to_table(columns, {});
   EXPECT_TRUE(result.ok());
   EXPECT_NE(result.ValueOrDie(), nullptr);
   table = result.ValueOrDie();
@@ -247,7 +247,7 @@ TEST_F(MemStoreTest, ConvertToTableWithColumnFiltering) {
 
   std::vector<std::string> columns = {"id", "name"};
 
-  auto result = store_->convertToTable(columns, {});
+  auto result = store_->convert_to_table(columns, {});
   EXPECT_TRUE(result.ok());
   EXPECT_NE(result.ValueOrDie(), nullptr);
   auto table = result.ValueOrDie();
@@ -255,7 +255,7 @@ TEST_F(MemStoreTest, ConvertToTableWithColumnFiltering) {
   EXPECT_EQ(table->num_columns(), 2);
 
   // re convert to table
-  result = store_->convertToTable(columns, {});
+  result = store_->convert_to_table(columns, {});
   EXPECT_TRUE(result.ok());
   EXPECT_NE(result.ValueOrDie(), nullptr);
   table = result.ValueOrDie();
@@ -275,7 +275,7 @@ TEST_F(MemStoreTest, ConvertToTableWithIndexFiltering) {
   std::vector<std::string> columns = {};
   std::vector<int> indices = {0, 2, 4};  // Select specific rows
 
-  auto result = store_->convertToTable(columns, indices);
+  auto result = store_->convert_to_table(columns, indices);
   EXPECT_TRUE(result.ok());
 
   auto table = result.ValueOrDie();
@@ -309,7 +309,7 @@ TEST_F(MemStoreTest, FetchWithMoreData) {
   auto schema = GetCollectionSchema();
   MemForwardStore::Ptr store = std::make_shared<MemForwardStore>(
       schema, "./scalar.block.0", FileFormat::IPC);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   for (size_t i = 0; i < 200; i++) {
     uint64_t doc_id = 0;
@@ -360,7 +360,7 @@ TEST_F(MemStoreTest, FetchOneFieldWithNullable) {
                               "id", DataType::UINT64, true, nullptr)));
   MemForwardStore::Ptr store = std::make_shared<MemForwardStore>(
       schema, "./scalar.block.0", FileFormat::IPC);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   for (size_t i = 0; i < 10; i++) {
     uint64_t doc_id = 0;
@@ -597,7 +597,7 @@ TEST_F(MemStoreTest, FetchSingleRowWithNullableData) {
                               "id", DataType::UINT64, true, nullptr)));
   MemForwardStore::Ptr store = std::make_shared<MemForwardStore>(
       schema, "./scalar.block.0", FileFormat::IPC);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   uint64_t doc_id = 0;
   Doc doc = CreateDoc(doc_id);
@@ -659,7 +659,7 @@ TEST_F(MemStoreTest, ScanWithMoreData) {
   auto schema = GetCollectionSchema();
   MemForwardStore::Ptr store = std::make_shared<MemForwardStore>(
       schema, "./scalar.block.0", FileFormat::IPC);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   for (size_t i = 0; i < 200; i++) {
     uint64_t doc_id = 0;
@@ -831,7 +831,7 @@ TEST_F(MemStoreTest, EmptySchema) {
   auto empty_store = std::make_unique<MemForwardStore>(
       empty_schema, "./scalar.block.0", FileFormat::IPC);
 
-  EXPECT_TRUE(empty_store->Open().ok());
+  EXPECT_TRUE(empty_store->open().ok());
 }
 
 arrow::Result<std::shared_ptr<arrow::Table>> ReadArrowIPCFile(
@@ -859,8 +859,8 @@ arrow::Result<std::shared_ptr<arrow::Table>> ReadArrowIPCFile(
 }
 
 TEST_F(MemStoreTest, Flush) {
-  size_t MAX_DOC = 10010;
-  for (size_t i = 0; i < MAX_DOC; i++) {
+  size_t max_doc = 10010;
+  for (size_t i = 0; i < max_doc; i++) {
     EXPECT_EQ(store_->insert(CreateDoc(i)), Status::OK());
   }
   EXPECT_EQ(store_->flush(), Status::OK());
@@ -871,7 +871,7 @@ TEST_F(MemStoreTest, Flush) {
       << "Failed to read Arrow IPC file: " << read_result.status().ToString();
 
   auto table = read_result.ValueOrDie();
-  EXPECT_EQ(table->num_rows(), MAX_DOC);
+  EXPECT_EQ(table->num_rows(), max_doc);
   EXPECT_EQ(table->num_columns(), 2 + 4);
 
   auto column_names = table->ColumnNames();
@@ -887,18 +887,18 @@ TEST_F(MemStoreTest, Flush) {
 
 
 TEST_F(MemStoreTest, ReFlush) {
-  size_t MAX_DOC = 10010;
-  for (size_t i = 0; i < MAX_DOC; i++) {
+  size_t max_doc = 10010;
+  for (size_t i = 0; i < max_doc; i++) {
     EXPECT_EQ(store_->insert(CreateDoc(i)), Status::OK());
   }
   EXPECT_EQ(store_->flush(), Status::OK());
 
-  for (size_t i = MAX_DOC; i < MAX_DOC + 10; i++) {
+  for (size_t i = max_doc; i < max_doc + 10; i++) {
     EXPECT_EQ(store_->insert(CreateDoc(i)), Status::OK());
   }
   EXPECT_EQ(store_->flush(), Status::OK());
 
-  for (size_t i = MAX_DOC + 10; i < MAX_DOC + 20; i++) {
+  for (size_t i = max_doc + 10; i < max_doc + 20; i++) {
     EXPECT_EQ(store_->insert(CreateDoc(i)), Status::OK());
   }
   EXPECT_EQ(store_->flush(), Status::OK());
@@ -910,7 +910,7 @@ TEST_F(MemStoreTest, ReFlush) {
       << "Failed to read Arrow IPC file: " << read_result.status().ToString();
 
   auto table = read_result.ValueOrDie();
-  EXPECT_EQ(table->num_rows(), MAX_DOC + 20);
+  EXPECT_EQ(table->num_rows(), max_doc + 20);
   EXPECT_EQ(table->num_columns(), 2 + 4);
 
   auto column_names = table->ColumnNames();
@@ -928,13 +928,13 @@ TEST_F(MemStoreTest, ReFlush) {
 TEST_F(MemStoreTest, MaxCacheBytesLimit) {
   uint32_t max_cache_rows = 105;
   uint32_t max_buffer_size = 260 * 100 * 100;
-  uint32_t max_cache_size_ = max_buffer_size / 100;
+  uint32_t max_cache_size = max_buffer_size / 100;
   std::vector<int> batch_num_rows;
 
   auto schema = GetCollectionSchema();
   MemForwardStore::Ptr store = std::make_shared<MemForwardStore>(
       schema, "./scalar.block.0", FileFormat::IPC, max_buffer_size);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   // Insert more documents than cache limit
   uint32_t cur_doc_total_bytes = 0;
@@ -944,7 +944,7 @@ TEST_F(MemStoreTest, MaxCacheBytesLimit) {
     EXPECT_EQ(store->insert(doc), Status::OK());
     cur_doc_total_bytes += doc.memory_usage();
     cur_batch_num_row++;
-    if (cur_doc_total_bytes >= max_cache_size_) {
+    if (cur_doc_total_bytes >= max_cache_size) {
       batch_num_rows.push_back(cur_batch_num_row);
       cur_doc_total_bytes = 0;
       cur_batch_num_row = 0;
@@ -985,7 +985,7 @@ TEST_F(MemStoreTest, AllDataType) {
 
   MemForwardStore::Ptr store = std::make_shared<MemForwardStore>(
       all_type_schema, "./scalar.block.0", FileFormat::IPC, 64 * 1024 * 1024);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   // Insert more documents than cache limit
   for (uint64_t i = 0; i < max_cache_rows; ++i) {
@@ -1050,7 +1050,7 @@ TEST_F(MemStoreTest, General) {
   auto collection_schema = GetCollectionSchema();
   MemForwardStore::Ptr store = std::make_shared<MemForwardStore>(
       collection_schema, "./scalar.block.0", FileFormat::IPC);
-  EXPECT_TRUE(store->Open().ok());
+  EXPECT_TRUE(store->open().ok());
 
   size_t MAX_DOC = 1000000;
 
@@ -1166,7 +1166,7 @@ TEST(MemStoreOpenTest, OpenReportsErrorWhenWriterCreationFails) {
   // ChunkedFileWriter::Open returns nullptr.
   auto store = std::make_shared<MemForwardStore>(
       schema, "/nonexistent_zvec_dir_xyz/scalar.block.0", FileFormat::IPC);
-  auto status = store->Open();
+  auto status = store->open();
   EXPECT_FALSE(status.ok());
   EXPECT_EQ(store->writer_, nullptr);
 }
diff --git a/tests/db/index/storage/mmap_store_test.cc b/tests/db/index/storage/mmap_store_test.cc
index e127dc431..f28aa63ae 100644
--- a/tests/db/index/storage/mmap_store_test.cc
+++ b/tests/db/index/storage/mmap_store_test.cc
@@ -50,9 +50,9 @@ arrow::Status WriteUnevenBatchIPC(const std::string &path) {
     std::shared_ptr<arrow::Array> ids;
     ARROW_RETURN_NOT_OK(builder.Finish(&ids));
     auto batch = arrow::RecordBatch::Make(schema, batch_size, {ids});
-    ARROW_RETURN_NOT_OK(writer->Write(*batch));
+    ARROW_RETURN_NOT_OK(writer->write(*batch));
   }
-  return writer->Close();
+  return writer->close();
 }
 
 }  // namespace
@@ -92,7 +92,7 @@ class MmapStoreTest : public testing::Test {
 
 TEST_F(MmapStoreTest, GeneralIPC) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   TablePtr ipc_table =
       ipc_store->fetch({"id", "name", "score"}, {0, 3, 6, 1, 0});
   ASSERT_TRUE(ipc_table != nullptr);
@@ -115,7 +115,7 @@ TEST_F(MmapStoreTest, GeneralIPC) {
 
 TEST_F(MmapStoreTest, IPCFetchWithLocalRowID) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   TablePtr ipc_table =
       ipc_store->fetch({LOCAL_ROW_ID, "id", "name", "score"}, {0, 3, 6, 1, 0});
   ASSERT_TRUE(ipc_table != nullptr);
@@ -125,7 +125,7 @@ TEST_F(MmapStoreTest, IPCFetchWithLocalRowID) {
 
 TEST_F(MmapStoreTest, IPCCheckOrderWithLocalRowIDMiddle) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   TablePtr mmap_table =
       ipc_store->fetch({"id", "name", LOCAL_ROW_ID, "score"}, {0, 3, 6, 1, 0});
   ASSERT_TRUE(mmap_table != nullptr);
@@ -152,7 +152,7 @@ TEST_F(MmapStoreTest, IPCCheckOrderWithLocalRowIDMiddle) {
 
 TEST_F(MmapStoreTest, IPCCheckOrderWithLocalRowIDEnd) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   TablePtr mmap_table =
       ipc_store->fetch({"id", "name", "score", LOCAL_ROW_ID}, {0, 3, 6, 1, 0});
   ASSERT_TRUE(mmap_table != nullptr);
@@ -180,7 +180,7 @@ TEST_F(MmapStoreTest, IPCCheckOrderWithLocalRowIDEnd) {
 
 TEST_F(MmapStoreTest, IPCFetchWithUID) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   TablePtr ipc_table =
       ipc_store->fetch({USER_ID, "id", "name", "score"}, {0, 3, 6, 1, 0});
   ASSERT_TRUE(ipc_table != nullptr);
@@ -190,7 +190,7 @@ TEST_F(MmapStoreTest, IPCFetchWithUID) {
 
 TEST_F(MmapStoreTest, IPCFetchWithGlobalDocID) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   TablePtr ipc_table =
       ipc_store->fetch({GLOBAL_DOC_ID, "id", "name", "score"}, {0, 3, 6, 1, 0});
   ASSERT_TRUE(ipc_table != nullptr);
@@ -200,14 +200,14 @@ TEST_F(MmapStoreTest, IPCFetchWithGlobalDocID) {
 
 TEST_F(MmapStoreTest, IPCFetchWithEmptyColumns) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   TablePtr ipc_table = ipc_store->fetch({}, std::vector<int>{});
   EXPECT_EQ(ipc_table, nullptr);
 }
 
 TEST_F(MmapStoreTest, IPCFetchWithInvalidColumns) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   TablePtr ipc_table =
       ipc_store->fetch({"id", "unknown_column"}, std::vector<int>{});
   EXPECT_EQ(ipc_table, nullptr);
@@ -215,7 +215,7 @@ TEST_F(MmapStoreTest, IPCFetchWithInvalidColumns) {
 
 TEST_F(MmapStoreTest, IPCFetchWithEmptyIndices) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   TablePtr ipc_table =
       ipc_store->fetch({"id", "name", "score"}, std::vector<int>{});
   ASSERT_TRUE(ipc_table != nullptr);
@@ -225,7 +225,7 @@ TEST_F(MmapStoreTest, IPCFetchWithEmptyIndices) {
 
 TEST_F(MmapStoreTest, IPCFetchWithInvalidIndices) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   TablePtr ipc_table =
       ipc_store->fetch({"id"}, std::vector<int>{-1});  // Negative index
   EXPECT_EQ(ipc_table, nullptr);
@@ -237,14 +237,14 @@ TEST_F(MmapStoreTest, IPCFetchWithInvalidIndices) {
 
 TEST_F(MmapStoreTest, IPCFetchWithEmptyColumnsValidIndices) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   TablePtr ipc_table = ipc_store->fetch({}, {0, 1});
   EXPECT_EQ(ipc_table, nullptr);
 }
 
 TEST_F(MmapStoreTest, IPCScan) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   auto table_reader = ipc_store->scan({"id", "name", "score"});
   ASSERT_TRUE(table_reader != nullptr);
   EXPECT_NE(table_reader->schema(), nullptr);
@@ -268,7 +268,7 @@ TEST_F(MmapStoreTest, IPCScan) {
 
 TEST_F(MmapStoreTest, IPCScanWithSelectColumns) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   auto table_reader = ipc_store->scan({"id", "name"});
   int batch_count = 0;
   int total_rows = 0;
@@ -290,14 +290,14 @@ TEST_F(MmapStoreTest, IPCScanWithSelectColumns) {
 
 TEST_F(MmapStoreTest, IPCScanWithInvalidColumn) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   auto table_reader = ipc_store->scan({"id", "unknown_column"});
   ASSERT_TRUE(table_reader == nullptr);
 }
 
 TEST_F(MmapStoreTest, IPCScanWithUserID) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   auto table_reader = ipc_store->scan({USER_ID, "id", "name", "score"});
   int batch_count = 0;
   int total_rows = 0;
@@ -319,7 +319,7 @@ TEST_F(MmapStoreTest, IPCScanWithUserID) {
 
 TEST_F(MmapStoreTest, IPCScanWithGlobalDocID) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   auto table_reader = ipc_store->scan({GLOBAL_DOC_ID, "id", "name", "score"});
   int batch_count = 0;
   int total_rows = 0;
@@ -342,7 +342,7 @@ TEST_F(MmapStoreTest, IPCScanWithGlobalDocID) {
 
 TEST_F(MmapStoreTest, GeneralParquet) {
   auto mmap_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
   TablePtr mmap_table = mmap_store->fetch({"id", "name", "score"}, {0, 1, 2});
   ASSERT_TRUE(mmap_table != nullptr);
   EXPECT_EQ(mmap_table->num_rows(), 3);
@@ -351,14 +351,14 @@ TEST_F(MmapStoreTest, GeneralParquet) {
 
 TEST_F(MmapStoreTest, ParquetFetchWitEmptyColumns) {
   auto mmap_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
   TablePtr mmap_table = mmap_store->fetch({}, std::vector<int>{});
   EXPECT_EQ(mmap_table, nullptr);
 }
 
 TEST_F(MmapStoreTest, ParquetFetchWithInvalidIndices) {
   auto parquet_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(parquet_store->Open().ok());
+  ASSERT_TRUE(parquet_store->open().ok());
   TablePtr parquet_table =
       parquet_store->fetch({"id"}, std::vector<int>{-1});  // Negative index
   EXPECT_EQ(parquet_table, nullptr);
@@ -370,7 +370,7 @@ TEST_F(MmapStoreTest, ParquetFetchWithInvalidIndices) {
 
 TEST_F(MmapStoreTest, ParquetCheckOrder) {
   auto mmap_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
   TablePtr mmap_table =
       mmap_store->fetch({"id", "name", "score"}, {0, 3, 6, 1, 0});
   ASSERT_TRUE(mmap_table != nullptr);
@@ -396,7 +396,7 @@ TEST_F(MmapStoreTest, ParquetCheckOrder) {
 
 TEST_F(MmapStoreTest, ParquetCheckOrderWithLocalRowIDMiddle) {
   auto mmap_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
   TablePtr mmap_table =
       mmap_store->fetch({"id", "name", LOCAL_ROW_ID, "score"}, {0, 3, 6, 1, 0});
   ASSERT_TRUE(mmap_table != nullptr);
@@ -423,7 +423,7 @@ TEST_F(MmapStoreTest, ParquetCheckOrderWithLocalRowIDMiddle) {
 
 TEST_F(MmapStoreTest, ParquetCheckOrderWithLocalRowIDEnd) {
   auto mmap_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
   TablePtr mmap_table =
       mmap_store->fetch({"id", "name", "score", LOCAL_ROW_ID}, {0, 3, 6, 1, 0});
   ASSERT_TRUE(mmap_table != nullptr);
@@ -450,7 +450,7 @@ TEST_F(MmapStoreTest, ParquetCheckOrderWithLocalRowIDEnd) {
 
 TEST_F(MmapStoreTest, ParquetScan) {
   auto mmap_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
   auto table_reader = mmap_store->scan({"id", "name", "score"});
   ASSERT_TRUE(table_reader != nullptr);
   EXPECT_NE(table_reader->schema(), nullptr);
@@ -474,14 +474,14 @@ TEST_F(MmapStoreTest, ParquetScan) {
 
 TEST_F(MmapStoreTest, ParquetScanWithInvalidColumn) {
   auto mmap_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
   auto table_reader = mmap_store->scan({"id", "unknown_column"});
   ASSERT_TRUE(table_reader == nullptr);
 }
 
 TEST_F(MmapStoreTest, ParquetScanWithUserID) {
   auto mmap_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
   auto table_reader = mmap_store->scan({USER_ID, "id", "name", "score"});
   int batch_count = 0;
   int total_rows = 0;
@@ -503,7 +503,7 @@ TEST_F(MmapStoreTest, ParquetScanWithUserID) {
 
 TEST_F(MmapStoreTest, ParquetScanWithGlobalDocID) {
   auto mmap_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
   auto table_reader = mmap_store->scan({GLOBAL_DOC_ID, "id", "name", "score"});
   int batch_count = 0;
   int total_rows = 0;
@@ -525,7 +525,7 @@ TEST_F(MmapStoreTest, ParquetScanWithGlobalDocID) {
 
 TEST_F(MmapStoreTest, IPCFetchSingleRow) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
 
   auto func = [&](int index) -> void {
     ExecBatchPtr ipc_batch = ipc_store->fetch({"id", "name", "score"}, index);
@@ -549,7 +549,7 @@ TEST_F(MmapStoreTest, IPCFetchSingleRow) {
 TEST_F(MmapStoreTest, IPCFetchFromLargerLastChunk) {
   ASSERT_TRUE(WriteUnevenBatchIPC(uneven_ipc_path).ok());
   auto ipc_store = std::make_shared<MmapForwardStore>(uneven_ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
 
   auto result = ipc_store->fetch({"id"}, std::vector<int>{6});
   ASSERT_NE(result, nullptr);
@@ -562,7 +562,7 @@ TEST_F(MmapStoreTest, IPCFetchFromLargerLastChunk) {
 
 TEST_F(MmapStoreTest, ParquetFetchSingleRow) {
   auto parquet_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(parquet_store->Open().ok());
+  ASSERT_TRUE(parquet_store->open().ok());
 
   auto func = [&](int index) -> void {
     ExecBatchPtr parquet_batch =
@@ -586,7 +586,7 @@ TEST_F(MmapStoreTest, ParquetFetchSingleRow) {
 
 TEST_F(MmapStoreTest, IPCFetchSingleRowWithInvalidIndex) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
 
   ExecBatchPtr ipc_batch = ipc_store->fetch({"id", "name"}, -1);
   EXPECT_EQ(ipc_batch, nullptr);
@@ -597,7 +597,7 @@ TEST_F(MmapStoreTest, IPCFetchSingleRowWithInvalidIndex) {
 
 TEST_F(MmapStoreTest, IPCFetchSingleRowWithInvalidColumn) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
 
   ExecBatchPtr ipc_batch = ipc_store->fetch({"id", "invalid_column"}, 0);
   EXPECT_EQ(ipc_batch, nullptr);
@@ -605,7 +605,7 @@ TEST_F(MmapStoreTest, IPCFetchSingleRowWithInvalidColumn) {
 
 TEST_F(MmapStoreTest, IPCFetchSingleRowWithEmptyColumns) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
 
   ExecBatchPtr ipc_batch = ipc_store->fetch({}, 0);
   EXPECT_EQ(ipc_batch, nullptr);
@@ -613,7 +613,7 @@ TEST_F(MmapStoreTest, IPCFetchSingleRowWithEmptyColumns) {
 
 TEST_F(MmapStoreTest, ParquetFetchSingleRowWithInvalidIndex) {
   auto parquet_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(parquet_store->Open().ok());
+  ASSERT_TRUE(parquet_store->open().ok());
 
   ExecBatchPtr parquet_batch = parquet_store->fetch({"id", "name"}, -1);
   EXPECT_EQ(parquet_batch, nullptr);
@@ -624,7 +624,7 @@ TEST_F(MmapStoreTest, ParquetFetchSingleRowWithInvalidIndex) {
 
 TEST_F(MmapStoreTest, AllDataType) {
   auto mmap_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
 
   std::vector<std::string> columns = {"id", "list_int32"};
   std::vector<int> indices = {0, 3, 6, 1, 0};
@@ -663,26 +663,26 @@ TEST_F(MmapStoreTest, AllDataType) {
 
 TEST_F(MmapStoreTest, FindRowGroupForRow) {
   auto mmap_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
 
-  EXPECT_EQ(mmap_store->FindRowGroupForRow(0), 0);
-  EXPECT_EQ(mmap_store->FindRowGroupForRow(1), 0);
-  EXPECT_EQ(mmap_store->FindRowGroupForRow(2), 0);
-  EXPECT_EQ(mmap_store->FindRowGroupForRow(3), 1);
-  EXPECT_EQ(mmap_store->FindRowGroupForRow(6), 2);
-  EXPECT_EQ(mmap_store->FindRowGroupForRow(9), 3);
+  EXPECT_EQ(mmap_store->find_row_group_for_row(0), 0);
+  EXPECT_EQ(mmap_store->find_row_group_for_row(1), 0);
+  EXPECT_EQ(mmap_store->find_row_group_for_row(2), 0);
+  EXPECT_EQ(mmap_store->find_row_group_for_row(3), 1);
+  EXPECT_EQ(mmap_store->find_row_group_for_row(6), 2);
+  EXPECT_EQ(mmap_store->find_row_group_for_row(9), 3);
 
-  EXPECT_EQ(mmap_store->FindRowGroupForRow(100), 3);
+  EXPECT_EQ(mmap_store->find_row_group_for_row(100), 3);
 }
 
 TEST_F(MmapStoreTest, GetRowGroupOffset) {
   auto mmap_store = std::make_shared<MmapForwardStore>(parquet_path);
-  ASSERT_TRUE(mmap_store->Open().ok());
+  ASSERT_TRUE(mmap_store->open().ok());
 
-  EXPECT_EQ(mmap_store->GetRowGroupOffset(0), 0);
-  EXPECT_EQ(mmap_store->GetRowGroupOffset(1), 3);
-  EXPECT_EQ(mmap_store->GetRowGroupOffset(2), 6);
-  EXPECT_EQ(mmap_store->GetRowGroupOffset(3), 9);
+  EXPECT_EQ(mmap_store->get_row_group_offset(0), 0);
+  EXPECT_EQ(mmap_store->get_row_group_offset(1), 3);
+  EXPECT_EQ(mmap_store->get_row_group_offset(2), 6);
+  EXPECT_EQ(mmap_store->get_row_group_offset(3), 9);
 }
 
 TEST_F(MmapStoreTest, InvalidPath) {
@@ -694,7 +694,7 @@ TEST_F(MmapStoreTest, InvalidPath) {
   };
   for (const auto &path : err_path) {
     auto ipc_store = std::make_shared<MmapForwardStore>(path);
-    ASSERT_FALSE(ipc_store->Open().ok());
+    ASSERT_FALSE(ipc_store->open().ok());
   }
 }
 
@@ -705,7 +705,7 @@ TEST_F(MmapStoreTest, InvalidFileFormat) {
 
 TEST_F(MmapStoreTest, ValidateEmptyColumns) {
   auto ipc_store = std::make_shared<MmapForwardStore>(ipc_path);
-  ASSERT_TRUE(ipc_store->Open().ok());
+  ASSERT_TRUE(ipc_store->open().ok());
   EXPECT_FALSE(ipc_store->validate({}));
 }
 
diff --git a/tests/db/index/storage/wal_file_test.cc b/tests/db/index/storage/wal_file_test.cc
index 50cd122da..271d89a28 100644
--- a/tests/db/index/storage/wal_file_test.cc
+++ b/tests/db/index/storage/wal_file_test.cc
@@ -289,13 +289,13 @@ TEST_F(WalFileTest, TestBoundaryCondition) {
 
 
   // write very large record 4Mb
-  size_t BIG_DATA_SIZE = 4 * 1024 * 1024;
-  std::vector<uint8_t> big_data(BIG_DATA_SIZE);
-  for (size_t i = 0; i < BIG_DATA_SIZE; i++) {
+  size_t big_data_size = 4 * 1024 * 1024;
+  std::vector<uint8_t> big_data(big_data_size);
+  for (size_t i = 0; i < big_data_size; i++) {
     big_data[i] = i % 256;
   }
   str.clear();
-  str.assign((const char *)big_data.data(), BIG_DATA_SIZE);
+  str.assign((const char *)big_data.data(), big_data_size);
   wal_option.create_new = true;
   ret = wal_file->open(wal_option);
   ASSERT_EQ(ret, 0);
@@ -314,8 +314,8 @@ TEST_F(WalFileTest, TestBoundaryCondition) {
   ASSERT_EQ(ret, 0);
   record = wal_file->next();
   while (!record.empty()) {
-    ASSERT_EQ(record.size(), BIG_DATA_SIZE);
-    for (size_t i = 0; i < BIG_DATA_SIZE; i++) {
+    ASSERT_EQ(record.size(), big_data_size);
+    for (size_t i = 0; i < big_data_size; i++) {
       ASSERT_EQ((uint8_t)record[i], i % 256);
     }
     record = wal_file->next();
diff --git a/tests/db/index/utils/utils.cc b/tests/db/index/utils/utils.cc
index 95c8da06e..7e8b98c00 100644
--- a/tests/db/index/utils/utils.cc
+++ b/tests/db/index/utils/utils.cc
@@ -428,10 +428,10 @@ Status TestHelper::SegmentInsertDoc(const Segment::Ptr &segment,
 
       Status s;
       if (upsert) {
-        s = segment->Upsert(new_doc);
+        s = segment->upsert(new_doc);
         CHECK_RETURN_STATUS(s);
       } else {
-        s = segment->Insert(new_doc);
+        s = segment->insert(new_doc);
         CHECK_RETURN_STATUS(s);
       }
     }
diff --git a/tests/db/sqlengine/fts_multi_segment_test.cc b/tests/db/sqlengine/fts_multi_segment_test.cc
index f405ec65e..c8932c758 100644
--- a/tests/db/sqlengine/fts_multi_segment_test.cc
+++ b/tests/db/sqlengine/fts_multi_segment_test.cc
@@ -171,7 +171,7 @@ class FtsMultiSegmentTest : public ::testing::Test {
       doc.set_pk(pk_prefix + std::to_string(i));
       doc.set_doc_id(i);
       doc.set<std::string>("content", entries[i].content);
-      auto status = segment->Insert(doc);
+      auto status = segment->insert(doc);
       ASSERT_TRUE(status.ok())
           << pk_prefix << i << " insert failed: " << status.c_str();
     }
diff --git a/tests/db/sqlengine/fts_recall_test.cc b/tests/db/sqlengine/fts_recall_test.cc
index 5b665234a..2dca6da73 100644
--- a/tests/db/sqlengine/fts_recall_test.cc
+++ b/tests/db/sqlengine/fts_recall_test.cc
@@ -200,7 +200,7 @@ class FtsRecallTest : public ::testing::Test {
       doc.set_doc_id(i);
       doc.set<std::string>("content", entries[i].content);
       doc.set<int32_t>("tag", entries[i].tag);
-      auto status = segment->Insert(doc);
+      auto status = segment->insert(doc);
       ASSERT_TRUE(status.ok())
           << "Insert doc " << i << " failed: " << status.c_str();
     }
@@ -702,7 +702,7 @@ class FtsRecallDeleteTest : public ::testing::Test {
       doc.set_doc_id(i);
       doc.set<std::string>("content", entries[i].content);
       doc.set<int32_t>("tag", entries[i].tag);
-      auto status = segment_->Insert(doc);
+      auto status = segment_->insert(doc);
       ASSERT_TRUE(status.ok())
           << "Insert doc " << i << " failed: " << status.c_str();
     }
@@ -776,7 +776,7 @@ TEST_F(FtsRecallDeleteTest, UpsertUpdatesSearchableContent) {
   updated.set_pk("pk_0");
   updated.set<std::string>("content", "mango pineapple watermelon");
   updated.set<int32_t>("tag", 1);
-  auto s = segment_->Upsert(updated);
+  auto s = segment_->upsert(updated);
   ASSERT_TRUE(s.ok()) << s.c_str();
 
   // "apple" should now only match doc 3
diff --git a/tests/db/sqlengine/mock_segment.h b/tests/db/sqlengine/mock_segment.h
index c5afacb55..a8fa1e0dc 100644
--- a/tests/db/sqlengine/mock_segment.h
+++ b/tests/db/sqlengine/mock_segment.h
@@ -85,7 +85,7 @@ class MockIndexResult : public InvertedSearchResult {
 class MockVectorIndexer : public CombinedVectorColumnIndexer {
  public:
   //! Search results with query
-  Result<IndexResults::Ptr> Search(
+  Result<IndexResults::Ptr> search(
       const vector_column_params::VectorData &vector_data,
       const vector_column_params::QueryParams &query_params) override {
     // return tl::make_unexpected(Status::InternalError("err"));
@@ -98,7 +98,7 @@ class MockVectorIndexer : public CombinedVectorColumnIndexer {
                                  "group_2", "group_0"});
   }
 
-  Result<vector_column_params::VectorDataBuffer> Fetch(
+  Result<vector_column_params::VectorDataBuffer> fetch(
       uint32_t doc_id) const override {
     // float f = doc_id;
     // std::vector<float> v(4, f);
@@ -494,15 +494,15 @@ class MockSegment : public Segment {
     return Status::OK();
   }
 
-  Status Insert(Doc &doc) override {
+  Status insert(Doc &doc) override {
     return Status::OK();
   }
 
-  Status Upsert(Doc &doc) override {
+  Status upsert(Doc &doc) override {
     return Status::OK();
   }
 
-  Status Update(Doc &doc) override {
+  Status update(Doc &doc) override {
     return Status::OK();
   }
 
@@ -514,7 +514,7 @@ class MockSegment : public Segment {
     return Status::OK();
   }
 
-  Doc::Ptr Fetch(uint64_t doc_id,
+  Doc::Ptr fetch(uint64_t doc_id,
                  const std::optional<std::vector<std::string>> &output_fields =
                      std::nullopt,
                  bool include_vector = true) override {
diff --git a/tests/db/sqlengine/optimizer_test.cc b/tests/db/sqlengine/optimizer_test.cc
index bc0df7278..d3f8e71c4 100644
--- a/tests/db/sqlengine/optimizer_test.cc
+++ b/tests/db/sqlengine/optimizer_test.cc
@@ -62,8 +62,8 @@ class OptimizerTest : public testing::Test {
   // Sets up the test fixture.
   static void SetUpTestSuite() {
     schema = std::make_shared<CollectionSchema>();
-    auto &collection_schema_ = *schema;
-    collection_schema_.set_name("collection");
+    auto &collection_schema = *schema;
+    collection_schema.set_name("collection");
 
     // feature field
     auto column1 = std::make_shared<FieldSchema>();
@@ -72,14 +72,14 @@ class OptimizerTest : public testing::Test {
     column1->set_index_params(vector_params);
     column1->set_dimension(4);
     column1->set_data_type(DataType::VECTOR_FP32);
-    collection_schema_.add_field(column1);
+    collection_schema.add_field(column1);
 
     // invert field
     auto column2 = std::make_shared<FieldSchema>();
     column2->set_name("age");
     column2->set_data_type(DataType::INT32);
     column2->set_index_params(std::make_shared<InvertIndexParams>(false));
-    collection_schema_.add_field(column2);
+    collection_schema.add_field(column2);
   }
 
   // Tears down the test fixture.
diff --git a/tests/db/sqlengine/perf_bench_test.cc b/tests/db/sqlengine/perf_bench_test.cc
index 83d0e4db7..0eaf17e19 100644
--- a/tests/db/sqlengine/perf_bench_test.cc
+++ b/tests/db/sqlengine/perf_bench_test.cc
@@ -156,8 +156,8 @@ class ScalarPerfBench : public RecallTest {
 
   // Builds a filter-only SearchQuery (no vector target) and returns a
   // runnable closure for RunBench.
-  std::function<Result<DocPtrList>()> FilterQuery(const std::string &filter,
-                                                  int topk = 2000) const {
+  std::function<Result<DocPtrList>()> filter_query(const std::string &filter,
+                                                   int topk = 2000) const {
     return [filter, topk]() -> Result<DocPtrList> {
       SearchQuery query;
       query.filter_ = filter;
@@ -180,55 +180,55 @@ class ScalarPerfBench : public RecallTest {
 TEST_F(ScalarPerfBench, ForwardFilterLowSelectivity) {
   PERF_SKIP();
   // age = doc_id % 100, so age < 5 matches 5% of the docs.
-  RunBench("forward_filter_age_lt_5", FilterQuery("age < 5"));
+  RunBench("forward_filter_age_lt_5", filter_query("age < 5"));
 }
 
 TEST_F(ScalarPerfBench, ForwardFilterHalfSelectivity) {
   PERF_SKIP();
-  RunBench("forward_filter_age_lt_50", FilterQuery("age < 50"));
+  RunBench("forward_filter_age_lt_50", filter_query("age < 50"));
 }
 
 TEST_F(ScalarPerfBench, ForwardFilterRange) {
   PERF_SKIP();
-  RunBench("forward_filter_age_range", FilterQuery("age >= 25 and age <= 75"));
+  RunBench("forward_filter_age_range", filter_query("age >= 25 and age <= 75"));
 }
 
 TEST_F(ScalarPerfBench, ForwardFilterString) {
   PERF_SKIP();
   // name = "user_" + doc_id % 100: full-scan string comparison.
-  RunBench("forward_filter_name_eq", FilterQuery("name = 'user_5'"));
+  RunBench("forward_filter_name_eq", filter_query("name = 'user_5'"));
 }
 
 TEST_F(ScalarPerfBench, ForwardFilterDouble) {
   PERF_SKIP();
-  RunBench("forward_filter_score_gt", FilterQuery("score > 50.0"));
+  RunBench("forward_filter_score_gt", filter_query("score > 50.0"));
 }
 
 TEST_F(ScalarPerfBench, InvertTerm) {
   PERF_SKIP();
-  RunBench("invert_term_age_eq_5", FilterQuery("invert_age = 5"));
+  RunBench("invert_term_age_eq_5", filter_query("invert_age = 5"));
 }
 
 TEST_F(ScalarPerfBench, InvertRange) {
   PERF_SKIP();
-  RunBench("invert_range_age_lt_10", FilterQuery("invert_age < 10"));
+  RunBench("invert_range_age_lt_10", filter_query("invert_age < 10"));
 }
 
 TEST_F(ScalarPerfBench, InvertStringTerm) {
   PERF_SKIP();
-  RunBench("invert_term_name_eq", FilterQuery("invert_name = 'user_5'"));
+  RunBench("invert_term_name_eq", filter_query("invert_name = 'user_5'"));
 }
 
 TEST_F(ScalarPerfBench, InvertWideRange) {
   PERF_SKIP();
   const std::string filter = "invert_id >= " + std::to_string(DocCount() / 2);
-  RunBench("invert_range_id_half", FilterQuery(filter));
+  RunBench("invert_range_id_half", filter_query(filter));
 }
 
 TEST_F(ScalarPerfBench, InvertBooleanOr) {
   PERF_SKIP();
   RunBench("invert_or_two_terms",
-           FilterQuery("invert_age = 5 or invert_age = 6"));
+           filter_query("invert_age = 5 or invert_age = 6"));
 }
 
 // Sanity-checks the hit counts that the benchmarks above rely on.
@@ -243,14 +243,14 @@ TEST_F(ScalarPerfBench, ExpectedHitCounts) {
     return count;
   };
 
-  auto result = FilterQuery("age < 5")();
+  auto result = filter_query("age < 5")();
   ASSERT_TRUE(result.has_value());
   const int64_t expected =
       count_ids_where([](uint64_t id) { return id % 100 < 5; });
   EXPECT_EQ(static_cast<int64_t>(result.value().size()),
             std::min<int64_t>(expected, 2000));
 
-  result = FilterQuery("invert_age = 5")();
+  result = filter_query("invert_age = 5")();
   ASSERT_TRUE(result.has_value());
   EXPECT_EQ(static_cast<int64_t>(result.value().size()),
             std::min<int64_t>(n / 100, 2000));
@@ -295,7 +295,7 @@ class FtsPerfBench : public ::testing::Test {
     FileHelper::RemoveDirectory(seg_path_);
   }
 
-  std::function<Result<DocPtrList>()> FtsMatch(
+  std::function<Result<DocPtrList>()> fts_match(
       const std::string &match_string, const std::string &default_op = "",
       const std::string &filter = "", int topk = 100) const {
     return [match_string, default_op, filter, topk]() -> Result<DocPtrList> {
@@ -396,7 +396,7 @@ class FtsPerfBench : public ::testing::Test {
       doc.set_doc_id(static_cast<uint64_t>(doc_id));
       doc.set<std::string>("content", content);
       doc.set<int32_t>("tag", static_cast<int32_t>(doc_id % 2));
-      auto status = segment->Insert(doc);
+      auto status = segment->insert(doc);
       if (!status.ok()) {
         std::printf("[PERF] fts insert failed at doc %lld: %s\n",
                     static_cast<long long>(doc_id), status.c_str());
@@ -414,35 +414,35 @@ class FtsPerfBench : public ::testing::Test {
 
 TEST_F(FtsPerfBench, RareTerm) {
   PERF_SKIP();
-  RunBench("fts_match_rare_0.1pct", FtsMatch("rareword"));
+  RunBench("fts_match_rare_0.1pct", fts_match("rareword"));
 }
 
 TEST_F(FtsPerfBench, MediumTerm) {
   PERF_SKIP();
-  RunBench("fts_match_medium_1pct", FtsMatch("mediumword"));
+  RunBench("fts_match_medium_1pct", fts_match("mediumword"));
 }
 
 TEST_F(FtsPerfBench, CommonTerm) {
   PERF_SKIP();
-  RunBench("fts_match_common_3pct", FtsMatch("w5"));
+  RunBench("fts_match_common_3pct", fts_match("w5"));
 }
 
 TEST_F(FtsPerfBench, MultiTermOr) {
   PERF_SKIP();
-  RunBench("fts_match_3term_or", FtsMatch("w1 w2 w3"));
+  RunBench("fts_match_3term_or", fts_match("w1 w2 w3"));
 }
 
 TEST_F(FtsPerfBench, MultiTermAnd) {
   PERF_SKIP();
   // Adjacent generated tokens differ by 31 (mod 256), so w1+w32 co-occur.
-  RunBench("fts_match_2term_and", FtsMatch("w1 w32", "AND"));
+  RunBench("fts_match_2term_and", fts_match("w1 w32", "AND"));
 }
 
 TEST_F(FtsPerfBench, MatchWithInvertedFilter) {
   PERF_SKIP();
   // mediumword only appears in docs whose id % 100 == 0, all of which have
   // tag = 0, so filter on tag = 0 keeps every match.
-  RunBench("fts_match_plus_filter", FtsMatch("mediumword", "", "tag = 0"));
+  RunBench("fts_match_plus_filter", fts_match("mediumword", "", "tag = 0"));
 }
 
 }  // namespace zvec::sqlengine
diff --git a/tests/db/sqlengine/recall_base.h b/tests/db/sqlengine/recall_base.h
index f5ea74ec0..d0dfa466d 100644
--- a/tests/db/sqlengine/recall_base.h
+++ b/tests/db/sqlengine/recall_base.h
@@ -167,7 +167,7 @@ inline Status InsertDoc(const Segment::Ptr &segment,
       create_total += create_cost;
 
       start = std::chrono::system_clock::now();
-      auto status = segment->Insert(new_doc);
+      auto status = segment->insert(new_doc);
       if (!status.ok()) {
         return status;
       }
diff --git a/tests/db/sqlengine/test_helper.h b/tests/db/sqlengine/test_helper.h
index 08582eafb..457248453 100644
--- a/tests/db/sqlengine/test_helper.h
+++ b/tests/db/sqlengine/test_helper.h
@@ -51,7 +51,7 @@ inline Status InsertDoc(const Segment::Ptr &segment,
       create_total += create_cost;
 
       start = std::chrono::system_clock::now();
-      auto status = segment->Insert(new_doc);
+      auto status = segment->insert(new_doc);
       if (!status.ok()) {
         return status;
       }
diff --git a/thirdparty/arrow/CMakeLists.txt b/thirdparty/arrow/CMakeLists.txt
index e497cc024..fecd78017 100644
--- a/thirdparty/arrow/CMakeLists.txt
+++ b/thirdparty/arrow/CMakeLists.txt
@@ -185,6 +185,9 @@ else ()
             LOG_CONFIGURE ON
             LOG_BUILD ON
             LOG_INSTALL ON
+            # Surface nested configure/build errors in CI instead of only
+            # pointing to log files on the temporary runner.
+            LOG_OUTPUT_ON_FAILURE ON
     )
 endif()
 
diff --git a/tools/core/bench.cc b/tools/core/bench.cc
index 1d10a6d31..bc990b3c8 100644
--- a/tools/core/bench.cc
+++ b/tools/core/bench.cc
@@ -50,10 +50,10 @@ class Bench {
   }
 
   static void stop(int signo) {
-    if (STOP_NOW) {
+    if (stop_now) {
       exit(signo);
     }
-    STOP_NOW = true;
+    stop_now = true;
     cout << "\rTrying to stop. press [Ctrl+C] again kill immediately." << endl
          << flush;
   }
@@ -160,13 +160,13 @@ class Bench {
     bench_result_.mark_start();
     auto start_time = Monotime::MilliSeconds();
     for (size_t i = 0; i < threads_; ++i) {
-      pool_->execute(this, &Bench<T>::start_bench, index, max_iter, &STOP_NOW);
+      pool_->execute(this, &Bench<T>::start_bench, index, max_iter, &stop_now);
     }
 
     while (!pool_->is_finished()) {
       this_thread::sleep_for(chrono::milliseconds(1));
       if (Monotime::MilliSeconds() - start_time > bench_secs_ * 1000) {
-        STOP_NOW = true;
+        stop_now = true;
       }
     }
 
@@ -207,10 +207,10 @@ class Bench {
           return;
         }
 
-        auto filterFunc = [&](uint64_t key) { return filter_cache.find(key); };
+        auto filter_func = [&](uint64_t key) { return filter_cache.find(key); };
 
         filter_ptr = std::make_shared<IndexFilter>();
-        filter_ptr->set(filterFunc);
+        filter_ptr->set(filter_func);
       }
 
       auto query_param = query_param_->clone();
@@ -321,11 +321,11 @@ class Bench {
   BenchResult bench_result_;
   RetrievalMode retrieval_mode_{RM_UNDEFINED};
   FilterMode filter_mode_{FM_NONE};
-  static bool STOP_NOW;
+  static bool stop_now;
 };
 
 template <typename T>
-bool Bench<T>::STOP_NOW = false;
+bool Bench<T>::stop_now = false;
 
 //------------------------------------------------------------
 // Sparse Bench
@@ -355,10 +355,10 @@ class SparseBench {
   }
 
   static void stop(int signo) {
-    if (STOP_NOW) {
+    if (stop_now) {
       exit(signo);
     }
-    STOP_NOW = true;
+    stop_now = true;
     cout << "\rTrying to stop. press [Ctrl+C] again kill immediately." << endl
          << flush;
   }
@@ -459,13 +459,13 @@ class SparseBench {
     auto start_time = Monotime::MilliSeconds();
     for (size_t i = 0; i < threads_; ++i) {
       pool_->execute(this, &SparseBench<T>::start_bench, index, max_iter,
-                     &STOP_NOW);
+                     &stop_now);
     }
 
     while (!pool_->is_finished()) {
       this_thread::sleep_for(chrono::milliseconds(1));
       if (Monotime::MilliSeconds() - start_time > bench_secs_ * 1000) {
-        STOP_NOW = true;
+        stop_now = true;
       }
     }
 
@@ -507,10 +507,10 @@ class SparseBench {
           return;
         }
 
-        auto filterFunc = [&](uint64_t key) { return filter_cache.find(key); };
+        auto filter_func = [&](uint64_t key) { return filter_cache.find(key); };
 
         filter_ptr = std::make_shared<IndexFilter>();
-        filter_ptr->set(filterFunc);
+        filter_ptr->set(filter_func);
       }
 
       auto query_param = query_param_->clone();
@@ -659,10 +659,10 @@ class SparseBench {
 
   FilterMode filter_mode_{FM_NONE};
   BenchResult bench_result_;
-  static bool STOP_NOW;
+  static bool stop_now;
 };
 template <typename T>
-bool SparseBench<T>::STOP_NOW = false;
+bool SparseBench<T>::stop_now = false;
 
 bool check_config(YAML::Node &config_node) {
   auto common = config_node["IndexCommon"];
@@ -817,17 +817,18 @@ int main(int argc, char *argv[]) {
   }
   auto config_common = config_node["IndexCommon"];
 
-  map<string, int> LOG_LEVEL = {{"debug", zvec::ailego::Logger::LEVEL_DEBUG},
-                                {"info", zvec::ailego::Logger::LEVEL_INFO},
-                                {"warn", zvec::ailego::Logger::LEVEL_WARN},
-                                {"error", zvec::ailego::Logger::LEVEL_ERROR},
-                                {"fatal", zvec::ailego::Logger::LEVEL_FATAL}};
+  map<string, int> log_level_map = {
+      {"debug", zvec::ailego::Logger::LEVEL_DEBUG},
+      {"info", zvec::ailego::Logger::LEVEL_INFO},
+      {"warn", zvec::ailego::Logger::LEVEL_WARN},
+      {"error", zvec::ailego::Logger::LEVEL_ERROR},
+      {"fatal", zvec::ailego::Logger::LEVEL_FATAL}};
   string log_level = config_common["LogLevel"]
                          ? config_common["LogLevel"].as<string>()
                          : "debug";
   transform(log_level.begin(), log_level.end(), log_level.begin(), ::tolower);
-  if (LOG_LEVEL.find(log_level) != LOG_LEVEL.end()) {
-    zvec::ailego::LoggerBroker::SetLevel(LOG_LEVEL[log_level]);
+  if (log_level_map.find(log_level) != log_level_map.end()) {
+    zvec::ailego::LoggerBroker::SetLevel(log_level_map[log_level]);
   }
 
   // Calculate Bench
diff --git a/tools/core/bench_original.cc b/tools/core/bench_original.cc
index 8c609c972..d27075835 100644
--- a/tools/core/bench_original.cc
+++ b/tools/core/bench_original.cc
@@ -85,10 +85,10 @@ class Bench {
   }
 
   static void stop(int signo) {
-    if (STOP_NOW) {
+    if (stop_now) {
       exit(signo);
     }
-    STOP_NOW = true;
+    stop_now = true;
     cout << "\rTrying to stop. press [Ctrl+C] again kill immediately." << endl
          << flush;
   }
@@ -195,13 +195,13 @@ class Bench {
     bench_result_.mark_start();
     auto start_time = Monotime::MilliSeconds();
     for (size_t i = 0; i < threads_; ++i) {
-      pool_->execute(this, &Bench<T>::start_bench, flower, max_iter, &STOP_NOW);
+      pool_->execute(this, &Bench<T>::start_bench, flower, max_iter, &stop_now);
     }
 
     while (!pool_->is_finished()) {
       this_thread::sleep_for(chrono::milliseconds(1));
       if (Monotime::MilliSeconds() - start_time > bench_secs_ * 1000) {
-        STOP_NOW = true;
+        stop_now = true;
       }
     }
 
@@ -243,9 +243,9 @@ class Bench {
           return;
         }
 
-        auto filterFunc = [&](uint64_t key) { return filter_cache.find(key); };
+        auto filter_func = [&](uint64_t key) { return filter_cache.find(key); };
 
-        contexts_[thread_index]->set_filter(filterFunc);
+        contexts_[thread_index]->set_filter(filter_func);
       }
 
       // Do knn_search
@@ -363,11 +363,11 @@ class Bench {
   BenchResult bench_result_;
   RetrievalMode retrieval_mode_{RM_UNDEFINED};
   FilterMode filter_mode_{FM_NONE};
-  static bool STOP_NOW;
+  static bool stop_now;
 };
 
 template <typename T>
-bool Bench<T>::STOP_NOW = false;
+bool Bench<T>::stop_now = false;
 
 //------------------------------------------------------------
 // Sparse Bench
@@ -397,10 +397,10 @@ class SparseBench {
   }
 
   static void stop(int signo) {
-    if (STOP_NOW) {
+    if (stop_now) {
       exit(signo);
     }
-    STOP_NOW = true;
+    stop_now = true;
     cout << "\rTrying to stop. press [Ctrl+C] again kill immediately." << endl
          << flush;
   }
@@ -481,13 +481,13 @@ class SparseBench {
     auto start_time = Monotime::MilliSeconds();
     for (size_t i = 0; i < threads_; ++i) {
       pool_->execute(this, &SparseBench<T>::start_bench, flower, max_iter,
-                     &STOP_NOW);
+                     &stop_now);
     }
 
     while (!pool_->is_finished()) {
       this_thread::sleep_for(chrono::milliseconds(1));
       if (Monotime::MilliSeconds() - start_time > bench_secs_ * 1000) {
-        STOP_NOW = true;
+        stop_now = true;
       }
     }
 
@@ -523,9 +523,9 @@ class SparseBench {
           return;
         }
 
-        auto filterFunc = [&](uint64_t key) { return filter_cache.find(key); };
+        auto filter_func = [&](uint64_t key) { return filter_cache.find(key); };
 
-        contexts_[thread_index]->set_filter(filterFunc);
+        contexts_[thread_index]->set_filter(filter_func);
       }
 
       // Do knn_search
@@ -669,10 +669,10 @@ class SparseBench {
 
   FilterMode filter_mode_{FM_NONE};
   BenchResult bench_result_;
-  static bool STOP_NOW;
+  static bool stop_now;
 };
 template <typename T>
-bool SparseBench<T>::STOP_NOW = false;
+bool SparseBench<T>::stop_now = false;
 
 // do
 bool prepare_params(YAML::Node &&config_params, Params &params) {
@@ -878,17 +878,17 @@ int main(int argc, char *argv[]) {
   }
   auto config_common = config_node["SearcherCommon"];
 
-  map<string, int> LOG_LEVEL = {{"debug", Logger::LEVEL_DEBUG},
-                                {"info", Logger::LEVEL_INFO},
-                                {"warn", Logger::LEVEL_WARN},
-                                {"error", Logger::LEVEL_ERROR},
-                                {"fatal", Logger::LEVEL_FATAL}};
+  map<string, int> log_level_map = {{"debug", Logger::LEVEL_DEBUG},
+                                    {"info", Logger::LEVEL_INFO},
+                                    {"warn", Logger::LEVEL_WARN},
+                                    {"error", Logger::LEVEL_ERROR},
+                                    {"fatal", Logger::LEVEL_FATAL}};
   string log_level = config_common["LogLevel"]
                          ? config_common["LogLevel"].as<string>()
                          : "debug";
   transform(log_level.begin(), log_level.end(), log_level.begin(), ::tolower);
-  if (LOG_LEVEL.find(log_level) != LOG_LEVEL.end()) {
-    zvec::ailego::LoggerBroker::SetLevel(LOG_LEVEL[log_level]);
+  if (log_level_map.find(log_level) != log_level_map.end()) {
+    zvec::ailego::LoggerBroker::SetLevel(log_level_map[log_level]);
   }
 
   // Calculate Bench
diff --git a/tools/core/bench_result.h b/tools/core/bench_result.h
index 23aba5090..a50848d15 100644
--- a/tools/core/bench_result.h
+++ b/tools/core/bench_result.h
@@ -59,14 +59,14 @@ class BenchResult {
 #ifdef _MSC_VER
     start_ = std::chrono::steady_clock::now();
 #else
-    gettimeofday(&start_, NULL);
+    gettimeofday(&start_, nullptr);
 #endif
   }
   void mark_end() {
 #ifdef _MSC_VER
     end_ = std::chrono::steady_clock::now();
 #else
-    gettimeofday(&end_, NULL);
+    gettimeofday(&end_, nullptr);
 #endif
   }
   long get_duration_by_ms() {
diff --git a/tools/core/local_builder.cc b/tools/core/local_builder.cc
index f1f51038c..03aea9d98 100644
--- a/tools/core/local_builder.cc
+++ b/tools/core/local_builder.cc
@@ -1573,19 +1573,20 @@ int main(int argc, char *argv[]) {
   }
   auto config_common = config_root["BuilderCommon"];
 
-  map<string, int> LOG_LEVEL = {{"debug", zvec::ailego::Logger::LEVEL_DEBUG},
-                                {"info", zvec::ailego::Logger::LEVEL_INFO},
-                                {"warn", zvec::ailego::Logger::LEVEL_WARN},
-                                {"error", zvec::ailego::Logger::LEVEL_ERROR},
-                                {"fatal", zvec::ailego::Logger::LEVEL_FATAL}};
+  map<string, int> log_level_map = {
+      {"debug", zvec::ailego::Logger::LEVEL_DEBUG},
+      {"info", zvec::ailego::Logger::LEVEL_INFO},
+      {"warn", zvec::ailego::Logger::LEVEL_WARN},
+      {"error", zvec::ailego::Logger::LEVEL_ERROR},
+      {"fatal", zvec::ailego::Logger::LEVEL_FATAL}};
 
   string log_level = config_common["LogLevel"]
                          ? config_common["LogLevel"].as<string>()
                          : "debug";
 
   transform(log_level.begin(), log_level.end(), log_level.begin(), ::tolower);
-  if (LOG_LEVEL.find(log_level) != LOG_LEVEL.end()) {
-    zvec::ailego::LoggerBroker::SetLevel(LOG_LEVEL[log_level]);
+  if (log_level_map.find(log_level) != log_level_map.end()) {
+    zvec::ailego::LoggerBroker::SetLevel(log_level_map[log_level]);
   }
 
   RetrievalMode retrieval_mode{RM_DENSE};
diff --git a/tools/core/local_builder_original.cc b/tools/core/local_builder_original.cc
index d034b0d46..895c37f1e 100644
--- a/tools/core/local_builder_original.cc
+++ b/tools/core/local_builder_original.cc
@@ -1403,19 +1403,20 @@ int main(int argc, char *argv[]) {
   }
   auto config_common = config_root["BuilderCommon"];
 
-  map<string, int> LOG_LEVEL = {{"debug", zvec::ailego::Logger::LEVEL_DEBUG},
-                                {"info", zvec::ailego::Logger::LEVEL_INFO},
-                                {"warn", zvec::ailego::Logger::LEVEL_WARN},
-                                {"error", zvec::ailego::Logger::LEVEL_ERROR},
-                                {"fatal", zvec::ailego::Logger::LEVEL_FATAL}};
+  map<string, int> log_level_map = {
+      {"debug", zvec::ailego::Logger::LEVEL_DEBUG},
+      {"info", zvec::ailego::Logger::LEVEL_INFO},
+      {"warn", zvec::ailego::Logger::LEVEL_WARN},
+      {"error", zvec::ailego::Logger::LEVEL_ERROR},
+      {"fatal", zvec::ailego::Logger::LEVEL_FATAL}};
 
   string log_level = config_common["LogLevel"]
                          ? config_common["LogLevel"].as<string>()
                          : "debug";
 
   transform(log_level.begin(), log_level.end(), log_level.begin(), ::tolower);
-  if (LOG_LEVEL.find(log_level) != LOG_LEVEL.end()) {
-    zvec::ailego::LoggerBroker::SetLevel(LOG_LEVEL[log_level]);
+  if (log_level_map.find(log_level) != log_level_map.end()) {
+    zvec::ailego::LoggerBroker::SetLevel(log_level_map[log_level]);
   }
 
   RetrievalMode retrieval_mode{RM_DENSE};
diff --git a/tools/core/recall.cc b/tools/core/recall.cc
index f147db11a..b979adb58 100644
--- a/tools/core/recall.cc
+++ b/tools/core/recall.cc
@@ -54,10 +54,10 @@ class Recall {
   }
 
   static void stop(int signo) {
-    if (STOP_NOW) {
+    if (stop_now) {
       exit(signo);
     }
-    STOP_NOW = true;
+    stop_now = true;
     cout << "\rTrying to stop. press [Ctrl+C] again kill immediately." << endl
          << flush;
   }
@@ -118,7 +118,7 @@ class Recall {
 
     signal(SIGINT, stop);
     size_t i = 0;
-    for (; !STOP_NOW && i < batch_queries_.size();) {
+    for (; !stop_now && i < batch_queries_.size();) {
       if (pool_->pending_count() >= pool_->count()) {
         this_thread::sleep_for(chrono::microseconds(1));
         continue;
@@ -341,12 +341,12 @@ class Recall {
             return;
           }
 
-          auto filterFunc = [&](uint64_t key) {
+          auto filter_func = [&](uint64_t key) {
             return filter_cache.find(key);
           };
 
           filter_ptr = std::make_shared<IndexFilter>();
-          filter_ptr->set(filterFunc);
+          filter_ptr->set(filter_func);
         }
 
         core_interface::DenseVector dense_query;
@@ -619,10 +619,10 @@ class Recall {
         return;
       }
 
-      auto filterFunc = [&](uint64_t key) { return filter_cache.find(key); };
+      auto filter_func = [&](uint64_t key) { return filter_cache.find(key); };
 
       filter_ptr = std::make_shared<core::IndexFilter>();
-      filter_ptr->set(filterFunc);
+      filter_ptr->set(filter_func);
     }
 
     core_interface::DenseVector dense_query;
@@ -710,7 +710,7 @@ class Recall {
 
   FilterMode filter_mode_{FM_NONE};
 
-  static bool STOP_NOW;
+  static bool stop_now;
 
   // Tag lists for filtering
   std::vector<std::vector<uint64_t>> id_to_tags_list_;
@@ -725,7 +725,7 @@ class Recall {
 };
 
 template <typename T>
-bool Recall<T>::STOP_NOW = false;
+bool Recall<T>::stop_now = false;
 
 //--------------------------------------------------
 // Sparse Recall
@@ -758,10 +758,10 @@ class SparseRecall {
   }
 
   static void stop(int signo) {
-    if (STOP_NOW) {
+    if (stop_now) {
       exit(signo);
     }
-    STOP_NOW = true;
+    stop_now = true;
     cout << "\rTrying to stop. press [Ctrl+C] again kill immediately." << endl
          << flush;
   }
@@ -853,7 +853,7 @@ class SparseRecall {
 
     signal(SIGINT, stop);
     size_t i = 0;
-    for (; !STOP_NOW && i < batch_sparse_counts_.size();) {
+    for (; !stop_now && i < batch_sparse_counts_.size();) {
       if (pool_->pending_count() >= pool_->count()) {
         this_thread::sleep_for(chrono::microseconds(1));
         continue;
@@ -1001,12 +1001,12 @@ class SparseRecall {
             return;
           }
 
-          auto filterFunc = [&](uint64_t key) {
+          auto filter_func = [&](uint64_t key) {
             return filter_cache.find(key);
           };
 
           filter_ptr = std::make_shared<IndexFilter>();
-          filter_ptr->set(filterFunc);
+          filter_ptr->set(filter_func);
         }
 
         core_interface::SparseVector sparse_query;
@@ -1327,10 +1327,10 @@ class SparseRecall {
         return;
       }
 
-      auto filterFunc = [&](uint64_t key) { return filter_cache.find(key); };
+      auto filter_func = [&](uint64_t key) { return filter_cache.find(key); };
 
       filter_ptr = std::make_shared<core::IndexFilter>();
-      filter_ptr->set(filterFunc);
+      filter_ptr->set(filter_func);
     }
 
     core_interface::SparseVector sparse_query;
@@ -1435,11 +1435,11 @@ class SparseRecall {
     tag_key_list_ = tag_key_list;
   }
 
-  static bool STOP_NOW;
+  static bool stop_now;
 };
 
 template <typename T>
-bool SparseRecall<T>::STOP_NOW = false;
+bool SparseRecall<T>::stop_now = false;
 
 bool check_config(YAML::Node &config_node) {
   auto common = config_node["IndexCommon"];
@@ -1660,17 +1660,18 @@ int main(int argc, char *argv[]) {
   }
   auto config_common = config_node["IndexCommon"];
 
-  map<string, int> LOG_LEVEL = {{"debug", zvec::ailego::Logger::LEVEL_DEBUG},
-                                {"info", zvec::ailego::Logger::LEVEL_INFO},
-                                {"warn", zvec::ailego::Logger::LEVEL_WARN},
-                                {"error", zvec::ailego::Logger::LEVEL_ERROR},
-                                {"fatal", zvec::ailego::Logger::LEVEL_FATAL}};
+  map<string, int> log_level_map = {
+      {"debug", zvec::ailego::Logger::LEVEL_DEBUG},
+      {"info", zvec::ailego::Logger::LEVEL_INFO},
+      {"warn", zvec::ailego::Logger::LEVEL_WARN},
+      {"error", zvec::ailego::Logger::LEVEL_ERROR},
+      {"fatal", zvec::ailego::Logger::LEVEL_FATAL}};
   string log_level = config_common["LogLevel"]
                          ? config_common["LogLevel"].as<string>()
                          : "debug";
   transform(log_level.begin(), log_level.end(), log_level.begin(), ::tolower);
-  if (LOG_LEVEL.find(log_level) != LOG_LEVEL.end()) {
-    zvec::ailego::LoggerBroker::SetLevel(LOG_LEVEL[log_level]);
+  if (log_level_map.find(log_level) != log_level_map.end()) {
+    zvec::ailego::LoggerBroker::SetLevel(log_level_map[log_level]);
   }
 
   // Calculate Recall
diff --git a/tools/core/recall_original.cc b/tools/core/recall_original.cc
index 620a13d31..13af832ff 100644
--- a/tools/core/recall_original.cc
+++ b/tools/core/recall_original.cc
@@ -95,10 +95,10 @@ class Recall {
   }
 
   static void stop(int signo) {
-    if (STOP_NOW) {
+    if (stop_now) {
       exit(signo);
     }
-    STOP_NOW = true;
+    stop_now = true;
     cout << "\rTrying to stop. press [Ctrl+C] again kill immediately." << endl
          << flush;
   }
@@ -159,7 +159,7 @@ class Recall {
 
     signal(SIGINT, stop);
     size_t i = 0;
-    for (; !STOP_NOW && i < batch_queries_.size();) {
+    for (; !stop_now && i < batch_queries_.size();) {
       if (pool_->pending_count() >= pool_->count()) {
         this_thread::sleep_for(chrono::microseconds(1));
         continue;
@@ -387,11 +387,11 @@ class Recall {
             return;
           }
 
-          auto filterFunc = [&](uint64_t key) {
+          auto filter_func = [&](uint64_t key) {
             return filter_cache.find(key);
           };
 
-          context->set_filter(filterFunc);
+          context->set_filter(filter_func);
         }
 
         context->set_topk(gt_count);
@@ -819,9 +819,9 @@ class Recall {
         return;
       }
 
-      auto filterFunc = [&](uint64_t key) { return filter_cache.find(key); };
+      auto filter_func = [&](uint64_t key) { return filter_cache.find(key); };
 
-      knn_context->set_filter(filterFunc);
+      knn_context->set_filter(filter_func);
     }
 
     if (call_batch_api_) {
@@ -887,11 +887,11 @@ class Recall {
 
   FilterMode filter_mode_{FM_NONE};
 
-  static bool STOP_NOW;
+  static bool stop_now;
 };
 
 template <typename T>
-bool Recall<T>::STOP_NOW = false;
+bool Recall<T>::stop_now = false;
 
 //--------------------------------------------------
 // Sparse Recall
@@ -924,10 +924,10 @@ class SparseRecall {
   }
 
   static void stop(int signo) {
-    if (STOP_NOW) {
+    if (stop_now) {
       exit(signo);
     }
-    STOP_NOW = true;
+    stop_now = true;
     cout << "\rTrying to stop. press [Ctrl+C] again kill immediately." << endl
          << flush;
   }
@@ -1019,7 +1019,7 @@ class SparseRecall {
 
     signal(SIGINT, stop);
     size_t i = 0;
-    for (; !STOP_NOW && i < batch_sparse_counts_.size();) {
+    for (; !stop_now && i < batch_sparse_counts_.size();) {
       if (pool_->pending_count() >= pool_->count()) {
         this_thread::sleep_for(chrono::microseconds(1));
         continue;
@@ -1174,11 +1174,11 @@ class SparseRecall {
             return;
           }
 
-          auto filterFunc = [&](uint64_t key) {
+          auto filter_func = [&](uint64_t key) {
             return filter_cache.find(key);
           };
 
-          context->set_filter(filterFunc);
+          context->set_filter(filter_func);
         }
 
         int ret =
@@ -1536,9 +1536,9 @@ class SparseRecall {
         return;
       }
 
-      auto filterFunc = [&](uint64_t key) { return filter_cache.find(key); };
+      auto filter_func = [&](uint64_t key) { return filter_cache.find(key); };
 
-      knn_context->set_filter(filterFunc);
+      knn_context->set_filter(filter_func);
     }
 
     if (call_batch_api_) {
@@ -1610,11 +1610,11 @@ class SparseRecall {
   bool external_gt_file_enabled_{false};
 
   FilterMode filter_mode_{FM_NONE};
-  static bool STOP_NOW;
+  static bool stop_now;
 };
 
 template <typename T>
-bool SparseRecall<T>::STOP_NOW = false;
+bool SparseRecall<T>::stop_now = false;
 
 bool prepare_params(YAML::Node &&config_params, Params &params) {
   cout << "Parse params as blow:" << endl;
@@ -1877,17 +1877,17 @@ int main(int argc, char *argv[]) {
   }
   auto config_common = config_node["SearcherCommon"];
 
-  map<string, int> LOG_LEVEL = {{"debug", Logger::LEVEL_DEBUG},
-                                {"info", Logger::LEVEL_INFO},
-                                {"warn", Logger::LEVEL_WARN},
-                                {"error", Logger::LEVEL_ERROR},
-                                {"fatal", Logger::LEVEL_FATAL}};
+  map<string, int> log_level_map = {{"debug", Logger::LEVEL_DEBUG},
+                                    {"info", Logger::LEVEL_INFO},
+                                    {"warn", Logger::LEVEL_WARN},
+                                    {"error", Logger::LEVEL_ERROR},
+                                    {"fatal", Logger::LEVEL_FATAL}};
   string log_level = config_common["LogLevel"]
                          ? config_common["LogLevel"].as<string>()
                          : "debug";
   transform(log_level.begin(), log_level.end(), log_level.begin(), ::tolower);
-  if (LOG_LEVEL.find(log_level) != LOG_LEVEL.end()) {
-    zvec::ailego::LoggerBroker::SetLevel(LOG_LEVEL[log_level]);
+  if (log_level_map.find(log_level) != log_level_map.end()) {
+    zvec::ailego::LoggerBroker::SetLevel(log_level_map[log_level]);
   }
 
   // Calculate Recall
diff --git a/tools/db/fts_bench_main.cc b/tools/db/fts_bench_main.cc
index d06417b11..7a86aa1b4 100644
--- a/tools/db/fts_bench_main.cc
+++ b/tools/db/fts_bench_main.cc
@@ -1034,7 +1034,7 @@ static int do_search() {
     RecallCounter recall1;
     RecallCounter recall5;
     RecallCounter recall10;
-    RecallCounter recallK;
+    RecallCounter recall_k;
     uint64_t no_result_count{0};
     uint64_t query_count{0};
   };
@@ -1162,7 +1162,7 @@ static int do_search() {
       result.recall1.add(compute_recall(1));
       result.recall5.add(compute_recall(5));
       result.recall10.add(compute_recall(10));
-      result.recallK.add(compute_recall(FLAGS_topk));
+      result.recall_k.add(compute_recall(FLAGS_topk));
     }
   };
 
@@ -1186,7 +1186,8 @@ static int do_search() {
 
   // Merge per-thread results
   LatencyStats merged_latency;
-  RecallCounter merged_recall1, merged_recall5, merged_recall10, merged_recallK;
+  RecallCounter merged_recall1, merged_recall5, merged_recall10,
+      merged_recall_k;
   uint64_t total_query_count = 0;
   uint64_t total_no_result_count = 0;
 
@@ -1200,8 +1201,8 @@ static int do_search() {
     merged_recall5.total += result.recall5.total;
     merged_recall10.sum += result.recall10.sum;
     merged_recall10.total += result.recall10.total;
-    merged_recallK.sum += result.recallK.sum;
-    merged_recallK.total += result.recallK.total;
+    merged_recall_k.sum += result.recall_k.sum;
+    merged_recall_k.total += result.recall_k.total;
     total_query_count += result.query_count;
     total_no_result_count += result.no_result_count;
   }
@@ -1232,8 +1233,8 @@ static int do_search() {
               << " (evaluated on " << merged_recall10.total << " queries)"
               << std::endl;
     if (FLAGS_topk > 10) {
-      std::cout << "  Recall@" << FLAGS_topk << " : " << merged_recallK.ratio()
-                << " (evaluated on " << merged_recallK.total << " queries)"
+      std::cout << "  Recall@" << FLAGS_topk << " : " << merged_recall_k.ratio()
+                << " (evaluated on " << merged_recall_k.total << " queries)"
                 << std::endl;
     }
   } else {
@@ -1321,7 +1322,7 @@ static int do_search_db() {
     RecallCounter recall1;
     RecallCounter recall5;
     RecallCounter recall10;
-    RecallCounter recallK;
+    RecallCounter recall_k;
     uint64_t no_result_count{0};
     uint64_t query_count{0};
   };
@@ -1398,7 +1399,7 @@ static int do_search_db() {
       result.recall1.add(compute_recall(1));
       result.recall5.add(compute_recall(5));
       result.recall10.add(compute_recall(10));
-      result.recallK.add(compute_recall(FLAGS_topk));
+      result.recall_k.add(compute_recall(FLAGS_topk));
     }
   };
 
@@ -1425,7 +1426,8 @@ static int do_search_db() {
 
   // Merge per-thread results
   LatencyStats merged_latency;
-  RecallCounter merged_recall1, merged_recall5, merged_recall10, merged_recallK;
+  RecallCounter merged_recall1, merged_recall5, merged_recall10,
+      merged_recall_k;
   uint64_t total_query_count = 0;
   uint64_t total_no_result_count = 0;
 
@@ -1439,8 +1441,8 @@ static int do_search_db() {
     merged_recall5.total += result.recall5.total;
     merged_recall10.sum += result.recall10.sum;
     merged_recall10.total += result.recall10.total;
-    merged_recallK.sum += result.recallK.sum;
-    merged_recallK.total += result.recallK.total;
+    merged_recall_k.sum += result.recall_k.sum;
+    merged_recall_k.total += result.recall_k.total;
     total_query_count += result.query_count;
     total_no_result_count += result.no_result_count;
   }
@@ -1470,8 +1472,8 @@ static int do_search_db() {
               << " (evaluated on " << merged_recall10.total << " queries)"
               << std::endl;
     if (FLAGS_topk > 10) {
-      std::cout << "  Recall@" << FLAGS_topk << " : " << merged_recallK.ratio()
-                << " (evaluated on " << merged_recallK.total << " queries)"
+      std::cout << "  Recall@" << FLAGS_topk << " : " << merged_recall_k.ratio()
+                << " (evaluated on " << merged_recall_k.total << " queries)"
                 << std::endl;
     }
   } else {