style: automated clang-format fixes

Author: poyrazK

include/catalog/catalog.hpp

@@ -193,7 +193,8 @@ class Catalog : public raft::RaftStateMachine {
     /**
      * @brief Local-only table creation (called by Raft)
      */
-    oid_t create_table_local(const std::string& table_name, std::vector<ColumnInfo> columns, std::vector<ShardInfo> shards = {});
+    oid_t create_table_local(const std::string& table_name, std::vector<ColumnInfo> columns,
+                             std::vector<ShardInfo> shards = {});
 
     /**
      * @brief Drop a table

include/common/cluster_manager.hpp

@@ -128,7 +128,8 @@ class ClusterManager {
             coordinators.push_back(self_node_);
         }
         for (const auto& [id, info] : nodes_) {
-            if (info.role == config::RunMode::Coordinator && info.is_active && id != self_node_.id) {
+            if (info.role == config::RunMode::Coordinator && info.is_active &&
+                id != self_node_.id) {
                 coordinators.push_back(info);
             }
         }

include/distributed/shard_manager.hpp

@@ -7,9 +7,9 @@
 #define SQL_ENGINE_DISTRIBUTED_SHARD_MANAGER_HPP
 
 #include <cstdint>
+#include <optional>
 #include <string>
 #include <vector>
-#include <optional>
 
 #include "catalog/catalog.hpp"
 #include "common/value.hpp"
@@ -49,7 +49,8 @@ class ShardManager {
     /**
      * @brief Find which data node is responsible for a given shard ID
      */
-    static std::optional<cloudsql::ShardInfo> get_target_node(const cloudsql::TableInfo& table, uint32_t shard_id) {
+    static std::optional<cloudsql::ShardInfo> get_target_node(const cloudsql::TableInfo& table,
+                                                              uint32_t shard_id) {
         for (const auto& shard : table.shards) {
             if (shard.shard_id == shard_id) {
                 return shard;

include/network/rpc_message.hpp

@@ -53,7 +53,8 @@ class Serializer {
 
         if (val.is_numeric()) {
             // POC: unify all numerics to 64-bit float/int in the stream for simplicity
-            if (val.type() == common::ValueType::TYPE_FLOAT32 || val.type() == common::ValueType::TYPE_FLOAT64) {
+            if (val.type() == common::ValueType::TYPE_FLOAT32 ||
+                val.type() == common::ValueType::TYPE_FLOAT64) {
                 double v = val.to_float64();
                 const size_t offset = out.size();
                 out.resize(offset + VAL_SIZE_64);
@@ -71,7 +72,7 @@ class Serializer {
             case common::ValueType::TYPE_TEXT:
             case common::ValueType::TYPE_VARCHAR:
             case common::ValueType::TYPE_CHAR: {
-                const std::string& s = val.to_string(); // fallback to string for anything else
+                const std::string& s = val.to_string();  // fallback to string for anything else
                 const auto len = static_cast<uint32_t>(s.size());
                 const size_t offset = out.size();
                 out.resize(offset + VAL_SIZE_32 + len);
@@ -261,7 +262,7 @@ struct RegisterNodeArgs {
     std::string id;
     std::string address;
     uint16_t port;
-    uint8_t mode; // 0: Standalone, 1: Coordinator, 2: Data
+    uint8_t mode;  // 0: Standalone, 1: Coordinator, 2: Data
 
     [[nodiscard]] std::vector<uint8_t> serialize() const {
         std::vector<uint8_t> out;

src/catalog/catalog.cpp

@@ -22,7 +22,6 @@
 
 namespace cloudsql {
 
-
 /**
  * @brief Create a new catalog
  */
@@ -73,13 +72,14 @@ bool Catalog::save(const std::string& filename) const {
  */
 oid_t Catalog::create_table(const std::string& table_name, std::vector<ColumnInfo> columns) {
     std::cerr << "--- [Catalog] create_table CALLED for " << table_name << " ---" << std::endl;
-    
+
     // Compute shards from ClusterManager for serialization
     std::vector<ShardInfo> shards;
     if (cluster_manager_ != nullptr) {
         auto data_nodes = cluster_manager_->get_data_nodes();
         if (!data_nodes.empty()) {
-            std::sort(data_nodes.begin(), data_nodes.end(), [](const auto& a, const auto& b) { return a.id < b.id; });
+            std::sort(data_nodes.begin(), data_nodes.end(),
+                      [](const auto& a, const auto& b) { return a.id < b.id; });
             uint32_t sid = 0;
             for (const auto& node : data_nodes) {
                 ShardInfo shard;
@@ -93,7 +93,8 @@ oid_t Catalog::create_table(const std::string& table_name, std::vector<ColumnInf
 
     if (raft_group_ != nullptr) {
         // Multi-Raft: Replicate DDL via Catalog Raft Group (ID 0)
-        // Serialize command: [Type:1][NameLen:4][Name][ColCount:4][Cols...][ShardCount:4][Shards...]
+        // Serialize command:
+        // [Type:1][NameLen:4][Name][ColCount:4][Cols...][ShardCount:4][Shards...]
         std::vector<uint8_t> cmd;
         cmd.push_back(1);  // Type 1: CreateTable
 
@@ -126,7 +127,7 @@ oid_t Catalog::create_table(const std::string& table_name, std::vector<ColumnInf
         for (const auto& shard : shards) {
             uint32_t addr_len = static_cast<uint32_t>(shard.node_address.size());
             offset = cmd.size();
-            cmd.resize(offset + 4 + addr_len + 4 + 2); 
+            cmd.resize(offset + 4 + addr_len + 4 + 2);
             std::memcpy(cmd.data() + offset, &addr_len, 4);
             std::memcpy(cmd.data() + offset + 4, shard.node_address.data(), addr_len);
             std::memcpy(cmd.data() + offset + 4 + addr_len, &shard.shard_id, 4);
@@ -137,13 +138,15 @@ oid_t Catalog::create_table(const std::string& table_name, std::vector<ColumnInf
             return create_table_local(table_name, std::move(columns), std::move(shards));
         }
     }
-    
+
     return create_table_local(table_name, std::move(columns), std::move(shards));
 }
 
-oid_t Catalog::create_table_local(const std::string& table_name, std::vector<ColumnInfo> columns, std::vector<ShardInfo> shards) {
+oid_t Catalog::create_table_local(const std::string& table_name, std::vector<ColumnInfo> columns,
+                                  std::vector<ShardInfo> shards) {
     if (table_exists_by_name(table_name)) {
-        std::cerr << "--- [Catalog] create_table_local: Table already exists " << table_name << " ---" << std::endl;
+        std::cerr << "--- [Catalog] create_table_local: Table already exists " << table_name
+                  << " ---" << std::endl;
         auto meta_opt = get_table_by_name(table_name);
         return (*meta_opt)->table_id;
     }
@@ -158,7 +161,8 @@ oid_t Catalog::create_table_local(const std::string& table_name, std::vector<Col
     if (table->shards.empty() && cluster_manager_ != nullptr) {
         auto data_nodes = cluster_manager_->get_data_nodes();
         if (!data_nodes.empty()) {
-            std::sort(data_nodes.begin(), data_nodes.end(), [](const auto& a, const auto& b) { return a.id < b.id; });
+            std::sort(data_nodes.begin(), data_nodes.end(),
+                      [](const auto& a, const auto& b) { return a.id < b.id; });
             uint32_t sid = 0;
             for (const auto& node : data_nodes) {
                 ShardInfo shard;
@@ -178,7 +182,8 @@ oid_t Catalog::create_table_local(const std::string& table_name, std::vector<Col
         table->shards.push_back(shard);
     }
 
-    std::cerr << "--- [Catalog] Table " << table_name << " initialized with " << table->shards.size() << " shards ---" << std::endl;
+    std::cerr << "--- [Catalog] Table " << table_name << " initialized with "
+              << table->shards.size() << " shards ---" << std::endl;
 
     const oid_t id = table->table_id;
     tables_[id] = std::move(table);
@@ -215,12 +220,13 @@ bool Catalog::drop_table_local(oid_t table_id) {
 
 void Catalog::apply(const raft::LogEntry& entry) {
     if (entry.data.empty()) return;
-    std::cerr << "--- [Catalog] apply CALLED for entry type " << (int)entry.data[0] << " ---" << std::endl;
+    std::cerr << "--- [Catalog] apply CALLED for entry type " << (int)entry.data[0] << " ---"
+              << std::endl;
 
     uint8_t type = entry.data[0];
     if (type == 1) {  // CreateTable
         size_t offset = 1;
-        
+
         uint32_t name_len = 0;
         std::memcpy(&name_len, entry.data.data() + offset, 4);
         offset += 4;
@@ -296,13 +302,13 @@ std::optional<TableInfo*> Catalog::get_table_by_name(const std::string& table_na
             return pair.second.get();
         }
     }
-    
+
     std::cerr << "--- [Catalog] Table NOT FOUND: " << table_name << ". Catalog contains: ";
     for (auto& pair : tables_) {
         std::cerr << pair.second->name << ", ";
     }
     std::cerr << " ---" << std::endl;
-    
+
     return std::nullopt;
 }
 

src/distributed/distributed_executor.cpp

@@ -9,9 +9,9 @@
 #include <future>
 #include <iostream>
 #include <string>
+#include <thread>
 #include <utility>
 #include <vector>
-#include <thread>
 
 #include "catalog/catalog.hpp"
 #include "common/cluster_manager.hpp"
@@ -132,7 +132,7 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                 std::vector<ColumnInfo> catalog_cols;
                 uint16_t pos = 0;
                 for (const auto& col : ct.columns()) {
-                    common::ValueType vtype = common::ValueType::TYPE_INT32; // Simplified for POC
+                    common::ValueType vtype = common::ValueType::TYPE_INT32;  // Simplified for POC
                     if (col.type_ == "TEXT") vtype = common::ValueType::TYPE_TEXT;
                     catalog_cols.emplace_back(col.name_, vtype, pos++);
                 }
@@ -145,7 +145,8 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                 }
             }
 
-            // Explicit forward to data nodes to ensure they have metadata IMMEDIATELY (POC workaround for Raft lag)
+            // Explicit forward to data nodes to ensure they have metadata IMMEDIATELY (POC
+            // workaround for Raft lag)
             network::ExecuteFragmentArgs args;
             args.sql = raw_sql;
             args.context_id = "ddl_sync";
@@ -155,10 +156,11 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                 network::RpcClient client(node.address, node.cluster_port);
                 if (client.connect()) {
                     std::vector<uint8_t> resp;
-                    static_cast<void>(client.call(network::RpcType::ExecuteFragment, payload, resp));
+                    static_cast<void>(
+                        client.call(network::RpcType::ExecuteFragment, payload, resp));
                 }
             }
-            
+
             res.set_rows_affected(1);
             // Small sleep after DDL to let things settle
             std::this_thread::sleep_for(std::chrono::milliseconds(500));
@@ -357,12 +359,13 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
         const auto* insert_stmt = dynamic_cast<const parser::InsertStatement*>(&stmt);
         if (insert_stmt != nullptr && !insert_stmt->values().empty()) {
             std::unordered_map<uint32_t, std::vector<std::vector<std::string>>> partitions;
-            
+
             for (const auto& row_exprs : insert_stmt->values()) {
                 if (row_exprs.empty()) continue;
                 // Assume first column is sharding key
                 if (row_exprs[0]->type() == parser::ExprType::Constant) {
-                    const auto* const_expr = dynamic_cast<const parser::ConstantExpr*>(row_exprs[0].get());
+                    const auto* const_expr =
+                        dynamic_cast<const parser::ConstantExpr*>(row_exprs[0].get());
                     if (const_expr != nullptr) {
                         const common::Value pk_val = const_expr->value();
                         const uint32_t shard_idx = cluster::ShardManager::compute_shard(
@@ -384,11 +387,13 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                 const auto& node = data_nodes[shard_idx];
                 network::RpcClient client(node.address, node.cluster_port);
                 if (client.connect()) {
-                    std::string shard_sql = "INSERT INTO " + insert_stmt->table()->to_string() + " VALUES ";
+                    std::string shard_sql =
+                        "INSERT INTO " + insert_stmt->table()->to_string() + " VALUES ";
                     for (size_t i = 0; i < rows.size(); ++i) {
                         shard_sql += "(";
                         for (size_t j = 0; j < rows[i].size(); ++j) {
-                            shard_sql += rows[i][j] + std::string(j == rows[i].size() - 1 ? "" : ", ");
+                            shard_sql +=
+                                rows[i][j] + std::string(j == rows[i].size() - 1 ? "" : ", ");
                         }
                         shard_sql += std::string(")") + (i == rows.size() - 1 ? "" : ", ");
                     }
@@ -411,22 +416,22 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                     errors += "[" + node.id + "] Connect failed; ";
                 }
             }
-            
+
             QueryResult res;
             if (!errors.empty()) res.set_error(errors);
             res.set_rows_affected(total_affected);
             return res;
         }
     } else if (type == parser::StmtType::Select || type == parser::StmtType::Update ||
                type == parser::StmtType::Delete) {
-        
         bool is_join = false;
         if (type == parser::StmtType::Select) {
             const auto* sel = dynamic_cast<const parser::SelectStatement*>(&stmt);
             if (sel && !sel->joins().empty()) is_join = true;
         }
 
-        // Try shard pruning based on WHERE clause, but ONLY if NOT a join (joins are complex in POC)
+        // Try shard pruning based on WHERE clause, but ONLY if NOT a join (joins are complex in
+        // POC)
         const parser::Expression* where_expr = nullptr;
         if (!is_join) {
             if (type == parser::StmtType::Select) {
@@ -465,7 +470,8 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
     }
 
     network::ExecuteFragmentArgs fragment_args;
-    // Strip LIMIT/OFFSET from fragment SQL to ensure data nodes return all rows for global processing
+    // Strip LIMIT/OFFSET from fragment SQL to ensure data nodes return all rows for global
+    // processing
     fragment_args.sql = (type == parser::StmtType::Select) ? strip_limit_offset(raw_sql) : raw_sql;
     fragment_args.context_id = context_id;
     auto fragment_payload = fragment_args.serialize();
@@ -526,8 +532,10 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                     if (col->type() == parser::ExprType::Function) {
                         const auto* func = dynamic_cast<const parser::FunctionExpr*>(col.get());
                         std::string name = func->name();
-                        std::transform(name.begin(), name.end(), name.begin(), [](unsigned char c){ return std::toupper(c); });
-                        if (name == "COUNT" || name == "SUM" || name == "MIN" || name == "MAX" || name == "AVG") {
+                        std::transform(name.begin(), name.end(), name.begin(),
+                                       [](unsigned char c) { return std::toupper(c); });
+                        if (name == "COUNT" || name == "SUM" || name == "MIN" || name == "MAX" ||
+                            name == "AVG") {
                             is_global_aggregate = true;
                             agg_types.push_back(name);
                         } else {
@@ -548,7 +556,7 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                 if (row.size() < agg_types.size()) continue;
                 for (size_t i = 0; i < agg_types.size(); ++i) {
                     if (agg_types[i].empty()) continue;
-                    
+
                     const auto& val = row.get(i);
                     if (val.is_null()) continue;
 
@@ -569,7 +577,7 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                     }
                 }
             }
-            
+
             executor::Tuple merged_tuple;
             for (auto& v : final_vals) {
                 merged_tuple.values().push_back(std::move(v));
@@ -587,18 +595,21 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                     if (col_idx == static_cast<size_t>(-1)) {
                         // try unqualified
                         size_t dot = col_name.find_last_of('.');
-                        if (dot != std::string::npos) col_idx = res.schema().find_column(col_name.substr(dot+1));
+                        if (dot != std::string::npos)
+                            col_idx = res.schema().find_column(col_name.substr(dot + 1));
                     }
 
                     if (col_idx == static_cast<size_t>(-1)) {
                         // Fallback for POC if ORDER BY key is not in projection
                         col_idx = 0;
                     }
 
-                    if (col_idx != static_cast<size_t>(-1) && col_idx < res.schema().columns().size()) {
-                        std::sort(aggregated_rows.begin(), aggregated_rows.end(), [col_idx](const auto& a, const auto& b) {
-                            return a.get(col_idx) < b.get(col_idx);
-                        });
+                    if (col_idx != static_cast<size_t>(-1) &&
+                        col_idx < res.schema().columns().size()) {
+                        std::sort(aggregated_rows.begin(), aggregated_rows.end(),
+                                  [col_idx](const auto& a, const auto& b) {
+                                      return a.get(col_idx) < b.get(col_idx);
+                                  });
                     }
                 }
             }
@@ -609,15 +620,16 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                 if (sel && (sel->has_limit() || sel->has_offset())) {
                     int64_t limit = sel->limit();
                     int64_t offset = sel->offset();
-                    
+
                     if (offset > 0) {
                         if (static_cast<size_t>(offset) >= aggregated_rows.size()) {
                             aggregated_rows.clear();
                         } else {
-                            aggregated_rows.erase(aggregated_rows.begin(), aggregated_rows.begin() + offset);
+                            aggregated_rows.erase(aggregated_rows.begin(),
+                                                  aggregated_rows.begin() + offset);
                         }
                     }
-                    
+
                     if (limit >= 0 && static_cast<size_t>(limit) < aggregated_rows.size()) {
                         aggregated_rows.resize(limit);
                     }