Move advanced column family options to advanced_options.h

Summary:
For the sake of making our options simpler, we should keep options.h as simple as possible and move more advanced/less common options to advaned_options.h

I started with ColumnFamilyOptions and also did some re-ordering

I have moved all ColumnFamilyOptions to advanced_options.h and only left these options in options.h

```
const Comparator* comparator = BytewiseComparator();
std::shared_ptr<MergeOperator> merge_operator = nullptr;
const CompactionFilter* compaction_filter = nullptr;
std::shared_ptr<CompactionFilterFactory> compaction_filter_factory = nullptr;
size_t write_buffer_size = 64 << 20;
CompressionType compression;
int level0_file_num_compaction_trigger = 4;
bool disable_auto_compactions = false;
```
Please feel free to comment on specific options if you think they should be advanced or should not be
Closes https://github.com/facebook/rocksdb/pull/1847

Differential Revision: D4519996

Pulled By: IslamAbdelRahman

fbshipit-source-id: abebd9a

util/options.cc

@@ -36,53 +36,42 @@
 
 namespace rocksdb {
 
-ColumnFamilyOptions::ColumnFamilyOptions()
-    : compression(Snappy_Supported() ? kSnappyCompression : kNoCompression),
-      table_factory(
-          std::shared_ptr<TableFactory>(new BlockBasedTableFactory())) {
+AdvancedColumnFamilyOptions::AdvancedColumnFamilyOptions() {
   assert(memtable_factory.get() != nullptr);
 }
 
-ColumnFamilyOptions::ColumnFamilyOptions(const Options& options)
-    : comparator(options.comparator),
-      merge_operator(options.merge_operator),
-      compaction_filter(options.compaction_filter),
-      compaction_filter_factory(options.compaction_filter_factory),
-      write_buffer_size(options.write_buffer_size),
-      max_write_buffer_number(options.max_write_buffer_number),
+AdvancedColumnFamilyOptions::AdvancedColumnFamilyOptions(const Options& options)
+    : max_write_buffer_number(options.max_write_buffer_number),
       min_write_buffer_number_to_merge(
           options.min_write_buffer_number_to_merge),
       max_write_buffer_number_to_maintain(
           options.max_write_buffer_number_to_maintain),
-      compression(options.compression),
+      inplace_update_support(options.inplace_update_support),
+      inplace_update_num_locks(options.inplace_update_num_locks),
+      inplace_callback(options.inplace_callback),
+      memtable_prefix_bloom_size_ratio(
+          options.memtable_prefix_bloom_size_ratio),
+      memtable_huge_page_size(options.memtable_huge_page_size),
+      memtable_insert_with_hint_prefix_extractor(
+          options.memtable_insert_with_hint_prefix_extractor),
+      bloom_locality(options.bloom_locality),
+      arena_block_size(options.arena_block_size),
       compression_per_level(options.compression_per_level),
-      bottommost_compression(options.bottommost_compression),
-      compression_opts(options.compression_opts),
-      prefix_extractor(options.prefix_extractor),
       num_levels(options.num_levels),
-      level0_file_num_compaction_trigger(
-          options.level0_file_num_compaction_trigger),
       level0_slowdown_writes_trigger(options.level0_slowdown_writes_trigger),
       level0_stop_writes_trigger(options.level0_stop_writes_trigger),
       target_file_size_base(options.target_file_size_base),
       target_file_size_multiplier(options.target_file_size_multiplier),
-      max_bytes_for_level_base(options.max_bytes_for_level_base),
       level_compaction_dynamic_level_bytes(
           options.level_compaction_dynamic_level_bytes),
       max_bytes_for_level_multiplier(options.max_bytes_for_level_multiplier),
       max_bytes_for_level_multiplier_additional(
           options.max_bytes_for_level_multiplier_additional),
       max_compaction_bytes(options.max_compaction_bytes),
-      soft_rate_limit(options.soft_rate_limit),
       soft_pending_compaction_bytes_limit(
           options.soft_pending_compaction_bytes_limit),
       hard_pending_compaction_bytes_limit(
           options.hard_pending_compaction_bytes_limit),
-      rate_limit_delay_max_milliseconds(
-          options.rate_limit_delay_max_milliseconds),
-      arena_block_size(options.arena_block_size),
-      disable_auto_compactions(options.disable_auto_compactions),
-      purge_redundant_kvs_while_flush(options.purge_redundant_kvs_while_flush),
       compaction_style(options.compaction_style),
       compaction_pri(options.compaction_pri),
       compaction_options_universal(options.compaction_options_universal),
@@ -90,18 +79,8 @@ ColumnFamilyOptions::ColumnFamilyOptions(const Options& options)
       max_sequential_skip_in_iterations(
           options.max_sequential_skip_in_iterations),
       memtable_factory(options.memtable_factory),
-      table_factory(options.table_factory),
       table_properties_collector_factories(
           options.table_properties_collector_factories),
-      inplace_update_support(options.inplace_update_support),
-      inplace_update_num_locks(options.inplace_update_num_locks),
-      inplace_callback(options.inplace_callback),
-      memtable_prefix_bloom_size_ratio(
-          options.memtable_prefix_bloom_size_ratio),
-      memtable_huge_page_size(options.memtable_huge_page_size),
-      memtable_insert_with_hint_prefix_extractor(
-          options.memtable_insert_with_hint_prefix_extractor),
-      bloom_locality(options.bloom_locality),
       max_successive_merges(options.max_successive_merges),
       optimize_filters_for_hits(options.optimize_filters_for_hits),
       paranoid_file_checks(options.paranoid_file_checks),
@@ -114,6 +93,28 @@ ColumnFamilyOptions::ColumnFamilyOptions(const Options& options)
   }
 }
 
