refactor: initialize missing fields in TableMetadata and update compile options

Author: Joe-Abraham

src/CMakeLists.txt

@@ -20,7 +20,8 @@ set(CMAKE_COMPILE_WARNING_AS_ERROR ON)
 if(MSVC)
   add_compile_options(/W4 /we4100)
 else()
-  add_compile_options(-Wall -Wextra -Werror=unused-parameter)
+  add_compile_options(-Wall -Wextra -Werror=unused-parameter
+                      -Werror=missing-field-initializers)
 endif()
 
 add_subdirectory(iceberg)

src/iceberg/table_metadata.h

@@ -80,31 +80,31 @@ struct ICEBERG_EXPORT TableMetadata {
   static inline const std::unordered_map<TypeId, int8_t> kMinFormatVersions{};
 
   /// An integer version number for the format
-  int8_t format_version = 0;
+  int8_t format_version;
   /// A UUID that identifies the table
   std::string table_uuid;
   /// The table's base location
   std::string location;
   /// The table's highest assigned sequence number
-  int64_t last_sequence_number = 0;
+  int64_t last_sequence_number;
   /// Timestamp in milliseconds from the unix epoch when the table was last updated.
-  TimePointMs last_updated_ms{};
+  TimePointMs last_updated_ms;
   /// The highest assigned column ID for the table
-  int32_t last_column_id = 0;
+  int32_t last_column_id;
   /// A list of schemas
   std::vector<std::shared_ptr<iceberg::Schema>> schemas;
   /// ID of the table's current schema
-  int32_t current_schema_id = 0;
+  int32_t current_schema_id;
   /// A list of partition specs
   std::vector<std::shared_ptr<iceberg::PartitionSpec>> partition_specs;
   /// ID of the current partition spec that writers should use by default
-  int32_t default_spec_id{};
+  int32_t default_spec_id;
   /// The highest assigned partition field ID across all partition specs for the table
-  int32_t last_partition_id{};
+  int32_t last_partition_id;
   /// A string to string map of table properties
-  TableProperties properties{};
+  TableProperties properties;
   /// ID of the current table snapshot
-  int64_t current_snapshot_id = 0;
+  int64_t current_snapshot_id;
   /// A list of valid snapshots
   std::vector<std::shared_ptr<iceberg::Snapshot>> snapshots;
   /// A list of timestamp and snapshot ID pairs that encodes changes to the current
@@ -116,15 +116,15 @@ struct ICEBERG_EXPORT TableMetadata {
   /// A list of sort orders
   std::vector<std::shared_ptr<iceberg::SortOrder>> sort_orders;
   /// Default sort order id of the table
-  int32_t default_sort_order_id = 0;
+  int32_t default_sort_order_id;
   /// A map of snapshot references
   std::unordered_map<std::string, std::shared_ptr<SnapshotRef>> refs;
   /// A list of table statistics
   std::vector<std::shared_ptr<struct StatisticsFile>> statistics;
   /// A list of partition statistics
   std::vector<std::shared_ptr<struct PartitionStatisticsFile>> partition_statistics;
   /// A `long` higher than all assigned row IDs
-  int64_t next_row_id = 0;
+  int64_t next_row_id;
 
   static Result<std::unique_ptr<TableMetadata>> Make(
       const Schema& schema, const PartitionSpec& spec, const SortOrder& sort_order,

src/iceberg/test/metrics_config_test.cc

@@ -72,8 +72,29 @@ TEST(MetricsConfigTest, ForTable) {
 
   {
     // Default
-    auto metadata = std::make_shared<TableMetadata>(
-        TableMetadata{.format_version = 2, .schemas = {schema}, .current_schema_id = 1});
+    auto metadata =
+        std::make_shared<TableMetadata>(TableMetadata{.format_version = 2,
+                                                      .table_uuid = "",
+                                                      .location = "",
+                                                      .last_sequence_number = 0,
+                                                      .last_updated_ms = {},
+                                                      .last_column_id = 0,
+                                                      .schemas = {schema},
+                                                      .current_schema_id = 1,
+                                                      .partition_specs = {},
+                                                      .default_spec_id = 0,
+                                                      .last_partition_id = 0,
+                                                      .properties = {},
+                                                      .current_snapshot_id = 0,
+                                                      .snapshots = {},
+                                                      .snapshot_log = {},
+                                                      .metadata_log = {},
+                                                      .sort_orders = {},
+                                                      .default_sort_order_id = 0,
+                                                      .refs = {},
+                                                      .statistics = {},
+                                                      .partition_statistics = {},
+                                                      .next_row_id = 0});
     ICEBERG_UNWRAP_OR_FAIL(
         auto table, Table::Make(ident, metadata, "s3://bucket/meta.json", io, catalog));
 
@@ -94,10 +115,28 @@ TEST(MetricsConfigTest, ForTable) {
     // Custom metrics mode by set default metrics mode properties
     auto metadata = std::make_shared<TableMetadata>(
         TableMetadata{.format_version = 2,
+                      .table_uuid = "",
+                      .location = "",
+                      .last_sequence_number = 0,
+                      .last_updated_ms = {},
+                      .last_column_id = 0,
                       .schemas = {schema},
                       .current_schema_id = 1,
+                      .partition_specs = {},
+                      .default_spec_id = 0,
+                      .last_partition_id = 0,
                       .properties = TableProperties::FromMap(
-                          {{TableProperties::kDefaultWriteMetricsMode.key(), "full"}})});
+                          {{TableProperties::kDefaultWriteMetricsMode.key(), "full"}}),
+                      .current_snapshot_id = 0,
+                      .snapshots = {},
+                      .snapshot_log = {},
+                      .metadata_log = {},
+                      .sort_orders = {},
+                      .default_sort_order_id = 0,
+                      .refs = {},
+                      .statistics = {},
+                      .partition_statistics = {},
+                      .next_row_id = 0});
     ICEBERG_UNWRAP_OR_FAIL(
         auto table, Table::Make(ident, metadata, "s3://bucket/meta.json", io, catalog));
 
@@ -123,16 +162,31 @@ TEST(MetricsConfigTest, ForTable) {
 
     auto metadata = std::make_shared<TableMetadata>(TableMetadata{
         .format_version = 2,
+        .table_uuid = "",
+        .location = "",
+        .last_sequence_number = 0,
+        .last_updated_ms = {},
+        .last_column_id = 0,
         .schemas = {schema},
         .current_schema_id = 1,
+        .partition_specs = {},
+        .default_spec_id = 0,
+        .last_partition_id = 0,
         .properties = TableProperties::FromMap(
             {{TableProperties::kDefaultWriteMetricsMode.key(), "none"},
              {TableProperties::kMetricsMaxInferredColumnDefaults.key(), "2"},
              {std::string(TableProperties::kMetricModeColumnConfPrefix) + "name",
               "full"}}),
+        .current_snapshot_id = 0,
+        .snapshots = {},
+        .snapshot_log = {},
+        .metadata_log = {},
         .sort_orders = {sort_order},
         .default_sort_order_id = 1,
-    });
+        .refs = {},
+        .statistics = {},
+        .partition_statistics = {},
+        .next_row_id = 0});
 
     ICEBERG_UNWRAP_OR_FAIL(
         auto table, Table::Make(ident, metadata, "s3://bucket/meta.json", io, catalog));

src/iceberg/test/schema_test.cc

@@ -709,8 +709,8 @@ struct SelectTestParam {
   std::function<std::unique_ptr<iceberg::Schema>()> create_schema;
   std::vector<std::string> select_fields;
   std::function<std::unique_ptr<iceberg::Schema>()> expected_schema;
-  bool should_succeed;
-  std::string expected_error_message;
+  bool should_succeed = false;
+  std::string expected_error_message = "";
   bool case_sensitive = true;
 };
 
@@ -850,8 +850,8 @@ struct ProjectTestParam {
   std::function<std::unique_ptr<iceberg::Schema>()> create_schema;
   std::unordered_set<int32_t> selected_ids;
   std::function<std::unique_ptr<iceberg::Schema>()> expected_schema;
-  bool should_succeed;
-  std::string expected_error_message;
+  bool should_succeed = false;
+  std::string expected_error_message = "";
 };
 
 class ProjectParamTest : public ::testing::TestWithParam<ProjectTestParam> {};