Apply formatting rules (#2649)

#### Reference Issues/PRs
Monday ref: 10048929527

#### What does this implement or fix?

#### Any other comments?

#### Checklist

<details>
  <summary>
   Checklist for code changes...
  </summary>
 
- [ ] Have you updated the relevant docstrings, documentation and
copyright notice?
- [ ] Is this contribution tested against [all ArcticDB's
features](../docs/mkdocs/docs/technical/contributing.md)?
- [ ] Do all exceptions introduced raise appropriate [error
messages](https://docs.arcticdb.io/error_messages/)?
 - [ ] Are API changes highlighted in the PR description?
- [ ] Is the PR labelled as enhancement or bug so it appears in
autogenerated release notes?
</details>

<!--
Thanks for contributing a Pull Request to ArcticDB! Please ensure you
have taken a look at:
- ArcticDB's Code of Conduct:
https://github.com/man-group/ArcticDB/blob/master/CODE_OF_CONDUCT.md
- ArcticDB's Contribution Licensing:
https://github.com/man-group/ArcticDB/blob/master/docs/mkdocs/docs/technical/contributing.md#contribution-licensing
-->

Author: G-D-Petrov

.github/workflows/build.yml

@@ -144,14 +144,12 @@ jobs:
       - name: Lint Python
         if: always()
         run: |
-          python3 build_tooling/format.py --check --type python \
-            || true # formatting not enforced yet
+          python3 build_tooling/format.py --check --type python
 
       - name: Lint C++
         if: always()
         run: |
-          python3 build_tooling/format.py --check --type cpp \
-            || true # formatting not enforced yet
+          python3 build_tooling/format.py --check --type cpp
 
   common_config:
     needs: [cibw_docker_image]

cpp/arcticdb/arrow/array_from_block.hpp

@@ -2,7 +2,8 @@
  *
  * Use of this software is governed by the Business Source License 1.1 included in the file licenses/BSL.txt.
  *
- * As of the Change Date specified in that file, in accordance with the Business Source License, use of this software will be governed by the Apache License, version 2.0.
+ * As of the Change Date specified in that file, in accordance with the Business Source License, use of this software
+ * will be governed by the Apache License, version 2.0.
  */
 #pragma once
 
@@ -13,77 +14,78 @@
 
 namespace arcticdb {
 
-inline std::optional<sparrow::validity_bitmap> create_validity_bitmap(size_t offset, const Column& column, size_t bitmap_size) {
-    if(column.has_extra_buffer(offset, ExtraBufferType::BITMAP)) {
-        auto &bitmap_buffer = column.get_extra_buffer(offset, ExtraBufferType::BITMAP);
-        return sparrow::validity_bitmap{reinterpret_cast<uint8_t *>(bitmap_buffer.block(0)->release()), bitmap_size};
+inline std::optional<sparrow::validity_bitmap> create_validity_bitmap(
+        size_t offset, const Column& column, size_t bitmap_size
+) {
+    if (column.has_extra_buffer(offset, ExtraBufferType::BITMAP)) {
+        auto& bitmap_buffer = column.get_extra_buffer(offset, ExtraBufferType::BITMAP);
+        return sparrow::validity_bitmap{reinterpret_cast<uint8_t*>(bitmap_buffer.block(0)->release()), bitmap_size};
     } else {
         return std::nullopt;
     }
 }
 
-template <typename T>
+template<typename T>
 sparrow::primitive_array<T> create_primitive_array(
-        T* data_ptr,
-        size_t data_size,
-        std::optional<sparrow::validity_bitmap>&& validity_bitmap) {
+        T* data_ptr, size_t data_size, std::optional<sparrow::validity_bitmap>&& validity_bitmap
+) {
     sparrow::u8_buffer<T> buffer(data_ptr, data_size);
-    if(validity_bitmap) {
+    if (validity_bitmap) {
         return sparrow::primitive_array<T>{std::move(buffer), data_size, std::move(*validity_bitmap)};
     } else {
         return sparrow::primitive_array<T>{std::move(buffer), data_size};
     }
 }
 
-template <>
+template<>
 inline sparrow::primitive_array<bool> create_primitive_array(
-        bool* data_ptr,
-        size_t data_size,
-        std::optional<sparrow::validity_bitmap>&& validity_bitmap) {
+        bool* data_ptr, size_t data_size, std::optional<sparrow::validity_bitmap>&& validity_bitmap
+) {
     // We need special handling for bools because arrow uses dense bool representation (i.e. 8 bools per byte)
     // Our internal representation is not dense. We use sparrow's `make_data_buffer` utility, but if needed, we can use
     // our own.
     auto buffer = sparrow::details::primitive_data_access<bool>::make_data_buffer(std::span{data_ptr, data_size});
-    if(validity_bitmap) {
+    if (validity_bitmap) {
         return sparrow::primitive_array<bool>{std::move(buffer), data_size, std::move(*validity_bitmap)};
     } else {
         return sparrow::primitive_array<bool>{std::move(buffer), data_size};
     }
 }
 
-template <typename T>
+template<typename T>
 sparrow::timestamp_without_timezone_nanoseconds_array create_timestamp_array(
-        T* data_ptr,
-        size_t data_size,
-        std::optional<sparrow::validity_bitmap>&& validity_bitmap) {
+        T* data_ptr, size_t data_size, std::optional<sparrow::validity_bitmap>&& validity_bitmap
+) {
     static_assert(sizeof(T) == sizeof(sparrow::zoned_time_without_timezone_nanoseconds));
     // We default to using timestamps without timezones. If the normalization metadata contains a timezone it will be
     // applied during normalization in python layer.
     sparrow::u8_buffer<sparrow::zoned_time_without_timezone_nanoseconds> buffer(
-        reinterpret_cast<sparrow::zoned_time_without_timezone_nanoseconds*>(data_ptr), data_size);
-    if(validity_bitmap) {
-        return sparrow::timestamp_without_timezone_nanoseconds_array{std::move(buffer), data_size, std::move(*validity_bitmap)};
+            reinterpret_cast<sparrow::zoned_time_without_timezone_nanoseconds*>(data_ptr), data_size
+    );
+    if (validity_bitmap) {
+        return sparrow::timestamp_without_timezone_nanoseconds_array{
+                std::move(buffer), data_size, std::move(*validity_bitmap)
+        };
     } else {
         return sparrow::timestamp_without_timezone_nanoseconds_array{std::move(buffer), data_size};
     }
 }
 
-template <typename T>
+template<typename T>
 sparrow::dictionary_encoded_array<T> create_dict_array(
-    sparrow::array&& dict_values_array,
-    sparrow::u8_buffer<T>&& dict_keys_buffer,
-    std::optional<sparrow::validity_bitmap>&& validity_bitmap
-    ) {
-    if(validity_bitmap) {
+        sparrow::array&& dict_values_array, sparrow::u8_buffer<T>&& dict_keys_buffer,
+        std::optional<sparrow::validity_bitmap>&& validity_bitmap
+) {
+    if (validity_bitmap) {
         return sparrow::dictionary_encoded_array<T>{
-            typename sparrow::dictionary_encoded_array<T>::keys_buffer_type(std::move(dict_keys_buffer)),
-            std::move(dict_values_array),
-            std::move(*validity_bitmap)
+                typename sparrow::dictionary_encoded_array<T>::keys_buffer_type(std::move(dict_keys_buffer)),
+                std::move(dict_values_array),
+                std::move(*validity_bitmap)
         };
     } else {
         return sparrow::dictionary_encoded_array<T>{
-            typename sparrow::dictionary_encoded_array<T>::keys_buffer_type(std::move(dict_keys_buffer)),
-            std::move(dict_values_array),
+                typename sparrow::dictionary_encoded_array<T>::keys_buffer_type(std::move(dict_keys_buffer)),
+                std::move(dict_values_array),
         };
     }
 }
@@ -102,12 +104,11 @@ inline sparrow::big_string_array minimal_strings_dict() {
     return {std::move(strings_buffer), std::move(offsets_buffer)};
 }
 
-template <typename TagType>
+template<typename TagType>
 sparrow::array string_dict_from_block(
-        TypedBlockData<TagType>& block,
-        const Column& column,
-        std::string_view name,
-        std::optional<sparrow::validity_bitmap>&& maybe_bitmap) {
+        TypedBlockData<TagType>& block, const Column& column, std::string_view name,
+        std::optional<sparrow::validity_bitmap>&& maybe_bitmap
+) {
     const auto offset = block.offset();
     // We use 64-bit offsets and 32-bit keys because we use a layout where each row-segment has its own arrow array.
     // By default, the row-segments are 100k rows, so number of rows wouldn't exceed 32-bit ints.
@@ -119,45 +120,47 @@ sparrow::array string_dict_from_block(
     // We use `int32_t` dictionary keys because pyarrow doesn't work with unsigned dictionary keys:
     // https://github.com/pola-rs/polars/issues/10977
     const auto block_size = block.row_count();
-    sparrow::u8_buffer<int32_t> dict_keys_buffer{reinterpret_cast<int32_t *>(block.release()), block_size};
+    sparrow::u8_buffer<int32_t> dict_keys_buffer{reinterpret_cast<int32_t*>(block.release()), block_size};
 
     const bool has_offset_buffer = column.has_extra_buffer(offset, ExtraBufferType::OFFSET);
     const bool has_string_buffer = column.has_extra_buffer(offset, ExtraBufferType::STRING);
     auto dict_values_array = [&]() -> sparrow::big_string_array {
         if (has_offset_buffer && has_string_buffer) {
             auto& string_offsets = column.get_extra_buffer(offset, ExtraBufferType::OFFSET);
             const auto offset_buffer_value_count = string_offsets.block(0)->bytes() / sizeof(int64_t);
-            sparrow::u8_buffer<int64_t> offsets_buffer(reinterpret_cast<int64_t *>(string_offsets.block(0)->release()), offset_buffer_value_count);
+            sparrow::u8_buffer<int64_t> offsets_buffer(
+                    reinterpret_cast<int64_t*>(string_offsets.block(0)->release()), offset_buffer_value_count
+            );
             auto& strings = column.get_extra_buffer(offset, ExtraBufferType::STRING);
             const auto strings_buffer_size = strings.block(0)->bytes();
-            sparrow::u8_buffer<char> strings_buffer(reinterpret_cast<char *>(strings.block(0)->release()), strings_buffer_size);
+            sparrow::u8_buffer<char> strings_buffer(
+                    reinterpret_cast<char*>(strings.block(0)->release()), strings_buffer_size
+            );
             return {std::move(strings_buffer), std::move(offsets_buffer)};
         } else if (!has_offset_buffer && !has_string_buffer) {
             return minimal_strings_dict();
         } else {
-            util::raise_rte("Arrow output string creation expected either both or neither of OFFSET and STRING buffers to be present");
+            util::raise_rte("Arrow output string creation expected either both or neither of OFFSET and STRING buffers "
+                            "to be present");
         }
     }();
 
     auto dict_encoded = create_dict_array<int32_t>(
-        sparrow::array{std::move(dict_values_array)},
-        std::move(dict_keys_buffer),
-        std::move(maybe_bitmap)
+            sparrow::array{std::move(dict_values_array)}, std::move(dict_keys_buffer), std::move(maybe_bitmap)
     );
 
     sparrow::array arr{std::move(dict_encoded)};
     arr.set_name(name);
     return arr;
 }
 
-template <typename TagType>
+template<typename TagType>
 sparrow::array arrow_array_from_block(
-        TypedBlockData<TagType>& block,
-        std::string_view name,
-        std::optional<sparrow::validity_bitmap>&& maybe_bitmap) {
+        TypedBlockData<TagType>& block, std::string_view name, std::optional<sparrow::validity_bitmap>&& maybe_bitmap
+) {
     using DataTagType = typename TagType::DataTypeTag;
     using RawType = typename DataTagType::raw_type;
-    auto *data_ptr = block.release();
+    auto* data_ptr = block.release();
     const auto data_size = block.row_count();
     auto arr = [&]() {
         if constexpr (is_time_type(TagType::DataTypeTag::data_type)) {
@@ -172,4 +175,4 @@ sparrow::array arrow_array_from_block(
     return arr;
 }
 
-}
+} // namespace arcticdb

cpp/arcticdb/arrow/arrow_handlers.cpp

@@ -2,7 +2,8 @@
  *
  * Use of this software is governed by the Business Source License 1.1 included in the file licenses/BSL.txt.
  *
- * As of the Change Date specified in that file, in accordance with the Business Source License, use of this software will be governed by the Apache License, version 2.0.
+ * As of the Change Date specified in that file, in accordance with the Business Source License, use of this software
+ * will be governed by the Apache License, version 2.0.
  */
 #include <arrow/arrow_handlers.hpp>
 #include <arcticdb/codec/encoding_sizes.hpp>
@@ -14,46 +15,41 @@
 namespace arcticdb {
 
 void ArrowStringHandler::handle_type(
-    const uint8_t *&data,
-    Column& dest_column,
-    const EncodedFieldImpl &field,
-    const ColumnMapping& m,
-    const DecodePathData& shared_data,
-    std::any& handler_data,
-    EncodingVersion encoding_version,
-    const std::shared_ptr<StringPool>& string_pool) {
+        const uint8_t*& data, Column& dest_column, const EncodedFieldImpl& field, const ColumnMapping& m,
+        const DecodePathData& shared_data, std::any& handler_data, EncodingVersion encoding_version,
+        const std::shared_ptr<StringPool>& string_pool
+) {
     ARCTICDB_SAMPLE(ArrowHandleString, 0)
     util::check(field.has_ndarray(), "String handler expected array");
     schema::check<ErrorCode::E_UNSUPPORTED_COLUMN_TYPE>(
             m.source_type_desc_.data_type() == DataType::UTF_DYNAMIC64,
             "Cannot read column '{}' into Arrow output format as it is of unsupported type {} (only {} is supported)",
-            m.frame_field_descriptor_.name(), m.source_type_desc_.data_type(), DataType::UTF_DYNAMIC64);
+            m.frame_field_descriptor_.name(),
+            m.source_type_desc_.data_type(),
+            DataType::UTF_DYNAMIC64
+    );
     ARCTICDB_DEBUG(log::version(), "String handler got encoded field: {}", field.DebugString());
-    const auto &ndarray = field.ndarray();
+    const auto& ndarray = field.ndarray();
     const auto bytes = encoding_sizes::data_uncompressed_size(ndarray);
 
-    Column decoded_data{m.source_type_desc_, bytes / get_type_size(m.source_type_desc_.data_type()),
-                                       AllocationType::DYNAMIC, Sparsity::PERMITTED};
-
+    Column decoded_data{
+            m.source_type_desc_,
+            bytes / get_type_size(m.source_type_desc_.data_type()),
+            AllocationType::DYNAMIC,
+            Sparsity::PERMITTED
+    };
 
-    data += decode_field(m.source_type_desc_, field, data, decoded_data, decoded_data.opt_sparse_map(), encoding_version);
+    data += decode_field(
+            m.source_type_desc_, field, data, decoded_data, decoded_data.opt_sparse_map(), encoding_version
+    );
 
-    convert_type(
-        decoded_data,
-        dest_column,
-        m,
-        shared_data,
-        handler_data,
-        string_pool);
+    convert_type(decoded_data, dest_column, m, shared_data, handler_data, string_pool);
 }
 
 void ArrowStringHandler::convert_type(
-    const Column& source_column,
-    Column& dest_column,
-    const ColumnMapping& mapping,
-    const DecodePathData&,
-    std::any&,
-    const std::shared_ptr<StringPool>& string_pool) const {
+        const Column& source_column, Column& dest_column, const ColumnMapping& mapping, const DecodePathData&,
+        std::any&, const std::shared_ptr<StringPool>& string_pool
+) const {
     using ArcticStringColumnTag = ScalarTagType<DataTypeTag<DataType::UTF_DYNAMIC64>>;
     auto input_data = source_column.data();
     struct DictEntry {
@@ -69,7 +65,9 @@ void ArrowStringHandler::convert_type(
     unique_offsets.reserve(source_column.row_count());
     int64_t bytes = 0;
     int32_t unique_offset_count = 0;
-    auto dest_ptr = reinterpret_cast<int32_t*>(dest_column.bytes_at(mapping.offset_bytes_, source_column.row_count() * sizeof(int32_t)));
+    auto dest_ptr = reinterpret_cast<int32_t*>(
+            dest_column.bytes_at(mapping.offset_bytes_, source_column.row_count() * sizeof(int32_t))
+    );
 
     util::BitSet bitset;
     util::BitSet::bulk_insert_iterator inserter(bitset);
@@ -78,7 +76,12 @@ void ArrowStringHandler::convert_type(
     // TODO: This can't be right if the column was sparse as it has only been decoded, not expanded
     for (auto en = input_data.cbegin<ArcticStringColumnTag, IteratorType::ENUMERATED>(); en != end; ++en) {
         if (is_a_string(en->value())) {
-            auto [entry, is_emplaced] = unique_offsets.try_emplace(en->value(), DictEntry{static_cast<int32_t>(unique_offset_count), bytes, string_pool->get_const_view(en->value())});
+            auto [entry, is_emplaced] = unique_offsets.try_emplace(
+                    en->value(),
+                    DictEntry{
+                            static_cast<int32_t>(unique_offset_count), bytes, string_pool->get_const_view(en->value())
+                    }
+            );
             if (is_emplaced) {
                 bytes += entry->second.strv.size();
                 unique_offsets_in_order.push_back(en->value());
@@ -102,14 +105,22 @@ void ArrowStringHandler::convert_type(
         create_dense_bitmap(mapping.offset_bytes_, bitset, dest_column, AllocationType::DETACHABLE);
     } // else there weren't any Nones or NaNs
     // bitset.count() == 0 is the special case where all of the rows contained None or NaN. In this case, do not create
-    // the extra string and offset buffers. string_dict_from_block will then do the right thing and call minimal_strings_dict
+    // the extra string and offset buffers. string_dict_from_block will then do the right thing and call
+    // minimal_strings_dict
     if (bitset.count() > 0) {
-        auto& string_buffer = dest_column.create_extra_buffer(mapping.offset_bytes_, ExtraBufferType::STRING, bytes, AllocationType::DETACHABLE);
-        auto& offsets_buffer = dest_column.create_extra_buffer(mapping.offset_bytes_, ExtraBufferType::OFFSET, (unique_offsets_in_order.size() + 1) * sizeof(int64_t), AllocationType::DETACHABLE);
+        auto& string_buffer = dest_column.create_extra_buffer(
+                mapping.offset_bytes_, ExtraBufferType::STRING, bytes, AllocationType::DETACHABLE
+        );
+        auto& offsets_buffer = dest_column.create_extra_buffer(
+                mapping.offset_bytes_,
+                ExtraBufferType::OFFSET,
+                (unique_offsets_in_order.size() + 1) * sizeof(int64_t),
+                AllocationType::DETACHABLE
+        );
         // Then go through unique_offsets to fill up the offset and string buffers.
         auto offsets_ptr = reinterpret_cast<int64_t*>(offsets_buffer.data());
         auto string_ptr = reinterpret_cast<char*>(string_buffer.data());
-        for (auto unique_offset: unique_offsets_in_order) {
+        for (auto unique_offset : unique_offsets_in_order) {
             const auto& entry = unique_offsets[unique_offset];
             *offsets_ptr++ = entry.string_buffer_pos_;
             memcpy(string_ptr, entry.strv.data(), entry.strv.size());
@@ -123,17 +134,11 @@ TypeDescriptor ArrowStringHandler::output_type(const TypeDescriptor&) const {
     return make_scalar_type(DataType::UTF_DYNAMIC32);
 }
 
-int ArrowStringHandler::type_size() const {
-    return sizeof(uint32_t);
-}
+int ArrowStringHandler::type_size() const { return sizeof(uint32_t); }
 
 void ArrowStringHandler::default_initialize(
-    ChunkedBuffer& /*buffer*/,
-    size_t /*offset*/,
-    size_t /*byte_size*/,
-    const DecodePathData& /*shared_data*/,
-    std::any& /*handler_data*/) const {
-
-}
+        ChunkedBuffer& /*buffer*/, size_t /*offset*/, size_t /*byte_size*/, const DecodePathData& /*shared_data*/,
+        std::any& /*handler_data*/
+) const {}
 
 } // namespace arcticdb