+ColumnFamilyOptions::ColumnFamilyOptions()
+    : compression(Snappy_Supported() ? kSnappyCompression : kNoCompression),
+      table_factory(
+          std::shared_ptr<TableFactory>(new BlockBasedTableFactory())) {}
+
+ColumnFamilyOptions::ColumnFamilyOptions(const Options& options)
+    : AdvancedColumnFamilyOptions(options),
+      comparator(options.comparator),
+      merge_operator(options.merge_operator),
+      compaction_filter(options.compaction_filter),
+      compaction_filter_factory(options.compaction_filter_factory),
+      write_buffer_size(options.write_buffer_size),
+      compression(options.compression),
+      bottommost_compression(options.bottommost_compression),
+      compression_opts(options.compression_opts),
+      level0_file_num_compaction_trigger(
+          options.level0_file_num_compaction_trigger),
+      prefix_extractor(options.prefix_extractor),
+      max_bytes_for_level_base(options.max_bytes_for_level_base),
+      disable_auto_compactions(options.disable_auto_compactions),
+      table_factory(options.table_factory) {}
+
 DBOptions::DBOptions() {}
 
 DBOptions::DBOptions(const Options& options)

util/options_helper.h

@@ -365,6 +365,21 @@ static std::unordered_map<std::string, OptionTypeInfo> db_options_type_info = {
       OptionType::kBoolean, OptionVerificationType::kNormal, true,
       offsetof(struct MutableDBOptions, avoid_flush_during_shutdown)}}};
 
