style: automated clang-format fixes

Author: poyrazK

include/executor/types.hpp

@@ -11,12 +11,12 @@
 #define CLOUDSQL_EXECUTOR_TYPES_HPP
 
 #include <cstdint>
+#include <initializer_list>
 #include <memory>
 #include <memory_resource>
 #include <stdexcept>
 #include <string>
 #include <vector>
-#include <initializer_list>
 
 #include "common/value.hpp"
 
@@ -131,21 +131,22 @@ class Tuple {
 
    public:
     Tuple() = default;
-    
+
     // Explicit PMR vector constructor
     explicit Tuple(std::pmr::vector<common::Value> values) : values_(std::move(values)) {}
-    
+
     // Initializer list constructor
     Tuple(std::initializer_list<common::Value> list) : values_(list) {}
 
     // Support allocation from a custom memory resource
     explicit Tuple(std::pmr::memory_resource* mr)
         : values_(mr ? mr : std::pmr::get_default_resource()) {}
-    
+
     // Support construction from standard vector or PMR vector with specific resource
     template <typename VectorType,
               typename = std::enable_if_t<!std::is_same_v<std::decay_t<VectorType>, Tuple>>,
-              typename std::enable_if_t<!std::is_same_v<std::decay_t<VectorType>, std::pmr::memory_resource*>>* = nullptr>
+              typename std::enable_if_t<
+                  !std::is_same_v<std::decay_t<VectorType>, std::pmr::memory_resource*>>* = nullptr>
     Tuple(const VectorType& values, std::pmr::memory_resource* mr = nullptr)
         : values_(values.begin(), values.end(), mr ? mr : std::pmr::get_default_resource()) {}
 

src/executor/operator.cpp

@@ -382,21 +382,21 @@ bool SortOperator::open() {
     }
 
     /* Perform sort using child schema for evaluation */
-    std::stable_sort(sorted_tuples_.begin(), sorted_tuples_.end(),
-                     [this](const Tuple& a, const Tuple& b) {
-                         for (size_t i = 0; i < sort_keys_.size(); ++i) {
-                             const common::Value val_a = sort_keys_[i]->evaluate(&a, &schema_, get_params());
-                             const common::Value val_b = sort_keys_[i]->evaluate(&b, &schema_, get_params());
-                             const bool asc = ascending_[i];
-                             if (val_a < val_b) {
-                                 return asc;
-                             }
-                             if (val_b < val_a) {
-                                 return !asc;
-                             }
-                         }
-                         return false;
-                     });
+    std::stable_sort(
+        sorted_tuples_.begin(), sorted_tuples_.end(), [this](const Tuple& a, const Tuple& b) {
+            for (size_t i = 0; i < sort_keys_.size(); ++i) {
+                const common::Value val_a = sort_keys_[i]->evaluate(&a, &schema_, get_params());
+                const common::Value val_b = sort_keys_[i]->evaluate(&b, &schema_, get_params());
+                const bool asc = ascending_[i];
+                if (val_a < val_b) {
+                    return asc;
+                }
+                if (val_b < val_a) {
+                    return !asc;
+                }
+            }
+            return false;
+        });
 
     current_index_ = 0;
     set_state(ExecState::Open);
@@ -502,7 +502,8 @@ bool AggregateOperator::open() {
         if (!is_global) {
             key = "";
             for (const auto& gb : group_by_) {
-                auto val = gb ? gb->evaluate(&tuple, &child_schema, get_params()) : common::Value::make_null();
+                auto val = gb ? gb->evaluate(&tuple, &child_schema, get_params())
+                              : common::Value::make_null();
                 key += val.to_string() + "|";
                 gb_vals.push_back(std::move(val));
             }
@@ -724,7 +725,8 @@ bool HashJoinOperator::next(Tuple& out_tuple) {
         if (left_->next(next_left)) {
             left_tuple_ = std::move(next_left);
             left_had_match_ = false;
-            const common::Value key = left_key_->evaluate(&(left_tuple_.value()), &left_schema, get_params());
+            const common::Value key =
+                left_key_->evaluate(&(left_tuple_.value()), &left_schema, get_params());
 
             /* Look up in hash table */
             auto range = hash_table_.equal_range(key.to_string());

src/executor/query_executor.cpp

@@ -204,8 +204,8 @@ QueryResult QueryExecutor::execute(const PreparedStatement& prepared,
                 for (const auto& idx_info : prepared.table_meta->indexes) {
                     if (!idx_info.column_positions.empty()) {
                         uint16_t pos = idx_info.column_positions[0];
-                        if (!apply_index_write(*prepared.indexes[cached_idx_ptr++], tuple.get(pos), tid,
-                                               IndexOp::Insert, err)) {
+                        if (!apply_index_write(*prepared.indexes[cached_idx_ptr++], tuple.get(pos),
+                                               tid, IndexOp::Insert, err)) {
                             throw std::runtime_error(err);
                         }
                     }

src/storage/heap_table.cpp

@@ -106,13 +106,13 @@ bool HeapTable::Iterator::next_meta(TupleMeta& out_meta) {
             if (offset != 0) {
                 /* Found a record: Deserialize it in-place from the pinned buffer */
                 const uint8_t* const data = reinterpret_cast<const uint8_t*>(buffer + offset);
-                
+
                 // Read Tuple Length (first 2 bytes)
                 uint16_t tuple_data_len;
                 std::memcpy(&tuple_data_len, data, 2);
-                
+
                 const size_t record_len = static_cast<size_t>(tuple_data_len);
-                if (record_len < 18) { // 2 len + 8 xmin + 8 xmax
+                if (record_len < 18) {  // 2 len + 8 xmin + 8 xmax
                     table_.bpm_.unpin_page(table_.filename_, next_id_.page_num, false);
                     return false;
                 }
@@ -123,8 +123,10 @@ bool HeapTable::Iterator::next_meta(TupleMeta& out_meta) {
 
                 size_t cursor = 18;
                 std::pmr::vector<common::Value> values(mr_);
-                
-                std::cerr << "DEBUG: Iterator::next_meta values.reserve(" << table_.schema_.column_count() << ") iter=" << this << " table=" << &table_ << " mr=" << mr_ << std::endl;
+
+                std::cerr << "DEBUG: Iterator::next_meta values.reserve("
+                          << table_.schema_.column_count() << ") iter=" << this
+                          << " table=" << &table_ << " mr=" << mr_ << std::endl;
                 values.reserve(table_.schema_.column_count());
 
                 for (size_t i = 0; i < table_.schema_.column_count(); ++i) {
@@ -209,7 +211,7 @@ HeapTable::TupleId HeapTable::insert(const executor::Tuple& tuple, uint64_t xmin
     };
 
     uint64_t xmax = 0;
-    payload_size = 18; // 2 len + 8 xmin + 8 xmax
+    payload_size = 18;  // 2 len + 8 xmin + 8 xmax
     // placeholder for length
     std::memset(payload_ptr, 0, 2);
     std::memcpy(payload_ptr + 2, &xmin, 8);
@@ -247,7 +249,7 @@ HeapTable::TupleId HeapTable::insert(const executor::Tuple& tuple, uint64_t xmin
     }
 
     const auto required = static_cast<uint16_t>(payload_size);
-    std::memcpy(payload_ptr, &required, 2); // set final length
+    std::memcpy(payload_ptr, &required, 2);  // set final length
 
     while (true) {
         // Use cached page if available
@@ -260,7 +262,7 @@ HeapTable::TupleId HeapTable::insert(const executor::Tuple& tuple, uint64_t xmin
             if (!cached_page_) {
                 cached_page_ = bpm_.new_page(filename_, &cached_page_id_);
                 if (!cached_page_) {
-                    return {0, 0}; // Buffer pool full or allocation failed
+                    return {0, 0};  // Buffer pool full or allocation failed
                 }
                 last_page_id_ = cached_page_id_;
             }
@@ -406,7 +408,7 @@ bool HeapTable::get_meta(const TupleId& tuple_id, TupleMeta& out_meta) const {
         if (offset == 0) return false;
 
         const uint8_t* const data = reinterpret_cast<const uint8_t*>(buffer + offset);
-        
+
         uint16_t tuple_data_len;
         std::memcpy(&tuple_data_len, data, 2);
         const size_t record_len = static_cast<size_t>(tuple_data_len);
@@ -481,7 +483,7 @@ bool HeapTable::get_meta(const TupleId& tuple_id, TupleMeta& out_meta) const {
     }
 
     const uint8_t* const data = reinterpret_cast<const uint8_t*>(buffer + offset);
-    
+
     uint16_t tuple_data_len;
     std::memcpy(&tuple_data_len, data, 2);
     const size_t record_len = static_cast<size_t>(tuple_data_len);
@@ -573,7 +575,7 @@ uint64_t HeapTable::tuple_count() const {
                         sizeof(uint16_t));
             if (offset != 0) {
                 uint64_t xmax = 0;
-                std::memcpy(&xmax, buffer + offset + 10, 8); // 2 len + 8 xmin
+                std::memcpy(&xmax, buffer + offset + 10, 8);  // 2 len + 8 xmin
                 if (xmax == 0) count++;
             }
         }