style: automated clang-format fixes

Author: poyrazK

include/common/cluster_manager.hpp

@@ -13,8 +13,8 @@
 #include <unordered_map>
 #include <vector>
 
-#include "common/config.hpp"
 #include "common/bloom_filter.hpp"
+#include "common/config.hpp"
 #include "executor/types.hpp"
 
 namespace cloudsql::raft {
@@ -243,7 +243,8 @@ class ClusterManager {
         const std::scoped_lock<std::mutex> lock(mutex_);
         auto it = bloom_filters_.find(context_id);
         if (it != bloom_filters_.end() && !it->second.filter_data.empty()) {
-            return common::BloomFilter(it->second.filter_data.data(), it->second.filter_data.size());
+            return common::BloomFilter(it->second.filter_data.data(),
+                                       it->second.filter_data.size());
         }
         return common::BloomFilter(1);  // Empty filter
     }

src/common/bloom_filter.cpp

@@ -86,8 +86,7 @@ size_t BloomFilter::get_bit_position(size_t hash, size_t i) const {
     // Double hashing technique: h(i) = h1 + i * h2
     // Use two different hash seeds
     size_t h1 = hash;
-    size_t h2 = murmur3_hash(reinterpret_cast<const uint8_t*>("salt"),
-                             4, 0xcafebabe);
+    size_t h2 = murmur3_hash(reinterpret_cast<const uint8_t*>("salt"), 4, 0xcafebabe);
 
     return (h1 + i * h2) % num_bits_;
 }

src/distributed/distributed_executor.cpp

@@ -242,11 +242,11 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                 }
 
                 // After Phase 1, each node will have received left table data.
-                // Now broadcast bloom filter built from that data to all nodes for Phase 2 filtering.
-                // The filter is sent as a separate RPC that data nodes will store and apply to their
-                // right table shuffle. For now, we send a simple metadata-only filter that signals
-                // "filtering enabled" - the actual filter building happens on each data node during
-                // Phase 1 and they stash it for use during Phase 2.
+                // Now broadcast bloom filter built from that data to all nodes for Phase 2
+                // filtering. The filter is sent as a separate RPC that data nodes will store and
+                // apply to their right table shuffle. For now, we send a simple metadata-only
+                // filter that signals "filtering enabled" - the actual filter building happens on
+                // each data node during Phase 1 and they stash it for use during Phase 2.
                 //
                 // In production, we'd collect and OR all local bloom filters, but for POC
                 // we just signal that bloom filtering is enabled for this context.
@@ -255,7 +255,7 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                 bf_args.build_table = left_table;
                 bf_args.probe_table = right_table;
                 bf_args.probe_key_col = right_key;  // Tell probe side which column to filter on
-                bf_args.filter_data.clear();  // Empty = filter built distributed
+                bf_args.filter_data.clear();        // Empty = filter built distributed
                 bf_args.expected_elements = data_nodes.size() * 1000;  // Estimate
                 bf_args.num_hashes = 4;
                 auto bf_payload = bf_args.serialize();

src/main.cpp

@@ -475,7 +475,8 @@ int main(int argc, char* argv[]) {
                             // Apply bloom filter if available for this context
                             if (cluster_manager->has_bloom_filter(args.context_id)) {
                                 auto bloom = cluster_manager->get_bloom_filter(args.context_id);
-                                std::string probe_key_col = cluster_manager->get_probe_key_col(args.context_id);
+                                std::string probe_key_col =
+                                    cluster_manager->get_probe_key_col(args.context_id);
 
                                 // Get probe table schema to find key column index
                                 auto table_meta_opt = catalog->get_table_by_name(args.table_name);
@@ -498,21 +499,22 @@ int main(int argc, char* argv[]) {
                                                 filtered_rows.push_back(std::move(row));
                                             }
                                         }
-                                        cluster_manager->buffer_shuffle_data(args.context_id, args.table_name,
-                                                                             std::move(filtered_rows));
+                                        cluster_manager->buffer_shuffle_data(
+                                            args.context_id, args.table_name,
+                                            std::move(filtered_rows));
                                     } else {
                                         // Key column not found, buffer as-is
-                                        cluster_manager->buffer_shuffle_data(args.context_id, args.table_name,
-                                                                             std::move(args.rows));
+                                        cluster_manager->buffer_shuffle_data(
+                                            args.context_id, args.table_name, std::move(args.rows));
                                     }
                                 } else {
                                     // No metadata, buffer as-is
-                                    cluster_manager->buffer_shuffle_data(args.context_id, args.table_name,
-                                                                         std::move(args.rows));
+                                    cluster_manager->buffer_shuffle_data(
+                                        args.context_id, args.table_name, std::move(args.rows));
                                 }
                             } else {
-                                cluster_manager->buffer_shuffle_data(args.context_id, args.table_name,
-                                                                     std::move(args.rows));
+                                cluster_manager->buffer_shuffle_data(
+                                    args.context_id, args.table_name, std::move(args.rows));
                             }
                         }
 