+// offset_of is used to get the offset of a class data member
+// ex: offset_of(&ColumnFamilyOptions::num_levels)
+// This call will return the offset of num_levels in ColumnFamilyOptions class
+//
+// This is the same as offsetof() but allow us to work with non standard-layout
+// classes and structures
+// refs:
+// http://en.cppreference.com/w/cpp/concept/StandardLayoutType
+// https://gist.github.com/graphitemaster/494f21190bb2c63c5516
+template <typename T1, typename T2>
+inline int offset_of(T1 T2::*member) {
+  static T2 obj;
+  return int(size_t(&(obj.*member)) - size_t(&obj));
+}
+
 static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
     /* not yet supported
     CompactionOptionsFIFO compaction_options_fifo;
@@ -379,45 +394,44 @@ static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
                                      std::string* merged_value);
      */
     {"report_bg_io_stats",
-     {offsetof(struct ColumnFamilyOptions, report_bg_io_stats),
-      OptionType::kBoolean, OptionVerificationType::kNormal, true,
+     {offset_of(&ColumnFamilyOptions::report_bg_io_stats), OptionType::kBoolean,
+      OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, report_bg_io_stats)}},
     {"compaction_measure_io_stats",
      {0, OptionType::kBoolean, OptionVerificationType::kDeprecated, false, 0}},
     {"disable_auto_compactions",
-     {offsetof(struct ColumnFamilyOptions, disable_auto_compactions),
+     {offset_of(&ColumnFamilyOptions::disable_auto_compactions),
       OptionType::kBoolean, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, disable_auto_compactions)}},
     {"filter_deletes",
      {0, OptionType::kBoolean, OptionVerificationType::kDeprecated, true, 0}},
     {"inplace_update_support",
-     {offsetof(struct ColumnFamilyOptions, inplace_update_support),
+     {offset_of(&ColumnFamilyOptions::inplace_update_support),
       OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"level_compaction_dynamic_level_bytes",
-     {offsetof(struct ColumnFamilyOptions,
-               level_compaction_dynamic_level_bytes),
+     {offset_of(&ColumnFamilyOptions::level_compaction_dynamic_level_bytes),
       OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"optimize_filters_for_hits",
-     {offsetof(struct ColumnFamilyOptions, optimize_filters_for_hits),
+     {offset_of(&ColumnFamilyOptions::optimize_filters_for_hits),
       OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"paranoid_file_checks",
-     {offsetof(struct ColumnFamilyOptions, paranoid_file_checks),
+     {offset_of(&ColumnFamilyOptions::paranoid_file_checks),
       OptionType::kBoolean, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, paranoid_file_checks)}},
     {"force_consistency_checks",
-     {offsetof(struct ColumnFamilyOptions, force_consistency_checks),
+     {offset_of(&ColumnFamilyOptions::force_consistency_checks),
       OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"purge_redundant_kvs_while_flush",
-     {offsetof(struct ColumnFamilyOptions, purge_redundant_kvs_while_flush),
+     {offset_of(&ColumnFamilyOptions::purge_redundant_kvs_while_flush),
       OptionType::kBoolean, OptionVerificationType::kNormal, false, 0}},
     {"verify_checksums_in_compaction",
      {0, OptionType::kBoolean, OptionVerificationType::kDeprecated, true, 0}},
     {"soft_pending_compaction_bytes_limit",
-     {offsetof(struct ColumnFamilyOptions, soft_pending_compaction_bytes_limit),
+     {offset_of(&ColumnFamilyOptions::soft_pending_compaction_bytes_limit),
       OptionType::kUInt64T, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, soft_pending_compaction_bytes_limit)}},
     {"hard_pending_compaction_bytes_limit",
-     {offsetof(struct ColumnFamilyOptions, hard_pending_compaction_bytes_limit),
+     {offset_of(&ColumnFamilyOptions::hard_pending_compaction_bytes_limit),
       OptionType::kUInt64T, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, hard_pending_compaction_bytes_limit)}},
     {"hard_rate_limit",
@@ -425,21 +439,21 @@ static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
     {"soft_rate_limit",
      {0, OptionType::kDouble, OptionVerificationType::kDeprecated, true, 0}},
     {"max_compaction_bytes",
-     {offsetof(struct ColumnFamilyOptions, max_compaction_bytes),
+     {offset_of(&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}},
     {"level0_file_num_compaction_trigger",
-     {offsetof(struct ColumnFamilyOptions, level0_file_num_compaction_trigger),
+     {offset_of(&ColumnFamilyOptions::level0_file_num_compaction_trigger),
       OptionType::kInt, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, level0_file_num_compaction_trigger)}},
     {"level0_slowdown_writes_trigger",
-     {offsetof(struct ColumnFamilyOptions, level0_slowdown_writes_trigger),
+     {offset_of(&ColumnFamilyOptions::level0_slowdown_writes_trigger),
       OptionType::kInt, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, level0_slowdown_writes_trigger)}},
     {"level0_stop_writes_trigger",
-     {offsetof(struct ColumnFamilyOptions, level0_stop_writes_trigger),
+     {offset_of(&ColumnFamilyOptions::level0_stop_writes_trigger),
       OptionType::kInt, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, level0_stop_writes_trigger)}},
     {"max_grandparent_overlap_factor",
@@ -447,53 +461,53 @@ static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
     {"max_mem_compaction_level",
      {0, OptionType::kInt, OptionVerificationType::kDeprecated, false, 0}},
     {"max_write_buffer_number",
-     {offsetof(struct ColumnFamilyOptions, max_write_buffer_number),
+     {offset_of(&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),
+     {offset_of(&ColumnFamilyOptions::max_write_buffer_number_to_maintain),
       OptionType::kInt, OptionVerificationType::kNormal, false, 0}},
     {"min_write_buffer_number_to_merge",
-     {offsetof(struct ColumnFamilyOptions, min_write_buffer_number_to_merge),
+     {offset_of(&ColumnFamilyOptions::min_write_buffer_number_to_merge),
       OptionType::kInt, OptionVerificationType::kNormal, false, 0}},
     {"num_levels",
-     {offsetof(struct ColumnFamilyOptions, num_levels), OptionType::kInt,
+     {offset_of(&ColumnFamilyOptions::num_levels), OptionType::kInt,
       OptionVerificationType::kNormal, false, 0}},
     {"source_compaction_factor",
      {0, OptionType::kInt, OptionVerificationType::kDeprecated, true, 0}},
     {"target_file_size_multiplier",
-     {offsetof(struct ColumnFamilyOptions, target_file_size_multiplier),
+     {offset_of(&ColumnFamilyOptions::target_file_size_multiplier),
       OptionType::kInt, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, target_file_size_multiplier)}},
     {"arena_block_size",
-     {offsetof(struct ColumnFamilyOptions, arena_block_size),
-      OptionType::kSizeT, OptionVerificationType::kNormal, true,
+     {offset_of(&ColumnFamilyOptions::arena_block_size), OptionType::kSizeT,
+      OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, arena_block_size)}},
     {"inplace_update_num_locks",
-     {offsetof(struct ColumnFamilyOptions, inplace_update_num_locks),
+     {offset_of(&ColumnFamilyOptions::inplace_update_num_locks),
       OptionType::kSizeT, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, inplace_update_num_locks)}},
     {"max_successive_merges",
-     {offsetof(struct ColumnFamilyOptions, max_successive_merges),
+     {offset_of(&ColumnFamilyOptions::max_successive_merges),
       OptionType::kSizeT, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, max_successive_merges)}},
     {"memtable_huge_page_size",
-     {offsetof(struct ColumnFamilyOptions, memtable_huge_page_size),
+     {offset_of(&ColumnFamilyOptions::memtable_huge_page_size),
       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}},
     {"write_buffer_size",
-     {offsetof(struct ColumnFamilyOptions, write_buffer_size),
-      OptionType::kSizeT, OptionVerificationType::kNormal, true,
+     {offset_of(&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, 0}},
+     {offset_of(&ColumnFamilyOptions::bloom_locality), OptionType::kUInt32T,
+      OptionVerificationType::kNormal, false, 0}},
     {"memtable_prefix_bloom_bits",
      {0, OptionType::kUInt32T, OptionVerificationType::kDeprecated, true, 0}},
     {"memtable_prefix_bloom_size_ratio",
-     {offsetof(struct ColumnFamilyOptions, memtable_prefix_bloom_size_ratio),
+     {offset_of(&ColumnFamilyOptions::memtable_prefix_bloom_size_ratio),
       OptionType::kDouble, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, memtable_prefix_bloom_size_ratio)}},
     {"memtable_prefix_bloom_probes",
@@ -501,72 +515,72 @@ static std::unordered_map<std::string, OptionTypeInfo> cf_options_type_info = {
     {"min_partial_merge_operands",
      {0, OptionType::kUInt32T, OptionVerificationType::kDeprecated, true, 0}},
     {"max_bytes_for_level_base",
-     {offsetof(struct ColumnFamilyOptions, max_bytes_for_level_base),
+     {offset_of(&ColumnFamilyOptions::max_bytes_for_level_base),
       OptionType::kUInt64T, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, max_bytes_for_level_base)}},
     {"max_bytes_for_level_multiplier",
-     {offsetof(struct ColumnFamilyOptions, max_bytes_for_level_multiplier),
+     {offset_of(&ColumnFamilyOptions::max_bytes_for_level_multiplier),
       OptionType::kDouble, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, max_bytes_for_level_multiplier)}},
     {"max_bytes_for_level_multiplier_additional",
-     {offsetof(struct ColumnFamilyOptions,
-               max_bytes_for_level_multiplier_additional),
+     {offset_of(
+          &ColumnFamilyOptions::max_bytes_for_level_multiplier_additional),
       OptionType::kVectorInt, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions,
                max_bytes_for_level_multiplier_additional)}},
     {"max_sequential_skip_in_iterations",
-     {offsetof(struct ColumnFamilyOptions, max_sequential_skip_in_iterations),
+     {offset_of(&ColumnFamilyOptions::max_sequential_skip_in_iterations),
       OptionType::kUInt64T, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, max_sequential_skip_in_iterations)}},
     {"target_file_size_base",
-     {offsetof(struct ColumnFamilyOptions, target_file_size_base),
+     {offset_of(&ColumnFamilyOptions::target_file_size_base),
       OptionType::kUInt64T, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, target_file_size_base)}},
     {"rate_limit_delay_max_milliseconds",
      {0, OptionType::kUInt, OptionVerificationType::kDeprecated, false, 0}},
     {"compression",
-     {offsetof(struct ColumnFamilyOptions, compression),
+     {offset_of(&ColumnFamilyOptions::compression),
       OptionType::kCompressionType, OptionVerificationType::kNormal, true,
       offsetof(struct MutableCFOptions, compression)}},
     {"compression_per_level",
-     {offsetof(struct ColumnFamilyOptions, compression_per_level),
+     {offset_of(&ColumnFamilyOptions::compression_per_level),
       OptionType::kVectorCompressionType, OptionVerificationType::kNormal,
       false, 0}},
     {"bottommost_compression",
-     {offsetof(struct ColumnFamilyOptions, bottommost_compression),
+     {offset_of(&ColumnFamilyOptions::bottommost_compression),
       OptionType::kCompressionType, OptionVerificationType::kNormal, false, 0}},
     {"comparator",
-     {offsetof(struct ColumnFamilyOptions, comparator), OptionType::kComparator,
+     {offset_of(&ColumnFamilyOptions::comparator), OptionType::kComparator,
       OptionVerificationType::kByName, false, 0}},
     {"prefix_extractor",
-     {offsetof(struct ColumnFamilyOptions, prefix_extractor),
+     {offset_of(&ColumnFamilyOptions::prefix_extractor),
       OptionType::kSliceTransform, OptionVerificationType::kByNameAllowNull,
       false, 0}},
     {"memtable_insert_with_hint_prefix_extractor",
-     {offsetof(struct ColumnFamilyOptions,
-               memtable_insert_with_hint_prefix_extractor),
+     {offset_of(
+          &ColumnFamilyOptions::memtable_insert_with_hint_prefix_extractor),
       OptionType::kSliceTransform, OptionVerificationType::kByNameAllowNull,
       false, 0}},
     {"memtable_factory",
-     {offsetof(struct ColumnFamilyOptions, memtable_factory),
+     {offset_of(&ColumnFamilyOptions::memtable_factory),
       OptionType::kMemTableRepFactory, OptionVerificationType::kByName, false,
       0}},
     {"table_factory",
-     {offsetof(struct ColumnFamilyOptions, table_factory),
-      OptionType::kTableFactory, OptionVerificationType::kByName, false, 0}},
+     {offset_of(&ColumnFamilyOptions::table_factory), OptionType::kTableFactory,
+      OptionVerificationType::kByName, false, 0}},
     {"compaction_filter",
-     {offsetof(struct ColumnFamilyOptions, compaction_filter),
+     {offset_of(&ColumnFamilyOptions::compaction_filter),
       OptionType::kCompactionFilter, OptionVerificationType::kByName, false,
       0}},
     {"compaction_filter_factory",
-     {offsetof(struct ColumnFamilyOptions, compaction_filter_factory),
+     {offset_of(&ColumnFamilyOptions::compaction_filter_factory),
       OptionType::kCompactionFilterFactory, OptionVerificationType::kByName,
       false, 0}},
     {"merge_operator",
-     {offsetof(struct ColumnFamilyOptions, merge_operator),
+     {offset_of(&ColumnFamilyOptions::merge_operator),
       OptionType::kMergeOperator, OptionVerificationType::kByName, false, 0}},
     {"compaction_style",
-     {offsetof(struct ColumnFamilyOptions, compaction_style),
+     {offset_of(&ColumnFamilyOptions::compaction_style),
       OptionType::kCompactionStyle, OptionVerificationType::kNormal, false,
       0}}};
 

util/options_settable_test.cc

@@ -314,32 +314,31 @@ TEST_F(OptionsSettableTest, ColumnFamilyOptionsAllFieldsSettable) {
   // options in the blacklist need to appear in the same order as in
   // ColumnFamilyOptions.
   const OffsetGap kColumnFamilyOptionsBlacklist = {
-      {offsetof(struct ColumnFamilyOptions, comparator), sizeof(Comparator*)},
-      {offsetof(struct ColumnFamilyOptions, merge_operator),
-       sizeof(std::shared_ptr<MergeOperator>)},
-      {offsetof(struct ColumnFamilyOptions, compaction_filter),
-       sizeof(const CompactionFilter*)},
-      {offsetof(struct ColumnFamilyOptions, compaction_filter_factory),
-       sizeof(std::shared_ptr<CompactionFilterFactory>)},
-      {offsetof(struct ColumnFamilyOptions, compression_per_level),
-       sizeof(std::vector<CompressionType>)},
-      {offsetof(struct ColumnFamilyOptions, prefix_extractor),
+      {offset_of(&ColumnFamilyOptions::inplace_callback),
+       sizeof(UpdateStatus(*)(char*, uint32_t*, Slice, std::string*))},
+      {offset_of(
+           &ColumnFamilyOptions::memtable_insert_with_hint_prefix_extractor),
        sizeof(std::shared_ptr<const SliceTransform>)},
-      {offsetof(struct ColumnFamilyOptions,
-                max_bytes_for_level_multiplier_additional),
+      {offset_of(&ColumnFamilyOptions::compression_per_level),
+       sizeof(std::vector<CompressionType>)},
+      {offset_of(
+           &ColumnFamilyOptions::max_bytes_for_level_multiplier_additional),
        sizeof(std::vector<int>)},
-      {offsetof(struct ColumnFamilyOptions, memtable_factory),
+      {offset_of(&ColumnFamilyOptions::memtable_factory),
        sizeof(std::shared_ptr<MemTableRepFactory>)},
-      {offsetof(struct ColumnFamilyOptions, table_factory),
-       sizeof(std::shared_ptr<TableFactory>)},
-      {offsetof(struct ColumnFamilyOptions,
-                table_properties_collector_factories),
+      {offset_of(&ColumnFamilyOptions::table_properties_collector_factories),
        sizeof(ColumnFamilyOptions::TablePropertiesCollectorFactories)},
-      {offsetof(struct ColumnFamilyOptions, inplace_callback),
-       sizeof(UpdateStatus(*)(char*, uint32_t*, Slice, std::string*))},
-      {offsetof(struct ColumnFamilyOptions,
-                memtable_insert_with_hint_prefix_extractor),
+      {offset_of(&ColumnFamilyOptions::comparator), sizeof(Comparator*)},
+      {offset_of(&ColumnFamilyOptions::merge_operator),
+       sizeof(std::shared_ptr<MergeOperator>)},
+      {offset_of(&ColumnFamilyOptions::compaction_filter),
+       sizeof(const CompactionFilter*)},
+      {offset_of(&ColumnFamilyOptions::compaction_filter_factory),
+       sizeof(std::shared_ptr<CompactionFilterFactory>)},
+      {offset_of(&ColumnFamilyOptions::prefix_extractor),
        sizeof(std::shared_ptr<const SliceTransform>)},
+      {offset_of(&ColumnFamilyOptions::table_factory),
+       sizeof(std::shared_ptr<TableFactory>)},
   };
 
   char* options_ptr = new char[sizeof(ColumnFamilyOptions)];