Fix compiling under -Werror=missing-field-initializers

Summary:
MyRocks build is broken because they are using "-Werror=missing-field-initializers"
We should fix that by explicitly passing these arguments

Test Plan: Build MyRocks

Reviewers: sdong, yiwu

Reviewed By: yiwu

Subscribers: andrewkr, dhruba

Differential Revision: https://reviews.facebook.net/D64161

util/options_helper.h

@@ -5,8 +5,8 @@
 
 #pragma once
 
-#include <string>
 #include <stdexcept>
+#include <string>
 #include <vector>
 
 #include "rocksdb/options.h"
@@ -164,172 +164,172 @@ static std::unordered_map<std::string, OptionTypeInfo> db_options_type_info = {
      */
     {"advise_random_on_open",
      {offsetof(struct DBOptions, advise_random_on_open), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"allow_mmap_reads",
      {offsetof(struct DBOptions, allow_mmap_reads), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"allow_fallocate",
      {offsetof(struct DBOptions, allow_fallocate), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"allow_mmap_writes",
      {offsetof(struct DBOptions, allow_mmap_writes), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"allow_2pc",
      {offsetof(struct DBOptions, allow_2pc), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"allow_os_buffer",
      {offsetof(struct DBOptions, allow_os_buffer), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"create_if_missing",
      {offsetof(struct DBOptions, create_if_missing), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"create_missing_column_families",
      {offsetof(struct DBOptions, create_missing_column_families),
-      OptionType::kBoolean, OptionVerificationType::kNormal}},
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"disableDataSync",
      {offsetof(struct DBOptions, disableDataSync), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"disable_data_sync",  // for compatibility
      {offsetof(struct DBOptions, disableDataSync), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"enable_thread_tracking",
      {offsetof(struct DBOptions, enable_thread_tracking), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"error_if_exists",
      {offsetof(struct DBOptions, error_if_exists), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"is_fd_close_on_exec",
      {offsetof(struct DBOptions, is_fd_close_on_exec), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"paranoid_checks",
      {offsetof(struct DBOptions, paranoid_checks), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"skip_log_error_on_recovery",
      {offsetof(struct DBOptions, skip_log_error_on_recovery),
-      OptionType::kBoolean, OptionVerificationType::kNormal}},
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"skip_stats_update_on_db_open",
      {offsetof(struct DBOptions, skip_stats_update_on_db_open),
-      OptionType::kBoolean, OptionVerificationType::kNormal}},
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"new_table_reader_for_compaction_inputs",
      {offsetof(struct DBOptions, new_table_reader_for_compaction_inputs),
-      OptionType::kBoolean, OptionVerificationType::kNormal}},
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"compaction_readahead_size",
      {offsetof(struct DBOptions, compaction_readahead_size), OptionType::kSizeT,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"random_access_max_buffer_size",
      {offsetof(struct DBOptions, random_access_max_buffer_size),
-      OptionType::kSizeT, OptionVerificationType::kNormal}},
+      OptionType::kSizeT, OptionVerificationType::kNormal, false, 0}},
     {"writable_file_max_buffer_size",
      {offsetof(struct DBOptions, writable_file_max_buffer_size),
-      OptionType::kSizeT, OptionVerificationType::kNormal}},
+      OptionType::kSizeT, OptionVerificationType::kNormal, false, 0}},
     {"use_adaptive_mutex",
      {offsetof(struct DBOptions, use_adaptive_mutex), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"use_fsync",
      {offsetof(struct DBOptions, use_fsync), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"max_background_compactions",
      {offsetof(struct DBOptions, max_background_compactions), OptionType::kInt,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"base_background_compactions",
      {offsetof(struct DBOptions, base_background_compactions), OptionType::kInt,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"max_background_flushes",
      {offsetof(struct DBOptions, max_background_flushes), OptionType::kInt,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"max_file_opening_threads",
      {offsetof(struct DBOptions, max_file_opening_threads), OptionType::kInt,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"max_open_files",
      {offsetof(struct DBOptions, max_open_files), OptionType::kInt,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"table_cache_numshardbits",
      {offsetof(struct DBOptions, table_cache_numshardbits), OptionType::kInt,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"db_write_buffer_size",
      {offsetof(struct DBOptions, db_write_buffer_size), OptionType::kSizeT,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"keep_log_file_num",
      {offsetof(struct DBOptions, keep_log_file_num), OptionType::kSizeT,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"recycle_log_file_num",
      {offsetof(struct DBOptions, recycle_log_file_num), OptionType::kSizeT,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"log_file_time_to_roll",
      {offsetof(struct DBOptions, log_file_time_to_roll), OptionType::kSizeT,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"manifest_preallocation_size",
      {offsetof(struct DBOptions, manifest_preallocation_size),
-      OptionType::kSizeT, OptionVerificationType::kNormal}},
+      OptionType::kSizeT, OptionVerificationType::kNormal, false, 0}},
     {"max_log_file_size",
      {offsetof(struct DBOptions, max_log_file_size), OptionType::kSizeT,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"db_log_dir",
      {offsetof(struct DBOptions, db_log_dir), OptionType::kString,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"wal_dir",
      {offsetof(struct DBOptions, wal_dir), OptionType::kString,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"max_subcompactions",
      {offsetof(struct DBOptions, max_subcompactions), OptionType::kUInt32T,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"WAL_size_limit_MB",
      {offsetof(struct DBOptions, WAL_size_limit_MB), OptionType::kUInt64T,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"WAL_ttl_seconds",
      {offsetof(struct DBOptions, WAL_ttl_seconds), OptionType::kUInt64T,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"bytes_per_sync",
      {offsetof(struct DBOptions, bytes_per_sync), OptionType::kUInt64T,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"delayed_write_rate",
      {offsetof(struct DBOptions, delayed_write_rate), OptionType::kUInt64T,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"delete_obsolete_files_period_micros",
      {offsetof(struct DBOptions, delete_obsolete_files_period_micros),
-      OptionType::kUInt64T, OptionVerificationType::kNormal}},
+      OptionType::kUInt64T, OptionVerificationType::kNormal, false, 0}},
     {"max_manifest_file_size",
      {offsetof(struct DBOptions, max_manifest_file_size), OptionType::kUInt64T,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"max_total_wal_size",
      {offsetof(struct DBOptions, max_total_wal_size), OptionType::kUInt64T,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"wal_bytes_per_sync",
      {offsetof(struct DBOptions, wal_bytes_per_sync), OptionType::kUInt64T,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"stats_dump_period_sec",
      {offsetof(struct DBOptions, stats_dump_period_sec), OptionType::kUInt,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"fail_if_options_file_error",
      {offsetof(struct DBOptions, fail_if_options_file_error),
-      OptionType::kBoolean, OptionVerificationType::kNormal}},
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"allow_concurrent_memtable_write",
      {offsetof(struct DBOptions, allow_concurrent_memtable_write),
-      OptionType::kBoolean, OptionVerificationType::kNormal}},
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"wal_recovery_mode",
      {offsetof(struct DBOptions, wal_recovery_mode),
-      OptionType::kWALRecoveryMode, OptionVerificationType::kNormal}},
+      OptionType::kWALRecoveryMode, OptionVerificationType::kNormal, false, 0}},
     {"enable_write_thread_adaptive_yield",
      {offsetof(struct DBOptions, enable_write_thread_adaptive_yield),
-      OptionType::kBoolean, OptionVerificationType::kNormal}},
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"write_thread_slow_yield_usec",
      {offsetof(struct DBOptions, write_thread_slow_yield_usec),
-      OptionType::kUInt64T, OptionVerificationType::kNormal}},
+      OptionType::kUInt64T, OptionVerificationType::kNormal, false, 0}},
     {"write_thread_max_yield_usec",
      {offsetof(struct DBOptions, write_thread_max_yield_usec),
-      OptionType::kUInt64T, OptionVerificationType::kNormal}},
+      OptionType::kUInt64T, OptionVerificationType::kNormal, false, 0}},
     {"access_hint_on_compaction_start",
      {offsetof(struct DBOptions, access_hint_on_compaction_start),
-      OptionType::kAccessHint, OptionVerificationType::kNormal}},
+      OptionType::kAccessHint, OptionVerificationType::kNormal, false, 0}},
     {"info_log_level",
      {offsetof(struct DBOptions, info_log_level), OptionType::kInfoLogLevel,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"dump_malloc_stats",
      {offsetof(struct DBOptions, dump_malloc_stats), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"avoid_flush_during_recovery",
      {offsetof(struct DBOptions, avoid_flush_during_recovery),
-      OptionType::kBoolean, OptionVerificationType::kNormal}}};
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}}};
 
 static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
     /* not yet supported
@@ -349,30 +349,30 @@ static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
       OptionType::kBoolean, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, report_bg_io_stats)}},
     {"compaction_measure_io_stats",
-     {0, OptionType::kBoolean, OptionVerificationType::kDeprecated, false}},
+     {0, OptionType::kBoolean, OptionVerificationType::kDeprecated, false, 0}},
     {"disable_auto_compactions",
      {offsetof(struct ColumnFamilyOptions, disable_auto_compactions),
       OptionType::kBoolean, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, disable_auto_compactions)}},
     {"filter_deletes",
-     {0, OptionType::kBoolean, OptionVerificationType::kDeprecated, true}},
+     {0, OptionType::kBoolean, OptionVerificationType::kDeprecated, true, 0}},
     {"inplace_update_support",
      {offsetof(struct ColumnFamilyOptions, inplace_update_support),
-      OptionType::kBoolean, OptionVerificationType::kNormal, false}},
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"level_compaction_dynamic_level_bytes",
      {offsetof(struct ColumnFamilyOptions,
                level_compaction_dynamic_level_bytes),
-      OptionType::kBoolean, OptionVerificationType::kNormal, false}},
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"optimize_filters_for_hits",
      {offsetof(struct ColumnFamilyOptions, optimize_filters_for_hits),
-      OptionType::kBoolean, OptionVerificationType::kNormal, false}},
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"paranoid_file_checks",
      {offsetof(struct ColumnFamilyOptions, paranoid_file_checks),
       OptionType::kBoolean, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, paranoid_file_checks)}},
     {"purge_redundant_kvs_while_flush",
      {offsetof(struct ColumnFamilyOptions, purge_redundant_kvs_while_flush),
-      OptionType::kBoolean, OptionVerificationType::kNormal, false}},
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"verify_checksums_in_compaction",
      {offsetof(struct ColumnFamilyOptions, verify_checksums_in_compaction),
       OptionType::kBoolean, OptionVerificationType::kNormal, true,
@@ -386,15 +386,15 @@ static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
       OptionType::kUInt64T, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, hard_pending_compaction_bytes_limit)}},
     {"hard_rate_limit",
-     {0, OptionType::kDouble, OptionVerificationType::kDeprecated, true}},
+     {0, OptionType::kDouble, OptionVerificationType::kDeprecated, true, 0}},
     {"soft_rate_limit",
-     {0, OptionType::kDouble, OptionVerificationType::kDeprecated, true}},
+     {0, OptionType::kDouble, OptionVerificationType::kDeprecated, true, 0}},
     {"max_compaction_bytes",
      {offsetof(struct ColumnFamilyOptions, max_compaction_bytes),
       OptionType::kUInt64T, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, max_compaction_bytes)}},
     {"expanded_compaction_factor",
-     {0, OptionType::kInt, OptionVerificationType::kDeprecated, true}},
+     {0, OptionType::kInt, OptionVerificationType::kDeprecated, true, 0}},
     {"level0_file_num_compaction_trigger",
      {offsetof(struct ColumnFamilyOptions, level0_file_num_compaction_trigger),
       OptionType::kInt, OptionVerificationType::kNormal, true,
@@ -408,24 +408,24 @@ static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
       OptionType::kInt, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, level0_stop_writes_trigger)}},
     {"max_grandparent_overlap_factor",
-     {0, OptionType::kInt, OptionVerificationType::kDeprecated, true}},
+     {0, OptionType::kInt, OptionVerificationType::kDeprecated, true, 0}},
     {"max_mem_compaction_level",
-     {0, OptionType::kInt, OptionVerificationType::kDeprecated, false}},
+     {0, OptionType::kInt, OptionVerificationType::kDeprecated, false, 0}},
     {"max_write_buffer_number",
      {offsetof(struct ColumnFamilyOptions, max_write_buffer_number),
       OptionType::kInt, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, max_write_buffer_number)}},
     {"max_write_buffer_number_to_maintain",
      {offsetof(struct ColumnFamilyOptions, max_write_buffer_number_to_maintain),
-      OptionType::kInt, OptionVerificationType::kNormal, false}},
+      OptionType::kInt, OptionVerificationType::kNormal, false, 0}},
     {"min_write_buffer_number_to_merge",
      {offsetof(struct ColumnFamilyOptions, min_write_buffer_number_to_merge),
-      OptionType::kInt, OptionVerificationType::kNormal, false}},
+      OptionType::kInt, OptionVerificationType::kNormal, false, 0}},
     {"num_levels",
      {offsetof(struct ColumnFamilyOptions, num_levels), OptionType::kInt,
-      OptionVerificationType::kNormal, false}},
+      OptionVerificationType::kNormal, false, 0}},
     {"source_compaction_factor",
-     {0, OptionType::kInt, OptionVerificationType::kDeprecated, true}},
+     {0, OptionType::kInt, OptionVerificationType::kDeprecated, true, 0}},
     {"target_file_size_multiplier",
      {offsetof(struct ColumnFamilyOptions, target_file_size_multiplier),
       OptionType::kInt, OptionVerificationType::kNormal, true,
@@ -447,22 +447,22 @@ static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
       OptionType::kSizeT, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, memtable_huge_page_size)}},
     {"memtable_prefix_bloom_huge_page_tlb_size",
-     {0, OptionType::kSizeT, OptionVerificationType::kDeprecated, true}},
+     {0, OptionType::kSizeT, OptionVerificationType::kDeprecated, true, 0}},
     {"write_buffer_size",
      {offsetof(struct ColumnFamilyOptions, write_buffer_size),
       OptionType::kSizeT, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, write_buffer_size)}},
     {"bloom_locality",
      {offsetof(struct ColumnFamilyOptions, bloom_locality),
-      OptionType::kUInt32T, OptionVerificationType::kNormal, false}},
+      OptionType::kUInt32T, OptionVerificationType::kNormal, false, 0}},
     {"memtable_prefix_bloom_bits",
-     {0, OptionType::kUInt32T, OptionVerificationType::kDeprecated, true}},
+     {0, OptionType::kUInt32T, OptionVerificationType::kDeprecated, true, 0}},
     {"memtable_prefix_bloom_size_ratio",
      {offsetof(struct ColumnFamilyOptions, memtable_prefix_bloom_size_ratio),
       OptionType::kDouble, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, memtable_prefix_bloom_size_ratio)}},
     {"memtable_prefix_bloom_probes",
-     {0, OptionType::kUInt32T, OptionVerificationType::kDeprecated, true}},
+     {0, OptionType::kUInt32T, OptionVerificationType::kDeprecated, true, 0}},
     {"min_partial_merge_operands",
      {offsetof(struct ColumnFamilyOptions, min_partial_merge_operands),
       OptionType::kUInt32T, OptionVerificationType::kNormal, true,
@@ -490,7 +490,7 @@ static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
       OptionType::kUInt64T, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, target_file_size_base)}},
     {"rate_limit_delay_max_milliseconds",
-     {0, OptionType::kUInt, OptionVerificationType::kDeprecated, false}},
+     {0, OptionType::kUInt, OptionVerificationType::kDeprecated, false, 0}},
     {"compression",
      {offsetof(struct ColumnFamilyOptions, compression),
       OptionType::kCompressionType, OptionVerificationType::kNormal, true,
@@ -498,36 +498,39 @@ static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
     {"compression_per_level",
      {offsetof(struct ColumnFamilyOptions, compression_per_level),
       OptionType::kVectorCompressionType, OptionVerificationType::kNormal,
-      false}},
+      false, 0}},
     {"bottommost_compression",
      {offsetof(struct ColumnFamilyOptions, bottommost_compression),
-      OptionType::kCompressionType, OptionVerificationType::kNormal, false}},
+      OptionType::kCompressionType, OptionVerificationType::kNormal, false, 0}},
     {"comparator",
      {offsetof(struct ColumnFamilyOptions, comparator), OptionType::kComparator,
-      OptionVerificationType::kByName, false}},
+      OptionVerificationType::kByName, false, 0}},
     {"prefix_extractor",
      {offsetof(struct ColumnFamilyOptions, prefix_extractor),
       OptionType::kSliceTransform, OptionVerificationType::kByNameAllowNull,
-      false}},
+      false, 0}},
     {"memtable_factory",
      {offsetof(struct ColumnFamilyOptions, memtable_factory),
-      OptionType::kMemTableRepFactory, OptionVerificationType::kByName, false}},
+      OptionType::kMemTableRepFactory, OptionVerificationType::kByName, false,
+      0}},
     {"table_factory",
      {offsetof(struct ColumnFamilyOptions, table_factory),
-      OptionType::kTableFactory, OptionVerificationType::kByName, false}},
+      OptionType::kTableFactory, OptionVerificationType::kByName, false, 0}},
     {"compaction_filter",
      {offsetof(struct ColumnFamilyOptions, compaction_filter),
-      OptionType::kCompactionFilter, OptionVerificationType::kByName, false}},
+      OptionType::kCompactionFilter, OptionVerificationType::kByName, false,
+      0}},
     {"compaction_filter_factory",
      {offsetof(struct ColumnFamilyOptions, compaction_filter_factory),
       OptionType::kCompactionFilterFactory, OptionVerificationType::kByName,
-      false}},
+      false, 0}},
     {"merge_operator",
      {offsetof(struct ColumnFamilyOptions, merge_operator),
-      OptionType::kMergeOperator, OptionVerificationType::kByName, false}},
+      OptionType::kMergeOperator, OptionVerificationType::kByName, false, 0}},
     {"compaction_style",
      {offsetof(struct ColumnFamilyOptions, compaction_style),
-      OptionType::kCompactionStyle, OptionVerificationType::kNormal, false}}};
+      OptionType::kCompactionStyle, OptionVerificationType::kNormal, false,
+      0}}};
 
 static std::unordered_map<std::string, OptionTypeInfo>
     block_based_table_type_info = {
@@ -537,89 +540,91 @@ static std::unordered_map<std::string, OptionTypeInfo>
          */
         {"flush_block_policy_factory",
          {offsetof(struct BlockBasedTableOptions, flush_block_policy_factory),
-          OptionType::kFlushBlockPolicyFactory,
-          OptionVerificationType::kByName}},
+          OptionType::kFlushBlockPolicyFactory, OptionVerificationType::kByName,
+          false, 0}},
         {"cache_index_and_filter_blocks",
          {offsetof(struct BlockBasedTableOptions,
                    cache_index_and_filter_blocks),
-          OptionType::kBoolean, OptionVerificationType::kNormal}},
+          OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
         {"cache_index_and_filter_blocks_with_high_priority",
          {offsetof(struct BlockBasedTableOptions,
                    cache_index_and_filter_blocks_with_high_priority),
-          OptionType::kBoolean, OptionVerificationType::kNormal}},
+          OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
         {"pin_l0_filter_and_index_blocks_in_cache",
          {offsetof(struct BlockBasedTableOptions,
                    pin_l0_filter_and_index_blocks_in_cache),
-          OptionType::kBoolean, OptionVerificationType::kNormal}},
+          OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
         {"index_type",
          {offsetof(struct BlockBasedTableOptions, index_type),
           OptionType::kBlockBasedTableIndexType,
-          OptionVerificationType::kNormal}},
+          OptionVerificationType::kNormal, false, 0}},
         {"hash_index_allow_collision",
          {offsetof(struct BlockBasedTableOptions, hash_index_allow_collision),
-          OptionType::kBoolean, OptionVerificationType::kNormal}},
+          OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
         {"checksum",
          {offsetof(struct BlockBasedTableOptions, checksum),
-          OptionType::kChecksumType, OptionVerificationType::kNormal}},
+          OptionType::kChecksumType, OptionVerificationType::kNormal, false,
+          0}},
         {"no_block_cache",
          {offsetof(struct BlockBasedTableOptions, no_block_cache),
-          OptionType::kBoolean, OptionVerificationType::kNormal}},
+          OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
         {"block_size",
          {offsetof(struct BlockBasedTableOptions, block_size),
-          OptionType::kSizeT, OptionVerificationType::kNormal}},
+          OptionType::kSizeT, OptionVerificationType::kNormal, false, 0}},
         {"block_size_deviation",
          {offsetof(struct BlockBasedTableOptions, block_size_deviation),
-          OptionType::kInt, OptionVerificationType::kNormal}},
+          OptionType::kInt, OptionVerificationType::kNormal, false, 0}},
         {"block_restart_interval",
          {offsetof(struct BlockBasedTableOptions, block_restart_interval),
-          OptionType::kInt, OptionVerificationType::kNormal}},
+          OptionType::kInt, OptionVerificationType::kNormal, false, 0}},
         {"index_block_restart_interval",
          {offsetof(struct BlockBasedTableOptions, index_block_restart_interval),
-          OptionType::kInt, OptionVerificationType::kNormal}},
+          OptionType::kInt, OptionVerificationType::kNormal, false, 0}},
         {"filter_policy",
          {offsetof(struct BlockBasedTableOptions, filter_policy),
-          OptionType::kFilterPolicy, OptionVerificationType::kByName}},
+          OptionType::kFilterPolicy, OptionVerificationType::kByName, false,
+          0}},
         {"whole_key_filtering",
          {offsetof(struct BlockBasedTableOptions, whole_key_filtering),
-          OptionType::kBoolean, OptionVerificationType::kNormal}},
+          OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
         {"skip_table_builder_flush",
          {offsetof(struct BlockBasedTableOptions, skip_table_builder_flush),
-          OptionType::kBoolean, OptionVerificationType::kNormal}},
+          OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
         {"format_version",
          {offsetof(struct BlockBasedTableOptions, format_version),
-          OptionType::kUInt32T, OptionVerificationType::kNormal}},
+          OptionType::kUInt32T, OptionVerificationType::kNormal, false, 0}},
         {"verify_compression",
          {offsetof(struct BlockBasedTableOptions, verify_compression),
-          OptionType::kBoolean, OptionVerificationType::kNormal}},
+          OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
         {"read_amp_bytes_per_bit",
          {offsetof(struct BlockBasedTableOptions, read_amp_bytes_per_bit),
-          OptionType::kSizeT, OptionVerificationType::kNormal}}};
+          OptionType::kSizeT, OptionVerificationType::kNormal, false, 0}}};
 
 static std::unordered_map<std::string, OptionTypeInfo> plain_table_type_info = {
     {"user_key_len",
      {offsetof(struct PlainTableOptions, user_key_len), OptionType::kUInt32T,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"bloom_bits_per_key",
      {offsetof(struct PlainTableOptions, bloom_bits_per_key), OptionType::kInt,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"hash_table_ratio",
      {offsetof(struct PlainTableOptions, hash_table_ratio), OptionType::kDouble,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"index_sparseness",
      {offsetof(struct PlainTableOptions, index_sparseness), OptionType::kSizeT,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"huge_page_tlb_size",
      {offsetof(struct PlainTableOptions, huge_page_tlb_size),
-      OptionType::kSizeT, OptionVerificationType::kNormal}},
+      OptionType::kSizeT, OptionVerificationType::kNormal, false, 0}},
     {"encoding_type",
      {offsetof(struct PlainTableOptions, encoding_type),
-      OptionType::kEncodingType, OptionVerificationType::kByName}},
+      OptionType::kEncodingType, OptionVerificationType::kByName, false, 0}},
     {"full_scan_mode",
      {offsetof(struct PlainTableOptions, full_scan_mode), OptionType::kBoolean,
-      OptionVerificationType::kNormal}},
+      OptionVerificationType::kNormal, false, 0}},
     {"store_index_in_file",
      {offsetof(struct PlainTableOptions, store_index_in_file),
-      OptionType::kBoolean, OptionVerificationType::kNormal}}};
+      OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}}};
 
 static std::unordered_map<std::string, CompressionType>
     compression_type_string_map = {