@@ -536,10 +538,10 @@ int main(int argc, char* argv[]) {
                         (void)h;
                         auto args = cloudsql::network::BloomFilterArgs::deserialize(p);
                         if (cluster_manager != nullptr) {
-                            cluster_manager->set_bloom_filter(args.context_id, args.build_table,
-                                                               args.probe_table, args.probe_key_col,
-                                                               args.filter_data, args.expected_elements,
-                                                               args.num_hashes);
+                            cluster_manager->set_bloom_filter(
+                                args.context_id, args.build_table, args.probe_table,
+                                args.probe_key_col, args.filter_data, args.expected_elements,
+                                args.num_hashes);
                         }
                         cloudsql::network::QueryResultsReply reply;
                         reply.success = true;

tests/bloom_filter_test.cpp

@@ -3,11 +3,12 @@
  * @brief Unit tests for BloomFilter implementation
  */
 
+#include "common/bloom_filter.hpp"
+
 #include <gtest/gtest.h>
 
 #include <vector>
 
-#include "common/bloom_filter.hpp"
 #include "common/cluster_manager.hpp"
 #include "common/value.hpp"
 #include "executor/types.hpp"
@@ -202,8 +203,8 @@ TEST(BloomFilterTests, ClusterManagerBloomFilterStorage) {
     auto filter_data = original.serialize();
 
     // Test set_bloom_filter and has_bloom_filter
-    cm.set_bloom_filter("ctx1", "table_build", "table_probe", "key_col",
-                        filter_data, original.expected_elements(), original.num_hashes());
+    cm.set_bloom_filter("ctx1", "table_build", "table_probe", "key_col", filter_data,
+                        original.expected_elements(), original.num_hashes());
     EXPECT_TRUE(cm.has_bloom_filter("ctx1"));
 
     // Test get_bloom_filter reconstructs correctly
@@ -240,10 +241,14 @@ TEST(BloomFilterTests, BloomFilterApplicationLogic) {
 
     // Simulate tuple filtering (as done in PushData handler)
     std::vector<cloudsql::executor::Tuple> tuples;
-    tuples.push_back(cloudsql::executor::Tuple(std::initializer_list<Value>{Value::make_int64(10)}));  // match
-    tuples.push_back(cloudsql::executor::Tuple(std::initializer_list<Value>{Value::make_int64(15)}));  // no match
-    tuples.push_back(cloudsql::executor::Tuple(std::initializer_list<Value>{Value::make_int64(20)}));  // match
-    tuples.push_back(cloudsql::executor::Tuple(std::initializer_list<Value>{Value::make_int64(99)}));  // no match
+    tuples.push_back(
+        cloudsql::executor::Tuple(std::initializer_list<Value>{Value::make_int64(10)}));  // match
+    tuples.push_back(cloudsql::executor::Tuple(
+        std::initializer_list<Value>{Value::make_int64(15)}));  // no match
+    tuples.push_back(
+        cloudsql::executor::Tuple(std::initializer_list<Value>{Value::make_int64(20)}));  // match
+    tuples.push_back(cloudsql::executor::Tuple(
+        std::initializer_list<Value>{Value::make_int64(99)}));  // no match
 
     std::vector<cloudsql::executor::Tuple> filtered;
     for (auto& row : tuples) {