ceph/src/rocksdb/java/rocksjni/options.cc

   1 // Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5 //
   6 // This file implements the "bridge" between Java and C++ for
   7 // ROCKSDB_NAMESPACE::Options.
   8
   9 #include <jni.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <memory>
  13 #include <vector>
  14
  15 #include "include/org_rocksdb_ColumnFamilyOptions.h"
  16 #include "include/org_rocksdb_ComparatorOptions.h"
  17 #include "include/org_rocksdb_DBOptions.h"
  18 #include "include/org_rocksdb_FlushOptions.h"
  19 #include "include/org_rocksdb_Options.h"
  20 #include "include/org_rocksdb_ReadOptions.h"
  21 #include "include/org_rocksdb_WriteOptions.h"
  22
  23 #include "rocksjni/comparatorjnicallback.h"
  24 #include "rocksjni/portal.h"
  25 #include "rocksjni/statisticsjni.h"
  26 #include "rocksjni/table_filter_jnicallback.h"
  27
  28 #include "rocksdb/comparator.h"
  29 #include "rocksdb/convenience.h"
  30 #include "rocksdb/db.h"
  31 #include "rocksdb/memtablerep.h"
  32 #include "rocksdb/merge_operator.h"
  33 #include "rocksdb/options.h"
  34 #include "rocksdb/rate_limiter.h"
  35 #include "rocksdb/slice_transform.h"
  36 #include "rocksdb/statistics.h"
  37 #include "rocksdb/table.h"
  38 #include "utilities/merge_operators.h"
  39
  40 /*
  41  * Class:     org_rocksdb_Options
  42  * Method:    newOptions
  43  * Signature: ()J
  44  */
  45 jlong Java_org_rocksdb_Options_newOptions__(
  46     JNIEnv*, jclass) {
  47   auto* op = new ROCKSDB_NAMESPACE::Options();
  48   return reinterpret_cast<jlong>(op);
  49 }
  50
  51 /*
  52  * Class:     org_rocksdb_Options
  53  * Method:    newOptions
  54  * Signature: (JJ)J
  55  */
  56 jlong Java_org_rocksdb_Options_newOptions__JJ(
  57     JNIEnv*, jclass, jlong jdboptions, jlong jcfoptions) {
  58   auto* dbOpt =
  59       reinterpret_cast<const ROCKSDB_NAMESPACE::DBOptions*>(jdboptions);
  60   auto* cfOpt = reinterpret_cast<const ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(
  61       jcfoptions);
  62   auto* op = new ROCKSDB_NAMESPACE::Options(*dbOpt, *cfOpt);
  63   return reinterpret_cast<jlong>(op);
  64 }
  65
  66 /*
  67  * Class:     org_rocksdb_Options
  68  * Method:    copyOptions
  69  * Signature: (J)J
  70  */
  71 jlong Java_org_rocksdb_Options_copyOptions(
  72     JNIEnv*, jclass, jlong jhandle) {
  73   auto new_opt = new ROCKSDB_NAMESPACE::Options(
  74       *(reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)));
  75   return reinterpret_cast<jlong>(new_opt);
  76 }
  77
  78 /*
  79  * Class:     org_rocksdb_Options
  80  * Method:    disposeInternal
  81  * Signature: (J)V
  82  */
  83 void Java_org_rocksdb_Options_disposeInternal(
  84     JNIEnv*, jobject, jlong handle) {
  85   auto* op = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(handle);
  86   assert(op != nullptr);
  87   delete op;
  88 }
  89
  90 /*
  91  * Class:     org_rocksdb_Options
  92  * Method:    setIncreaseParallelism
  93  * Signature: (JI)V
  94  */
  95 void Java_org_rocksdb_Options_setIncreaseParallelism(
  96     JNIEnv*, jobject, jlong jhandle, jint totalThreads) {
  97   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->IncreaseParallelism(
  98       static_cast<int>(totalThreads));
  99 }
 100
 101 /*
 102  * Class:     org_rocksdb_Options
 103  * Method:    setCreateIfMissing
 104  * Signature: (JZ)V
 105  */
 106 void Java_org_rocksdb_Options_setCreateIfMissing(
 107     JNIEnv*, jobject, jlong jhandle, jboolean flag) {
 108   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->create_if_missing =
 109       flag;
 110 }
 111
 112 /*
 113  * Class:     org_rocksdb_Options
 114  * Method:    createIfMissing
 115  * Signature: (J)Z
 116  */
 117 jboolean Java_org_rocksdb_Options_createIfMissing(
 118     JNIEnv*, jobject, jlong jhandle) {
 119   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 120       ->create_if_missing;
 121 }
 122
 123 /*
 124  * Class:     org_rocksdb_Options
 125  * Method:    setCreateMissingColumnFamilies
 126  * Signature: (JZ)V
 127  */
 128 void Java_org_rocksdb_Options_setCreateMissingColumnFamilies(
 129     JNIEnv*, jobject, jlong jhandle, jboolean flag) {
 130   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 131       ->create_missing_column_families = flag;
 132 }
 133
 134 /*
 135  * Class:     org_rocksdb_Options
 136  * Method:    createMissingColumnFamilies
 137  * Signature: (J)Z
 138  */
 139 jboolean Java_org_rocksdb_Options_createMissingColumnFamilies(
 140     JNIEnv*, jobject, jlong jhandle) {
 141   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 142       ->create_missing_column_families;
 143 }
 144
 145 /*
 146  * Class:     org_rocksdb_Options
 147  * Method:    setComparatorHandle
 148  * Signature: (JI)V
 149  */
 150 void Java_org_rocksdb_Options_setComparatorHandle__JI(
 151     JNIEnv*, jobject, jlong jhandle, jint builtinComparator) {
 152   switch (builtinComparator) {
 153     case 1:
 154       reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->comparator =
 155           ROCKSDB_NAMESPACE::ReverseBytewiseComparator();
 156       break;
 157     default:
 158       reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->comparator =
 159           ROCKSDB_NAMESPACE::BytewiseComparator();
 160       break;
 161   }
 162 }
 163
 164 /*
 165  * Class:     org_rocksdb_Options
 166  * Method:    setComparatorHandle
 167  * Signature: (JJB)V
 168  */
 169 void Java_org_rocksdb_Options_setComparatorHandle__JJB(
 170     JNIEnv*, jobject, jlong jopt_handle, jlong jcomparator_handle,
 171     jbyte jcomparator_type) {
 172   ROCKSDB_NAMESPACE::Comparator* comparator = nullptr;
 173   switch (jcomparator_type) {
 174     // JAVA_COMPARATOR
 175     case 0x0:
 176       comparator = reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallback*>(
 177           jcomparator_handle);
 178       break;
 179
 180     // JAVA_NATIVE_COMPARATOR_WRAPPER
 181     case 0x1:
 182       comparator =
 183           reinterpret_cast<ROCKSDB_NAMESPACE::Comparator*>(jcomparator_handle);
 184       break;
 185   }
 186   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jopt_handle);
 187   opt->comparator = comparator;
 188 }
 189
 190 /*
 191  * Class:     org_rocksdb_Options
 192  * Method:    setMergeOperatorName
 193  * Signature: (JJjava/lang/String)V
 194  */
 195 void Java_org_rocksdb_Options_setMergeOperatorName(
 196     JNIEnv* env, jobject, jlong jhandle, jstring jop_name) {
 197   const char* op_name = env->GetStringUTFChars(jop_name, nullptr);
 198   if (op_name == nullptr) {
 199     // exception thrown: OutOfMemoryError
 200     return;
 201   }
 202
 203   auto* options = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
 204   options->merge_operator =
 205       ROCKSDB_NAMESPACE::MergeOperators::CreateFromStringId(op_name);
 206
 207   env->ReleaseStringUTFChars(jop_name, op_name);
 208 }
 209
 210 /*
 211  * Class:     org_rocksdb_Options
 212  * Method:    setMergeOperator
 213  * Signature: (JJjava/lang/String)V
 214  */
 215 void Java_org_rocksdb_Options_setMergeOperator(
 216     JNIEnv*, jobject, jlong jhandle, jlong mergeOperatorHandle) {
 217   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->merge_operator =
 218       *(reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::MergeOperator>*>(
 219           mergeOperatorHandle));
 220 }
 221
 222 /*
 223  * Class:     org_rocksdb_Options
 224  * Method:    setCompactionFilterHandle
 225  * Signature: (JJ)V
 226  */
 227 void Java_org_rocksdb_Options_setCompactionFilterHandle(
 228     JNIEnv*, jobject, jlong jopt_handle,
 229     jlong jcompactionfilter_handle) {
 230   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jopt_handle)
 231       ->compaction_filter =
 232       reinterpret_cast<ROCKSDB_NAMESPACE::CompactionFilter*>(
 233           jcompactionfilter_handle);
 234 }
 235
 236 /*
 237  * Class:     org_rocksdb_Options
 238  * Method:    setCompactionFilterFactoryHandle
 239  * Signature: (JJ)V
 240  */
 241 void JNICALL Java_org_rocksdb_Options_setCompactionFilterFactoryHandle(
 242     JNIEnv*, jobject, jlong jopt_handle,
 243     jlong jcompactionfilterfactory_handle) {
 244   auto* cff_factory = reinterpret_cast<
 245       std::shared_ptr<ROCKSDB_NAMESPACE::CompactionFilterFactory>*>(
 246       jcompactionfilterfactory_handle);
 247   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jopt_handle)
 248       ->compaction_filter_factory = *cff_factory;
 249 }
 250
 251 /*
 252  * Class:     org_rocksdb_Options
 253  * Method:    setWriteBufferSize
 254  * Signature: (JJ)I
 255  */
 256 void Java_org_rocksdb_Options_setWriteBufferSize(
 257     JNIEnv* env, jobject, jlong jhandle, jlong jwrite_buffer_size) {
 258   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
 259       jwrite_buffer_size);
 260   if (s.ok()) {
 261     reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->write_buffer_size =
 262         jwrite_buffer_size;
 263   } else {
 264     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
 265   }
 266 }
 267
 268 /*
 269  * Class:     org_rocksdb_Options
 270  * Method:    setWriteBufferManager
 271  * Signature: (JJ)V
 272  */
 273 void Java_org_rocksdb_Options_setWriteBufferManager(
 274     JNIEnv*, jobject, jlong joptions_handle,
 275     jlong jwrite_buffer_manager_handle) {
 276   auto* write_buffer_manager =
 277       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::WriteBufferManager>*>(
 278           jwrite_buffer_manager_handle);
 279   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(joptions_handle)
 280       ->write_buffer_manager = *write_buffer_manager;
 281 }
 282
 283 /*
 284  * Class:     org_rocksdb_Options
 285  * Method:    writeBufferSize
 286  * Signature: (J)J
 287  */
 288 jlong Java_org_rocksdb_Options_writeBufferSize(
 289     JNIEnv*, jobject, jlong jhandle) {
 290   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 291       ->write_buffer_size;
 292 }
 293
 294 /*
 295  * Class:     org_rocksdb_Options
 296  * Method:    setMaxWriteBufferNumber
 297  * Signature: (JI)V
 298  */
 299 void Java_org_rocksdb_Options_setMaxWriteBufferNumber(
 300     JNIEnv*, jobject, jlong jhandle,
 301     jint jmax_write_buffer_number) {
 302   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 303       ->max_write_buffer_number = jmax_write_buffer_number;
 304 }
 305
 306 /*
 307  * Class:     org_rocksdb_Options
 308  * Method:    setStatistics
 309  * Signature: (JJ)V
 310  */
 311 void Java_org_rocksdb_Options_setStatistics(
 312     JNIEnv*, jobject, jlong jhandle, jlong jstatistics_handle) {
 313   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
 314   auto* pSptr =
 315       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::StatisticsJni>*>(
 316           jstatistics_handle);
 317   opt->statistics = *pSptr;
 318 }
 319
 320 /*
 321  * Class:     org_rocksdb_Options
 322  * Method:    statistics
 323  * Signature: (J)J
 324  */
 325 jlong Java_org_rocksdb_Options_statistics(
 326     JNIEnv*, jobject, jlong jhandle) {
 327   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
 328   std::shared_ptr<ROCKSDB_NAMESPACE::Statistics> sptr = opt->statistics;
 329   if (sptr == nullptr) {
 330     return 0;
 331   } else {
 332     std::shared_ptr<ROCKSDB_NAMESPACE::Statistics>* pSptr =
 333         new std::shared_ptr<ROCKSDB_NAMESPACE::Statistics>(sptr);
 334     return reinterpret_cast<jlong>(pSptr);
 335   }
 336 }
 337
 338 /*
 339  * Class:     org_rocksdb_Options
 340  * Method:    maxWriteBufferNumber
 341  * Signature: (J)I
 342  */
 343 jint Java_org_rocksdb_Options_maxWriteBufferNumber(
 344     JNIEnv*, jobject, jlong jhandle) {
 345   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 346       ->max_write_buffer_number;
 347 }
 348
 349 /*
 350  * Class:     org_rocksdb_Options
 351  * Method:    errorIfExists
 352  * Signature: (J)Z
 353  */
 354 jboolean Java_org_rocksdb_Options_errorIfExists(
 355     JNIEnv*, jobject, jlong jhandle) {
 356   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 357       ->error_if_exists;
 358 }
 359
 360 /*
 361  * Class:     org_rocksdb_Options
 362  * Method:    setErrorIfExists
 363  * Signature: (JZ)V
 364  */
 365 void Java_org_rocksdb_Options_setErrorIfExists(
 366     JNIEnv*, jobject, jlong jhandle, jboolean error_if_exists) {
 367   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->error_if_exists =
 368       static_cast<bool>(error_if_exists);
 369 }
 370
 371 /*
 372  * Class:     org_rocksdb_Options
 373  * Method:    paranoidChecks
 374  * Signature: (J)Z
 375  */
 376 jboolean Java_org_rocksdb_Options_paranoidChecks(
 377     JNIEnv*, jobject, jlong jhandle) {
 378   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 379       ->paranoid_checks;
 380 }
 381
 382 /*
 383  * Class:     org_rocksdb_Options
 384  * Method:    setParanoidChecks
 385  * Signature: (JZ)V
 386  */
 387 void Java_org_rocksdb_Options_setParanoidChecks(
 388     JNIEnv*, jobject, jlong jhandle, jboolean paranoid_checks) {
 389   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->paranoid_checks =
 390       static_cast<bool>(paranoid_checks);
 391 }
 392
 393 /*
 394  * Class:     org_rocksdb_Options
 395  * Method:    setEnv
 396  * Signature: (JJ)V
 397  */
 398 void Java_org_rocksdb_Options_setEnv(
 399     JNIEnv*, jobject, jlong jhandle, jlong jenv) {
 400   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->env =
 401       reinterpret_cast<ROCKSDB_NAMESPACE::Env*>(jenv);
 402 }
 403
 404 /*
 405  * Class:     org_rocksdb_Options
 406  * Method:    setMaxTotalWalSize
 407  * Signature: (JJ)V
 408  */
 409 void Java_org_rocksdb_Options_setMaxTotalWalSize(
 410     JNIEnv*, jobject, jlong jhandle, jlong jmax_total_wal_size) {
 411   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->max_total_wal_size =
 412       static_cast<jlong>(jmax_total_wal_size);
 413 }
 414
 415 /*
 416  * Class:     org_rocksdb_Options
 417  * Method:    maxTotalWalSize
 418  * Signature: (J)J
 419  */
 420 jlong Java_org_rocksdb_Options_maxTotalWalSize(
 421     JNIEnv*, jobject, jlong jhandle) {
 422   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 423       ->max_total_wal_size;
 424 }
 425
 426 /*
 427  * Class:     org_rocksdb_Options
 428  * Method:    maxOpenFiles
 429  * Signature: (J)I
 430  */
 431 jint Java_org_rocksdb_Options_maxOpenFiles(
 432     JNIEnv*, jobject, jlong jhandle) {
 433   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->max_open_files;
 434 }
 435
 436 /*
 437  * Class:     org_rocksdb_Options
 438  * Method:    setMaxOpenFiles
 439  * Signature: (JI)V
 440  */
 441 void Java_org_rocksdb_Options_setMaxOpenFiles(
 442     JNIEnv*, jobject, jlong jhandle, jint max_open_files) {
 443   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->max_open_files =
 444       static_cast<int>(max_open_files);
 445 }
 446
 447 /*
 448  * Class:     org_rocksdb_Options
 449  * Method:    setMaxFileOpeningThreads
 450  * Signature: (JI)V
 451  */
 452 void Java_org_rocksdb_Options_setMaxFileOpeningThreads(
 453     JNIEnv*, jobject, jlong jhandle, jint jmax_file_opening_threads) {
 454   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 455       ->max_file_opening_threads = static_cast<int>(jmax_file_opening_threads);
 456 }
 457
 458 /*
 459  * Class:     org_rocksdb_Options
 460  * Method:    maxFileOpeningThreads
 461  * Signature: (J)I
 462  */
 463 jint Java_org_rocksdb_Options_maxFileOpeningThreads(
 464     JNIEnv*, jobject, jlong jhandle) {
 465   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
 466   return static_cast<int>(opt->max_file_opening_threads);
 467 }
 468
 469 /*
 470  * Class:     org_rocksdb_Options
 471  * Method:    useFsync
 472  * Signature: (J)Z
 473  */
 474 jboolean Java_org_rocksdb_Options_useFsync(
 475     JNIEnv*, jobject, jlong jhandle) {
 476   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->use_fsync;
 477 }
 478
 479 /*
 480  * Class:     org_rocksdb_Options
 481  * Method:    setUseFsync
 482  * Signature: (JZ)V
 483  */
 484 void Java_org_rocksdb_Options_setUseFsync(
 485     JNIEnv*, jobject, jlong jhandle, jboolean use_fsync) {
 486   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->use_fsync =
 487       static_cast<bool>(use_fsync);
 488 }
 489
 490 /*
 491  * Class:     org_rocksdb_Options
 492  * Method:    setDbPaths
 493  * Signature: (J[Ljava/lang/String;[J)V
 494  */
 495 void Java_org_rocksdb_Options_setDbPaths(
 496     JNIEnv* env, jobject, jlong jhandle, jobjectArray jpaths,
 497     jlongArray jtarget_sizes) {
 498   std::vector<ROCKSDB_NAMESPACE::DbPath> db_paths;
 499   jlong* ptr_jtarget_size = env->GetLongArrayElements(jtarget_sizes, nullptr);
 500   if (ptr_jtarget_size == nullptr) {
 501     // exception thrown: OutOfMemoryError
 502     return;
 503   }
 504
 505   jboolean has_exception = JNI_FALSE;
 506   const jsize len = env->GetArrayLength(jpaths);
 507   for (jsize i = 0; i < len; i++) {
 508     jobject jpath =
 509         reinterpret_cast<jstring>(env->GetObjectArrayElement(jpaths, i));
 510     if (env->ExceptionCheck()) {
 511       // exception thrown: ArrayIndexOutOfBoundsException
 512       env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
 513       return;
 514     }
 515     std::string path = ROCKSDB_NAMESPACE::JniUtil::copyStdString(
 516         env, static_cast<jstring>(jpath), &has_exception);
 517     env->DeleteLocalRef(jpath);
 518
 519     if (has_exception == JNI_TRUE) {
 520       env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
 521       return;
 522     }
 523
 524     jlong jtarget_size = ptr_jtarget_size[i];
 525
 526     db_paths.push_back(
 527         ROCKSDB_NAMESPACE::DbPath(path, static_cast<uint64_t>(jtarget_size)));
 528   }
 529
 530   env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
 531
 532   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
 533   opt->db_paths = db_paths;
 534 }
 535
 536 /*
 537  * Class:     org_rocksdb_Options
 538  * Method:    dbPathsLen
 539  * Signature: (J)J
 540  */
 541 jlong Java_org_rocksdb_Options_dbPathsLen(
 542     JNIEnv*, jobject, jlong jhandle) {
 543   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
 544   return static_cast<jlong>(opt->db_paths.size());
 545 }
 546
 547 /*
 548  * Class:     org_rocksdb_Options
 549  * Method:    dbPaths
 550  * Signature: (J[Ljava/lang/String;[J)V
 551  */
 552 void Java_org_rocksdb_Options_dbPaths(
 553     JNIEnv* env, jobject, jlong jhandle, jobjectArray jpaths,
 554     jlongArray jtarget_sizes) {
 555   jlong* ptr_jtarget_size = env->GetLongArrayElements(jtarget_sizes, nullptr);
 556   if (ptr_jtarget_size == nullptr) {
 557     // exception thrown: OutOfMemoryError
 558     return;
 559   }
 560
 561   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
 562   const jsize len = env->GetArrayLength(jpaths);
 563   for (jsize i = 0; i < len; i++) {
 564     ROCKSDB_NAMESPACE::DbPath db_path = opt->db_paths[i];
 565
 566     jstring jpath = env->NewStringUTF(db_path.path.c_str());
 567     if (jpath == nullptr) {
 568       // exception thrown: OutOfMemoryError
 569       env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
 570       return;
 571     }
 572     env->SetObjectArrayElement(jpaths, i, jpath);
 573     if (env->ExceptionCheck()) {
 574       // exception thrown: ArrayIndexOutOfBoundsException
 575       env->DeleteLocalRef(jpath);
 576       env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
 577       return;
 578     }
 579
 580     ptr_jtarget_size[i] = static_cast<jint>(db_path.target_size);
 581   }
 582
 583   env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_COMMIT);
 584 }
 585
 586 /*
 587  * Class:     org_rocksdb_Options
 588  * Method:    dbLogDir
 589  * Signature: (J)Ljava/lang/String
 590  */
 591 jstring Java_org_rocksdb_Options_dbLogDir(
 592     JNIEnv* env, jobject, jlong jhandle) {
 593   return env->NewStringUTF(
 594       reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 595           ->db_log_dir.c_str());
 596 }
 597
 598 /*
 599  * Class:     org_rocksdb_Options
 600  * Method:    setDbLogDir
 601  * Signature: (JLjava/lang/String)V
 602  */
 603 void Java_org_rocksdb_Options_setDbLogDir(
 604     JNIEnv* env, jobject, jlong jhandle, jstring jdb_log_dir) {
 605   const char* log_dir = env->GetStringUTFChars(jdb_log_dir, nullptr);
 606   if (log_dir == nullptr) {
 607     // exception thrown: OutOfMemoryError
 608     return;
 609   }
 610   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->db_log_dir.assign(
 611       log_dir);
 612   env->ReleaseStringUTFChars(jdb_log_dir, log_dir);
 613 }
 614
 615 /*
 616  * Class:     org_rocksdb_Options
 617  * Method:    walDir
 618  * Signature: (J)Ljava/lang/String
 619  */
 620 jstring Java_org_rocksdb_Options_walDir(
 621     JNIEnv* env, jobject, jlong jhandle) {
 622   return env->NewStringUTF(
 623       reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->wal_dir.c_str());
 624 }
 625
 626 /*
 627  * Class:     org_rocksdb_Options
 628  * Method:    setWalDir
 629  * Signature: (JLjava/lang/String)V
 630  */
 631 void Java_org_rocksdb_Options_setWalDir(
 632     JNIEnv* env, jobject, jlong jhandle, jstring jwal_dir) {
 633   const char* wal_dir = env->GetStringUTFChars(jwal_dir, nullptr);
 634   if (wal_dir == nullptr) {
 635     // exception thrown: OutOfMemoryError
 636     return;
 637   }
 638   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->wal_dir.assign(
 639       wal_dir);
 640   env->ReleaseStringUTFChars(jwal_dir, wal_dir);
 641 }
 642
 643 /*
 644  * Class:     org_rocksdb_Options
 645  * Method:    deleteObsoleteFilesPeriodMicros
 646  * Signature: (J)J
 647  */
 648 jlong Java_org_rocksdb_Options_deleteObsoleteFilesPeriodMicros(
 649     JNIEnv*, jobject, jlong jhandle) {
 650   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 651       ->delete_obsolete_files_period_micros;
 652 }
 653
 654 /*
 655  * Class:     org_rocksdb_Options
 656  * Method:    setDeleteObsoleteFilesPeriodMicros
 657  * Signature: (JJ)V
 658  */
 659 void Java_org_rocksdb_Options_setDeleteObsoleteFilesPeriodMicros(
 660     JNIEnv*, jobject, jlong jhandle, jlong micros) {
 661   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 662       ->delete_obsolete_files_period_micros = static_cast<int64_t>(micros);
 663 }
 664
 665 /*
 666  * Class:     org_rocksdb_Options
 667  * Method:    setBaseBackgroundCompactions
 668  * Signature: (JI)V
 669  */
 670 void Java_org_rocksdb_Options_setBaseBackgroundCompactions(
 671     JNIEnv*, jobject, jlong jhandle, jint max) {
 672   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 673       ->base_background_compactions = static_cast<int>(max);
 674 }
 675
 676 /*
 677  * Class:     org_rocksdb_Options
 678  * Method:    baseBackgroundCompactions
 679  * Signature: (J)I
 680  */
 681 jint Java_org_rocksdb_Options_baseBackgroundCompactions(
 682     JNIEnv*, jobject, jlong jhandle) {
 683   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 684       ->base_background_compactions;
 685 }
 686
 687 /*
 688  * Class:     org_rocksdb_Options
 689  * Method:    maxBackgroundCompactions
 690  * Signature: (J)I
 691  */
 692 jint Java_org_rocksdb_Options_maxBackgroundCompactions(
 693     JNIEnv*, jobject, jlong jhandle) {
 694   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 695       ->max_background_compactions;
 696 }
 697
 698 /*
 699  * Class:     org_rocksdb_Options
 700  * Method:    setMaxBackgroundCompactions
 701  * Signature: (JI)V
 702  */
 703 void Java_org_rocksdb_Options_setMaxBackgroundCompactions(
 704     JNIEnv*, jobject, jlong jhandle, jint max) {
 705   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 706       ->max_background_compactions = static_cast<int>(max);
 707 }
 708
 709 /*
 710  * Class:     org_rocksdb_Options
 711  * Method:    setMaxSubcompactions
 712  * Signature: (JI)V
 713  */
 714 void Java_org_rocksdb_Options_setMaxSubcompactions(
 715     JNIEnv*, jobject, jlong jhandle, jint max) {
 716   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->max_subcompactions =
 717       static_cast<int32_t>(max);
 718 }
 719
 720 /*
 721  * Class:     org_rocksdb_Options
 722  * Method:    maxSubcompactions
 723  * Signature: (J)I
 724  */
 725 jint Java_org_rocksdb_Options_maxSubcompactions(
 726     JNIEnv*, jobject, jlong jhandle) {
 727   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 728       ->max_subcompactions;
 729 }
 730
 731 /*
 732  * Class:     org_rocksdb_Options
 733  * Method:    maxBackgroundFlushes
 734  * Signature: (J)I
 735  */
 736 jint Java_org_rocksdb_Options_maxBackgroundFlushes(
 737     JNIEnv*, jobject, jlong jhandle) {
 738   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 739       ->max_background_flushes;
 740 }
 741
 742 /*
 743  * Class:     org_rocksdb_Options
 744  * Method:    setMaxBackgroundFlushes
 745  * Signature: (JI)V
 746  */
 747 void Java_org_rocksdb_Options_setMaxBackgroundFlushes(
 748     JNIEnv*, jobject, jlong jhandle, jint max_background_flushes) {
 749   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 750       ->max_background_flushes = static_cast<int>(max_background_flushes);
 751 }
 752
 753 /*
 754  * Class:     org_rocksdb_Options
 755  * Method:    maxBackgroundJobs
 756  * Signature: (J)I
 757  */
 758 jint Java_org_rocksdb_Options_maxBackgroundJobs(
 759     JNIEnv*, jobject, jlong jhandle) {
 760   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 761       ->max_background_jobs;
 762 }
 763
 764 /*
 765  * Class:     org_rocksdb_Options
 766  * Method:    setMaxBackgroundJobs
 767  * Signature: (JI)V
 768  */
 769 void Java_org_rocksdb_Options_setMaxBackgroundJobs(
 770     JNIEnv*, jobject, jlong jhandle, jint max_background_jobs) {
 771   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->max_background_jobs =
 772       static_cast<int>(max_background_jobs);
 773 }
 774
 775 /*
 776  * Class:     org_rocksdb_Options
 777  * Method:    maxLogFileSize
 778  * Signature: (J)J
 779  */
 780 jlong Java_org_rocksdb_Options_maxLogFileSize(
 781     JNIEnv*, jobject, jlong jhandle) {
 782   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 783       ->max_log_file_size;
 784 }
 785
 786 /*
 787  * Class:     org_rocksdb_Options
 788  * Method:    setMaxLogFileSize
 789  * Signature: (JJ)V
 790  */
 791 void Java_org_rocksdb_Options_setMaxLogFileSize(
 792     JNIEnv* env, jobject, jlong jhandle, jlong max_log_file_size) {
 793   auto s =
 794       ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(max_log_file_size);
 795   if (s.ok()) {
 796     reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->max_log_file_size =
 797         max_log_file_size;
 798   } else {
 799     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
 800   }
 801 }
 802
 803 /*
 804  * Class:     org_rocksdb_Options
 805  * Method:    logFileTimeToRoll
 806  * Signature: (J)J
 807  */
 808 jlong Java_org_rocksdb_Options_logFileTimeToRoll(
 809     JNIEnv*, jobject, jlong jhandle) {
 810   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 811       ->log_file_time_to_roll;
 812 }
 813
 814 /*
 815  * Class:     org_rocksdb_Options
 816  * Method:    setLogFileTimeToRoll
 817  * Signature: (JJ)V
 818  */
 819 void Java_org_rocksdb_Options_setLogFileTimeToRoll(
 820     JNIEnv* env, jobject, jlong jhandle, jlong log_file_time_to_roll) {
 821   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
 822       log_file_time_to_roll);
 823   if (s.ok()) {
 824     reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 825         ->log_file_time_to_roll = log_file_time_to_roll;
 826   } else {
 827     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
 828   }
 829 }
 830
 831 /*
 832  * Class:     org_rocksdb_Options
 833  * Method:    keepLogFileNum
 834  * Signature: (J)J
 835  */
 836 jlong Java_org_rocksdb_Options_keepLogFileNum(
 837     JNIEnv*, jobject, jlong jhandle) {
 838   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 839       ->keep_log_file_num;
 840 }
 841
 842 /*
 843  * Class:     org_rocksdb_Options
 844  * Method:    setKeepLogFileNum
 845  * Signature: (JJ)V
 846  */
 847 void Java_org_rocksdb_Options_setKeepLogFileNum(
 848     JNIEnv* env, jobject, jlong jhandle, jlong keep_log_file_num) {
 849   auto s =
 850       ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(keep_log_file_num);
 851   if (s.ok()) {
 852     reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->keep_log_file_num =
 853         keep_log_file_num;
 854   } else {
 855     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
 856   }
 857 }
 858
 859 /*
 860  * Class:     org_rocksdb_Options
 861  * Method:    recycleLogFileNum
 862  * Signature: (J)J
 863  */
 864 jlong Java_org_rocksdb_Options_recycleLogFileNum(
 865     JNIEnv*, jobject, jlong jhandle) {
 866   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 867       ->recycle_log_file_num;
 868 }
 869
 870 /*
 871  * Class:     org_rocksdb_Options
 872  * Method:    setRecycleLogFileNum
 873  * Signature: (JJ)V
 874  */
 875 void Java_org_rocksdb_Options_setRecycleLogFileNum(
 876     JNIEnv* env, jobject, jlong jhandle, jlong recycle_log_file_num) {
 877   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
 878       recycle_log_file_num);
 879   if (s.ok()) {
 880     reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 881         ->recycle_log_file_num = recycle_log_file_num;
 882   } else {
 883     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
 884   }
 885 }
 886
 887 /*
 888  * Class:     org_rocksdb_Options
 889  * Method:    maxManifestFileSize
 890  * Signature: (J)J
 891  */
 892 jlong Java_org_rocksdb_Options_maxManifestFileSize(
 893     JNIEnv*, jobject, jlong jhandle) {
 894   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 895       ->max_manifest_file_size;
 896 }
 897
 898 /*
 899  * Method:    memTableFactoryName
 900  * Signature: (J)Ljava/lang/String
 901  */
 902 jstring Java_org_rocksdb_Options_memTableFactoryName(
 903     JNIEnv* env, jobject, jlong jhandle) {
 904   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
 905   ROCKSDB_NAMESPACE::MemTableRepFactory* tf = opt->memtable_factory.get();
 906
 907   // Should never be nullptr.
 908   // Default memtable factory is SkipListFactory
 909   assert(tf);
 910
 911   // temporarly fix for the historical typo
 912   if (strcmp(tf->Name(), "HashLinkListRepFactory") == 0) {
 913     return env->NewStringUTF("HashLinkedListRepFactory");
 914   }
 915
 916   return env->NewStringUTF(tf->Name());
 917 }
 918
 919 /*
 920  * Class:     org_rocksdb_Options
 921  * Method:    setMaxManifestFileSize
 922  * Signature: (JJ)V
 923  */
 924 void Java_org_rocksdb_Options_setMaxManifestFileSize(
 925     JNIEnv*, jobject, jlong jhandle, jlong max_manifest_file_size) {
 926   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 927       ->max_manifest_file_size = static_cast<int64_t>(max_manifest_file_size);
 928 }
 929
 930 /*
 931  * Method:    setMemTableFactory
 932  * Signature: (JJ)V
 933  */
 934 void Java_org_rocksdb_Options_setMemTableFactory(
 935     JNIEnv*, jobject, jlong jhandle, jlong jfactory_handle) {
 936   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
 937       ->memtable_factory.reset(
 938           reinterpret_cast<ROCKSDB_NAMESPACE::MemTableRepFactory*>(
 939               jfactory_handle));
 940 }
 941
 942 /*
 943  * Class:     org_rocksdb_Options
 944  * Method:    setRateLimiter
 945  * Signature: (JJ)V
 946  */
 947 void Java_org_rocksdb_Options_setRateLimiter(
 948     JNIEnv*, jobject, jlong jhandle, jlong jrate_limiter_handle) {
 949   std::shared_ptr<ROCKSDB_NAMESPACE::RateLimiter>* pRateLimiter =
 950       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::RateLimiter>*>(
 951           jrate_limiter_handle);
 952   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->rate_limiter =
 953       *pRateLimiter;
 954 }
 955
 956 /*
 957  * Class:     org_rocksdb_Options
 958  * Method:    setSstFileManager
 959  * Signature: (JJ)V
 960  */
 961 void Java_org_rocksdb_Options_setSstFileManager(
 962     JNIEnv*, jobject, jlong jhandle, jlong jsst_file_manager_handle) {
 963   auto* sptr_sst_file_manager =
 964       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::SstFileManager>*>(
 965           jsst_file_manager_handle);
 966   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->sst_file_manager =
 967       *sptr_sst_file_manager;
 968 }
 969
 970 /*
 971  * Class:     org_rocksdb_Options
 972  * Method:    setLogger
 973  * Signature: (JJ)V
 974  */
 975 void Java_org_rocksdb_Options_setLogger(
 976     JNIEnv*, jobject, jlong jhandle, jlong jlogger_handle) {
 977   std::shared_ptr<ROCKSDB_NAMESPACE::LoggerJniCallback>* pLogger =
 978       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::LoggerJniCallback>*>(
 979           jlogger_handle);
 980   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->info_log = *pLogger;
 981 }
 982
 983 /*
 984  * Class:     org_rocksdb_Options
 985  * Method:    setInfoLogLevel
 986  * Signature: (JB)V
 987  */
 988 void Java_org_rocksdb_Options_setInfoLogLevel(
 989     JNIEnv*, jobject, jlong jhandle, jbyte jlog_level) {
 990   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->info_log_level =
 991       static_cast<ROCKSDB_NAMESPACE::InfoLogLevel>(jlog_level);
 992 }
 993
 994 /*
 995  * Class:     org_rocksdb_Options
 996  * Method:    infoLogLevel
 997  * Signature: (J)B
 998  */
 999 jbyte Java_org_rocksdb_Options_infoLogLevel(
1000     JNIEnv*, jobject, jlong jhandle) {
1001   return static_cast<jbyte>(
1002       reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->info_log_level);
1003 }
1004
1005 /*
1006  * Class:     org_rocksdb_Options
1007  * Method:    tableCacheNumshardbits
1008  * Signature: (J)I
1009  */
1010 jint Java_org_rocksdb_Options_tableCacheNumshardbits(
1011     JNIEnv*, jobject, jlong jhandle) {
1012   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1013       ->table_cache_numshardbits;
1014 }
1015
1016 /*
1017  * Class:     org_rocksdb_Options
1018  * Method:    setTableCacheNumshardbits
1019  * Signature: (JI)V
1020  */
1021 void Java_org_rocksdb_Options_setTableCacheNumshardbits(
1022     JNIEnv*, jobject, jlong jhandle, jint table_cache_numshardbits) {
1023   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1024       ->table_cache_numshardbits = static_cast<int>(table_cache_numshardbits);
1025 }
1026
1027 /*
1028  * Method:    useFixedLengthPrefixExtractor
1029  * Signature: (JI)V
1030  */
1031 void Java_org_rocksdb_Options_useFixedLengthPrefixExtractor(
1032     JNIEnv*, jobject, jlong jhandle, jint jprefix_length) {
1033   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1034       ->prefix_extractor.reset(ROCKSDB_NAMESPACE::NewFixedPrefixTransform(
1035           static_cast<int>(jprefix_length)));
1036 }
1037
1038 /*
1039  * Method:    useCappedPrefixExtractor
1040  * Signature: (JI)V
1041  */
1042 void Java_org_rocksdb_Options_useCappedPrefixExtractor(
1043     JNIEnv*, jobject, jlong jhandle, jint jprefix_length) {
1044   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1045       ->prefix_extractor.reset(ROCKSDB_NAMESPACE::NewCappedPrefixTransform(
1046           static_cast<int>(jprefix_length)));
1047 }
1048
1049 /*
1050  * Class:     org_rocksdb_Options
1051  * Method:    walTtlSeconds
1052  * Signature: (J)J
1053  */
1054 jlong Java_org_rocksdb_Options_walTtlSeconds(
1055     JNIEnv*, jobject, jlong jhandle) {
1056   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1057       ->WAL_ttl_seconds;
1058 }
1059
1060 /*
1061  * Class:     org_rocksdb_Options
1062  * Method:    setWalTtlSeconds
1063  * Signature: (JJ)V
1064  */
1065 void Java_org_rocksdb_Options_setWalTtlSeconds(
1066     JNIEnv*, jobject, jlong jhandle, jlong WAL_ttl_seconds) {
1067   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->WAL_ttl_seconds =
1068       static_cast<int64_t>(WAL_ttl_seconds);
1069 }
1070
1071 /*
1072  * Class:     org_rocksdb_Options
1073  * Method:    walTtlSeconds
1074  * Signature: (J)J
1075  */
1076 jlong Java_org_rocksdb_Options_walSizeLimitMB(
1077     JNIEnv*, jobject, jlong jhandle) {
1078   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1079       ->WAL_size_limit_MB;
1080 }
1081
1082 /*
1083  * Class:     org_rocksdb_Options
1084  * Method:    setWalSizeLimitMB
1085  * Signature: (JJ)V
1086  */
1087 void Java_org_rocksdb_Options_setWalSizeLimitMB(
1088     JNIEnv*, jobject, jlong jhandle, jlong WAL_size_limit_MB) {
1089   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->WAL_size_limit_MB =
1090       static_cast<int64_t>(WAL_size_limit_MB);
1091 }
1092
1093 /*
1094  * Class:     org_rocksdb_Options
1095  * Method:    manifestPreallocationSize
1096  * Signature: (J)J
1097  */
1098 jlong Java_org_rocksdb_Options_manifestPreallocationSize(
1099     JNIEnv*, jobject, jlong jhandle) {
1100   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1101       ->manifest_preallocation_size;
1102 }
1103
1104 /*
1105  * Class:     org_rocksdb_Options
1106  * Method:    setManifestPreallocationSize
1107  * Signature: (JJ)V
1108  */
1109 void Java_org_rocksdb_Options_setManifestPreallocationSize(
1110     JNIEnv* env, jobject, jlong jhandle, jlong preallocation_size) {
1111   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
1112       preallocation_size);
1113   if (s.ok()) {
1114     reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1115         ->manifest_preallocation_size = preallocation_size;
1116   } else {
1117     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
1118   }
1119 }
1120
1121 /*
1122  * Method:    setTableFactory
1123  * Signature: (JJ)V
1124  */
1125 void Java_org_rocksdb_Options_setTableFactory(
1126     JNIEnv*, jobject, jlong jhandle, jlong jtable_factory_handle) {
1127   auto* options = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1128   auto* table_factory =
1129       reinterpret_cast<ROCKSDB_NAMESPACE::TableFactory*>(jtable_factory_handle);
1130   options->table_factory.reset(table_factory);
1131 }
1132
1133 /*
1134  * Class:     org_rocksdb_Options
1135  * Method:    allowMmapReads
1136  * Signature: (J)Z
1137  */
1138 jboolean Java_org_rocksdb_Options_allowMmapReads(
1139     JNIEnv*, jobject, jlong jhandle) {
1140   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1141       ->allow_mmap_reads;
1142 }
1143
1144 /*
1145  * Class:     org_rocksdb_Options
1146  * Method:    setAllowMmapReads
1147  * Signature: (JZ)V
1148  */
1149 void Java_org_rocksdb_Options_setAllowMmapReads(
1150     JNIEnv*, jobject, jlong jhandle, jboolean allow_mmap_reads) {
1151   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->allow_mmap_reads =
1152       static_cast<bool>(allow_mmap_reads);
1153 }
1154
1155 /*
1156  * Class:     org_rocksdb_Options
1157  * Method:    allowMmapWrites
1158  * Signature: (J)Z
1159  */
1160 jboolean Java_org_rocksdb_Options_allowMmapWrites(
1161     JNIEnv*, jobject, jlong jhandle) {
1162   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1163       ->allow_mmap_writes;
1164 }
1165
1166 /*
1167  * Class:     org_rocksdb_Options
1168  * Method:    setAllowMmapWrites
1169  * Signature: (JZ)V
1170  */
1171 void Java_org_rocksdb_Options_setAllowMmapWrites(
1172     JNIEnv*, jobject, jlong jhandle, jboolean allow_mmap_writes) {
1173   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->allow_mmap_writes =
1174       static_cast<bool>(allow_mmap_writes);
1175 }
1176
1177 /*
1178  * Class:     org_rocksdb_Options
1179  * Method:    useDirectReads
1180  * Signature: (J)Z
1181  */
1182 jboolean Java_org_rocksdb_Options_useDirectReads(
1183     JNIEnv*, jobject, jlong jhandle) {
1184   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1185       ->use_direct_reads;
1186 }
1187
1188 /*
1189  * Class:     org_rocksdb_Options
1190  * Method:    setUseDirectReads
1191  * Signature: (JZ)V
1192  */
1193 void Java_org_rocksdb_Options_setUseDirectReads(
1194     JNIEnv*, jobject, jlong jhandle, jboolean use_direct_reads) {
1195   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->use_direct_reads =
1196       static_cast<bool>(use_direct_reads);
1197 }
1198
1199 /*
1200  * Class:     org_rocksdb_Options
1201  * Method:    useDirectIoForFlushAndCompaction
1202  * Signature: (J)Z
1203  */
1204 jboolean Java_org_rocksdb_Options_useDirectIoForFlushAndCompaction(
1205     JNIEnv*, jobject, jlong jhandle) {
1206   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1207       ->use_direct_io_for_flush_and_compaction;
1208 }
1209
1210 /*
1211  * Class:     org_rocksdb_Options
1212  * Method:    setUseDirectIoForFlushAndCompaction
1213  * Signature: (JZ)V
1214  */
1215 void Java_org_rocksdb_Options_setUseDirectIoForFlushAndCompaction(
1216     JNIEnv*, jobject, jlong jhandle,
1217     jboolean use_direct_io_for_flush_and_compaction) {
1218   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1219       ->use_direct_io_for_flush_and_compaction =
1220       static_cast<bool>(use_direct_io_for_flush_and_compaction);
1221 }
1222
1223 /*
1224  * Class:     org_rocksdb_Options
1225  * Method:    setAllowFAllocate
1226  * Signature: (JZ)V
1227  */
1228 void Java_org_rocksdb_Options_setAllowFAllocate(
1229     JNIEnv*, jobject, jlong jhandle, jboolean jallow_fallocate) {
1230   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->allow_fallocate =
1231       static_cast<bool>(jallow_fallocate);
1232 }
1233
1234 /*
1235  * Class:     org_rocksdb_Options
1236  * Method:    allowFAllocate
1237  * Signature: (J)Z
1238  */
1239 jboolean Java_org_rocksdb_Options_allowFAllocate(
1240     JNIEnv*, jobject, jlong jhandle) {
1241   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1242   return static_cast<jboolean>(opt->allow_fallocate);
1243 }
1244
1245 /*
1246  * Class:     org_rocksdb_Options
1247  * Method:    isFdCloseOnExec
1248  * Signature: (J)Z
1249  */
1250 jboolean Java_org_rocksdb_Options_isFdCloseOnExec(
1251     JNIEnv*, jobject, jlong jhandle) {
1252   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1253       ->is_fd_close_on_exec;
1254 }
1255
1256 /*
1257  * Class:     org_rocksdb_Options
1258  * Method:    setIsFdCloseOnExec
1259  * Signature: (JZ)V
1260  */
1261 void Java_org_rocksdb_Options_setIsFdCloseOnExec(
1262     JNIEnv*, jobject, jlong jhandle, jboolean is_fd_close_on_exec) {
1263   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->is_fd_close_on_exec =
1264       static_cast<bool>(is_fd_close_on_exec);
1265 }
1266
1267 /*
1268  * Class:     org_rocksdb_Options
1269  * Method:    statsDumpPeriodSec
1270  * Signature: (J)I
1271  */
1272 jint Java_org_rocksdb_Options_statsDumpPeriodSec(
1273     JNIEnv*, jobject, jlong jhandle) {
1274   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1275       ->stats_dump_period_sec;
1276 }
1277
1278 /*
1279  * Class:     org_rocksdb_Options
1280  * Method:    setStatsDumpPeriodSec
1281  * Signature: (JI)V
1282  */
1283 void Java_org_rocksdb_Options_setStatsDumpPeriodSec(
1284     JNIEnv*, jobject, jlong jhandle,
1285     jint jstats_dump_period_sec) {
1286   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1287       ->stats_dump_period_sec =
1288       static_cast<unsigned int>(jstats_dump_period_sec);
1289 }
1290
1291 /*
1292  * Class:     org_rocksdb_Options
1293  * Method:    statsPersistPeriodSec
1294  * Signature: (J)I
1295  */
1296 jint Java_org_rocksdb_Options_statsPersistPeriodSec(
1297     JNIEnv*, jobject, jlong jhandle) {
1298   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1299       ->stats_persist_period_sec;
1300 }
1301
1302 /*
1303  * Class:     org_rocksdb_Options
1304  * Method:    setStatsPersistPeriodSec
1305  * Signature: (JI)V
1306  */
1307 void Java_org_rocksdb_Options_setStatsPersistPeriodSec(
1308     JNIEnv*, jobject, jlong jhandle, jint jstats_persist_period_sec) {
1309   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1310       ->stats_persist_period_sec =
1311       static_cast<unsigned int>(jstats_persist_period_sec);
1312 }
1313
1314 /*
1315  * Class:     org_rocksdb_Options
1316  * Method:    statsHistoryBufferSize
1317  * Signature: (J)J
1318  */
1319 jlong Java_org_rocksdb_Options_statsHistoryBufferSize(
1320     JNIEnv*, jobject, jlong jhandle) {
1321   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1322       ->stats_history_buffer_size;
1323 }
1324
1325 /*
1326  * Class:     org_rocksdb_Options
1327  * Method:    setStatsHistoryBufferSize
1328  * Signature: (JJ)V
1329  */
1330 void Java_org_rocksdb_Options_setStatsHistoryBufferSize(
1331     JNIEnv*, jobject, jlong jhandle, jlong jstats_history_buffer_size) {
1332   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1333       ->stats_history_buffer_size =
1334       static_cast<size_t>(jstats_history_buffer_size);
1335 }
1336
1337 /*
1338  * Class:     org_rocksdb_Options
1339  * Method:    adviseRandomOnOpen
1340  * Signature: (J)Z
1341  */
1342 jboolean Java_org_rocksdb_Options_adviseRandomOnOpen(
1343     JNIEnv*, jobject, jlong jhandle) {
1344   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1345       ->advise_random_on_open;
1346 }
1347
1348 /*
1349  * Class:     org_rocksdb_Options
1350  * Method:    setAdviseRandomOnOpen
1351  * Signature: (JZ)V
1352  */
1353 void Java_org_rocksdb_Options_setAdviseRandomOnOpen(
1354     JNIEnv*, jobject, jlong jhandle,
1355     jboolean advise_random_on_open) {
1356   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1357       ->advise_random_on_open = static_cast<bool>(advise_random_on_open);
1358 }
1359
1360 /*
1361  * Class:     org_rocksdb_Options
1362  * Method:    setDbWriteBufferSize
1363  * Signature: (JJ)V
1364  */
1365 void Java_org_rocksdb_Options_setDbWriteBufferSize(
1366     JNIEnv*, jobject, jlong jhandle,
1367     jlong jdb_write_buffer_size) {
1368   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1369   opt->db_write_buffer_size = static_cast<size_t>(jdb_write_buffer_size);
1370 }
1371
1372 /*
1373  * Class:     org_rocksdb_Options
1374  * Method:    dbWriteBufferSize
1375  * Signature: (J)J
1376  */
1377 jlong Java_org_rocksdb_Options_dbWriteBufferSize(
1378     JNIEnv*, jobject, jlong jhandle) {
1379   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1380   return static_cast<jlong>(opt->db_write_buffer_size);
1381 }
1382
1383 /*
1384  * Class:     org_rocksdb_Options
1385  * Method:    setAccessHintOnCompactionStart
1386  * Signature: (JB)V
1387  */
1388 void Java_org_rocksdb_Options_setAccessHintOnCompactionStart(
1389     JNIEnv*, jobject, jlong jhandle,
1390     jbyte jaccess_hint_value) {
1391   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1392   opt->access_hint_on_compaction_start =
1393       ROCKSDB_NAMESPACE::AccessHintJni::toCppAccessHint(jaccess_hint_value);
1394 }
1395
1396 /*
1397  * Class:     org_rocksdb_Options
1398  * Method:    accessHintOnCompactionStart
1399  * Signature: (J)B
1400  */
1401 jbyte Java_org_rocksdb_Options_accessHintOnCompactionStart(
1402     JNIEnv*, jobject, jlong jhandle) {
1403   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1404   return ROCKSDB_NAMESPACE::AccessHintJni::toJavaAccessHint(
1405       opt->access_hint_on_compaction_start);
1406 }
1407
1408 /*
1409  * Class:     org_rocksdb_Options
1410  * Method:    setNewTableReaderForCompactionInputs
1411  * Signature: (JZ)V
1412  */
1413 void Java_org_rocksdb_Options_setNewTableReaderForCompactionInputs(
1414     JNIEnv*, jobject, jlong jhandle,
1415     jboolean jnew_table_reader_for_compaction_inputs) {
1416   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1417   opt->new_table_reader_for_compaction_inputs =
1418       static_cast<bool>(jnew_table_reader_for_compaction_inputs);
1419 }
1420
1421 /*
1422  * Class:     org_rocksdb_Options
1423  * Method:    newTableReaderForCompactionInputs
1424  * Signature: (J)Z
1425  */
1426 jboolean Java_org_rocksdb_Options_newTableReaderForCompactionInputs(
1427     JNIEnv*, jobject, jlong jhandle) {
1428   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1429   return static_cast<bool>(opt->new_table_reader_for_compaction_inputs);
1430 }
1431
1432 /*
1433  * Class:     org_rocksdb_Options
1434  * Method:    setCompactionReadaheadSize
1435  * Signature: (JJ)V
1436  */
1437 void Java_org_rocksdb_Options_setCompactionReadaheadSize(
1438     JNIEnv*, jobject, jlong jhandle,
1439     jlong jcompaction_readahead_size) {
1440   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1441   opt->compaction_readahead_size =
1442       static_cast<size_t>(jcompaction_readahead_size);
1443 }
1444
1445 /*
1446  * Class:     org_rocksdb_Options
1447  * Method:    compactionReadaheadSize
1448  * Signature: (J)J
1449  */
1450 jlong Java_org_rocksdb_Options_compactionReadaheadSize(
1451     JNIEnv*, jobject, jlong jhandle) {
1452   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1453   return static_cast<jlong>(opt->compaction_readahead_size);
1454 }
1455
1456 /*
1457  * Class:     org_rocksdb_Options
1458  * Method:    setRandomAccessMaxBufferSize
1459  * Signature: (JJ)V
1460  */
1461 void Java_org_rocksdb_Options_setRandomAccessMaxBufferSize(
1462     JNIEnv*, jobject, jlong jhandle, jlong jrandom_access_max_buffer_size) {
1463   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1464   opt->random_access_max_buffer_size =
1465       static_cast<size_t>(jrandom_access_max_buffer_size);
1466 }
1467
1468 /*
1469  * Class:     org_rocksdb_Options
1470  * Method:    randomAccessMaxBufferSize
1471  * Signature: (J)J
1472  */
1473 jlong Java_org_rocksdb_Options_randomAccessMaxBufferSize(
1474     JNIEnv*, jobject, jlong jhandle) {
1475   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1476   return static_cast<jlong>(opt->random_access_max_buffer_size);
1477 }
1478
1479 /*
1480  * Class:     org_rocksdb_Options
1481  * Method:    setWritableFileMaxBufferSize
1482  * Signature: (JJ)V
1483  */
1484 void Java_org_rocksdb_Options_setWritableFileMaxBufferSize(
1485     JNIEnv*, jobject, jlong jhandle,
1486     jlong jwritable_file_max_buffer_size) {
1487   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1488   opt->writable_file_max_buffer_size =
1489       static_cast<size_t>(jwritable_file_max_buffer_size);
1490 }
1491
1492 /*
1493  * Class:     org_rocksdb_Options
1494  * Method:    writableFileMaxBufferSize
1495  * Signature: (J)J
1496  */
1497 jlong Java_org_rocksdb_Options_writableFileMaxBufferSize(
1498     JNIEnv*, jobject, jlong jhandle) {
1499   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1500   return static_cast<jlong>(opt->writable_file_max_buffer_size);
1501 }
1502
1503 /*
1504  * Class:     org_rocksdb_Options
1505  * Method:    useAdaptiveMutex
1506  * Signature: (J)Z
1507  */
1508 jboolean Java_org_rocksdb_Options_useAdaptiveMutex(
1509     JNIEnv*, jobject, jlong jhandle) {
1510   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1511       ->use_adaptive_mutex;
1512 }
1513
1514 /*
1515  * Class:     org_rocksdb_Options
1516  * Method:    setUseAdaptiveMutex
1517  * Signature: (JZ)V
1518  */
1519 void Java_org_rocksdb_Options_setUseAdaptiveMutex(
1520     JNIEnv*, jobject, jlong jhandle, jboolean use_adaptive_mutex) {
1521   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->use_adaptive_mutex =
1522       static_cast<bool>(use_adaptive_mutex);
1523 }
1524
1525 /*
1526  * Class:     org_rocksdb_Options
1527  * Method:    bytesPerSync
1528  * Signature: (J)J
1529  */
1530 jlong Java_org_rocksdb_Options_bytesPerSync(
1531     JNIEnv*, jobject, jlong jhandle) {
1532   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->bytes_per_sync;
1533 }
1534
1535 /*
1536  * Class:     org_rocksdb_Options
1537  * Method:    setBytesPerSync
1538  * Signature: (JJ)V
1539  */
1540 void Java_org_rocksdb_Options_setBytesPerSync(
1541     JNIEnv*, jobject, jlong jhandle, jlong bytes_per_sync) {
1542   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->bytes_per_sync =
1543       static_cast<int64_t>(bytes_per_sync);
1544 }
1545
1546 /*
1547  * Class:     org_rocksdb_Options
1548  * Method:    setWalBytesPerSync
1549  * Signature: (JJ)V
1550  */
1551 void Java_org_rocksdb_Options_setWalBytesPerSync(
1552     JNIEnv*, jobject, jlong jhandle, jlong jwal_bytes_per_sync) {
1553   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->wal_bytes_per_sync =
1554       static_cast<int64_t>(jwal_bytes_per_sync);
1555 }
1556
1557 /*
1558  * Class:     org_rocksdb_Options
1559  * Method:    walBytesPerSync
1560  * Signature: (J)J
1561  */
1562 jlong Java_org_rocksdb_Options_walBytesPerSync(
1563     JNIEnv*, jobject, jlong jhandle) {
1564   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1565   return static_cast<jlong>(opt->wal_bytes_per_sync);
1566 }
1567
1568 /*
1569  * Class:     org_rocksdb_Options
1570  * Method:    setStrictBytesPerSync
1571  * Signature: (JZ)V
1572  */
1573 void Java_org_rocksdb_Options_setStrictBytesPerSync(
1574     JNIEnv*, jobject, jlong jhandle, jboolean jstrict_bytes_per_sync) {
1575   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1576       ->strict_bytes_per_sync = jstrict_bytes_per_sync == JNI_TRUE;
1577 }
1578
1579 /*
1580  * Class:     org_rocksdb_Options
1581  * Method:    strictBytesPerSync
1582  * Signature: (J)Z
1583  */
1584 jboolean Java_org_rocksdb_Options_strictBytesPerSync(
1585     JNIEnv*, jobject, jlong jhandle) {
1586   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1587   return static_cast<jboolean>(opt->strict_bytes_per_sync);
1588 }
1589
1590 /*
1591  * Class:     org_rocksdb_Options
1592  * Method:    setEnableThreadTracking
1593  * Signature: (JZ)V
1594  */
1595 void Java_org_rocksdb_Options_setEnableThreadTracking(
1596     JNIEnv*, jobject, jlong jhandle, jboolean jenable_thread_tracking) {
1597   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1598   opt->enable_thread_tracking = static_cast<bool>(jenable_thread_tracking);
1599 }
1600
1601 /*
1602  * Class:     org_rocksdb_Options
1603  * Method:    enableThreadTracking
1604  * Signature: (J)Z
1605  */
1606 jboolean Java_org_rocksdb_Options_enableThreadTracking(
1607     JNIEnv*, jobject, jlong jhandle) {
1608   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1609   return static_cast<jboolean>(opt->enable_thread_tracking);
1610 }
1611
1612 /*
1613  * Class:     org_rocksdb_Options
1614  * Method:    setDelayedWriteRate
1615  * Signature: (JJ)V
1616  */
1617 void Java_org_rocksdb_Options_setDelayedWriteRate(
1618     JNIEnv*, jobject, jlong jhandle, jlong jdelayed_write_rate) {
1619   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1620   opt->delayed_write_rate = static_cast<uint64_t>(jdelayed_write_rate);
1621 }
1622
1623 /*
1624  * Class:     org_rocksdb_Options
1625  * Method:    delayedWriteRate
1626  * Signature: (J)J
1627  */
1628 jlong Java_org_rocksdb_Options_delayedWriteRate(
1629     JNIEnv*, jobject, jlong jhandle) {
1630   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1631   return static_cast<jlong>(opt->delayed_write_rate);
1632 }
1633
1634 /*
1635  * Class:     org_rocksdb_Options
1636  * Method:    setEnablePipelinedWrite
1637  * Signature: (JZ)V
1638  */
1639 void Java_org_rocksdb_Options_setEnablePipelinedWrite(
1640     JNIEnv*, jobject, jlong jhandle, jboolean jenable_pipelined_write) {
1641   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1642   opt->enable_pipelined_write = jenable_pipelined_write == JNI_TRUE;
1643 }
1644
1645 /*
1646  * Class:     org_rocksdb_Options
1647  * Method:    enablePipelinedWrite
1648  * Signature: (J)Z
1649  */
1650 jboolean Java_org_rocksdb_Options_enablePipelinedWrite(
1651     JNIEnv*, jobject, jlong jhandle) {
1652   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1653   return static_cast<jboolean>(opt->enable_pipelined_write);
1654 }
1655
1656 /*
1657  * Class:     org_rocksdb_Options
1658  * Method:    setUnorderedWrite
1659  * Signature: (JZ)V
1660  */
1661 void Java_org_rocksdb_Options_setUnorderedWrite(
1662     JNIEnv*, jobject, jlong jhandle, jboolean unordered_write) {
1663   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->unordered_write =
1664       static_cast<bool>(unordered_write);
1665 }
1666
1667 /*
1668  * Class:     org_rocksdb_Options
1669  * Method:    unorderedWrite
1670  * Signature: (J)Z
1671  */
1672 jboolean Java_org_rocksdb_Options_unorderedWrite(
1673         JNIEnv*, jobject, jlong jhandle) {
1674   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1675       ->unordered_write;
1676 }
1677
1678 /*
1679  * Class:     org_rocksdb_Options
1680  * Method:    setAllowConcurrentMemtableWrite
1681  * Signature: (JZ)V
1682  */
1683 void Java_org_rocksdb_Options_setAllowConcurrentMemtableWrite(
1684     JNIEnv*, jobject, jlong jhandle, jboolean allow) {
1685   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1686       ->allow_concurrent_memtable_write = static_cast<bool>(allow);
1687 }
1688
1689 /*
1690  * Class:     org_rocksdb_Options
1691  * Method:    allowConcurrentMemtableWrite
1692  * Signature: (J)Z
1693  */
1694 jboolean Java_org_rocksdb_Options_allowConcurrentMemtableWrite(
1695     JNIEnv*, jobject, jlong jhandle) {
1696   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1697       ->allow_concurrent_memtable_write;
1698 }
1699
1700 /*
1701  * Class:     org_rocksdb_Options
1702  * Method:    setEnableWriteThreadAdaptiveYield
1703  * Signature: (JZ)V
1704  */
1705 void Java_org_rocksdb_Options_setEnableWriteThreadAdaptiveYield(
1706     JNIEnv*, jobject, jlong jhandle, jboolean yield) {
1707   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1708       ->enable_write_thread_adaptive_yield = static_cast<bool>(yield);
1709 }
1710
1711 /*
1712  * Class:     org_rocksdb_Options
1713  * Method:    enableWriteThreadAdaptiveYield
1714  * Signature: (J)Z
1715  */
1716 jboolean Java_org_rocksdb_Options_enableWriteThreadAdaptiveYield(
1717     JNIEnv*, jobject, jlong jhandle) {
1718   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1719       ->enable_write_thread_adaptive_yield;
1720 }
1721
1722 /*
1723  * Class:     org_rocksdb_Options
1724  * Method:    setWriteThreadMaxYieldUsec
1725  * Signature: (JJ)V
1726  */
1727 void Java_org_rocksdb_Options_setWriteThreadMaxYieldUsec(
1728     JNIEnv*, jobject, jlong jhandle, jlong max) {
1729   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1730       ->write_thread_max_yield_usec = static_cast<int64_t>(max);
1731 }
1732
1733 /*
1734  * Class:     org_rocksdb_Options
1735  * Method:    writeThreadMaxYieldUsec
1736  * Signature: (J)J
1737  */
1738 jlong Java_org_rocksdb_Options_writeThreadMaxYieldUsec(
1739     JNIEnv*, jobject, jlong jhandle) {
1740   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1741       ->write_thread_max_yield_usec;
1742 }
1743
1744 /*
1745  * Class:     org_rocksdb_Options
1746  * Method:    setWriteThreadSlowYieldUsec
1747  * Signature: (JJ)V
1748  */
1749 void Java_org_rocksdb_Options_setWriteThreadSlowYieldUsec(
1750     JNIEnv*, jobject, jlong jhandle, jlong slow) {
1751   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1752       ->write_thread_slow_yield_usec = static_cast<int64_t>(slow);
1753 }
1754
1755 /*
1756  * Class:     org_rocksdb_Options
1757  * Method:    writeThreadSlowYieldUsec
1758  * Signature: (J)J
1759  */
1760 jlong Java_org_rocksdb_Options_writeThreadSlowYieldUsec(
1761     JNIEnv*, jobject, jlong jhandle) {
1762   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
1763       ->write_thread_slow_yield_usec;
1764 }
1765
1766 /*
1767  * Class:     org_rocksdb_Options
1768  * Method:    setSkipStatsUpdateOnDbOpen
1769  * Signature: (JZ)V
1770  */
1771 void Java_org_rocksdb_Options_setSkipStatsUpdateOnDbOpen(
1772     JNIEnv*, jobject, jlong jhandle,
1773     jboolean jskip_stats_update_on_db_open) {
1774   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1775   opt->skip_stats_update_on_db_open =
1776       static_cast<bool>(jskip_stats_update_on_db_open);
1777 }
1778
1779 /*
1780  * Class:     org_rocksdb_Options
1781  * Method:    skipStatsUpdateOnDbOpen
1782  * Signature: (J)Z
1783  */
1784 jboolean Java_org_rocksdb_Options_skipStatsUpdateOnDbOpen(
1785     JNIEnv*, jobject, jlong jhandle) {
1786   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1787   return static_cast<jboolean>(opt->skip_stats_update_on_db_open);
1788 }
1789
1790 /*
1791  * Class:     org_rocksdb_Options
1792  * Method:    setSkipCheckingSstFileSizesOnDbOpen
1793  * Signature: (JZ)V
1794  */
1795 void Java_org_rocksdb_Options_setSkipCheckingSstFileSizesOnDbOpen(
1796     JNIEnv*, jobject, jlong jhandle,
1797     jboolean jskip_checking_sst_file_sizes_on_db_open) {
1798   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1799   opt->skip_checking_sst_file_sizes_on_db_open =
1800       static_cast<bool>(jskip_checking_sst_file_sizes_on_db_open);
1801 }
1802
1803 /*
1804  * Class:     org_rocksdb_Options
1805  * Method:    skipCheckingSstFileSizesOnDbOpen
1806  * Signature: (J)Z
1807  */
1808 jboolean Java_org_rocksdb_Options_skipCheckingSstFileSizesOnDbOpen(
1809     JNIEnv*, jobject, jlong jhandle) {
1810   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1811   return static_cast<jboolean>(opt->skip_checking_sst_file_sizes_on_db_open);
1812 }
1813
1814 /*
1815  * Class:     org_rocksdb_Options
1816  * Method:    setWalRecoveryMode
1817  * Signature: (JB)V
1818  */
1819 void Java_org_rocksdb_Options_setWalRecoveryMode(
1820     JNIEnv*, jobject, jlong jhandle,
1821     jbyte jwal_recovery_mode_value) {
1822   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1823   opt->wal_recovery_mode =
1824       ROCKSDB_NAMESPACE::WALRecoveryModeJni::toCppWALRecoveryMode(
1825           jwal_recovery_mode_value);
1826 }
1827
1828 /*
1829  * Class:     org_rocksdb_Options
1830  * Method:    walRecoveryMode
1831  * Signature: (J)B
1832  */
1833 jbyte Java_org_rocksdb_Options_walRecoveryMode(
1834     JNIEnv*, jobject, jlong jhandle) {
1835   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1836   return ROCKSDB_NAMESPACE::WALRecoveryModeJni::toJavaWALRecoveryMode(
1837       opt->wal_recovery_mode);
1838 }
1839
1840 /*
1841  * Class:     org_rocksdb_Options
1842  * Method:    setAllow2pc
1843  * Signature: (JZ)V
1844  */
1845 void Java_org_rocksdb_Options_setAllow2pc(
1846     JNIEnv*, jobject, jlong jhandle, jboolean jallow_2pc) {
1847   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1848   opt->allow_2pc = static_cast<bool>(jallow_2pc);
1849 }
1850
1851 /*
1852  * Class:     org_rocksdb_Options
1853  * Method:    allow2pc
1854  * Signature: (J)Z
1855  */
1856 jboolean Java_org_rocksdb_Options_allow2pc(
1857     JNIEnv*, jobject, jlong jhandle) {
1858   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1859   return static_cast<jboolean>(opt->allow_2pc);
1860 }
1861
1862 /*
1863  * Class:     org_rocksdb_Options
1864  * Method:    setRowCache
1865  * Signature: (JJ)V
1866  */
1867 void Java_org_rocksdb_Options_setRowCache(
1868     JNIEnv*, jobject, jlong jhandle, jlong jrow_cache_handle) {
1869   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1870   auto* row_cache =
1871       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::Cache>*>(
1872           jrow_cache_handle);
1873   opt->row_cache = *row_cache;
1874 }
1875
1876
1877 /*
1878  * Class:     org_rocksdb_Options
1879  * Method:    setWalFilter
1880  * Signature: (JJ)V
1881  */
1882 void Java_org_rocksdb_Options_setWalFilter(
1883     JNIEnv*, jobject, jlong jhandle, jlong jwal_filter_handle) {
1884   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1885   auto* wal_filter = reinterpret_cast<ROCKSDB_NAMESPACE::WalFilterJniCallback*>(
1886       jwal_filter_handle);
1887   opt->wal_filter = wal_filter;
1888 }
1889
1890 /*
1891  * Class:     org_rocksdb_Options
1892  * Method:    setFailIfOptionsFileError
1893  * Signature: (JZ)V
1894  */
1895 void Java_org_rocksdb_Options_setFailIfOptionsFileError(
1896     JNIEnv*, jobject, jlong jhandle, jboolean jfail_if_options_file_error) {
1897   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1898   opt->fail_if_options_file_error =
1899       static_cast<bool>(jfail_if_options_file_error);
1900 }
1901
1902 /*
1903  * Class:     org_rocksdb_Options
1904  * Method:    failIfOptionsFileError
1905  * Signature: (J)Z
1906  */
1907 jboolean Java_org_rocksdb_Options_failIfOptionsFileError(
1908     JNIEnv*, jobject, jlong jhandle) {
1909   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1910   return static_cast<jboolean>(opt->fail_if_options_file_error);
1911 }
1912
1913 /*
1914  * Class:     org_rocksdb_Options
1915  * Method:    setDumpMallocStats
1916  * Signature: (JZ)V
1917  */
1918 void Java_org_rocksdb_Options_setDumpMallocStats(
1919     JNIEnv*, jobject, jlong jhandle, jboolean jdump_malloc_stats) {
1920   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1921   opt->dump_malloc_stats = static_cast<bool>(jdump_malloc_stats);
1922 }
1923
1924 /*
1925  * Class:     org_rocksdb_Options
1926  * Method:    dumpMallocStats
1927  * Signature: (J)Z
1928  */
1929 jboolean Java_org_rocksdb_Options_dumpMallocStats(
1930     JNIEnv*, jobject, jlong jhandle) {
1931   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1932   return static_cast<jboolean>(opt->dump_malloc_stats);
1933 }
1934
1935 /*
1936  * Class:     org_rocksdb_Options
1937  * Method:    setAvoidFlushDuringRecovery
1938  * Signature: (JZ)V
1939  */
1940 void Java_org_rocksdb_Options_setAvoidFlushDuringRecovery(
1941     JNIEnv*, jobject, jlong jhandle, jboolean javoid_flush_during_recovery) {
1942   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1943   opt->avoid_flush_during_recovery =
1944       static_cast<bool>(javoid_flush_during_recovery);
1945 }
1946
1947 /*
1948  * Class:     org_rocksdb_Options
1949  * Method:    avoidFlushDuringRecovery
1950  * Signature: (J)Z
1951  */
1952 jboolean Java_org_rocksdb_Options_avoidFlushDuringRecovery(
1953     JNIEnv*, jobject, jlong jhandle) {
1954   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1955   return static_cast<jboolean>(opt->avoid_flush_during_recovery);
1956 }
1957
1958 /*
1959  * Class:     org_rocksdb_Options
1960  * Method:    setAvoidFlushDuringShutdown
1961  * Signature: (JZ)V
1962  */
1963 void Java_org_rocksdb_Options_setAvoidFlushDuringShutdown(
1964     JNIEnv*, jobject, jlong jhandle, jboolean javoid_flush_during_shutdown) {
1965   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1966   opt->avoid_flush_during_shutdown =
1967       static_cast<bool>(javoid_flush_during_shutdown);
1968 }
1969
1970 /*
1971  * Class:     org_rocksdb_Options
1972  * Method:    avoidFlushDuringShutdown
1973  * Signature: (J)Z
1974  */
1975 jboolean Java_org_rocksdb_Options_avoidFlushDuringShutdown(
1976     JNIEnv*, jobject, jlong jhandle) {
1977   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1978   return static_cast<jboolean>(opt->avoid_flush_during_shutdown);
1979 }
1980
1981 /*
1982  * Class:     org_rocksdb_Options
1983  * Method:    setAllowIngestBehind
1984  * Signature: (JZ)V
1985  */
1986 void Java_org_rocksdb_Options_setAllowIngestBehind(
1987     JNIEnv*, jobject, jlong jhandle, jboolean jallow_ingest_behind) {
1988   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
1989   opt->allow_ingest_behind = jallow_ingest_behind == JNI_TRUE;
1990 }
1991
1992 /*
1993  * Class:     org_rocksdb_Options
1994  * Method:    allowIngestBehind
1995  * Signature: (J)Z
1996  */
1997 jboolean Java_org_rocksdb_Options_allowIngestBehind(
1998     JNIEnv*, jobject, jlong jhandle) {
1999   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2000   return static_cast<jboolean>(opt->allow_ingest_behind);
2001 }
2002
2003 /*
2004  * Class:     org_rocksdb_Options
2005  * Method:    setPreserveDeletes
2006  * Signature: (JZ)V
2007  */
2008 void Java_org_rocksdb_Options_setPreserveDeletes(
2009     JNIEnv*, jobject, jlong jhandle, jboolean jpreserve_deletes) {
2010   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2011   opt->preserve_deletes = jpreserve_deletes == JNI_TRUE;
2012 }
2013
2014 /*
2015  * Class:     org_rocksdb_Options
2016  * Method:    preserveDeletes
2017  * Signature: (J)Z
2018  */
2019 jboolean Java_org_rocksdb_Options_preserveDeletes(
2020     JNIEnv*, jobject, jlong jhandle) {
2021   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2022   return static_cast<jboolean>(opt->preserve_deletes);
2023 }
2024
2025 /*
2026  * Class:     org_rocksdb_Options
2027  * Method:    setTwoWriteQueues
2028  * Signature: (JZ)V
2029  */
2030 void Java_org_rocksdb_Options_setTwoWriteQueues(
2031     JNIEnv*, jobject, jlong jhandle, jboolean jtwo_write_queues) {
2032   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2033   opt->two_write_queues = jtwo_write_queues == JNI_TRUE;
2034 }
2035
2036 /*
2037  * Class:     org_rocksdb_Options
2038  * Method:    twoWriteQueues
2039  * Signature: (J)Z
2040  */
2041 jboolean Java_org_rocksdb_Options_twoWriteQueues(
2042     JNIEnv*, jobject, jlong jhandle) {
2043   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2044   return static_cast<jboolean>(opt->two_write_queues);
2045 }
2046
2047 /*
2048  * Class:     org_rocksdb_Options
2049  * Method:    setManualWalFlush
2050  * Signature: (JZ)V
2051  */
2052 void Java_org_rocksdb_Options_setManualWalFlush(
2053     JNIEnv*, jobject, jlong jhandle, jboolean jmanual_wal_flush) {
2054   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2055   opt->manual_wal_flush = jmanual_wal_flush == JNI_TRUE;
2056 }
2057
2058 /*
2059  * Class:     org_rocksdb_Options
2060  * Method:    manualWalFlush
2061  * Signature: (J)Z
2062  */
2063 jboolean Java_org_rocksdb_Options_manualWalFlush(
2064     JNIEnv*, jobject, jlong jhandle) {
2065   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2066   return static_cast<jboolean>(opt->manual_wal_flush);
2067 }
2068
2069 /*
2070  * Class:     org_rocksdb_Options
2071  * Method:    setAtomicFlush
2072  * Signature: (JZ)V
2073  */
2074 void Java_org_rocksdb_Options_setAtomicFlush(
2075     JNIEnv*, jobject, jlong jhandle, jboolean jatomic_flush) {
2076   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2077   opt->atomic_flush = jatomic_flush == JNI_TRUE;
2078 }
2079
2080 /*
2081  * Class:     org_rocksdb_Options
2082  * Method:    atomicFlush
2083  * Signature: (J)Z
2084  */
2085 jboolean Java_org_rocksdb_Options_atomicFlush(
2086     JNIEnv *, jobject, jlong jhandle) {
2087   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2088   return static_cast<jboolean>(opt->atomic_flush);
2089 }
2090
2091 /*
2092  * Method:    tableFactoryName
2093  * Signature: (J)Ljava/lang/String
2094  */
2095 jstring Java_org_rocksdb_Options_tableFactoryName(
2096     JNIEnv* env, jobject, jlong jhandle) {
2097   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2098   ROCKSDB_NAMESPACE::TableFactory* tf = opt->table_factory.get();
2099
2100   // Should never be nullptr.
2101   // Default memtable factory is SkipListFactory
2102   assert(tf);
2103
2104   return env->NewStringUTF(tf->Name());
2105 }
2106
2107 /*
2108  * Class:     org_rocksdb_Options
2109  * Method:    minWriteBufferNumberToMerge
2110  * Signature: (J)I
2111  */
2112 jint Java_org_rocksdb_Options_minWriteBufferNumberToMerge(
2113     JNIEnv*, jobject, jlong jhandle) {
2114   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2115       ->min_write_buffer_number_to_merge;
2116 }
2117
2118 /*
2119  * Class:     org_rocksdb_Options
2120  * Method:    setMinWriteBufferNumberToMerge
2121  * Signature: (JI)V
2122  */
2123 void Java_org_rocksdb_Options_setMinWriteBufferNumberToMerge(
2124     JNIEnv*, jobject, jlong jhandle, jint jmin_write_buffer_number_to_merge) {
2125   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2126       ->min_write_buffer_number_to_merge =
2127       static_cast<int>(jmin_write_buffer_number_to_merge);
2128 }
2129 /*
2130  * Class:     org_rocksdb_Options
2131  * Method:    maxWriteBufferNumberToMaintain
2132  * Signature: (J)I
2133  */
2134 jint Java_org_rocksdb_Options_maxWriteBufferNumberToMaintain(
2135     JNIEnv*, jobject, jlong jhandle) {
2136   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2137       ->max_write_buffer_number_to_maintain;
2138 }
2139
2140 /*
2141  * Class:     org_rocksdb_Options
2142  * Method:    setMaxWriteBufferNumberToMaintain
2143  * Signature: (JI)V
2144  */
2145 void Java_org_rocksdb_Options_setMaxWriteBufferNumberToMaintain(
2146     JNIEnv*, jobject, jlong jhandle,
2147     jint jmax_write_buffer_number_to_maintain) {
2148   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2149       ->max_write_buffer_number_to_maintain =
2150       static_cast<int>(jmax_write_buffer_number_to_maintain);
2151 }
2152
2153 /*
2154  * Class:     org_rocksdb_Options
2155  * Method:    setCompressionType
2156  * Signature: (JB)V
2157  */
2158 void Java_org_rocksdb_Options_setCompressionType(
2159     JNIEnv*, jobject, jlong jhandle, jbyte jcompression_type_value) {
2160   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2161   opts->compression =
2162       ROCKSDB_NAMESPACE::CompressionTypeJni::toCppCompressionType(
2163           jcompression_type_value);
2164 }
2165
2166 /*
2167  * Class:     org_rocksdb_Options
2168  * Method:    compressionType
2169  * Signature: (J)B
2170  */
2171 jbyte Java_org_rocksdb_Options_compressionType(
2172     JNIEnv*, jobject, jlong jhandle) {
2173   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2174   return ROCKSDB_NAMESPACE::CompressionTypeJni::toJavaCompressionType(
2175       opts->compression);
2176 }
2177
2178 /**
2179  * Helper method to convert a Java byte array of compression levels
2180  * to a C++ vector of ROCKSDB_NAMESPACE::CompressionType
2181  *
2182  * @param env A pointer to the Java environment
2183  * @param jcompression_levels A reference to a java byte array
2184  *     where each byte indicates a compression level
2185  *
2186  * @return A std::unique_ptr to the vector, or std::unique_ptr(nullptr) if a JNI
2187  * exception occurs
2188  */
2189 std::unique_ptr<std::vector<ROCKSDB_NAMESPACE::CompressionType>>
2190 rocksdb_compression_vector_helper(JNIEnv* env, jbyteArray jcompression_levels) {
2191   jsize len = env->GetArrayLength(jcompression_levels);
2192   jbyte* jcompression_level =
2193       env->GetByteArrayElements(jcompression_levels, nullptr);
2194   if (jcompression_level == nullptr) {
2195     // exception thrown: OutOfMemoryError
2196     return std::unique_ptr<std::vector<ROCKSDB_NAMESPACE::CompressionType>>();
2197   }
2198
2199   auto* compression_levels =
2200       new std::vector<ROCKSDB_NAMESPACE::CompressionType>();
2201   std::unique_ptr<std::vector<ROCKSDB_NAMESPACE::CompressionType>>
2202       uptr_compression_levels(compression_levels);
2203
2204   for (jsize i = 0; i < len; i++) {
2205     jbyte jcl = jcompression_level[i];
2206     compression_levels->push_back(
2207         static_cast<ROCKSDB_NAMESPACE::CompressionType>(jcl));
2208   }
2209
2210   env->ReleaseByteArrayElements(jcompression_levels, jcompression_level,
2211                                 JNI_ABORT);
2212
2213   return uptr_compression_levels;
2214 }
2215
2216 /**
2217  * Helper method to convert a C++ vector of ROCKSDB_NAMESPACE::CompressionType
2218  * to a Java byte array of compression levels
2219  *
2220  * @param env A pointer to the Java environment
2221  * @param jcompression_levels A reference to a java byte array
2222  *     where each byte indicates a compression level
2223  *
2224  * @return A jbytearray or nullptr if an exception occurs
2225  */
2226 jbyteArray rocksdb_compression_list_helper(
2227     JNIEnv* env,
2228     std::vector<ROCKSDB_NAMESPACE::CompressionType> compression_levels) {
2229   const size_t len = compression_levels.size();
2230   jbyte* jbuf = new jbyte[len];
2231
2232   for (size_t i = 0; i < len; i++) {
2233     jbuf[i] = compression_levels[i];
2234   }
2235
2236   // insert in java array
2237   jbyteArray jcompression_levels = env->NewByteArray(static_cast<jsize>(len));
2238   if (jcompression_levels == nullptr) {
2239     // exception thrown: OutOfMemoryError
2240     delete[] jbuf;
2241     return nullptr;
2242   }
2243   env->SetByteArrayRegion(jcompression_levels, 0, static_cast<jsize>(len),
2244                           jbuf);
2245   if (env->ExceptionCheck()) {
2246     // exception thrown: ArrayIndexOutOfBoundsException
2247     env->DeleteLocalRef(jcompression_levels);
2248     delete[] jbuf;
2249     return nullptr;
2250   }
2251
2252   delete[] jbuf;
2253
2254   return jcompression_levels;
2255 }
2256
2257 /*
2258  * Class:     org_rocksdb_Options
2259  * Method:    setCompressionPerLevel
2260  * Signature: (J[B)V
2261  */
2262 void Java_org_rocksdb_Options_setCompressionPerLevel(
2263     JNIEnv* env, jobject, jlong jhandle, jbyteArray jcompressionLevels) {
2264   auto uptr_compression_levels =
2265       rocksdb_compression_vector_helper(env, jcompressionLevels);
2266   if (!uptr_compression_levels) {
2267     // exception occurred
2268     return;
2269   }
2270   auto* options = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2271   options->compression_per_level = *(uptr_compression_levels.get());
2272 }
2273
2274 /*
2275  * Class:     org_rocksdb_Options
2276  * Method:    compressionPerLevel
2277  * Signature: (J)[B
2278  */
2279 jbyteArray Java_org_rocksdb_Options_compressionPerLevel(
2280     JNIEnv* env, jobject, jlong jhandle) {
2281   auto* options = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2282   return rocksdb_compression_list_helper(env, options->compression_per_level);
2283 }
2284
2285 /*
2286  * Class:     org_rocksdb_Options
2287  * Method:    setBottommostCompressionType
2288  * Signature: (JB)V
2289  */
2290 void Java_org_rocksdb_Options_setBottommostCompressionType(
2291     JNIEnv*, jobject, jlong jhandle, jbyte jcompression_type_value) {
2292   auto* options = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2293   options->bottommost_compression =
2294       ROCKSDB_NAMESPACE::CompressionTypeJni::toCppCompressionType(
2295           jcompression_type_value);
2296 }
2297
2298 /*
2299  * Class:     org_rocksdb_Options
2300  * Method:    bottommostCompressionType
2301  * Signature: (J)B
2302  */
2303 jbyte Java_org_rocksdb_Options_bottommostCompressionType(
2304     JNIEnv*, jobject, jlong jhandle) {
2305   auto* options = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2306   return ROCKSDB_NAMESPACE::CompressionTypeJni::toJavaCompressionType(
2307       options->bottommost_compression);
2308 }
2309
2310 /*
2311  * Class:     org_rocksdb_Options
2312  * Method:    setBottommostCompressionOptions
2313  * Signature: (JJ)V
2314  */
2315 void Java_org_rocksdb_Options_setBottommostCompressionOptions(
2316     JNIEnv*, jobject, jlong jhandle,
2317     jlong jbottommost_compression_options_handle) {
2318   auto* options = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2319   auto* bottommost_compression_options =
2320       reinterpret_cast<ROCKSDB_NAMESPACE::CompressionOptions*>(
2321           jbottommost_compression_options_handle);
2322   options->bottommost_compression_opts = *bottommost_compression_options;
2323 }
2324
2325 /*
2326  * Class:     org_rocksdb_Options
2327  * Method:    setCompressionOptions
2328  * Signature: (JJ)V
2329  */
2330 void Java_org_rocksdb_Options_setCompressionOptions(
2331     JNIEnv*, jobject, jlong jhandle, jlong jcompression_options_handle) {
2332   auto* options = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2333   auto* compression_options =
2334       reinterpret_cast<ROCKSDB_NAMESPACE::CompressionOptions*>(
2335           jcompression_options_handle);
2336   options->compression_opts = *compression_options;
2337 }
2338
2339 /*
2340  * Class:     org_rocksdb_Options
2341  * Method:    setCompactionStyle
2342  * Signature: (JB)V
2343  */
2344 void Java_org_rocksdb_Options_setCompactionStyle(
2345     JNIEnv*, jobject, jlong jhandle, jbyte jcompaction_style) {
2346   auto* options = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2347   options->compaction_style =
2348       ROCKSDB_NAMESPACE::CompactionStyleJni::toCppCompactionStyle(
2349           jcompaction_style);
2350 }
2351
2352 /*
2353  * Class:     org_rocksdb_Options
2354  * Method:    compactionStyle
2355  * Signature: (J)B
2356  */
2357 jbyte Java_org_rocksdb_Options_compactionStyle(
2358     JNIEnv*, jobject, jlong jhandle) {
2359   auto* options = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
2360   return ROCKSDB_NAMESPACE::CompactionStyleJni::toJavaCompactionStyle(
2361       options->compaction_style);
2362 }
2363
2364 /*
2365  * Class:     org_rocksdb_Options
2366  * Method:    setMaxTableFilesSizeFIFO
2367  * Signature: (JJ)V
2368  */
2369 void Java_org_rocksdb_Options_setMaxTableFilesSizeFIFO(
2370     JNIEnv*, jobject, jlong jhandle, jlong jmax_table_files_size) {
2371   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2372       ->compaction_options_fifo.max_table_files_size =
2373       static_cast<uint64_t>(jmax_table_files_size);
2374 }
2375
2376 /*
2377  * Class:     org_rocksdb_Options
2378  * Method:    maxTableFilesSizeFIFO
2379  * Signature: (J)J
2380  */
2381 jlong Java_org_rocksdb_Options_maxTableFilesSizeFIFO(
2382     JNIEnv*, jobject, jlong jhandle) {
2383   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2384       ->compaction_options_fifo.max_table_files_size;
2385 }
2386
2387 /*
2388  * Class:     org_rocksdb_Options
2389  * Method:    numLevels
2390  * Signature: (J)I
2391  */
2392 jint Java_org_rocksdb_Options_numLevels(
2393     JNIEnv*, jobject, jlong jhandle) {
2394   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->num_levels;
2395 }
2396
2397 /*
2398  * Class:     org_rocksdb_Options
2399  * Method:    setNumLevels
2400  * Signature: (JI)V
2401  */
2402 void Java_org_rocksdb_Options_setNumLevels(
2403     JNIEnv*, jobject, jlong jhandle, jint jnum_levels) {
2404   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->num_levels =
2405       static_cast<int>(jnum_levels);
2406 }
2407
2408 /*
2409  * Class:     org_rocksdb_Options
2410  * Method:    levelZeroFileNumCompactionTrigger
2411  * Signature: (J)I
2412  */
2413 jint Java_org_rocksdb_Options_levelZeroFileNumCompactionTrigger(
2414     JNIEnv*, jobject, jlong jhandle) {
2415   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2416       ->level0_file_num_compaction_trigger;
2417 }
2418
2419 /*
2420  * Class:     org_rocksdb_Options
2421  * Method:    setLevelZeroFileNumCompactionTrigger
2422  * Signature: (JI)V
2423  */
2424 void Java_org_rocksdb_Options_setLevelZeroFileNumCompactionTrigger(
2425     JNIEnv*, jobject, jlong jhandle,
2426     jint jlevel0_file_num_compaction_trigger) {
2427   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2428       ->level0_file_num_compaction_trigger =
2429       static_cast<int>(jlevel0_file_num_compaction_trigger);
2430 }
2431
2432 /*
2433  * Class:     org_rocksdb_Options
2434  * Method:    levelZeroSlowdownWritesTrigger
2435  * Signature: (J)I
2436  */
2437 jint Java_org_rocksdb_Options_levelZeroSlowdownWritesTrigger(
2438     JNIEnv*, jobject, jlong jhandle) {
2439   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2440       ->level0_slowdown_writes_trigger;
2441 }
2442
2443 /*
2444  * Class:     org_rocksdb_Options
2445  * Method:    setLevelSlowdownWritesTrigger
2446  * Signature: (JI)V
2447  */
2448 void Java_org_rocksdb_Options_setLevelZeroSlowdownWritesTrigger(
2449     JNIEnv*, jobject, jlong jhandle, jint jlevel0_slowdown_writes_trigger) {
2450   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2451       ->level0_slowdown_writes_trigger =
2452       static_cast<int>(jlevel0_slowdown_writes_trigger);
2453 }
2454
2455 /*
2456  * Class:     org_rocksdb_Options
2457  * Method:    levelZeroStopWritesTrigger
2458  * Signature: (J)I
2459  */
2460 jint Java_org_rocksdb_Options_levelZeroStopWritesTrigger(
2461     JNIEnv*, jobject, jlong jhandle) {
2462   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2463       ->level0_stop_writes_trigger;
2464 }
2465
2466 /*
2467  * Class:     org_rocksdb_Options
2468  * Method:    setLevelStopWritesTrigger
2469  * Signature: (JI)V
2470  */
2471 void Java_org_rocksdb_Options_setLevelZeroStopWritesTrigger(
2472     JNIEnv*, jobject, jlong jhandle, jint jlevel0_stop_writes_trigger) {
2473   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2474       ->level0_stop_writes_trigger =
2475       static_cast<int>(jlevel0_stop_writes_trigger);
2476 }
2477
2478 /*
2479  * Class:     org_rocksdb_Options
2480  * Method:    targetFileSizeBase
2481  * Signature: (J)J
2482  */
2483 jlong Java_org_rocksdb_Options_targetFileSizeBase(
2484     JNIEnv*, jobject, jlong jhandle) {
2485   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2486       ->target_file_size_base;
2487 }
2488
2489 /*
2490  * Class:     org_rocksdb_Options
2491  * Method:    setTargetFileSizeBase
2492  * Signature: (JJ)V
2493  */
2494 void Java_org_rocksdb_Options_setTargetFileSizeBase(
2495     JNIEnv*, jobject, jlong jhandle, jlong jtarget_file_size_base) {
2496   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2497       ->target_file_size_base = static_cast<uint64_t>(jtarget_file_size_base);
2498 }
2499
2500 /*
2501  * Class:     org_rocksdb_Options
2502  * Method:    targetFileSizeMultiplier
2503  * Signature: (J)I
2504  */
2505 jint Java_org_rocksdb_Options_targetFileSizeMultiplier(
2506     JNIEnv*, jobject, jlong jhandle) {
2507   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2508       ->target_file_size_multiplier;
2509 }
2510
2511 /*
2512  * Class:     org_rocksdb_Options
2513  * Method:    setTargetFileSizeMultiplier
2514  * Signature: (JI)V
2515  */
2516 void Java_org_rocksdb_Options_setTargetFileSizeMultiplier(
2517     JNIEnv*, jobject, jlong jhandle, jint jtarget_file_size_multiplier) {
2518   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2519       ->target_file_size_multiplier =
2520       static_cast<int>(jtarget_file_size_multiplier);
2521 }
2522
2523 /*
2524  * Class:     org_rocksdb_Options
2525  * Method:    maxBytesForLevelBase
2526  * Signature: (J)J
2527  */
2528 jlong Java_org_rocksdb_Options_maxBytesForLevelBase(
2529     JNIEnv*, jobject, jlong jhandle) {
2530   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2531       ->max_bytes_for_level_base;
2532 }
2533
2534 /*
2535  * Class:     org_rocksdb_Options
2536  * Method:    setMaxBytesForLevelBase
2537  * Signature: (JJ)V
2538  */
2539 void Java_org_rocksdb_Options_setMaxBytesForLevelBase(
2540     JNIEnv*, jobject, jlong jhandle, jlong jmax_bytes_for_level_base) {
2541   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2542       ->max_bytes_for_level_base =
2543       static_cast<int64_t>(jmax_bytes_for_level_base);
2544 }
2545
2546 /*
2547  * Class:     org_rocksdb_Options
2548  * Method:    levelCompactionDynamicLevelBytes
2549  * Signature: (J)Z
2550  */
2551 jboolean Java_org_rocksdb_Options_levelCompactionDynamicLevelBytes(
2552     JNIEnv*, jobject, jlong jhandle) {
2553   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2554       ->level_compaction_dynamic_level_bytes;
2555 }
2556
2557 /*
2558  * Class:     org_rocksdb_Options
2559  * Method:    setLevelCompactionDynamicLevelBytes
2560  * Signature: (JZ)V
2561  */
2562 void Java_org_rocksdb_Options_setLevelCompactionDynamicLevelBytes(
2563     JNIEnv*, jobject, jlong jhandle, jboolean jenable_dynamic_level_bytes) {
2564   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2565       ->level_compaction_dynamic_level_bytes = (jenable_dynamic_level_bytes);
2566 }
2567
2568 /*
2569  * Class:     org_rocksdb_Options
2570  * Method:    maxBytesForLevelMultiplier
2571  * Signature: (J)D
2572  */
2573 jdouble Java_org_rocksdb_Options_maxBytesForLevelMultiplier(
2574     JNIEnv*, jobject, jlong jhandle) {
2575   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2576       ->max_bytes_for_level_multiplier;
2577 }
2578
2579 /*
2580  * Class:     org_rocksdb_Options
2581  * Method:    setMaxBytesForLevelMultiplier
2582  * Signature: (JD)V
2583  */
2584 void Java_org_rocksdb_Options_setMaxBytesForLevelMultiplier(
2585     JNIEnv*, jobject, jlong jhandle, jdouble jmax_bytes_for_level_multiplier) {
2586   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2587       ->max_bytes_for_level_multiplier =
2588       static_cast<double>(jmax_bytes_for_level_multiplier);
2589 }
2590
2591 /*
2592  * Class:     org_rocksdb_Options
2593  * Method:    maxCompactionBytes
2594  * Signature: (J)I
2595  */
2596 jlong Java_org_rocksdb_Options_maxCompactionBytes(
2597     JNIEnv*, jobject, jlong jhandle) {
2598   return static_cast<jlong>(
2599       reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2600           ->max_compaction_bytes);
2601 }
2602
2603 /*
2604  * Class:     org_rocksdb_Options
2605  * Method:    setMaxCompactionBytes
2606  * Signature: (JI)V
2607  */
2608 void Java_org_rocksdb_Options_setMaxCompactionBytes(
2609     JNIEnv*, jobject, jlong jhandle, jlong jmax_compaction_bytes) {
2610   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->max_compaction_bytes =
2611       static_cast<uint64_t>(jmax_compaction_bytes);
2612 }
2613
2614 /*
2615  * Class:     org_rocksdb_Options
2616  * Method:    arenaBlockSize
2617  * Signature: (J)J
2618  */
2619 jlong Java_org_rocksdb_Options_arenaBlockSize(
2620     JNIEnv*, jobject, jlong jhandle) {
2621   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2622       ->arena_block_size;
2623 }
2624
2625 /*
2626  * Class:     org_rocksdb_Options
2627  * Method:    setArenaBlockSize
2628  * Signature: (JJ)V
2629  */
2630 void Java_org_rocksdb_Options_setArenaBlockSize(
2631     JNIEnv* env, jobject, jlong jhandle, jlong jarena_block_size) {
2632   auto s =
2633       ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(jarena_block_size);
2634   if (s.ok()) {
2635     reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->arena_block_size =
2636         jarena_block_size;
2637   } else {
2638     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
2639   }
2640 }
2641
2642 /*
2643  * Class:     org_rocksdb_Options
2644  * Method:    disableAutoCompactions
2645  * Signature: (J)Z
2646  */
2647 jboolean Java_org_rocksdb_Options_disableAutoCompactions(
2648     JNIEnv*, jobject, jlong jhandle) {
2649   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2650       ->disable_auto_compactions;
2651 }
2652
2653 /*
2654  * Class:     org_rocksdb_Options
2655  * Method:    setDisableAutoCompactions
2656  * Signature: (JZ)V
2657  */
2658 void Java_org_rocksdb_Options_setDisableAutoCompactions(
2659     JNIEnv*, jobject, jlong jhandle, jboolean jdisable_auto_compactions) {
2660   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2661       ->disable_auto_compactions = static_cast<bool>(jdisable_auto_compactions);
2662 }
2663
2664 /*
2665  * Class:     org_rocksdb_Options
2666  * Method:    maxSequentialSkipInIterations
2667  * Signature: (J)J
2668  */
2669 jlong Java_org_rocksdb_Options_maxSequentialSkipInIterations(
2670     JNIEnv*, jobject, jlong jhandle) {
2671   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2672       ->max_sequential_skip_in_iterations;
2673 }
2674
2675 /*
2676  * Class:     org_rocksdb_Options
2677  * Method:    setMaxSequentialSkipInIterations
2678  * Signature: (JJ)V
2679  */
2680 void Java_org_rocksdb_Options_setMaxSequentialSkipInIterations(
2681     JNIEnv*, jobject, jlong jhandle,
2682     jlong jmax_sequential_skip_in_iterations) {
2683   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2684       ->max_sequential_skip_in_iterations =
2685       static_cast<int64_t>(jmax_sequential_skip_in_iterations);
2686 }
2687
2688 /*
2689  * Class:     org_rocksdb_Options
2690  * Method:    inplaceUpdateSupport
2691  * Signature: (J)Z
2692  */
2693 jboolean Java_org_rocksdb_Options_inplaceUpdateSupport(
2694     JNIEnv*, jobject, jlong jhandle) {
2695   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2696       ->inplace_update_support;
2697 }
2698
2699 /*
2700  * Class:     org_rocksdb_Options
2701  * Method:    setInplaceUpdateSupport
2702  * Signature: (JZ)V
2703  */
2704 void Java_org_rocksdb_Options_setInplaceUpdateSupport(
2705     JNIEnv*, jobject, jlong jhandle, jboolean jinplace_update_support) {
2706   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2707       ->inplace_update_support = static_cast<bool>(jinplace_update_support);
2708 }
2709
2710 /*
2711  * Class:     org_rocksdb_Options
2712  * Method:    inplaceUpdateNumLocks
2713  * Signature: (J)J
2714  */
2715 jlong Java_org_rocksdb_Options_inplaceUpdateNumLocks(
2716     JNIEnv*, jobject, jlong jhandle) {
2717   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2718       ->inplace_update_num_locks;
2719 }
2720
2721 /*
2722  * Class:     org_rocksdb_Options
2723  * Method:    setInplaceUpdateNumLocks
2724  * Signature: (JJ)V
2725  */
2726 void Java_org_rocksdb_Options_setInplaceUpdateNumLocks(
2727     JNIEnv* env, jobject, jlong jhandle, jlong jinplace_update_num_locks) {
2728   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
2729       jinplace_update_num_locks);
2730   if (s.ok()) {
2731     reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2732         ->inplace_update_num_locks = jinplace_update_num_locks;
2733   } else {
2734     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
2735   }
2736 }
2737
2738 /*
2739  * Class:     org_rocksdb_Options
2740  * Method:    memtablePrefixBloomSizeRatio
2741  * Signature: (J)I
2742  */
2743 jdouble Java_org_rocksdb_Options_memtablePrefixBloomSizeRatio(
2744     JNIEnv*, jobject, jlong jhandle) {
2745   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2746       ->memtable_prefix_bloom_size_ratio;
2747 }
2748
2749 /*
2750  * Class:     org_rocksdb_Options
2751  * Method:    setMemtablePrefixBloomSizeRatio
2752  * Signature: (JI)V
2753  */
2754 void Java_org_rocksdb_Options_setMemtablePrefixBloomSizeRatio(
2755     JNIEnv*, jobject, jlong jhandle,
2756     jdouble jmemtable_prefix_bloom_size_ratio) {
2757   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2758       ->memtable_prefix_bloom_size_ratio =
2759       static_cast<double>(jmemtable_prefix_bloom_size_ratio);
2760 }
2761
2762 /*
2763  * Class:     org_rocksdb_Options
2764  * Method:    bloomLocality
2765  * Signature: (J)I
2766  */
2767 jint Java_org_rocksdb_Options_bloomLocality(
2768     JNIEnv*, jobject, jlong jhandle) {
2769   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->bloom_locality;
2770 }
2771
2772 /*
2773  * Class:     org_rocksdb_Options
2774  * Method:    setBloomLocality
2775  * Signature: (JI)V
2776  */
2777 void Java_org_rocksdb_Options_setBloomLocality(
2778     JNIEnv*, jobject, jlong jhandle, jint jbloom_locality) {
2779   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->bloom_locality =
2780       static_cast<int32_t>(jbloom_locality);
2781 }
2782
2783 /*
2784  * Class:     org_rocksdb_Options
2785  * Method:    maxSuccessiveMerges
2786  * Signature: (J)J
2787  */
2788 jlong Java_org_rocksdb_Options_maxSuccessiveMerges(
2789     JNIEnv*, jobject, jlong jhandle) {
2790   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2791       ->max_successive_merges;
2792 }
2793
2794 /*
2795  * Class:     org_rocksdb_Options
2796  * Method:    setMaxSuccessiveMerges
2797  * Signature: (JJ)V
2798  */
2799 void Java_org_rocksdb_Options_setMaxSuccessiveMerges(
2800     JNIEnv* env, jobject, jlong jhandle, jlong jmax_successive_merges) {
2801   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
2802       jmax_successive_merges);
2803   if (s.ok()) {
2804     reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2805         ->max_successive_merges = jmax_successive_merges;
2806   } else {
2807     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
2808   }
2809 }
2810
2811 /*
2812  * Class:     org_rocksdb_Options
2813  * Method:    optimizeFiltersForHits
2814  * Signature: (J)Z
2815  */
2816 jboolean Java_org_rocksdb_Options_optimizeFiltersForHits(
2817     JNIEnv*, jobject, jlong jhandle) {
2818   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2819       ->optimize_filters_for_hits;
2820 }
2821
2822 /*
2823  * Class:     org_rocksdb_Options
2824  * Method:    setOptimizeFiltersForHits
2825  * Signature: (JZ)V
2826  */
2827 void Java_org_rocksdb_Options_setOptimizeFiltersForHits(
2828     JNIEnv*, jobject, jlong jhandle, jboolean joptimize_filters_for_hits) {
2829   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2830       ->optimize_filters_for_hits =
2831       static_cast<bool>(joptimize_filters_for_hits);
2832 }
2833
2834 /*
2835  * Class:     org_rocksdb_Options
2836  * Method:    optimizeForSmallDb
2837  * Signature: (J)V
2838  */
2839 void Java_org_rocksdb_Options_optimizeForSmallDb(
2840     JNIEnv*, jobject, jlong jhandle) {
2841   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->OptimizeForSmallDb();
2842 }
2843
2844 /*
2845  * Class:     org_rocksdb_Options
2846  * Method:    optimizeForPointLookup
2847  * Signature: (JJ)V
2848  */
2849 void Java_org_rocksdb_Options_optimizeForPointLookup(
2850     JNIEnv*, jobject, jlong jhandle, jlong block_cache_size_mb) {
2851   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2852       ->OptimizeForPointLookup(block_cache_size_mb);
2853 }
2854
2855 /*
2856  * Class:     org_rocksdb_Options
2857  * Method:    optimizeLevelStyleCompaction
2858  * Signature: (JJ)V
2859  */
2860 void Java_org_rocksdb_Options_optimizeLevelStyleCompaction(
2861     JNIEnv*, jobject, jlong jhandle, jlong memtable_memory_budget) {
2862   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2863       ->OptimizeLevelStyleCompaction(memtable_memory_budget);
2864 }
2865
2866 /*
2867  * Class:     org_rocksdb_Options
2868  * Method:    optimizeUniversalStyleCompaction
2869  * Signature: (JJ)V
2870  */
2871 void Java_org_rocksdb_Options_optimizeUniversalStyleCompaction(
2872     JNIEnv*, jobject, jlong jhandle, jlong memtable_memory_budget) {
2873   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2874       ->OptimizeUniversalStyleCompaction(memtable_memory_budget);
2875 }
2876
2877 /*
2878  * Class:     org_rocksdb_Options
2879  * Method:    prepareForBulkLoad
2880  * Signature: (J)V
2881  */
2882 void Java_org_rocksdb_Options_prepareForBulkLoad(
2883     JNIEnv*, jobject, jlong jhandle) {
2884   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->PrepareForBulkLoad();
2885 }
2886
2887 /*
2888  * Class:     org_rocksdb_Options
2889  * Method:    memtableHugePageSize
2890  * Signature: (J)J
2891  */
2892 jlong Java_org_rocksdb_Options_memtableHugePageSize(
2893     JNIEnv*, jobject, jlong jhandle) {
2894   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2895       ->memtable_huge_page_size;
2896 }
2897
2898 /*
2899  * Class:     org_rocksdb_Options
2900  * Method:    setMemtableHugePageSize
2901  * Signature: (JJ)V
2902  */
2903 void Java_org_rocksdb_Options_setMemtableHugePageSize(
2904     JNIEnv* env, jobject, jlong jhandle, jlong jmemtable_huge_page_size) {
2905   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
2906       jmemtable_huge_page_size);
2907   if (s.ok()) {
2908     reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2909         ->memtable_huge_page_size = jmemtable_huge_page_size;
2910   } else {
2911     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
2912   }
2913 }
2914
2915 /*
2916  * Class:     org_rocksdb_Options
2917  * Method:    softPendingCompactionBytesLimit
2918  * Signature: (J)J
2919  */
2920 jlong Java_org_rocksdb_Options_softPendingCompactionBytesLimit(
2921     JNIEnv*, jobject, jlong jhandle) {
2922   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2923       ->soft_pending_compaction_bytes_limit;
2924 }
2925
2926 /*
2927  * Class:     org_rocksdb_Options
2928  * Method:    setSoftPendingCompactionBytesLimit
2929  * Signature: (JJ)V
2930  */
2931 void Java_org_rocksdb_Options_setSoftPendingCompactionBytesLimit(
2932     JNIEnv*, jobject, jlong jhandle,
2933     jlong jsoft_pending_compaction_bytes_limit) {
2934   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2935       ->soft_pending_compaction_bytes_limit =
2936       static_cast<int64_t>(jsoft_pending_compaction_bytes_limit);
2937 }
2938
2939 /*
2940  * Class:     org_rocksdb_Options
2941  * Method:    softHardCompactionBytesLimit
2942  * Signature: (J)J
2943  */
2944 jlong Java_org_rocksdb_Options_hardPendingCompactionBytesLimit(
2945     JNIEnv*, jobject, jlong jhandle) {
2946   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2947       ->hard_pending_compaction_bytes_limit;
2948 }
2949
2950 /*
2951  * Class:     org_rocksdb_Options
2952  * Method:    setHardPendingCompactionBytesLimit
2953  * Signature: (JJ)V
2954  */
2955 void Java_org_rocksdb_Options_setHardPendingCompactionBytesLimit(
2956     JNIEnv*, jobject, jlong jhandle,
2957     jlong jhard_pending_compaction_bytes_limit) {
2958   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2959       ->hard_pending_compaction_bytes_limit =
2960       static_cast<int64_t>(jhard_pending_compaction_bytes_limit);
2961 }
2962
2963 /*
2964  * Class:     org_rocksdb_Options
2965  * Method:    level0FileNumCompactionTrigger
2966  * Signature: (J)I
2967  */
2968 jint Java_org_rocksdb_Options_level0FileNumCompactionTrigger(
2969     JNIEnv*, jobject, jlong jhandle) {
2970   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2971       ->level0_file_num_compaction_trigger;
2972 }
2973
2974 /*
2975  * Class:     org_rocksdb_Options
2976  * Method:    setLevel0FileNumCompactionTrigger
2977  * Signature: (JI)V
2978  */
2979 void Java_org_rocksdb_Options_setLevel0FileNumCompactionTrigger(
2980     JNIEnv*, jobject, jlong jhandle,
2981     jint jlevel0_file_num_compaction_trigger) {
2982   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2983       ->level0_file_num_compaction_trigger =
2984       static_cast<int32_t>(jlevel0_file_num_compaction_trigger);
2985 }
2986
2987 /*
2988  * Class:     org_rocksdb_Options
2989  * Method:    level0SlowdownWritesTrigger
2990  * Signature: (J)I
2991  */
2992 jint Java_org_rocksdb_Options_level0SlowdownWritesTrigger(
2993     JNIEnv*, jobject, jlong jhandle) {
2994   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
2995       ->level0_slowdown_writes_trigger;
2996 }
2997
2998 /*
2999  * Class:     org_rocksdb_Options
3000  * Method:    setLevel0SlowdownWritesTrigger
3001  * Signature: (JI)V
3002  */
3003 void Java_org_rocksdb_Options_setLevel0SlowdownWritesTrigger(
3004     JNIEnv*, jobject, jlong jhandle, jint jlevel0_slowdown_writes_trigger) {
3005   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
3006       ->level0_slowdown_writes_trigger =
3007       static_cast<int32_t>(jlevel0_slowdown_writes_trigger);
3008 }
3009
3010 /*
3011  * Class:     org_rocksdb_Options
3012  * Method:    level0StopWritesTrigger
3013  * Signature: (J)I
3014  */
3015 jint Java_org_rocksdb_Options_level0StopWritesTrigger(
3016     JNIEnv*, jobject, jlong jhandle) {
3017   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
3018       ->level0_stop_writes_trigger;
3019 }
3020
3021 /*
3022  * Class:     org_rocksdb_Options
3023  * Method:    setLevel0StopWritesTrigger
3024  * Signature: (JI)V
3025  */
3026 void Java_org_rocksdb_Options_setLevel0StopWritesTrigger(
3027     JNIEnv*, jobject, jlong jhandle, jint jlevel0_stop_writes_trigger) {
3028   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
3029       ->level0_stop_writes_trigger =
3030       static_cast<int32_t>(jlevel0_stop_writes_trigger);
3031 }
3032
3033 /*
3034  * Class:     org_rocksdb_Options
3035  * Method:    maxBytesForLevelMultiplierAdditional
3036  * Signature: (J)[I
3037  */
3038 jintArray Java_org_rocksdb_Options_maxBytesForLevelMultiplierAdditional(
3039     JNIEnv* env, jobject, jlong jhandle) {
3040   auto mbflma = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
3041                     ->max_bytes_for_level_multiplier_additional;
3042
3043   const size_t size = mbflma.size();
3044
3045   jint* additionals = new jint[size];
3046   for (size_t i = 0; i < size; i++) {
3047     additionals[i] = static_cast<jint>(mbflma[i]);
3048   }
3049
3050   jsize jlen = static_cast<jsize>(size);
3051   jintArray result = env->NewIntArray(jlen);
3052   if (result == nullptr) {
3053     // exception thrown: OutOfMemoryError
3054     delete[] additionals;
3055     return nullptr;
3056   }
3057
3058   env->SetIntArrayRegion(result, 0, jlen, additionals);
3059   if (env->ExceptionCheck()) {
3060     // exception thrown: ArrayIndexOutOfBoundsException
3061     env->DeleteLocalRef(result);
3062     delete[] additionals;
3063     return nullptr;
3064   }
3065
3066   delete[] additionals;
3067
3068   return result;
3069 }
3070
3071 /*
3072  * Class:     org_rocksdb_Options
3073  * Method:    setMaxBytesForLevelMultiplierAdditional
3074  * Signature: (J[I)V
3075  */
3076 void Java_org_rocksdb_Options_setMaxBytesForLevelMultiplierAdditional(
3077     JNIEnv* env, jobject, jlong jhandle,
3078     jintArray jmax_bytes_for_level_multiplier_additional) {
3079   jsize len = env->GetArrayLength(jmax_bytes_for_level_multiplier_additional);
3080   jint* additionals = env->GetIntArrayElements(
3081       jmax_bytes_for_level_multiplier_additional, nullptr);
3082   if (additionals == nullptr) {
3083     // exception thrown: OutOfMemoryError
3084     return;
3085   }
3086
3087   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3088   opt->max_bytes_for_level_multiplier_additional.clear();
3089   for (jsize i = 0; i < len; i++) {
3090     opt->max_bytes_for_level_multiplier_additional.push_back(
3091         static_cast<int32_t>(additionals[i]));
3092   }
3093
3094   env->ReleaseIntArrayElements(jmax_bytes_for_level_multiplier_additional,
3095                                additionals, JNI_ABORT);
3096 }
3097
3098 /*
3099  * Class:     org_rocksdb_Options
3100  * Method:    paranoidFileChecks
3101  * Signature: (J)Z
3102  */
3103 jboolean Java_org_rocksdb_Options_paranoidFileChecks(
3104     JNIEnv*, jobject, jlong jhandle) {
3105   return reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)
3106       ->paranoid_file_checks;
3107 }
3108
3109 /*
3110  * Class:     org_rocksdb_Options
3111  * Method:    setParanoidFileChecks
3112  * Signature: (JZ)V
3113  */
3114 void Java_org_rocksdb_Options_setParanoidFileChecks(
3115     JNIEnv*, jobject, jlong jhandle, jboolean jparanoid_file_checks) {
3116   reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle)->paranoid_file_checks =
3117       static_cast<bool>(jparanoid_file_checks);
3118 }
3119
3120 /*
3121  * Class:     org_rocksdb_Options
3122  * Method:    setCompactionPriority
3123  * Signature: (JB)V
3124  */
3125 void Java_org_rocksdb_Options_setCompactionPriority(
3126     JNIEnv*, jobject, jlong jhandle, jbyte jcompaction_priority_value) {
3127   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3128   opts->compaction_pri =
3129       ROCKSDB_NAMESPACE::CompactionPriorityJni::toCppCompactionPriority(
3130           jcompaction_priority_value);
3131 }
3132
3133 /*
3134  * Class:     org_rocksdb_Options
3135  * Method:    compactionPriority
3136  * Signature: (J)B
3137  */
3138 jbyte Java_org_rocksdb_Options_compactionPriority(
3139     JNIEnv*, jobject, jlong jhandle) {
3140   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3141   return ROCKSDB_NAMESPACE::CompactionPriorityJni::toJavaCompactionPriority(
3142       opts->compaction_pri);
3143 }
3144
3145 /*
3146  * Class:     org_rocksdb_Options
3147  * Method:    setReportBgIoStats
3148  * Signature: (JZ)V
3149  */
3150 void Java_org_rocksdb_Options_setReportBgIoStats(
3151     JNIEnv*, jobject, jlong jhandle, jboolean jreport_bg_io_stats) {
3152   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3153   opts->report_bg_io_stats = static_cast<bool>(jreport_bg_io_stats);
3154 }
3155
3156 /*
3157  * Class:     org_rocksdb_Options
3158  * Method:    reportBgIoStats
3159  * Signature: (J)Z
3160  */
3161 jboolean Java_org_rocksdb_Options_reportBgIoStats(
3162     JNIEnv*, jobject, jlong jhandle) {
3163   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3164   return static_cast<bool>(opts->report_bg_io_stats);
3165 }
3166
3167 /*
3168  * Class:     org_rocksdb_Options
3169  * Method:    setTtl
3170  * Signature: (JJ)V
3171  */
3172 void Java_org_rocksdb_Options_setTtl(
3173     JNIEnv*, jobject, jlong jhandle, jlong jttl) {
3174   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3175   opts->ttl = static_cast<uint64_t>(jttl);
3176 }
3177
3178 /*
3179  * Class:     org_rocksdb_Options
3180  * Method:    ttl
3181  * Signature: (J)J
3182  */
3183 jlong Java_org_rocksdb_Options_ttl(
3184     JNIEnv*, jobject, jlong jhandle) {
3185   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3186   return static_cast<jlong>(opts->ttl);
3187 }
3188
3189 /*
3190  * Class:     org_rocksdb_Options
3191  * Method:    setCompactionOptionsUniversal
3192  * Signature: (JJ)V
3193  */
3194 void Java_org_rocksdb_Options_setCompactionOptionsUniversal(
3195     JNIEnv*, jobject, jlong jhandle,
3196     jlong jcompaction_options_universal_handle) {
3197   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3198   auto* opts_uni =
3199       reinterpret_cast<ROCKSDB_NAMESPACE::CompactionOptionsUniversal*>(
3200           jcompaction_options_universal_handle);
3201   opts->compaction_options_universal = *opts_uni;
3202 }
3203
3204 /*
3205  * Class:     org_rocksdb_Options
3206  * Method:    setCompactionOptionsFIFO
3207  * Signature: (JJ)V
3208  */
3209 void Java_org_rocksdb_Options_setCompactionOptionsFIFO(
3210     JNIEnv*, jobject, jlong jhandle, jlong jcompaction_options_fifo_handle) {
3211   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3212   auto* opts_fifo = reinterpret_cast<ROCKSDB_NAMESPACE::CompactionOptionsFIFO*>(
3213       jcompaction_options_fifo_handle);
3214   opts->compaction_options_fifo = *opts_fifo;
3215 }
3216
3217 /*
3218  * Class:     org_rocksdb_Options
3219  * Method:    setForceConsistencyChecks
3220  * Signature: (JZ)V
3221  */
3222 void Java_org_rocksdb_Options_setForceConsistencyChecks(
3223     JNIEnv*, jobject, jlong jhandle, jboolean jforce_consistency_checks) {
3224   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3225   opts->force_consistency_checks = static_cast<bool>(jforce_consistency_checks);
3226 }
3227
3228 /*
3229  * Class:     org_rocksdb_Options
3230  * Method:    forceConsistencyChecks
3231  * Signature: (J)Z
3232  */
3233 jboolean Java_org_rocksdb_Options_forceConsistencyChecks(
3234     JNIEnv*, jobject, jlong jhandle) {
3235   auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3236   return static_cast<bool>(opts->force_consistency_checks);
3237 }
3238
3239 //////////////////////////////////////////////////////////////////////////////
3240 // ROCKSDB_NAMESPACE::ColumnFamilyOptions
3241
3242 /*
3243  * Class:     org_rocksdb_ColumnFamilyOptions
3244  * Method:    newColumnFamilyOptions
3245  * Signature: ()J
3246  */
3247 jlong Java_org_rocksdb_ColumnFamilyOptions_newColumnFamilyOptions(
3248     JNIEnv*, jclass) {
3249   auto* op = new ROCKSDB_NAMESPACE::ColumnFamilyOptions();
3250   return reinterpret_cast<jlong>(op);
3251 }
3252
3253 /*
3254  * Class:     org_rocksdb_ColumnFamilyOptions
3255  * Method:    copyColumnFamilyOptions
3256  * Signature: (J)J
3257  */
3258 jlong Java_org_rocksdb_ColumnFamilyOptions_copyColumnFamilyOptions(
3259     JNIEnv*, jclass, jlong jhandle) {
3260   auto new_opt = new ROCKSDB_NAMESPACE::ColumnFamilyOptions(
3261       *(reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)));
3262   return reinterpret_cast<jlong>(new_opt);
3263 }
3264
3265 /*
3266  * Class:     org_rocksdb_ColumnFamilyOptions
3267  * Method:    newColumnFamilyOptionsFromOptions
3268  * Signature: (J)J
3269  */
3270 jlong Java_org_rocksdb_ColumnFamilyOptions_newColumnFamilyOptionsFromOptions(
3271     JNIEnv*, jclass, jlong joptions_handle) {
3272   auto new_opt = new ROCKSDB_NAMESPACE::ColumnFamilyOptions(
3273       *reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(joptions_handle));
3274   return reinterpret_cast<jlong>(new_opt);
3275 }
3276
3277 /*
3278  * Class:     org_rocksdb_ColumnFamilyOptions
3279  * Method:    getColumnFamilyOptionsFromProps
3280  * Signature: (Ljava/util/String;)J
3281  */
3282 jlong Java_org_rocksdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps(
3283     JNIEnv* env, jclass, jstring jopt_string) {
3284   const char* opt_string = env->GetStringUTFChars(jopt_string, nullptr);
3285   if (opt_string == nullptr) {
3286     // exception thrown: OutOfMemoryError
3287     return 0;
3288   }
3289
3290   auto* cf_options = new ROCKSDB_NAMESPACE::ColumnFamilyOptions();
3291   ROCKSDB_NAMESPACE::Status status =
3292       ROCKSDB_NAMESPACE::GetColumnFamilyOptionsFromString(
3293           ROCKSDB_NAMESPACE::ColumnFamilyOptions(), opt_string, cf_options);
3294
3295   env->ReleaseStringUTFChars(jopt_string, opt_string);
3296
3297   // Check if ColumnFamilyOptions creation was possible.
3298   jlong ret_value = 0;
3299   if (status.ok()) {
3300     ret_value = reinterpret_cast<jlong>(cf_options);
3301   } else {
3302     // if operation failed the ColumnFamilyOptions need to be deleted
3303     // again to prevent a memory leak.
3304     delete cf_options;
3305   }
3306   return ret_value;
3307 }
3308
3309 /*
3310  * Class:     org_rocksdb_ColumnFamilyOptions
3311  * Method:    disposeInternal
3312  * Signature: (J)V
3313  */
3314 void Java_org_rocksdb_ColumnFamilyOptions_disposeInternal(
3315     JNIEnv*, jobject, jlong handle) {
3316   auto* cfo = reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(handle);
3317   assert(cfo != nullptr);
3318   delete cfo;
3319 }
3320
3321 /*
3322  * Class:     org_rocksdb_ColumnFamilyOptions
3323  * Method:    optimizeForSmallDb
3324  * Signature: (J)V
3325  */
3326 void Java_org_rocksdb_ColumnFamilyOptions_optimizeForSmallDb(
3327     JNIEnv*, jobject, jlong jhandle) {
3328   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3329       ->OptimizeForSmallDb();
3330 }
3331
3332 /*
3333  * Class:     org_rocksdb_ColumnFamilyOptions
3334  * Method:    optimizeForPointLookup
3335  * Signature: (JJ)V
3336  */
3337 void Java_org_rocksdb_ColumnFamilyOptions_optimizeForPointLookup(
3338     JNIEnv*, jobject, jlong jhandle, jlong block_cache_size_mb) {
3339   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3340       ->OptimizeForPointLookup(block_cache_size_mb);
3341 }
3342
3343 /*
3344  * Class:     org_rocksdb_ColumnFamilyOptions
3345  * Method:    optimizeLevelStyleCompaction
3346  * Signature: (JJ)V
3347  */
3348 void Java_org_rocksdb_ColumnFamilyOptions_optimizeLevelStyleCompaction(
3349     JNIEnv*, jobject, jlong jhandle, jlong memtable_memory_budget) {
3350   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3351       ->OptimizeLevelStyleCompaction(memtable_memory_budget);
3352 }
3353
3354 /*
3355  * Class:     org_rocksdb_ColumnFamilyOptions
3356  * Method:    optimizeUniversalStyleCompaction
3357  * Signature: (JJ)V
3358  */
3359 void Java_org_rocksdb_ColumnFamilyOptions_optimizeUniversalStyleCompaction(
3360     JNIEnv*, jobject, jlong jhandle, jlong memtable_memory_budget) {
3361   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3362       ->OptimizeUniversalStyleCompaction(memtable_memory_budget);
3363 }
3364
3365 /*
3366  * Class:     org_rocksdb_ColumnFamilyOptions
3367  * Method:    setComparatorHandle
3368  * Signature: (JI)V
3369  */
3370 void Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JI(
3371     JNIEnv*, jobject, jlong jhandle, jint builtinComparator) {
3372   switch (builtinComparator) {
3373     case 1:
3374       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3375           ->comparator = ROCKSDB_NAMESPACE::ReverseBytewiseComparator();
3376       break;
3377     default:
3378       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3379           ->comparator = ROCKSDB_NAMESPACE::BytewiseComparator();
3380       break;
3381   }
3382 }
3383
3384 /*
3385  * Class:     org_rocksdb_ColumnFamilyOptions
3386  * Method:    setComparatorHandle
3387  * Signature: (JJB)V
3388  */
3389 void Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JJB(
3390     JNIEnv*, jobject, jlong jopt_handle, jlong jcomparator_handle,
3391     jbyte jcomparator_type) {
3392   ROCKSDB_NAMESPACE::Comparator* comparator = nullptr;
3393   switch (jcomparator_type) {
3394     // JAVA_COMPARATOR
3395     case 0x0:
3396       comparator = reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallback*>(
3397           jcomparator_handle);
3398       break;
3399
3400     // JAVA_NATIVE_COMPARATOR_WRAPPER
3401     case 0x1:
3402       comparator =
3403           reinterpret_cast<ROCKSDB_NAMESPACE::Comparator*>(jcomparator_handle);
3404       break;
3405   }
3406   auto* opt =
3407       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jopt_handle);
3408   opt->comparator = comparator;
3409 }
3410
3411 /*
3412  * Class:     org_rocksdb_ColumnFamilyOptions
3413  * Method:    setMergeOperatorName
3414  * Signature: (JJjava/lang/String)V
3415  */
3416 void Java_org_rocksdb_ColumnFamilyOptions_setMergeOperatorName(
3417     JNIEnv* env, jobject, jlong jhandle, jstring jop_name) {
3418   auto* options =
3419       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3420   const char* op_name = env->GetStringUTFChars(jop_name, nullptr);
3421   if (op_name == nullptr) {
3422     // exception thrown: OutOfMemoryError
3423     return;
3424   }
3425
3426   options->merge_operator =
3427       ROCKSDB_NAMESPACE::MergeOperators::CreateFromStringId(op_name);
3428   env->ReleaseStringUTFChars(jop_name, op_name);
3429 }
3430
3431 /*
3432  * Class:     org_rocksdb_ColumnFamilyOptions
3433  * Method:    setMergeOperator
3434  * Signature: (JJjava/lang/String)V
3435  */
3436 void Java_org_rocksdb_ColumnFamilyOptions_setMergeOperator(
3437     JNIEnv*, jobject, jlong jhandle, jlong mergeOperatorHandle) {
3438   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3439       ->merge_operator =
3440       *(reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::MergeOperator>*>(
3441           mergeOperatorHandle));
3442 }
3443
3444 /*
3445  * Class:     org_rocksdb_ColumnFamilyOptions
3446  * Method:    setCompactionFilterHandle
3447  * Signature: (JJ)V
3448  */
3449 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionFilterHandle(
3450     JNIEnv*, jobject, jlong jopt_handle, jlong jcompactionfilter_handle) {
3451   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jopt_handle)
3452       ->compaction_filter =
3453       reinterpret_cast<ROCKSDB_NAMESPACE::CompactionFilter*>(
3454           jcompactionfilter_handle);
3455 }
3456
3457 /*
3458  * Class:     org_rocksdb_ColumnFamilyOptions
3459  * Method:    setCompactionFilterFactoryHandle
3460  * Signature: (JJ)V
3461  */
3462 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionFilterFactoryHandle(
3463     JNIEnv*, jobject, jlong jopt_handle,
3464     jlong jcompactionfilterfactory_handle) {
3465   auto* cff_factory = reinterpret_cast<
3466       std::shared_ptr<ROCKSDB_NAMESPACE::CompactionFilterFactoryJniCallback>*>(
3467       jcompactionfilterfactory_handle);
3468   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jopt_handle)
3469       ->compaction_filter_factory = *cff_factory;
3470 }
3471
3472 /*
3473  * Class:     org_rocksdb_ColumnFamilyOptions
3474  * Method:    setWriteBufferSize
3475  * Signature: (JJ)I
3476  */
3477 void Java_org_rocksdb_ColumnFamilyOptions_setWriteBufferSize(
3478     JNIEnv* env, jobject, jlong jhandle, jlong jwrite_buffer_size) {
3479   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
3480       jwrite_buffer_size);
3481   if (s.ok()) {
3482     reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3483         ->write_buffer_size = jwrite_buffer_size;
3484   } else {
3485     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
3486   }
3487 }
3488
3489 /*
3490  * Class:     org_rocksdb_ColumnFamilyOptions
3491  * Method:    writeBufferSize
3492  * Signature: (J)J
3493  */
3494 jlong Java_org_rocksdb_ColumnFamilyOptions_writeBufferSize(
3495     JNIEnv*, jobject, jlong jhandle) {
3496   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3497       ->write_buffer_size;
3498 }
3499
3500 /*
3501  * Class:     org_rocksdb_ColumnFamilyOptions
3502  * Method:    setMaxWriteBufferNumber
3503  * Signature: (JI)V
3504  */
3505 void Java_org_rocksdb_ColumnFamilyOptions_setMaxWriteBufferNumber(
3506     JNIEnv*, jobject, jlong jhandle, jint jmax_write_buffer_number) {
3507   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3508       ->max_write_buffer_number = jmax_write_buffer_number;
3509 }
3510
3511 /*
3512  * Class:     org_rocksdb_ColumnFamilyOptions
3513  * Method:    maxWriteBufferNumber
3514  * Signature: (J)I
3515  */
3516 jint Java_org_rocksdb_ColumnFamilyOptions_maxWriteBufferNumber(
3517     JNIEnv*, jobject, jlong jhandle) {
3518   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3519       ->max_write_buffer_number;
3520 }
3521
3522 /*
3523  * Method:    setMemTableFactory
3524  * Signature: (JJ)V
3525  */
3526 void Java_org_rocksdb_ColumnFamilyOptions_setMemTableFactory(
3527     JNIEnv*, jobject, jlong jhandle, jlong jfactory_handle) {
3528   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3529       ->memtable_factory.reset(
3530           reinterpret_cast<ROCKSDB_NAMESPACE::MemTableRepFactory*>(
3531               jfactory_handle));
3532 }
3533
3534 /*
3535  * Class:     org_rocksdb_ColumnFamilyOptions
3536  * Method:    memTableFactoryName
3537  * Signature: (J)Ljava/lang/String
3538  */
3539 jstring Java_org_rocksdb_ColumnFamilyOptions_memTableFactoryName(
3540     JNIEnv* env, jobject, jlong jhandle) {
3541   auto* opt =
3542       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3543   ROCKSDB_NAMESPACE::MemTableRepFactory* tf = opt->memtable_factory.get();
3544
3545   // Should never be nullptr.
3546   // Default memtable factory is SkipListFactory
3547   assert(tf);
3548
3549   // temporarly fix for the historical typo
3550   if (strcmp(tf->Name(), "HashLinkListRepFactory") == 0) {
3551     return env->NewStringUTF("HashLinkedListRepFactory");
3552   }
3553
3554   return env->NewStringUTF(tf->Name());
3555 }
3556
3557 /*
3558  * Method:    useFixedLengthPrefixExtractor
3559  * Signature: (JI)V
3560  */
3561 void Java_org_rocksdb_ColumnFamilyOptions_useFixedLengthPrefixExtractor(
3562     JNIEnv*, jobject, jlong jhandle, jint jprefix_length) {
3563   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3564       ->prefix_extractor.reset(ROCKSDB_NAMESPACE::NewFixedPrefixTransform(
3565           static_cast<int>(jprefix_length)));
3566 }
3567
3568 /*
3569  * Method:    useCappedPrefixExtractor
3570  * Signature: (JI)V
3571  */
3572 void Java_org_rocksdb_ColumnFamilyOptions_useCappedPrefixExtractor(
3573     JNIEnv*, jobject, jlong jhandle, jint jprefix_length) {
3574   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3575       ->prefix_extractor.reset(ROCKSDB_NAMESPACE::NewCappedPrefixTransform(
3576           static_cast<int>(jprefix_length)));
3577 }
3578
3579 /*
3580  * Method:    setTableFactory
3581  * Signature: (JJ)V
3582  */
3583 void Java_org_rocksdb_ColumnFamilyOptions_setTableFactory(
3584     JNIEnv*, jobject, jlong jhandle, jlong jfactory_handle) {
3585   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3586       ->table_factory.reset(
3587           reinterpret_cast<ROCKSDB_NAMESPACE::TableFactory*>(jfactory_handle));
3588 }
3589
3590 /*
3591  * Method:    tableFactoryName
3592  * Signature: (J)Ljava/lang/String
3593  */
3594 jstring Java_org_rocksdb_ColumnFamilyOptions_tableFactoryName(
3595     JNIEnv* env, jobject, jlong jhandle) {
3596   auto* opt =
3597       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3598   ROCKSDB_NAMESPACE::TableFactory* tf = opt->table_factory.get();
3599
3600   // Should never be nullptr.
3601   // Default memtable factory is SkipListFactory
3602   assert(tf);
3603
3604   return env->NewStringUTF(tf->Name());
3605 }
3606
3607 /*
3608  * Class:     org_rocksdb_ColumnFamilyOptions
3609  * Method:    minWriteBufferNumberToMerge
3610  * Signature: (J)I
3611  */
3612 jint Java_org_rocksdb_ColumnFamilyOptions_minWriteBufferNumberToMerge(
3613     JNIEnv*, jobject, jlong jhandle) {
3614   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3615       ->min_write_buffer_number_to_merge;
3616 }
3617
3618 /*
3619  * Class:     org_rocksdb_ColumnFamilyOptions
3620  * Method:    setMinWriteBufferNumberToMerge
3621  * Signature: (JI)V
3622  */
3623 void Java_org_rocksdb_ColumnFamilyOptions_setMinWriteBufferNumberToMerge(
3624     JNIEnv*, jobject, jlong jhandle, jint jmin_write_buffer_number_to_merge) {
3625   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3626       ->min_write_buffer_number_to_merge =
3627       static_cast<int>(jmin_write_buffer_number_to_merge);
3628 }
3629
3630 /*
3631  * Class:     org_rocksdb_ColumnFamilyOptions
3632  * Method:    maxWriteBufferNumberToMaintain
3633  * Signature: (J)I
3634  */
3635 jint Java_org_rocksdb_ColumnFamilyOptions_maxWriteBufferNumberToMaintain(
3636     JNIEnv*, jobject, jlong jhandle) {
3637   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3638       ->max_write_buffer_number_to_maintain;
3639 }
3640
3641 /*
3642  * Class:     org_rocksdb_ColumnFamilyOptions
3643  * Method:    setMaxWriteBufferNumberToMaintain
3644  * Signature: (JI)V
3645  */
3646 void Java_org_rocksdb_ColumnFamilyOptions_setMaxWriteBufferNumberToMaintain(
3647     JNIEnv*, jobject, jlong jhandle,
3648     jint jmax_write_buffer_number_to_maintain) {
3649   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3650       ->max_write_buffer_number_to_maintain =
3651       static_cast<int>(jmax_write_buffer_number_to_maintain);
3652 }
3653
3654 /*
3655  * Class:     org_rocksdb_ColumnFamilyOptions
3656  * Method:    setCompressionType
3657  * Signature: (JB)V
3658  */
3659 void Java_org_rocksdb_ColumnFamilyOptions_setCompressionType(
3660     JNIEnv*, jobject, jlong jhandle, jbyte jcompression_type_value) {
3661   auto* cf_opts =
3662       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3663   cf_opts->compression =
3664       ROCKSDB_NAMESPACE::CompressionTypeJni::toCppCompressionType(
3665           jcompression_type_value);
3666 }
3667
3668 /*
3669  * Class:     org_rocksdb_ColumnFamilyOptions
3670  * Method:    compressionType
3671  * Signature: (J)B
3672  */
3673 jbyte Java_org_rocksdb_ColumnFamilyOptions_compressionType(
3674     JNIEnv*, jobject, jlong jhandle) {
3675   auto* cf_opts =
3676       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3677   return ROCKSDB_NAMESPACE::CompressionTypeJni::toJavaCompressionType(
3678       cf_opts->compression);
3679 }
3680
3681 /*
3682  * Class:     org_rocksdb_ColumnFamilyOptions
3683  * Method:    setCompressionPerLevel
3684  * Signature: (J[B)V
3685  */
3686 void Java_org_rocksdb_ColumnFamilyOptions_setCompressionPerLevel(
3687     JNIEnv* env, jobject, jlong jhandle, jbyteArray jcompressionLevels) {
3688   auto* options =
3689       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3690   auto uptr_compression_levels =
3691       rocksdb_compression_vector_helper(env, jcompressionLevels);
3692   if (!uptr_compression_levels) {
3693     // exception occurred
3694     return;
3695   }
3696   options->compression_per_level = *(uptr_compression_levels.get());
3697 }
3698
3699 /*
3700  * Class:     org_rocksdb_ColumnFamilyOptions
3701  * Method:    compressionPerLevel
3702  * Signature: (J)[B
3703  */
3704 jbyteArray Java_org_rocksdb_ColumnFamilyOptions_compressionPerLevel(
3705     JNIEnv* env, jobject, jlong jhandle) {
3706   auto* cf_options =
3707       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3708   return rocksdb_compression_list_helper(env,
3709                                          cf_options->compression_per_level);
3710 }
3711
3712 /*
3713  * Class:     org_rocksdb_ColumnFamilyOptions
3714  * Method:    setBottommostCompressionType
3715  * Signature: (JB)V
3716  */
3717 void Java_org_rocksdb_ColumnFamilyOptions_setBottommostCompressionType(
3718     JNIEnv*, jobject, jlong jhandle, jbyte jcompression_type_value) {
3719   auto* cf_options =
3720       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3721   cf_options->bottommost_compression =
3722       ROCKSDB_NAMESPACE::CompressionTypeJni::toCppCompressionType(
3723           jcompression_type_value);
3724 }
3725
3726 /*
3727  * Class:     org_rocksdb_ColumnFamilyOptions
3728  * Method:    bottommostCompressionType
3729  * Signature: (J)B
3730  */
3731 jbyte Java_org_rocksdb_ColumnFamilyOptions_bottommostCompressionType(
3732     JNIEnv*, jobject, jlong jhandle) {
3733   auto* cf_options =
3734       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3735   return ROCKSDB_NAMESPACE::CompressionTypeJni::toJavaCompressionType(
3736       cf_options->bottommost_compression);
3737 }
3738 /*
3739  * Class:     org_rocksdb_ColumnFamilyOptions
3740  * Method:    setBottommostCompressionOptions
3741  * Signature: (JJ)V
3742  */
3743 void Java_org_rocksdb_ColumnFamilyOptions_setBottommostCompressionOptions(
3744     JNIEnv*, jobject, jlong jhandle,
3745     jlong jbottommost_compression_options_handle) {
3746   auto* cf_options =
3747       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3748   auto* bottommost_compression_options =
3749       reinterpret_cast<ROCKSDB_NAMESPACE::CompressionOptions*>(
3750           jbottommost_compression_options_handle);
3751   cf_options->bottommost_compression_opts = *bottommost_compression_options;
3752 }
3753
3754 /*
3755  * Class:     org_rocksdb_ColumnFamilyOptions
3756  * Method:    setCompressionOptions
3757  * Signature: (JJ)V
3758  */
3759 void Java_org_rocksdb_ColumnFamilyOptions_setCompressionOptions(
3760     JNIEnv*, jobject, jlong jhandle, jlong jcompression_options_handle) {
3761   auto* cf_options =
3762       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3763   auto* compression_options =
3764       reinterpret_cast<ROCKSDB_NAMESPACE::CompressionOptions*>(
3765           jcompression_options_handle);
3766   cf_options->compression_opts = *compression_options;
3767 }
3768
3769 /*
3770  * Class:     org_rocksdb_ColumnFamilyOptions
3771  * Method:    setCompactionStyle
3772  * Signature: (JB)V
3773  */
3774 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionStyle(
3775     JNIEnv*, jobject, jlong jhandle, jbyte jcompaction_style) {
3776   auto* cf_options =
3777       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3778   cf_options->compaction_style =
3779       ROCKSDB_NAMESPACE::CompactionStyleJni::toCppCompactionStyle(
3780           jcompaction_style);
3781 }
3782
3783 /*
3784  * Class:     org_rocksdb_ColumnFamilyOptions
3785  * Method:    compactionStyle
3786  * Signature: (J)B
3787  */
3788 jbyte Java_org_rocksdb_ColumnFamilyOptions_compactionStyle(
3789     JNIEnv*, jobject, jlong jhandle) {
3790   auto* cf_options =
3791       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3792   return ROCKSDB_NAMESPACE::CompactionStyleJni::toJavaCompactionStyle(
3793       cf_options->compaction_style);
3794 }
3795
3796 /*
3797  * Class:     org_rocksdb_ColumnFamilyOptions
3798  * Method:    setMaxTableFilesSizeFIFO
3799  * Signature: (JJ)V
3800  */
3801 void Java_org_rocksdb_ColumnFamilyOptions_setMaxTableFilesSizeFIFO(
3802     JNIEnv*, jobject, jlong jhandle, jlong jmax_table_files_size) {
3803   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3804       ->compaction_options_fifo.max_table_files_size =
3805       static_cast<uint64_t>(jmax_table_files_size);
3806 }
3807
3808 /*
3809  * Class:     org_rocksdb_ColumnFamilyOptions
3810  * Method:    maxTableFilesSizeFIFO
3811  * Signature: (J)J
3812  */
3813 jlong Java_org_rocksdb_ColumnFamilyOptions_maxTableFilesSizeFIFO(
3814     JNIEnv*, jobject, jlong jhandle) {
3815   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3816       ->compaction_options_fifo.max_table_files_size;
3817 }
3818
3819 /*
3820  * Class:     org_rocksdb_ColumnFamilyOptions
3821  * Method:    numLevels
3822  * Signature: (J)I
3823  */
3824 jint Java_org_rocksdb_ColumnFamilyOptions_numLevels(
3825     JNIEnv*, jobject, jlong jhandle) {
3826   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3827       ->num_levels;
3828 }
3829
3830 /*
3831  * Class:     org_rocksdb_ColumnFamilyOptions
3832  * Method:    setNumLevels
3833  * Signature: (JI)V
3834  */
3835 void Java_org_rocksdb_ColumnFamilyOptions_setNumLevels(
3836     JNIEnv*, jobject, jlong jhandle, jint jnum_levels) {
3837   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3838       ->num_levels = static_cast<int>(jnum_levels);
3839 }
3840
3841 /*
3842  * Class:     org_rocksdb_ColumnFamilyOptions
3843  * Method:    levelZeroFileNumCompactionTrigger
3844  * Signature: (J)I
3845  */
3846 jint Java_org_rocksdb_ColumnFamilyOptions_levelZeroFileNumCompactionTrigger(
3847     JNIEnv*, jobject, jlong jhandle) {
3848   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3849       ->level0_file_num_compaction_trigger;
3850 }
3851
3852 /*
3853  * Class:     org_rocksdb_ColumnFamilyOptions
3854  * Method:    setLevelZeroFileNumCompactionTrigger
3855  * Signature: (JI)V
3856  */
3857 void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroFileNumCompactionTrigger(
3858     JNIEnv*, jobject, jlong jhandle,
3859     jint jlevel0_file_num_compaction_trigger) {
3860   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3861       ->level0_file_num_compaction_trigger =
3862       static_cast<int>(jlevel0_file_num_compaction_trigger);
3863 }
3864
3865 /*
3866  * Class:     org_rocksdb_ColumnFamilyOptions
3867  * Method:    levelZeroSlowdownWritesTrigger
3868  * Signature: (J)I
3869  */
3870 jint Java_org_rocksdb_ColumnFamilyOptions_levelZeroSlowdownWritesTrigger(
3871     JNIEnv*, jobject, jlong jhandle) {
3872   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3873       ->level0_slowdown_writes_trigger;
3874 }
3875
3876 /*
3877  * Class:     org_rocksdb_ColumnFamilyOptions
3878  * Method:    setLevelSlowdownWritesTrigger
3879  * Signature: (JI)V
3880  */
3881 void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroSlowdownWritesTrigger(
3882     JNIEnv*, jobject, jlong jhandle, jint jlevel0_slowdown_writes_trigger) {
3883   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3884       ->level0_slowdown_writes_trigger =
3885       static_cast<int>(jlevel0_slowdown_writes_trigger);
3886 }
3887
3888 /*
3889  * Class:     org_rocksdb_ColumnFamilyOptions
3890  * Method:    levelZeroStopWritesTrigger
3891  * Signature: (J)I
3892  */
3893 jint Java_org_rocksdb_ColumnFamilyOptions_levelZeroStopWritesTrigger(
3894     JNIEnv*, jobject, jlong jhandle) {
3895   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3896       ->level0_stop_writes_trigger;
3897 }
3898
3899 /*
3900  * Class:     org_rocksdb_ColumnFamilyOptions
3901  * Method:    setLevelStopWritesTrigger
3902  * Signature: (JI)V
3903  */
3904 void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroStopWritesTrigger(
3905     JNIEnv*, jobject, jlong jhandle, jint jlevel0_stop_writes_trigger) {
3906   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3907       ->level0_stop_writes_trigger =
3908       static_cast<int>(jlevel0_stop_writes_trigger);
3909 }
3910
3911 /*
3912  * Class:     org_rocksdb_ColumnFamilyOptions
3913  * Method:    targetFileSizeBase
3914  * Signature: (J)J
3915  */
3916 jlong Java_org_rocksdb_ColumnFamilyOptions_targetFileSizeBase(
3917     JNIEnv*, jobject, jlong jhandle) {
3918   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3919       ->target_file_size_base;
3920 }
3921
3922 /*
3923  * Class:     org_rocksdb_ColumnFamilyOptions
3924  * Method:    setTargetFileSizeBase
3925  * Signature: (JJ)V
3926  */
3927 void Java_org_rocksdb_ColumnFamilyOptions_setTargetFileSizeBase(
3928     JNIEnv*, jobject, jlong jhandle, jlong jtarget_file_size_base) {
3929   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3930       ->target_file_size_base = static_cast<uint64_t>(jtarget_file_size_base);
3931 }
3932
3933 /*
3934  * Class:     org_rocksdb_ColumnFamilyOptions
3935  * Method:    targetFileSizeMultiplier
3936  * Signature: (J)I
3937  */
3938 jint Java_org_rocksdb_ColumnFamilyOptions_targetFileSizeMultiplier(
3939     JNIEnv*, jobject, jlong jhandle) {
3940   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3941       ->target_file_size_multiplier;
3942 }
3943
3944 /*
3945  * Class:     org_rocksdb_ColumnFamilyOptions
3946  * Method:    setTargetFileSizeMultiplier
3947  * Signature: (JI)V
3948  */
3949 void Java_org_rocksdb_ColumnFamilyOptions_setTargetFileSizeMultiplier(
3950     JNIEnv*, jobject, jlong jhandle, jint jtarget_file_size_multiplier) {
3951   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3952       ->target_file_size_multiplier =
3953       static_cast<int>(jtarget_file_size_multiplier);
3954 }
3955
3956 /*
3957  * Class:     org_rocksdb_ColumnFamilyOptions
3958  * Method:    maxBytesForLevelBase
3959  * Signature: (J)J
3960  */
3961 jlong Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelBase(
3962     JNIEnv*, jobject, jlong jhandle) {
3963   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3964       ->max_bytes_for_level_base;
3965 }
3966
3967 /*
3968  * Class:     org_rocksdb_ColumnFamilyOptions
3969  * Method:    setMaxBytesForLevelBase
3970  * Signature: (JJ)V
3971  */
3972 void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelBase(
3973     JNIEnv*, jobject, jlong jhandle, jlong jmax_bytes_for_level_base) {
3974   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3975       ->max_bytes_for_level_base =
3976       static_cast<int64_t>(jmax_bytes_for_level_base);
3977 }
3978
3979 /*
3980  * Class:     org_rocksdb_ColumnFamilyOptions
3981  * Method:    levelCompactionDynamicLevelBytes
3982  * Signature: (J)Z
3983  */
3984 jboolean Java_org_rocksdb_ColumnFamilyOptions_levelCompactionDynamicLevelBytes(
3985     JNIEnv*, jobject, jlong jhandle) {
3986   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3987       ->level_compaction_dynamic_level_bytes;
3988 }
3989
3990 /*
3991  * Class:     org_rocksdb_ColumnFamilyOptions
3992  * Method:    setLevelCompactionDynamicLevelBytes
3993  * Signature: (JZ)V
3994  */
3995 void Java_org_rocksdb_ColumnFamilyOptions_setLevelCompactionDynamicLevelBytes(
3996     JNIEnv*, jobject, jlong jhandle, jboolean jenable_dynamic_level_bytes) {
3997   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3998       ->level_compaction_dynamic_level_bytes = (jenable_dynamic_level_bytes);
3999 }
4000
4001 /*
4002  * Class:     org_rocksdb_ColumnFamilyOptions
4003  * Method:    maxBytesForLevelMultiplier
4004  * Signature: (J)D
4005  */
4006 jdouble Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelMultiplier(
4007     JNIEnv*, jobject, jlong jhandle) {
4008   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4009       ->max_bytes_for_level_multiplier;
4010 }
4011
4012 /*
4013  * Class:     org_rocksdb_ColumnFamilyOptions
4014  * Method:    setMaxBytesForLevelMultiplier
4015  * Signature: (JD)V
4016  */
4017 void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplier(
4018     JNIEnv*, jobject, jlong jhandle, jdouble jmax_bytes_for_level_multiplier) {
4019   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4020       ->max_bytes_for_level_multiplier =
4021       static_cast<double>(jmax_bytes_for_level_multiplier);
4022 }
4023
4024 /*
4025  * Class:     org_rocksdb_ColumnFamilyOptions
4026  * Method:    maxCompactionBytes
4027  * Signature: (J)I
4028  */
4029 jlong Java_org_rocksdb_ColumnFamilyOptions_maxCompactionBytes(
4030     JNIEnv*, jobject, jlong jhandle) {
4031   return static_cast<jlong>(
4032       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4033           ->max_compaction_bytes);
4034 }
4035
4036 /*
4037  * Class:     org_rocksdb_ColumnFamilyOptions
4038  * Method:    setMaxCompactionBytes
4039  * Signature: (JI)V
4040  */
4041 void Java_org_rocksdb_ColumnFamilyOptions_setMaxCompactionBytes(
4042     JNIEnv*, jobject, jlong jhandle, jlong jmax_compaction_bytes) {
4043   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4044       ->max_compaction_bytes = static_cast<uint64_t>(jmax_compaction_bytes);
4045 }
4046
4047 /*
4048  * Class:     org_rocksdb_ColumnFamilyOptions
4049  * Method:    arenaBlockSize
4050  * Signature: (J)J
4051  */
4052 jlong Java_org_rocksdb_ColumnFamilyOptions_arenaBlockSize(
4053     JNIEnv*, jobject, jlong jhandle) {
4054   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4055       ->arena_block_size;
4056 }
4057
4058 /*
4059  * Class:     org_rocksdb_ColumnFamilyOptions
4060  * Method:    setArenaBlockSize
4061  * Signature: (JJ)V
4062  */
4063 void Java_org_rocksdb_ColumnFamilyOptions_setArenaBlockSize(
4064     JNIEnv* env, jobject, jlong jhandle, jlong jarena_block_size) {
4065   auto s =
4066       ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(jarena_block_size);
4067   if (s.ok()) {
4068     reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4069         ->arena_block_size = jarena_block_size;
4070   } else {
4071     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
4072   }
4073 }
4074
4075 /*
4076  * Class:     org_rocksdb_ColumnFamilyOptions
4077  * Method:    disableAutoCompactions
4078  * Signature: (J)Z
4079  */
4080 jboolean Java_org_rocksdb_ColumnFamilyOptions_disableAutoCompactions(
4081     JNIEnv*, jobject, jlong jhandle) {
4082   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4083       ->disable_auto_compactions;
4084 }
4085
4086 /*
4087  * Class:     org_rocksdb_ColumnFamilyOptions
4088  * Method:    setDisableAutoCompactions
4089  * Signature: (JZ)V
4090  */
4091 void Java_org_rocksdb_ColumnFamilyOptions_setDisableAutoCompactions(
4092     JNIEnv*, jobject, jlong jhandle, jboolean jdisable_auto_compactions) {
4093   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4094       ->disable_auto_compactions = static_cast<bool>(jdisable_auto_compactions);
4095 }
4096
4097 /*
4098  * Class:     org_rocksdb_ColumnFamilyOptions
4099  * Method:    maxSequentialSkipInIterations
4100  * Signature: (J)J
4101  */
4102 jlong Java_org_rocksdb_ColumnFamilyOptions_maxSequentialSkipInIterations(
4103     JNIEnv*, jobject, jlong jhandle) {
4104   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4105       ->max_sequential_skip_in_iterations;
4106 }
4107
4108 /*
4109  * Class:     org_rocksdb_ColumnFamilyOptions
4110  * Method:    setMaxSequentialSkipInIterations
4111  * Signature: (JJ)V
4112  */
4113 void Java_org_rocksdb_ColumnFamilyOptions_setMaxSequentialSkipInIterations(
4114     JNIEnv*, jobject, jlong jhandle,
4115     jlong jmax_sequential_skip_in_iterations) {
4116   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4117       ->max_sequential_skip_in_iterations =
4118       static_cast<int64_t>(jmax_sequential_skip_in_iterations);
4119 }
4120
4121 /*
4122  * Class:     org_rocksdb_ColumnFamilyOptions
4123  * Method:    inplaceUpdateSupport
4124  * Signature: (J)Z
4125  */
4126 jboolean Java_org_rocksdb_ColumnFamilyOptions_inplaceUpdateSupport(
4127     JNIEnv*, jobject, jlong jhandle) {
4128   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4129       ->inplace_update_support;
4130 }
4131
4132 /*
4133  * Class:     org_rocksdb_ColumnFamilyOptions
4134  * Method:    setInplaceUpdateSupport
4135  * Signature: (JZ)V
4136  */
4137 void Java_org_rocksdb_ColumnFamilyOptions_setInplaceUpdateSupport(
4138     JNIEnv*, jobject, jlong jhandle, jboolean jinplace_update_support) {
4139   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4140       ->inplace_update_support = static_cast<bool>(jinplace_update_support);
4141 }
4142
4143 /*
4144  * Class:     org_rocksdb_ColumnFamilyOptions
4145  * Method:    inplaceUpdateNumLocks
4146  * Signature: (J)J
4147  */
4148 jlong Java_org_rocksdb_ColumnFamilyOptions_inplaceUpdateNumLocks(
4149     JNIEnv*, jobject, jlong jhandle) {
4150   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4151       ->inplace_update_num_locks;
4152 }
4153
4154 /*
4155  * Class:     org_rocksdb_ColumnFamilyOptions
4156  * Method:    setInplaceUpdateNumLocks
4157  * Signature: (JJ)V
4158  */
4159 void Java_org_rocksdb_ColumnFamilyOptions_setInplaceUpdateNumLocks(
4160     JNIEnv* env, jobject, jlong jhandle, jlong jinplace_update_num_locks) {
4161   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
4162       jinplace_update_num_locks);
4163   if (s.ok()) {
4164     reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4165         ->inplace_update_num_locks = jinplace_update_num_locks;
4166   } else {
4167     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
4168   }
4169 }
4170
4171 /*
4172  * Class:     org_rocksdb_ColumnFamilyOptions
4173  * Method:    memtablePrefixBloomSizeRatio
4174  * Signature: (J)I
4175  */
4176 jdouble Java_org_rocksdb_ColumnFamilyOptions_memtablePrefixBloomSizeRatio(
4177     JNIEnv*, jobject, jlong jhandle) {
4178   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4179       ->memtable_prefix_bloom_size_ratio;
4180 }
4181
4182 /*
4183  * Class:     org_rocksdb_ColumnFamilyOptions
4184  * Method:    setMemtablePrefixBloomSizeRatio
4185  * Signature: (JI)V
4186  */
4187 void Java_org_rocksdb_ColumnFamilyOptions_setMemtablePrefixBloomSizeRatio(
4188     JNIEnv*, jobject, jlong jhandle,
4189     jdouble jmemtable_prefix_bloom_size_ratio) {
4190   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4191       ->memtable_prefix_bloom_size_ratio =
4192       static_cast<double>(jmemtable_prefix_bloom_size_ratio);
4193 }
4194
4195 /*
4196  * Class:     org_rocksdb_ColumnFamilyOptions
4197  * Method:    bloomLocality
4198  * Signature: (J)I
4199  */
4200 jint Java_org_rocksdb_ColumnFamilyOptions_bloomLocality(
4201     JNIEnv*, jobject, jlong jhandle) {
4202   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4203       ->bloom_locality;
4204 }
4205
4206 /*
4207  * Class:     org_rocksdb_ColumnFamilyOptions
4208  * Method:    setBloomLocality
4209  * Signature: (JI)V
4210  */
4211 void Java_org_rocksdb_ColumnFamilyOptions_setBloomLocality(
4212     JNIEnv*, jobject, jlong jhandle, jint jbloom_locality) {
4213   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4214       ->bloom_locality = static_cast<int32_t>(jbloom_locality);
4215 }
4216
4217 /*
4218  * Class:     org_rocksdb_ColumnFamilyOptions
4219  * Method:    maxSuccessiveMerges
4220  * Signature: (J)J
4221  */
4222 jlong Java_org_rocksdb_ColumnFamilyOptions_maxSuccessiveMerges(
4223     JNIEnv*, jobject, jlong jhandle) {
4224   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4225       ->max_successive_merges;
4226 }
4227
4228 /*
4229  * Class:     org_rocksdb_ColumnFamilyOptions
4230  * Method:    setMaxSuccessiveMerges
4231  * Signature: (JJ)V
4232  */
4233 void Java_org_rocksdb_ColumnFamilyOptions_setMaxSuccessiveMerges(
4234     JNIEnv* env, jobject, jlong jhandle, jlong jmax_successive_merges) {
4235   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
4236       jmax_successive_merges);
4237   if (s.ok()) {
4238     reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4239         ->max_successive_merges = jmax_successive_merges;
4240   } else {
4241     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
4242   }
4243 }
4244
4245 /*
4246  * Class:     org_rocksdb_ColumnFamilyOptions
4247  * Method:    optimizeFiltersForHits
4248  * Signature: (J)Z
4249  */
4250 jboolean Java_org_rocksdb_ColumnFamilyOptions_optimizeFiltersForHits(
4251     JNIEnv*, jobject, jlong jhandle) {
4252   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4253       ->optimize_filters_for_hits;
4254 }
4255
4256 /*
4257  * Class:     org_rocksdb_ColumnFamilyOptions
4258  * Method:    setOptimizeFiltersForHits
4259  * Signature: (JZ)V
4260  */
4261 void Java_org_rocksdb_ColumnFamilyOptions_setOptimizeFiltersForHits(
4262     JNIEnv*, jobject, jlong jhandle, jboolean joptimize_filters_for_hits) {
4263   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4264       ->optimize_filters_for_hits =
4265       static_cast<bool>(joptimize_filters_for_hits);
4266 }
4267
4268 /*
4269  * Class:     org_rocksdb_ColumnFamilyOptions
4270  * Method:    memtableHugePageSize
4271  * Signature: (J)J
4272  */
4273 jlong Java_org_rocksdb_ColumnFamilyOptions_memtableHugePageSize(
4274     JNIEnv*, jobject, jlong jhandle) {
4275   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4276       ->memtable_huge_page_size;
4277 }
4278
4279 /*
4280  * Class:     org_rocksdb_ColumnFamilyOptions
4281  * Method:    setMemtableHugePageSize
4282  * Signature: (JJ)V
4283  */
4284 void Java_org_rocksdb_ColumnFamilyOptions_setMemtableHugePageSize(
4285     JNIEnv* env, jobject, jlong jhandle, jlong jmemtable_huge_page_size) {
4286   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
4287       jmemtable_huge_page_size);
4288   if (s.ok()) {
4289     reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4290         ->memtable_huge_page_size = jmemtable_huge_page_size;
4291   } else {
4292     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
4293   }
4294 }
4295
4296 /*
4297  * Class:     org_rocksdb_ColumnFamilyOptions
4298  * Method:    softPendingCompactionBytesLimit
4299  * Signature: (J)J
4300  */
4301 jlong Java_org_rocksdb_ColumnFamilyOptions_softPendingCompactionBytesLimit(
4302     JNIEnv*, jobject, jlong jhandle) {
4303   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4304       ->soft_pending_compaction_bytes_limit;
4305 }
4306
4307 /*
4308  * Class:     org_rocksdb_ColumnFamilyOptions
4309  * Method:    setSoftPendingCompactionBytesLimit
4310  * Signature: (JJ)V
4311  */
4312 void Java_org_rocksdb_ColumnFamilyOptions_setSoftPendingCompactionBytesLimit(
4313     JNIEnv*, jobject, jlong jhandle,
4314     jlong jsoft_pending_compaction_bytes_limit) {
4315   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4316       ->soft_pending_compaction_bytes_limit =
4317       static_cast<int64_t>(jsoft_pending_compaction_bytes_limit);
4318 }
4319
4320 /*
4321  * Class:     org_rocksdb_ColumnFamilyOptions
4322  * Method:    softHardCompactionBytesLimit
4323  * Signature: (J)J
4324  */
4325 jlong Java_org_rocksdb_ColumnFamilyOptions_hardPendingCompactionBytesLimit(
4326     JNIEnv*, jobject, jlong jhandle) {
4327   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4328       ->hard_pending_compaction_bytes_limit;
4329 }
4330
4331 /*
4332  * Class:     org_rocksdb_ColumnFamilyOptions
4333  * Method:    setHardPendingCompactionBytesLimit
4334  * Signature: (JJ)V
4335  */
4336 void Java_org_rocksdb_ColumnFamilyOptions_setHardPendingCompactionBytesLimit(
4337     JNIEnv*, jobject, jlong jhandle,
4338     jlong jhard_pending_compaction_bytes_limit) {
4339   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4340       ->hard_pending_compaction_bytes_limit =
4341       static_cast<int64_t>(jhard_pending_compaction_bytes_limit);
4342 }
4343
4344 /*
4345  * Class:     org_rocksdb_ColumnFamilyOptions
4346  * Method:    level0FileNumCompactionTrigger
4347  * Signature: (J)I
4348  */
4349 jint Java_org_rocksdb_ColumnFamilyOptions_level0FileNumCompactionTrigger(
4350     JNIEnv*, jobject, jlong jhandle) {
4351   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4352       ->level0_file_num_compaction_trigger;
4353 }
4354
4355 /*
4356  * Class:     org_rocksdb_ColumnFamilyOptions
4357  * Method:    setLevel0FileNumCompactionTrigger
4358  * Signature: (JI)V
4359  */
4360 void Java_org_rocksdb_ColumnFamilyOptions_setLevel0FileNumCompactionTrigger(
4361     JNIEnv*, jobject, jlong jhandle,
4362     jint jlevel0_file_num_compaction_trigger) {
4363   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4364       ->level0_file_num_compaction_trigger =
4365       static_cast<int32_t>(jlevel0_file_num_compaction_trigger);
4366 }
4367
4368 /*
4369  * Class:     org_rocksdb_ColumnFamilyOptions
4370  * Method:    level0SlowdownWritesTrigger
4371  * Signature: (J)I
4372  */
4373 jint Java_org_rocksdb_ColumnFamilyOptions_level0SlowdownWritesTrigger(
4374     JNIEnv*, jobject, jlong jhandle) {
4375   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4376       ->level0_slowdown_writes_trigger;
4377 }
4378
4379 /*
4380  * Class:     org_rocksdb_ColumnFamilyOptions
4381  * Method:    setLevel0SlowdownWritesTrigger
4382  * Signature: (JI)V
4383  */
4384 void Java_org_rocksdb_ColumnFamilyOptions_setLevel0SlowdownWritesTrigger(
4385     JNIEnv*, jobject, jlong jhandle, jint jlevel0_slowdown_writes_trigger) {
4386   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4387       ->level0_slowdown_writes_trigger =
4388       static_cast<int32_t>(jlevel0_slowdown_writes_trigger);
4389 }
4390
4391 /*
4392  * Class:     org_rocksdb_ColumnFamilyOptions
4393  * Method:    level0StopWritesTrigger
4394  * Signature: (J)I
4395  */
4396 jint Java_org_rocksdb_ColumnFamilyOptions_level0StopWritesTrigger(
4397     JNIEnv*, jobject, jlong jhandle) {
4398   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4399       ->level0_stop_writes_trigger;
4400 }
4401
4402 /*
4403  * Class:     org_rocksdb_ColumnFamilyOptions
4404  * Method:    setLevel0StopWritesTrigger
4405  * Signature: (JI)V
4406  */
4407 void Java_org_rocksdb_ColumnFamilyOptions_setLevel0StopWritesTrigger(
4408     JNIEnv*, jobject, jlong jhandle, jint jlevel0_stop_writes_trigger) {
4409   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4410       ->level0_stop_writes_trigger =
4411       static_cast<int32_t>(jlevel0_stop_writes_trigger);
4412 }
4413
4414 /*
4415  * Class:     org_rocksdb_ColumnFamilyOptions
4416  * Method:    maxBytesForLevelMultiplierAdditional
4417  * Signature: (J)[I
4418  */
4419 jintArray Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelMultiplierAdditional(
4420     JNIEnv* env, jobject, jlong jhandle) {
4421   auto mbflma =
4422       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4423           ->max_bytes_for_level_multiplier_additional;
4424
4425   const size_t size = mbflma.size();
4426
4427   jint* additionals = new jint[size];
4428   for (size_t i = 0; i < size; i++) {
4429     additionals[i] = static_cast<jint>(mbflma[i]);
4430   }
4431
4432   jsize jlen = static_cast<jsize>(size);
4433   jintArray result = env->NewIntArray(jlen);
4434   if (result == nullptr) {
4435     // exception thrown: OutOfMemoryError
4436     delete[] additionals;
4437     return nullptr;
4438   }
4439   env->SetIntArrayRegion(result, 0, jlen, additionals);
4440   if (env->ExceptionCheck()) {
4441     // exception thrown: ArrayIndexOutOfBoundsException
4442     env->DeleteLocalRef(result);
4443     delete[] additionals;
4444     return nullptr;
4445   }
4446
4447   delete[] additionals;
4448
4449   return result;
4450 }
4451
4452 /*
4453  * Class:     org_rocksdb_ColumnFamilyOptions
4454  * Method:    setMaxBytesForLevelMultiplierAdditional
4455  * Signature: (J[I)V
4456  */
4457 void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplierAdditional(
4458     JNIEnv* env, jobject, jlong jhandle,
4459     jintArray jmax_bytes_for_level_multiplier_additional) {
4460   jsize len = env->GetArrayLength(jmax_bytes_for_level_multiplier_additional);
4461   jint* additionals =
4462       env->GetIntArrayElements(jmax_bytes_for_level_multiplier_additional, 0);
4463   if (additionals == nullptr) {
4464     // exception thrown: OutOfMemoryError
4465     return;
4466   }
4467
4468   auto* cf_opt =
4469       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4470   cf_opt->max_bytes_for_level_multiplier_additional.clear();
4471   for (jsize i = 0; i < len; i++) {
4472     cf_opt->max_bytes_for_level_multiplier_additional.push_back(
4473         static_cast<int32_t>(additionals[i]));
4474   }
4475
4476   env->ReleaseIntArrayElements(jmax_bytes_for_level_multiplier_additional,
4477                                additionals, JNI_ABORT);
4478 }
4479
4480 /*
4481  * Class:     org_rocksdb_ColumnFamilyOptions
4482  * Method:    paranoidFileChecks
4483  * Signature: (J)Z
4484  */
4485 jboolean Java_org_rocksdb_ColumnFamilyOptions_paranoidFileChecks(
4486     JNIEnv*, jobject, jlong jhandle) {
4487   return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4488       ->paranoid_file_checks;
4489 }
4490
4491 /*
4492  * Class:     org_rocksdb_ColumnFamilyOptions
4493  * Method:    setParanoidFileChecks
4494  * Signature: (JZ)V
4495  */
4496 void Java_org_rocksdb_ColumnFamilyOptions_setParanoidFileChecks(
4497     JNIEnv*, jobject, jlong jhandle, jboolean jparanoid_file_checks) {
4498   reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4499       ->paranoid_file_checks = static_cast<bool>(jparanoid_file_checks);
4500 }
4501
4502 /*
4503  * Class:     org_rocksdb_ColumnFamilyOptions
4504  * Method:    setCompactionPriority
4505  * Signature: (JB)V
4506  */
4507 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionPriority(
4508     JNIEnv*, jobject, jlong jhandle, jbyte jcompaction_priority_value) {
4509   auto* cf_opts =
4510       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4511   cf_opts->compaction_pri =
4512       ROCKSDB_NAMESPACE::CompactionPriorityJni::toCppCompactionPriority(
4513           jcompaction_priority_value);
4514 }
4515
4516 /*
4517  * Class:     org_rocksdb_ColumnFamilyOptions
4518  * Method:    compactionPriority
4519  * Signature: (J)B
4520  */
4521 jbyte Java_org_rocksdb_ColumnFamilyOptions_compactionPriority(
4522     JNIEnv*, jobject, jlong jhandle) {
4523   auto* cf_opts =
4524       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4525   return ROCKSDB_NAMESPACE::CompactionPriorityJni::toJavaCompactionPriority(
4526       cf_opts->compaction_pri);
4527 }
4528
4529 /*
4530  * Class:     org_rocksdb_ColumnFamilyOptions
4531  * Method:    setReportBgIoStats
4532  * Signature: (JZ)V
4533  */
4534 void Java_org_rocksdb_ColumnFamilyOptions_setReportBgIoStats(
4535     JNIEnv*, jobject, jlong jhandle, jboolean jreport_bg_io_stats) {
4536   auto* cf_opts =
4537       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4538   cf_opts->report_bg_io_stats = static_cast<bool>(jreport_bg_io_stats);
4539 }
4540
4541 /*
4542  * Class:     org_rocksdb_ColumnFamilyOptions
4543  * Method:    reportBgIoStats
4544  * Signature: (J)Z
4545  */
4546 jboolean Java_org_rocksdb_ColumnFamilyOptions_reportBgIoStats(
4547     JNIEnv*, jobject, jlong jhandle) {
4548   auto* cf_opts =
4549       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4550   return static_cast<bool>(cf_opts->report_bg_io_stats);
4551 }
4552
4553 /*
4554  * Class:     org_rocksdb_ColumnFamilyOptions
4555  * Method:    setTtl
4556  * Signature: (JJ)V
4557  */
4558 void Java_org_rocksdb_ColumnFamilyOptions_setTtl(
4559     JNIEnv*, jobject, jlong jhandle, jlong jttl) {
4560   auto* cf_opts =
4561       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4562   cf_opts->ttl = static_cast<uint64_t>(jttl);
4563 }
4564
4565 /*
4566  * Class:     org_rocksdb_ColumnFamilyOptions
4567  * Method:    ttl
4568  * Signature: (J)J
4569  */
4570 JNIEXPORT jlong JNICALL Java_org_rocksdb_ColumnFamilyOptions_ttl(
4571     JNIEnv*, jobject, jlong jhandle) {
4572   auto* cf_opts =
4573       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4574   return static_cast<jlong>(cf_opts->ttl);
4575 }
4576
4577 /*
4578  * Class:     org_rocksdb_ColumnFamilyOptions
4579  * Method:    setCompactionOptionsUniversal
4580  * Signature: (JJ)V
4581  */
4582 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionOptionsUniversal(
4583     JNIEnv*, jobject, jlong jhandle,
4584     jlong jcompaction_options_universal_handle) {
4585   auto* cf_opts =
4586       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4587   auto* opts_uni =
4588       reinterpret_cast<ROCKSDB_NAMESPACE::CompactionOptionsUniversal*>(
4589           jcompaction_options_universal_handle);
4590   cf_opts->compaction_options_universal = *opts_uni;
4591 }
4592
4593 /*
4594  * Class:     org_rocksdb_ColumnFamilyOptions
4595  * Method:    setCompactionOptionsFIFO
4596  * Signature: (JJ)V
4597  */
4598 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionOptionsFIFO(
4599     JNIEnv*, jobject, jlong jhandle, jlong jcompaction_options_fifo_handle) {
4600   auto* cf_opts =
4601       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4602   auto* opts_fifo = reinterpret_cast<ROCKSDB_NAMESPACE::CompactionOptionsFIFO*>(
4603       jcompaction_options_fifo_handle);
4604   cf_opts->compaction_options_fifo = *opts_fifo;
4605 }
4606
4607 /*
4608  * Class:     org_rocksdb_ColumnFamilyOptions
4609  * Method:    setForceConsistencyChecks
4610  * Signature: (JZ)V
4611  */
4612 void Java_org_rocksdb_ColumnFamilyOptions_setForceConsistencyChecks(
4613     JNIEnv*, jobject, jlong jhandle, jboolean jforce_consistency_checks) {
4614   auto* cf_opts =
4615       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4616   cf_opts->force_consistency_checks =
4617       static_cast<bool>(jforce_consistency_checks);
4618 }
4619
4620 /*
4621  * Class:     org_rocksdb_ColumnFamilyOptions
4622  * Method:    forceConsistencyChecks
4623  * Signature: (J)Z
4624  */
4625 jboolean Java_org_rocksdb_ColumnFamilyOptions_forceConsistencyChecks(
4626     JNIEnv*, jobject, jlong jhandle) {
4627   auto* cf_opts =
4628       reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4629   return static_cast<bool>(cf_opts->force_consistency_checks);
4630 }
4631
4632 /////////////////////////////////////////////////////////////////////
4633 // ROCKSDB_NAMESPACE::DBOptions
4634
4635 /*
4636  * Class:     org_rocksdb_DBOptions
4637  * Method:    newDBOptions
4638  * Signature: ()J
4639  */
4640 jlong Java_org_rocksdb_DBOptions_newDBOptions(
4641     JNIEnv*, jclass) {
4642   auto* dbop = new ROCKSDB_NAMESPACE::DBOptions();
4643   return reinterpret_cast<jlong>(dbop);
4644 }
4645
4646 /*
4647  * Class:     org_rocksdb_DBOptions
4648  * Method:    copyDBOptions
4649  * Signature: (J)J
4650  */
4651 jlong Java_org_rocksdb_DBOptions_copyDBOptions(
4652     JNIEnv*, jclass, jlong jhandle) {
4653   auto new_opt = new ROCKSDB_NAMESPACE::DBOptions(
4654       *(reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)));
4655   return reinterpret_cast<jlong>(new_opt);
4656 }
4657
4658 /*
4659  * Class:     org_rocksdb_DBOptions
4660  * Method:    newDBOptionsFromOptions
4661  * Signature: (J)J
4662  */
4663 jlong Java_org_rocksdb_DBOptions_newDBOptionsFromOptions(
4664     JNIEnv*, jclass, jlong joptions_handle) {
4665   auto new_opt = new ROCKSDB_NAMESPACE::DBOptions(
4666       *reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(joptions_handle));
4667   return reinterpret_cast<jlong>(new_opt);
4668 }
4669
4670 /*
4671  * Class:     org_rocksdb_DBOptions
4672  * Method:    getDBOptionsFromProps
4673  * Signature: (Ljava/util/String;)J
4674  */
4675 jlong Java_org_rocksdb_DBOptions_getDBOptionsFromProps(
4676     JNIEnv* env, jclass, jstring jopt_string) {
4677   const char* opt_string = env->GetStringUTFChars(jopt_string, nullptr);
4678   if (opt_string == nullptr) {
4679     // exception thrown: OutOfMemoryError
4680     return 0;
4681   }
4682
4683   auto* db_options = new ROCKSDB_NAMESPACE::DBOptions();
4684   ROCKSDB_NAMESPACE::Status status = ROCKSDB_NAMESPACE::GetDBOptionsFromString(
4685       ROCKSDB_NAMESPACE::DBOptions(), opt_string, db_options);
4686
4687   env->ReleaseStringUTFChars(jopt_string, opt_string);
4688
4689   // Check if DBOptions creation was possible.
4690   jlong ret_value = 0;
4691   if (status.ok()) {
4692     ret_value = reinterpret_cast<jlong>(db_options);
4693   } else {
4694     // if operation failed the DBOptions need to be deleted
4695     // again to prevent a memory leak.
4696     delete db_options;
4697   }
4698   return ret_value;
4699 }
4700
4701 /*
4702  * Class:     org_rocksdb_DBOptions
4703  * Method:    disposeInternal
4704  * Signature: (J)V
4705  */
4706 void Java_org_rocksdb_DBOptions_disposeInternal(
4707     JNIEnv*, jobject, jlong handle) {
4708   auto* dbo = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(handle);
4709   assert(dbo != nullptr);
4710   delete dbo;
4711 }
4712
4713 /*
4714  * Class:     org_rocksdb_DBOptions
4715  * Method:    optimizeForSmallDb
4716  * Signature: (J)V
4717  */
4718 void Java_org_rocksdb_DBOptions_optimizeForSmallDb(
4719     JNIEnv*, jobject, jlong jhandle) {
4720   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
4721       ->OptimizeForSmallDb();
4722 }
4723
4724 /*
4725  * Class:     org_rocksdb_DBOptions
4726  * Method:    setEnv
4727  * Signature: (JJ)V
4728  */
4729 void Java_org_rocksdb_DBOptions_setEnv(
4730     JNIEnv*, jobject, jlong jhandle, jlong jenv_handle) {
4731   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->env =
4732       reinterpret_cast<ROCKSDB_NAMESPACE::Env*>(jenv_handle);
4733 }
4734
4735 /*
4736  * Class:     org_rocksdb_DBOptions
4737  * Method:    setIncreaseParallelism
4738  * Signature: (JI)V
4739  */
4740 void Java_org_rocksdb_DBOptions_setIncreaseParallelism(
4741     JNIEnv*, jobject, jlong jhandle, jint totalThreads) {
4742   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->IncreaseParallelism(
4743       static_cast<int>(totalThreads));
4744 }
4745
4746 /*
4747  * Class:     org_rocksdb_DBOptions
4748  * Method:    setCreateIfMissing
4749  * Signature: (JZ)V
4750  */
4751 void Java_org_rocksdb_DBOptions_setCreateIfMissing(
4752     JNIEnv*, jobject, jlong jhandle, jboolean flag) {
4753   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->create_if_missing =
4754       flag;
4755 }
4756
4757 /*
4758  * Class:     org_rocksdb_DBOptions
4759  * Method:    createIfMissing
4760  * Signature: (J)Z
4761  */
4762 jboolean Java_org_rocksdb_DBOptions_createIfMissing(
4763     JNIEnv*, jobject, jlong jhandle) {
4764   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
4765       ->create_if_missing;
4766 }
4767
4768 /*
4769  * Class:     org_rocksdb_DBOptions
4770  * Method:    setCreateMissingColumnFamilies
4771  * Signature: (JZ)V
4772  */
4773 void Java_org_rocksdb_DBOptions_setCreateMissingColumnFamilies(
4774     JNIEnv*, jobject, jlong jhandle, jboolean flag) {
4775   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
4776       ->create_missing_column_families = flag;
4777 }
4778
4779 /*
4780  * Class:     org_rocksdb_DBOptions
4781  * Method:    createMissingColumnFamilies
4782  * Signature: (J)Z
4783  */
4784 jboolean Java_org_rocksdb_DBOptions_createMissingColumnFamilies(
4785     JNIEnv*, jobject, jlong jhandle) {
4786   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
4787       ->create_missing_column_families;
4788 }
4789
4790 /*
4791  * Class:     org_rocksdb_DBOptions
4792  * Method:    setErrorIfExists
4793  * Signature: (JZ)V
4794  */
4795 void Java_org_rocksdb_DBOptions_setErrorIfExists(
4796     JNIEnv*, jobject, jlong jhandle, jboolean error_if_exists) {
4797   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->error_if_exists =
4798       static_cast<bool>(error_if_exists);
4799 }
4800
4801 /*
4802  * Class:     org_rocksdb_DBOptions
4803  * Method:    errorIfExists
4804  * Signature: (J)Z
4805  */
4806 jboolean Java_org_rocksdb_DBOptions_errorIfExists(
4807     JNIEnv*, jobject, jlong jhandle) {
4808   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
4809       ->error_if_exists;
4810 }
4811
4812 /*
4813  * Class:     org_rocksdb_DBOptions
4814  * Method:    setParanoidChecks
4815  * Signature: (JZ)V
4816  */
4817 void Java_org_rocksdb_DBOptions_setParanoidChecks(
4818     JNIEnv*, jobject, jlong jhandle, jboolean paranoid_checks) {
4819   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->paranoid_checks =
4820       static_cast<bool>(paranoid_checks);
4821 }
4822
4823 /*
4824  * Class:     org_rocksdb_DBOptions
4825  * Method:    paranoidChecks
4826  * Signature: (J)Z
4827  */
4828 jboolean Java_org_rocksdb_DBOptions_paranoidChecks(
4829     JNIEnv*, jobject, jlong jhandle) {
4830   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
4831       ->paranoid_checks;
4832 }
4833
4834 /*
4835  * Class:     org_rocksdb_DBOptions
4836  * Method:    setRateLimiter
4837  * Signature: (JJ)V
4838  */
4839 void Java_org_rocksdb_DBOptions_setRateLimiter(
4840     JNIEnv*, jobject, jlong jhandle, jlong jrate_limiter_handle) {
4841   std::shared_ptr<ROCKSDB_NAMESPACE::RateLimiter>* pRateLimiter =
4842       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::RateLimiter>*>(
4843           jrate_limiter_handle);
4844   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->rate_limiter =
4845       *pRateLimiter;
4846 }
4847
4848 /*
4849  * Class:     org_rocksdb_DBOptions
4850  * Method:    setSstFileManager
4851  * Signature: (JJ)V
4852  */
4853 void Java_org_rocksdb_DBOptions_setSstFileManager(
4854     JNIEnv*, jobject, jlong jhandle, jlong jsst_file_manager_handle) {
4855   auto* sptr_sst_file_manager =
4856       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::SstFileManager>*>(
4857           jsst_file_manager_handle);
4858   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->sst_file_manager =
4859       *sptr_sst_file_manager;
4860 }
4861
4862 /*
4863  * Class:     org_rocksdb_DBOptions
4864  * Method:    setLogger
4865  * Signature: (JJ)V
4866  */
4867 void Java_org_rocksdb_DBOptions_setLogger(
4868     JNIEnv*, jobject, jlong jhandle, jlong jlogger_handle) {
4869   std::shared_ptr<ROCKSDB_NAMESPACE::LoggerJniCallback>* pLogger =
4870       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::LoggerJniCallback>*>(
4871           jlogger_handle);
4872   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->info_log = *pLogger;
4873 }
4874
4875 /*
4876  * Class:     org_rocksdb_DBOptions
4877  * Method:    setInfoLogLevel
4878  * Signature: (JB)V
4879  */
4880 void Java_org_rocksdb_DBOptions_setInfoLogLevel(
4881     JNIEnv*, jobject, jlong jhandle, jbyte jlog_level) {
4882   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->info_log_level =
4883       static_cast<ROCKSDB_NAMESPACE::InfoLogLevel>(jlog_level);
4884 }
4885
4886 /*
4887  * Class:     org_rocksdb_DBOptions
4888  * Method:    infoLogLevel
4889  * Signature: (J)B
4890  */
4891 jbyte Java_org_rocksdb_DBOptions_infoLogLevel(
4892     JNIEnv*, jobject, jlong jhandle) {
4893   return static_cast<jbyte>(
4894       reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->info_log_level);
4895 }
4896
4897 /*
4898  * Class:     org_rocksdb_DBOptions
4899  * Method:    setMaxTotalWalSize
4900  * Signature: (JJ)V
4901  */
4902 void Java_org_rocksdb_DBOptions_setMaxTotalWalSize(
4903     JNIEnv*, jobject, jlong jhandle, jlong jmax_total_wal_size) {
4904   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->max_total_wal_size =
4905       static_cast<jlong>(jmax_total_wal_size);
4906 }
4907
4908 /*
4909  * Class:     org_rocksdb_DBOptions
4910  * Method:    maxTotalWalSize
4911  * Signature: (J)J
4912  */
4913 jlong Java_org_rocksdb_DBOptions_maxTotalWalSize(
4914     JNIEnv*, jobject, jlong jhandle) {
4915   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
4916       ->max_total_wal_size;
4917 }
4918
4919 /*
4920  * Class:     org_rocksdb_DBOptions
4921  * Method:    setMaxOpenFiles
4922  * Signature: (JI)V
4923  */
4924 void Java_org_rocksdb_DBOptions_setMaxOpenFiles(
4925     JNIEnv*, jobject, jlong jhandle, jint max_open_files) {
4926   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->max_open_files =
4927       static_cast<int>(max_open_files);
4928 }
4929
4930 /*
4931  * Class:     org_rocksdb_DBOptions
4932  * Method:    maxOpenFiles
4933  * Signature: (J)I
4934  */
4935 jint Java_org_rocksdb_DBOptions_maxOpenFiles(
4936     JNIEnv*, jobject, jlong jhandle) {
4937   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
4938       ->max_open_files;
4939 }
4940
4941 /*
4942  * Class:     org_rocksdb_DBOptions
4943  * Method:    setMaxFileOpeningThreads
4944  * Signature: (JI)V
4945  */
4946 void Java_org_rocksdb_DBOptions_setMaxFileOpeningThreads(
4947     JNIEnv*, jobject, jlong jhandle, jint jmax_file_opening_threads) {
4948   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
4949       ->max_file_opening_threads = static_cast<int>(jmax_file_opening_threads);
4950 }
4951
4952 /*
4953  * Class:     org_rocksdb_DBOptions
4954  * Method:    maxFileOpeningThreads
4955  * Signature: (J)I
4956  */
4957 jint Java_org_rocksdb_DBOptions_maxFileOpeningThreads(
4958     JNIEnv*, jobject, jlong jhandle) {
4959   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
4960   return static_cast<int>(opt->max_file_opening_threads);
4961 }
4962
4963 /*
4964  * Class:     org_rocksdb_DBOptions
4965  * Method:    setStatistics
4966  * Signature: (JJ)V
4967  */
4968 void Java_org_rocksdb_DBOptions_setStatistics(
4969     JNIEnv*, jobject, jlong jhandle, jlong jstatistics_handle) {
4970   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
4971   auto* pSptr =
4972       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::StatisticsJni>*>(
4973           jstatistics_handle);
4974   opt->statistics = *pSptr;
4975 }
4976
4977 /*
4978  * Class:     org_rocksdb_DBOptions
4979  * Method:    statistics
4980  * Signature: (J)J
4981  */
4982 jlong Java_org_rocksdb_DBOptions_statistics(
4983     JNIEnv*, jobject, jlong jhandle) {
4984   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
4985   std::shared_ptr<ROCKSDB_NAMESPACE::Statistics> sptr = opt->statistics;
4986   if (sptr == nullptr) {
4987     return 0;
4988   } else {
4989     std::shared_ptr<ROCKSDB_NAMESPACE::Statistics>* pSptr =
4990         new std::shared_ptr<ROCKSDB_NAMESPACE::Statistics>(sptr);
4991     return reinterpret_cast<jlong>(pSptr);
4992   }
4993 }
4994
4995 /*
4996  * Class:     org_rocksdb_DBOptions
4997  * Method:    setUseFsync
4998  * Signature: (JZ)V
4999  */
5000 void Java_org_rocksdb_DBOptions_setUseFsync(
5001     JNIEnv*, jobject, jlong jhandle, jboolean use_fsync) {
5002   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->use_fsync =
5003       static_cast<bool>(use_fsync);
5004 }
5005
5006 /*
5007  * Class:     org_rocksdb_DBOptions
5008  * Method:    useFsync
5009  * Signature: (J)Z
5010  */
5011 jboolean Java_org_rocksdb_DBOptions_useFsync(
5012     JNIEnv*, jobject, jlong jhandle) {
5013   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->use_fsync;
5014 }
5015
5016 /*
5017  * Class:     org_rocksdb_DBOptions
5018  * Method:    setDbPaths
5019  * Signature: (J[Ljava/lang/String;[J)V
5020  */
5021 void Java_org_rocksdb_DBOptions_setDbPaths(
5022     JNIEnv* env, jobject, jlong jhandle, jobjectArray jpaths,
5023     jlongArray jtarget_sizes) {
5024   std::vector<ROCKSDB_NAMESPACE::DbPath> db_paths;
5025   jlong* ptr_jtarget_size = env->GetLongArrayElements(jtarget_sizes, nullptr);
5026   if (ptr_jtarget_size == nullptr) {
5027     // exception thrown: OutOfMemoryError
5028     return;
5029   }
5030
5031   jboolean has_exception = JNI_FALSE;
5032   const jsize len = env->GetArrayLength(jpaths);
5033   for (jsize i = 0; i < len; i++) {
5034     jobject jpath =
5035         reinterpret_cast<jstring>(env->GetObjectArrayElement(jpaths, i));
5036     if (env->ExceptionCheck()) {
5037       // exception thrown: ArrayIndexOutOfBoundsException
5038       env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
5039       return;
5040     }
5041     std::string path = ROCKSDB_NAMESPACE::JniUtil::copyStdString(
5042         env, static_cast<jstring>(jpath), &has_exception);
5043     env->DeleteLocalRef(jpath);
5044
5045     if (has_exception == JNI_TRUE) {
5046       env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
5047       return;
5048     }
5049
5050     jlong jtarget_size = ptr_jtarget_size[i];
5051
5052     db_paths.push_back(
5053         ROCKSDB_NAMESPACE::DbPath(path, static_cast<uint64_t>(jtarget_size)));
5054   }
5055
5056   env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
5057
5058   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5059   opt->db_paths = db_paths;
5060 }
5061
5062 /*
5063  * Class:     org_rocksdb_DBOptions
5064  * Method:    dbPathsLen
5065  * Signature: (J)J
5066  */
5067 jlong Java_org_rocksdb_DBOptions_dbPathsLen(
5068     JNIEnv*, jobject, jlong jhandle) {
5069   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5070   return static_cast<jlong>(opt->db_paths.size());
5071 }
5072
5073 /*
5074  * Class:     org_rocksdb_DBOptions
5075  * Method:    dbPaths
5076  * Signature: (J[Ljava/lang/String;[J)V
5077  */
5078 void Java_org_rocksdb_DBOptions_dbPaths(
5079     JNIEnv* env, jobject, jlong jhandle, jobjectArray jpaths,
5080     jlongArray jtarget_sizes) {
5081   jlong* ptr_jtarget_size = env->GetLongArrayElements(jtarget_sizes, nullptr);
5082   if (ptr_jtarget_size == nullptr) {
5083     // exception thrown: OutOfMemoryError
5084     return;
5085   }
5086
5087   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5088   const jsize len = env->GetArrayLength(jpaths);
5089   for (jsize i = 0; i < len; i++) {
5090     ROCKSDB_NAMESPACE::DbPath db_path = opt->db_paths[i];
5091
5092     jstring jpath = env->NewStringUTF(db_path.path.c_str());
5093     if (jpath == nullptr) {
5094       // exception thrown: OutOfMemoryError
5095       env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
5096       return;
5097     }
5098     env->SetObjectArrayElement(jpaths, i, jpath);
5099     if (env->ExceptionCheck()) {
5100       // exception thrown: ArrayIndexOutOfBoundsException
5101       env->DeleteLocalRef(jpath);
5102       env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
5103       return;
5104     }
5105
5106     ptr_jtarget_size[i] = static_cast<jint>(db_path.target_size);
5107   }
5108
5109   env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_COMMIT);
5110 }
5111
5112 /*
5113  * Class:     org_rocksdb_DBOptions
5114  * Method:    setDbLogDir
5115  * Signature: (JLjava/lang/String)V
5116  */
5117 void Java_org_rocksdb_DBOptions_setDbLogDir(
5118     JNIEnv* env, jobject, jlong jhandle, jstring jdb_log_dir) {
5119   const char* log_dir = env->GetStringUTFChars(jdb_log_dir, nullptr);
5120   if (log_dir == nullptr) {
5121     // exception thrown: OutOfMemoryError
5122     return;
5123   }
5124
5125   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->db_log_dir.assign(
5126       log_dir);
5127   env->ReleaseStringUTFChars(jdb_log_dir, log_dir);
5128 }
5129
5130 /*
5131  * Class:     org_rocksdb_DBOptions
5132  * Method:    dbLogDir
5133  * Signature: (J)Ljava/lang/String
5134  */
5135 jstring Java_org_rocksdb_DBOptions_dbLogDir(
5136     JNIEnv* env, jobject, jlong jhandle) {
5137   return env->NewStringUTF(
5138       reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5139           ->db_log_dir.c_str());
5140 }
5141
5142 /*
5143  * Class:     org_rocksdb_DBOptions
5144  * Method:    setWalDir
5145  * Signature: (JLjava/lang/String)V
5146  */
5147 void Java_org_rocksdb_DBOptions_setWalDir(
5148     JNIEnv* env, jobject, jlong jhandle, jstring jwal_dir) {
5149   const char* wal_dir = env->GetStringUTFChars(jwal_dir, 0);
5150   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->wal_dir.assign(
5151       wal_dir);
5152   env->ReleaseStringUTFChars(jwal_dir, wal_dir);
5153 }
5154
5155 /*
5156  * Class:     org_rocksdb_DBOptions
5157  * Method:    walDir
5158  * Signature: (J)Ljava/lang/String
5159  */
5160 jstring Java_org_rocksdb_DBOptions_walDir(
5161     JNIEnv* env, jobject, jlong jhandle) {
5162   return env->NewStringUTF(
5163       reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5164           ->wal_dir.c_str());
5165 }
5166
5167 /*
5168  * Class:     org_rocksdb_DBOptions
5169  * Method:    setDeleteObsoleteFilesPeriodMicros
5170  * Signature: (JJ)V
5171  */
5172 void Java_org_rocksdb_DBOptions_setDeleteObsoleteFilesPeriodMicros(
5173     JNIEnv*, jobject, jlong jhandle, jlong micros) {
5174   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5175       ->delete_obsolete_files_period_micros = static_cast<int64_t>(micros);
5176 }
5177
5178 /*
5179  * Class:     org_rocksdb_DBOptions
5180  * Method:    deleteObsoleteFilesPeriodMicros
5181  * Signature: (J)J
5182  */
5183 jlong Java_org_rocksdb_DBOptions_deleteObsoleteFilesPeriodMicros(
5184     JNIEnv*, jobject, jlong jhandle) {
5185   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5186       ->delete_obsolete_files_period_micros;
5187 }
5188
5189 /*
5190  * Class:     org_rocksdb_DBOptions
5191  * Method:    setBaseBackgroundCompactions
5192  * Signature: (JI)V
5193  */
5194 void Java_org_rocksdb_DBOptions_setBaseBackgroundCompactions(
5195     JNIEnv*, jobject, jlong jhandle, jint max) {
5196   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5197       ->base_background_compactions = static_cast<int>(max);
5198 }
5199
5200 /*
5201  * Class:     org_rocksdb_DBOptions
5202  * Method:    baseBackgroundCompactions
5203  * Signature: (J)I
5204  */
5205 jint Java_org_rocksdb_DBOptions_baseBackgroundCompactions(
5206     JNIEnv*, jobject, jlong jhandle) {
5207   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5208       ->base_background_compactions;
5209 }
5210
5211 /*
5212  * Class:     org_rocksdb_DBOptions
5213  * Method:    setMaxBackgroundCompactions
5214  * Signature: (JI)V
5215  */
5216 void Java_org_rocksdb_DBOptions_setMaxBackgroundCompactions(
5217     JNIEnv*, jobject, jlong jhandle, jint max) {
5218   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5219       ->max_background_compactions = static_cast<int>(max);
5220 }
5221
5222 /*
5223  * Class:     org_rocksdb_DBOptions
5224  * Method:    maxBackgroundCompactions
5225  * Signature: (J)I
5226  */
5227 jint Java_org_rocksdb_DBOptions_maxBackgroundCompactions(
5228     JNIEnv*, jobject, jlong jhandle) {
5229   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5230       ->max_background_compactions;
5231 }
5232
5233 /*
5234  * Class:     org_rocksdb_DBOptions
5235  * Method:    setMaxSubcompactions
5236  * Signature: (JI)V
5237  */
5238 void Java_org_rocksdb_DBOptions_setMaxSubcompactions(
5239     JNIEnv*, jobject, jlong jhandle, jint max) {
5240   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->max_subcompactions =
5241       static_cast<int32_t>(max);
5242 }
5243
5244 /*
5245  * Class:     org_rocksdb_DBOptions
5246  * Method:    maxSubcompactions
5247  * Signature: (J)I
5248  */
5249 jint Java_org_rocksdb_DBOptions_maxSubcompactions(
5250     JNIEnv*, jobject, jlong jhandle) {
5251   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5252       ->max_subcompactions;
5253 }
5254
5255 /*
5256  * Class:     org_rocksdb_DBOptions
5257  * Method:    setMaxBackgroundFlushes
5258  * Signature: (JI)V
5259  */
5260 void Java_org_rocksdb_DBOptions_setMaxBackgroundFlushes(
5261     JNIEnv*, jobject, jlong jhandle, jint max_background_flushes) {
5262   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5263       ->max_background_flushes = static_cast<int>(max_background_flushes);
5264 }
5265
5266 /*
5267  * Class:     org_rocksdb_DBOptions
5268  * Method:    maxBackgroundFlushes
5269  * Signature: (J)I
5270  */
5271 jint Java_org_rocksdb_DBOptions_maxBackgroundFlushes(
5272     JNIEnv*, jobject, jlong jhandle) {
5273   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5274       ->max_background_flushes;
5275 }
5276
5277 /*
5278  * Class:     org_rocksdb_DBOptions
5279  * Method:    setMaxBackgroundJobs
5280  * Signature: (JI)V
5281  */
5282 void Java_org_rocksdb_DBOptions_setMaxBackgroundJobs(
5283     JNIEnv*, jobject, jlong jhandle, jint max_background_jobs) {
5284   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5285       ->max_background_jobs = static_cast<int>(max_background_jobs);
5286 }
5287
5288 /*
5289  * Class:     org_rocksdb_DBOptions
5290  * Method:    maxBackgroundJobs
5291  * Signature: (J)I
5292  */
5293 jint Java_org_rocksdb_DBOptions_maxBackgroundJobs(
5294     JNIEnv*, jobject, jlong jhandle) {
5295   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5296       ->max_background_jobs;
5297 }
5298
5299 /*
5300  * Class:     org_rocksdb_DBOptions
5301  * Method:    setMaxLogFileSize
5302  * Signature: (JJ)V
5303  */
5304 void Java_org_rocksdb_DBOptions_setMaxLogFileSize(
5305     JNIEnv* env, jobject, jlong jhandle, jlong max_log_file_size) {
5306   auto s =
5307       ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(max_log_file_size);
5308   if (s.ok()) {
5309     reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5310         ->max_log_file_size = max_log_file_size;
5311   } else {
5312     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
5313   }
5314 }
5315
5316 /*
5317  * Class:     org_rocksdb_DBOptions
5318  * Method:    maxLogFileSize
5319  * Signature: (J)J
5320  */
5321 jlong Java_org_rocksdb_DBOptions_maxLogFileSize(
5322     JNIEnv*, jobject, jlong jhandle) {
5323   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5324       ->max_log_file_size;
5325 }
5326
5327 /*
5328  * Class:     org_rocksdb_DBOptions
5329  * Method:    setLogFileTimeToRoll
5330  * Signature: (JJ)V
5331  */
5332 void Java_org_rocksdb_DBOptions_setLogFileTimeToRoll(
5333     JNIEnv* env, jobject, jlong jhandle, jlong log_file_time_to_roll) {
5334   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
5335       log_file_time_to_roll);
5336   if (s.ok()) {
5337     reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5338         ->log_file_time_to_roll = log_file_time_to_roll;
5339   } else {
5340     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
5341   }
5342 }
5343
5344 /*
5345  * Class:     org_rocksdb_DBOptions
5346  * Method:    logFileTimeToRoll
5347  * Signature: (J)J
5348  */
5349 jlong Java_org_rocksdb_DBOptions_logFileTimeToRoll(
5350     JNIEnv*, jobject, jlong jhandle) {
5351   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5352       ->log_file_time_to_roll;
5353 }
5354
5355 /*
5356  * Class:     org_rocksdb_DBOptions
5357  * Method:    setKeepLogFileNum
5358  * Signature: (JJ)V
5359  */
5360 void Java_org_rocksdb_DBOptions_setKeepLogFileNum(
5361     JNIEnv* env, jobject, jlong jhandle, jlong keep_log_file_num) {
5362   auto s =
5363       ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(keep_log_file_num);
5364   if (s.ok()) {
5365     reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5366         ->keep_log_file_num = keep_log_file_num;
5367   } else {
5368     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
5369   }
5370 }
5371
5372 /*
5373  * Class:     org_rocksdb_DBOptions
5374  * Method:    keepLogFileNum
5375  * Signature: (J)J
5376  */
5377 jlong Java_org_rocksdb_DBOptions_keepLogFileNum(
5378     JNIEnv*, jobject, jlong jhandle) {
5379   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5380       ->keep_log_file_num;
5381 }
5382
5383 /*
5384  * Class:     org_rocksdb_DBOptions
5385  * Method:    setRecycleLogFileNum
5386  * Signature: (JJ)V
5387  */
5388 void Java_org_rocksdb_DBOptions_setRecycleLogFileNum(
5389     JNIEnv* env, jobject, jlong jhandle, jlong recycle_log_file_num) {
5390   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
5391       recycle_log_file_num);
5392   if (s.ok()) {
5393     reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5394         ->recycle_log_file_num = recycle_log_file_num;
5395   } else {
5396     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
5397   }
5398 }
5399
5400 /*
5401  * Class:     org_rocksdb_DBOptions
5402  * Method:    recycleLogFileNum
5403  * Signature: (J)J
5404  */
5405 jlong Java_org_rocksdb_DBOptions_recycleLogFileNum(
5406     JNIEnv*, jobject, jlong jhandle) {
5407   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5408       ->recycle_log_file_num;
5409 }
5410
5411 /*
5412  * Class:     org_rocksdb_DBOptions
5413  * Method:    setMaxManifestFileSize
5414  * Signature: (JJ)V
5415  */
5416 void Java_org_rocksdb_DBOptions_setMaxManifestFileSize(
5417     JNIEnv*, jobject, jlong jhandle, jlong max_manifest_file_size) {
5418   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5419       ->max_manifest_file_size = static_cast<int64_t>(max_manifest_file_size);
5420 }
5421
5422 /*
5423  * Class:     org_rocksdb_DBOptions
5424  * Method:    maxManifestFileSize
5425  * Signature: (J)J
5426  */
5427 jlong Java_org_rocksdb_DBOptions_maxManifestFileSize(
5428     JNIEnv*, jobject, jlong jhandle) {
5429   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5430       ->max_manifest_file_size;
5431 }
5432
5433 /*
5434  * Class:     org_rocksdb_DBOptions
5435  * Method:    setTableCacheNumshardbits
5436  * Signature: (JI)V
5437  */
5438 void Java_org_rocksdb_DBOptions_setTableCacheNumshardbits(
5439     JNIEnv*, jobject, jlong jhandle, jint table_cache_numshardbits) {
5440   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5441       ->table_cache_numshardbits = static_cast<int>(table_cache_numshardbits);
5442 }
5443
5444 /*
5445  * Class:     org_rocksdb_DBOptions
5446  * Method:    tableCacheNumshardbits
5447  * Signature: (J)I
5448  */
5449 jint Java_org_rocksdb_DBOptions_tableCacheNumshardbits(
5450     JNIEnv*, jobject, jlong jhandle) {
5451   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5452       ->table_cache_numshardbits;
5453 }
5454
5455 /*
5456  * Class:     org_rocksdb_DBOptions
5457  * Method:    setWalTtlSeconds
5458  * Signature: (JJ)V
5459  */
5460 void Java_org_rocksdb_DBOptions_setWalTtlSeconds(
5461     JNIEnv*, jobject, jlong jhandle, jlong WAL_ttl_seconds) {
5462   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->WAL_ttl_seconds =
5463       static_cast<int64_t>(WAL_ttl_seconds);
5464 }
5465
5466 /*
5467  * Class:     org_rocksdb_DBOptions
5468  * Method:    walTtlSeconds
5469  * Signature: (J)J
5470  */
5471 jlong Java_org_rocksdb_DBOptions_walTtlSeconds(
5472     JNIEnv*, jobject, jlong jhandle) {
5473   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5474       ->WAL_ttl_seconds;
5475 }
5476
5477 /*
5478  * Class:     org_rocksdb_DBOptions
5479  * Method:    setWalSizeLimitMB
5480  * Signature: (JJ)V
5481  */
5482 void Java_org_rocksdb_DBOptions_setWalSizeLimitMB(
5483     JNIEnv*, jobject, jlong jhandle, jlong WAL_size_limit_MB) {
5484   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->WAL_size_limit_MB =
5485       static_cast<int64_t>(WAL_size_limit_MB);
5486 }
5487
5488 /*
5489  * Class:     org_rocksdb_DBOptions
5490  * Method:    walTtlSeconds
5491  * Signature: (J)J
5492  */
5493 jlong Java_org_rocksdb_DBOptions_walSizeLimitMB(
5494     JNIEnv*, jobject, jlong jhandle) {
5495   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5496       ->WAL_size_limit_MB;
5497 }
5498
5499 /*
5500  * Class:     org_rocksdb_DBOptions
5501  * Method:    setManifestPreallocationSize
5502  * Signature: (JJ)V
5503  */
5504 void Java_org_rocksdb_DBOptions_setManifestPreallocationSize(
5505     JNIEnv* env, jobject, jlong jhandle, jlong preallocation_size) {
5506   auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
5507       preallocation_size);
5508   if (s.ok()) {
5509     reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5510         ->manifest_preallocation_size = preallocation_size;
5511   } else {
5512     ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
5513   }
5514 }
5515
5516 /*
5517  * Class:     org_rocksdb_DBOptions
5518  * Method:    manifestPreallocationSize
5519  * Signature: (J)J
5520  */
5521 jlong Java_org_rocksdb_DBOptions_manifestPreallocationSize(
5522     JNIEnv*, jobject, jlong jhandle) {
5523   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5524       ->manifest_preallocation_size;
5525 }
5526
5527 /*
5528  * Class:     org_rocksdb_DBOptions
5529  * Method:    useDirectReads
5530  * Signature: (J)Z
5531  */
5532 jboolean Java_org_rocksdb_DBOptions_useDirectReads(
5533     JNIEnv*, jobject, jlong jhandle) {
5534   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5535       ->use_direct_reads;
5536 }
5537
5538 /*
5539  * Class:     org_rocksdb_DBOptions
5540  * Method:    setUseDirectReads
5541  * Signature: (JZ)V
5542  */
5543 void Java_org_rocksdb_DBOptions_setUseDirectReads(
5544     JNIEnv*, jobject, jlong jhandle, jboolean use_direct_reads) {
5545   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->use_direct_reads =
5546       static_cast<bool>(use_direct_reads);
5547 }
5548
5549 /*
5550  * Class:     org_rocksdb_DBOptions
5551  * Method:    useDirectIoForFlushAndCompaction
5552  * Signature: (J)Z
5553  */
5554 jboolean Java_org_rocksdb_DBOptions_useDirectIoForFlushAndCompaction(
5555     JNIEnv*, jobject, jlong jhandle) {
5556   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5557       ->use_direct_io_for_flush_and_compaction;
5558 }
5559
5560 /*
5561  * Class:     org_rocksdb_DBOptions
5562  * Method:    setUseDirectReads
5563  * Signature: (JZ)V
5564  */
5565 void Java_org_rocksdb_DBOptions_setUseDirectIoForFlushAndCompaction(
5566     JNIEnv*, jobject, jlong jhandle,
5567     jboolean use_direct_io_for_flush_and_compaction) {
5568   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5569       ->use_direct_io_for_flush_and_compaction =
5570       static_cast<bool>(use_direct_io_for_flush_and_compaction);
5571 }
5572
5573 /*
5574  * Class:     org_rocksdb_DBOptions
5575  * Method:    setAllowFAllocate
5576  * Signature: (JZ)V
5577  */
5578 void Java_org_rocksdb_DBOptions_setAllowFAllocate(
5579     JNIEnv*, jobject, jlong jhandle, jboolean jallow_fallocate) {
5580   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->allow_fallocate =
5581       static_cast<bool>(jallow_fallocate);
5582 }
5583
5584 /*
5585  * Class:     org_rocksdb_DBOptions
5586  * Method:    allowFAllocate
5587  * Signature: (J)Z
5588  */
5589 jboolean Java_org_rocksdb_DBOptions_allowFAllocate(
5590     JNIEnv*, jobject, jlong jhandle) {
5591   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5592   return static_cast<jboolean>(opt->allow_fallocate);
5593 }
5594
5595 /*
5596  * Class:     org_rocksdb_DBOptions
5597  * Method:    setAllowMmapReads
5598  * Signature: (JZ)V
5599  */
5600 void Java_org_rocksdb_DBOptions_setAllowMmapReads(
5601     JNIEnv*, jobject, jlong jhandle, jboolean allow_mmap_reads) {
5602   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->allow_mmap_reads =
5603       static_cast<bool>(allow_mmap_reads);
5604 }
5605
5606 /*
5607  * Class:     org_rocksdb_DBOptions
5608  * Method:    allowMmapReads
5609  * Signature: (J)Z
5610  */
5611 jboolean Java_org_rocksdb_DBOptions_allowMmapReads(
5612     JNIEnv*, jobject, jlong jhandle) {
5613   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5614       ->allow_mmap_reads;
5615 }
5616
5617 /*
5618  * Class:     org_rocksdb_DBOptions
5619  * Method:    setAllowMmapWrites
5620  * Signature: (JZ)V
5621  */
5622 void Java_org_rocksdb_DBOptions_setAllowMmapWrites(
5623     JNIEnv*, jobject, jlong jhandle, jboolean allow_mmap_writes) {
5624   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->allow_mmap_writes =
5625       static_cast<bool>(allow_mmap_writes);
5626 }
5627
5628 /*
5629  * Class:     org_rocksdb_DBOptions
5630  * Method:    allowMmapWrites
5631  * Signature: (J)Z
5632  */
5633 jboolean Java_org_rocksdb_DBOptions_allowMmapWrites(
5634     JNIEnv*, jobject, jlong jhandle) {
5635   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5636       ->allow_mmap_writes;
5637 }
5638
5639 /*
5640  * Class:     org_rocksdb_DBOptions
5641  * Method:    setIsFdCloseOnExec
5642  * Signature: (JZ)V
5643  */
5644 void Java_org_rocksdb_DBOptions_setIsFdCloseOnExec(
5645     JNIEnv*, jobject, jlong jhandle, jboolean is_fd_close_on_exec) {
5646   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5647       ->is_fd_close_on_exec = static_cast<bool>(is_fd_close_on_exec);
5648 }
5649
5650 /*
5651  * Class:     org_rocksdb_DBOptions
5652  * Method:    isFdCloseOnExec
5653  * Signature: (J)Z
5654  */
5655 jboolean Java_org_rocksdb_DBOptions_isFdCloseOnExec(
5656     JNIEnv*, jobject, jlong jhandle) {
5657   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5658       ->is_fd_close_on_exec;
5659 }
5660
5661 /*
5662  * Class:     org_rocksdb_DBOptions
5663  * Method:    setStatsDumpPeriodSec
5664  * Signature: (JI)V
5665  */
5666 void Java_org_rocksdb_DBOptions_setStatsDumpPeriodSec(
5667     JNIEnv*, jobject, jlong jhandle, jint jstats_dump_period_sec) {
5668   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5669       ->stats_dump_period_sec =
5670       static_cast<unsigned int>(jstats_dump_period_sec);
5671 }
5672
5673 /*
5674  * Class:     org_rocksdb_DBOptions
5675  * Method:    statsDumpPeriodSec
5676  * Signature: (J)I
5677  */
5678 jint Java_org_rocksdb_DBOptions_statsDumpPeriodSec(
5679     JNIEnv*, jobject, jlong jhandle) {
5680   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5681       ->stats_dump_period_sec;
5682 }
5683
5684 /*
5685  * Class:     org_rocksdb_DBOptions
5686  * Method:    setStatsPersistPeriodSec
5687  * Signature: (JI)V
5688  */
5689 void Java_org_rocksdb_DBOptions_setStatsPersistPeriodSec(
5690     JNIEnv*, jobject, jlong jhandle, jint jstats_persist_period_sec) {
5691   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5692       ->stats_persist_period_sec =
5693       static_cast<unsigned int>(jstats_persist_period_sec);
5694 }
5695
5696 /*
5697  * Class:     org_rocksdb_DBOptions
5698  * Method:    statsPersistPeriodSec
5699  * Signature: (J)I
5700  */
5701 jint Java_org_rocksdb_DBOptions_statsPersistPeriodSec(
5702     JNIEnv*, jobject, jlong jhandle) {
5703   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5704       ->stats_persist_period_sec;
5705 }
5706
5707 /*
5708  * Class:     org_rocksdb_DBOptions
5709  * Method:    setStatsHistoryBufferSize
5710  * Signature: (JJ)V
5711  */
5712 void Java_org_rocksdb_DBOptions_setStatsHistoryBufferSize(
5713     JNIEnv*, jobject, jlong jhandle, jlong jstats_history_buffer_size) {
5714   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5715       ->stats_history_buffer_size =
5716       static_cast<size_t>(jstats_history_buffer_size);
5717 }
5718
5719 /*
5720  * Class:     org_rocksdb_DBOptions
5721  * Method:    statsHistoryBufferSize
5722  * Signature: (J)J
5723  */
5724 jlong Java_org_rocksdb_DBOptions_statsHistoryBufferSize(
5725     JNIEnv*, jobject, jlong jhandle) {
5726   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5727       ->stats_history_buffer_size;
5728 }
5729
5730 /*
5731  * Class:     org_rocksdb_DBOptions
5732  * Method:    setAdviseRandomOnOpen
5733  * Signature: (JZ)V
5734  */
5735 void Java_org_rocksdb_DBOptions_setAdviseRandomOnOpen(
5736     JNIEnv*, jobject, jlong jhandle, jboolean advise_random_on_open) {
5737   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5738       ->advise_random_on_open = static_cast<bool>(advise_random_on_open);
5739 }
5740
5741 /*
5742  * Class:     org_rocksdb_DBOptions
5743  * Method:    adviseRandomOnOpen
5744  * Signature: (J)Z
5745  */
5746 jboolean Java_org_rocksdb_DBOptions_adviseRandomOnOpen(
5747     JNIEnv*, jobject, jlong jhandle) {
5748   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5749       ->advise_random_on_open;
5750 }
5751
5752 /*
5753  * Class:     org_rocksdb_DBOptions
5754  * Method:    setDbWriteBufferSize
5755  * Signature: (JJ)V
5756  */
5757 void Java_org_rocksdb_DBOptions_setDbWriteBufferSize(
5758     JNIEnv*, jobject, jlong jhandle, jlong jdb_write_buffer_size) {
5759   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5760   opt->db_write_buffer_size = static_cast<size_t>(jdb_write_buffer_size);
5761 }
5762
5763 /*
5764  * Class:     org_rocksdb_DBOptions
5765  * Method:    setWriteBufferManager
5766  * Signature: (JJ)V
5767  */
5768 void Java_org_rocksdb_DBOptions_setWriteBufferManager(
5769     JNIEnv*, jobject, jlong jdb_options_handle,
5770     jlong jwrite_buffer_manager_handle) {
5771   auto* write_buffer_manager =
5772       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::WriteBufferManager>*>(
5773           jwrite_buffer_manager_handle);
5774   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jdb_options_handle)
5775       ->write_buffer_manager = *write_buffer_manager;
5776 }
5777
5778 /*
5779  * Class:     org_rocksdb_DBOptions
5780  * Method:    dbWriteBufferSize
5781  * Signature: (J)J
5782  */
5783 jlong Java_org_rocksdb_DBOptions_dbWriteBufferSize(
5784     JNIEnv*, jobject, jlong jhandle) {
5785   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5786   return static_cast<jlong>(opt->db_write_buffer_size);
5787 }
5788
5789 /*
5790  * Class:     org_rocksdb_DBOptions
5791  * Method:    setAccessHintOnCompactionStart
5792  * Signature: (JB)V
5793  */
5794 void Java_org_rocksdb_DBOptions_setAccessHintOnCompactionStart(
5795     JNIEnv*, jobject, jlong jhandle, jbyte jaccess_hint_value) {
5796   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5797   opt->access_hint_on_compaction_start =
5798       ROCKSDB_NAMESPACE::AccessHintJni::toCppAccessHint(jaccess_hint_value);
5799 }
5800
5801 /*
5802  * Class:     org_rocksdb_DBOptions
5803  * Method:    accessHintOnCompactionStart
5804  * Signature: (J)B
5805  */
5806 jbyte Java_org_rocksdb_DBOptions_accessHintOnCompactionStart(
5807     JNIEnv*, jobject, jlong jhandle) {
5808   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5809   return ROCKSDB_NAMESPACE::AccessHintJni::toJavaAccessHint(
5810       opt->access_hint_on_compaction_start);
5811 }
5812
5813 /*
5814  * Class:     org_rocksdb_DBOptions
5815  * Method:    setNewTableReaderForCompactionInputs
5816  * Signature: (JZ)V
5817  */
5818 void Java_org_rocksdb_DBOptions_setNewTableReaderForCompactionInputs(
5819     JNIEnv*, jobject, jlong jhandle,
5820     jboolean jnew_table_reader_for_compaction_inputs) {
5821   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5822   opt->new_table_reader_for_compaction_inputs =
5823       static_cast<bool>(jnew_table_reader_for_compaction_inputs);
5824 }
5825
5826 /*
5827  * Class:     org_rocksdb_DBOptions
5828  * Method:    newTableReaderForCompactionInputs
5829  * Signature: (J)Z
5830  */
5831 jboolean Java_org_rocksdb_DBOptions_newTableReaderForCompactionInputs(
5832     JNIEnv*, jobject, jlong jhandle) {
5833   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5834   return static_cast<bool>(opt->new_table_reader_for_compaction_inputs);
5835 }
5836
5837 /*
5838  * Class:     org_rocksdb_DBOptions
5839  * Method:    setCompactionReadaheadSize
5840  * Signature: (JJ)V
5841  */
5842 void Java_org_rocksdb_DBOptions_setCompactionReadaheadSize(
5843     JNIEnv*, jobject, jlong jhandle, jlong jcompaction_readahead_size) {
5844   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5845   opt->compaction_readahead_size =
5846       static_cast<size_t>(jcompaction_readahead_size);
5847 }
5848
5849 /*
5850  * Class:     org_rocksdb_DBOptions
5851  * Method:    compactionReadaheadSize
5852  * Signature: (J)J
5853  */
5854 jlong Java_org_rocksdb_DBOptions_compactionReadaheadSize(
5855     JNIEnv*, jobject, jlong jhandle) {
5856   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5857   return static_cast<jlong>(opt->compaction_readahead_size);
5858 }
5859
5860 /*
5861  * Class:     org_rocksdb_DBOptions
5862  * Method:    setRandomAccessMaxBufferSize
5863  * Signature: (JJ)V
5864  */
5865 void Java_org_rocksdb_DBOptions_setRandomAccessMaxBufferSize(
5866     JNIEnv*, jobject, jlong jhandle, jlong jrandom_access_max_buffer_size) {
5867   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5868   opt->random_access_max_buffer_size =
5869       static_cast<size_t>(jrandom_access_max_buffer_size);
5870 }
5871
5872 /*
5873  * Class:     org_rocksdb_DBOptions
5874  * Method:    randomAccessMaxBufferSize
5875  * Signature: (J)J
5876  */
5877 jlong Java_org_rocksdb_DBOptions_randomAccessMaxBufferSize(
5878     JNIEnv*, jobject, jlong jhandle) {
5879   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5880   return static_cast<jlong>(opt->random_access_max_buffer_size);
5881 }
5882
5883 /*
5884  * Class:     org_rocksdb_DBOptions
5885  * Method:    setWritableFileMaxBufferSize
5886  * Signature: (JJ)V
5887  */
5888 void Java_org_rocksdb_DBOptions_setWritableFileMaxBufferSize(
5889     JNIEnv*, jobject, jlong jhandle, jlong jwritable_file_max_buffer_size) {
5890   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5891   opt->writable_file_max_buffer_size =
5892       static_cast<size_t>(jwritable_file_max_buffer_size);
5893 }
5894
5895 /*
5896  * Class:     org_rocksdb_DBOptions
5897  * Method:    writableFileMaxBufferSize
5898  * Signature: (J)J
5899  */
5900 jlong Java_org_rocksdb_DBOptions_writableFileMaxBufferSize(
5901     JNIEnv*, jobject, jlong jhandle) {
5902   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5903   return static_cast<jlong>(opt->writable_file_max_buffer_size);
5904 }
5905
5906 /*
5907  * Class:     org_rocksdb_DBOptions
5908  * Method:    setUseAdaptiveMutex
5909  * Signature: (JZ)V
5910  */
5911 void Java_org_rocksdb_DBOptions_setUseAdaptiveMutex(
5912     JNIEnv*, jobject, jlong jhandle, jboolean use_adaptive_mutex) {
5913   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->use_adaptive_mutex =
5914       static_cast<bool>(use_adaptive_mutex);
5915 }
5916
5917 /*
5918  * Class:     org_rocksdb_DBOptions
5919  * Method:    useAdaptiveMutex
5920  * Signature: (J)Z
5921  */
5922 jboolean Java_org_rocksdb_DBOptions_useAdaptiveMutex(
5923     JNIEnv*, jobject, jlong jhandle) {
5924   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5925       ->use_adaptive_mutex;
5926 }
5927
5928 /*
5929  * Class:     org_rocksdb_DBOptions
5930  * Method:    setBytesPerSync
5931  * Signature: (JJ)V
5932  */
5933 void Java_org_rocksdb_DBOptions_setBytesPerSync(
5934     JNIEnv*, jobject, jlong jhandle, jlong bytes_per_sync) {
5935   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->bytes_per_sync =
5936       static_cast<int64_t>(bytes_per_sync);
5937 }
5938
5939 /*
5940  * Class:     org_rocksdb_DBOptions
5941  * Method:    bytesPerSync
5942  * Signature: (J)J
5943  */
5944 jlong Java_org_rocksdb_DBOptions_bytesPerSync(
5945     JNIEnv*, jobject, jlong jhandle) {
5946   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5947       ->bytes_per_sync;
5948 }
5949
5950 /*
5951  * Class:     org_rocksdb_DBOptions
5952  * Method:    setWalBytesPerSync
5953  * Signature: (JJ)V
5954  */
5955 void Java_org_rocksdb_DBOptions_setWalBytesPerSync(
5956     JNIEnv*, jobject, jlong jhandle, jlong jwal_bytes_per_sync) {
5957   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->wal_bytes_per_sync =
5958       static_cast<int64_t>(jwal_bytes_per_sync);
5959 }
5960
5961 /*
5962  * Class:     org_rocksdb_DBOptions
5963  * Method:    walBytesPerSync
5964  * Signature: (J)J
5965  */
5966 jlong Java_org_rocksdb_DBOptions_walBytesPerSync(
5967     JNIEnv*, jobject, jlong jhandle) {
5968   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5969   return static_cast<jlong>(opt->wal_bytes_per_sync);
5970 }
5971
5972 /*
5973  * Class:     org_rocksdb_DBOptions
5974  * Method:    setStrictBytesPerSync
5975  * Signature: (JZ)V
5976  */
5977 void Java_org_rocksdb_DBOptions_setStrictBytesPerSync(
5978     JNIEnv*, jobject, jlong jhandle, jboolean jstrict_bytes_per_sync) {
5979   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5980       ->strict_bytes_per_sync = jstrict_bytes_per_sync == JNI_TRUE;
5981 }
5982
5983 /*
5984  * Class:     org_rocksdb_DBOptions
5985  * Method:    strictBytesPerSync
5986  * Signature: (J)Z
5987  */
5988 jboolean Java_org_rocksdb_DBOptions_strictBytesPerSync(
5989     JNIEnv*, jobject, jlong jhandle) {
5990   return static_cast<jboolean>(
5991       reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5992           ->strict_bytes_per_sync);
5993 }
5994
5995 /*
5996  * Class:     org_rocksdb_DBOptions
5997  * Method:    setDelayedWriteRate
5998  * Signature: (JJ)V
5999  */
6000 void Java_org_rocksdb_DBOptions_setDelayedWriteRate(
6001     JNIEnv*, jobject, jlong jhandle, jlong jdelayed_write_rate) {
6002   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6003   opt->delayed_write_rate = static_cast<uint64_t>(jdelayed_write_rate);
6004 }
6005
6006 /*
6007  * Class:     org_rocksdb_DBOptions
6008  * Method:    delayedWriteRate
6009  * Signature: (J)J
6010  */
6011 jlong Java_org_rocksdb_DBOptions_delayedWriteRate(
6012     JNIEnv*, jobject, jlong jhandle) {
6013   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6014   return static_cast<jlong>(opt->delayed_write_rate);
6015 }
6016
6017 /*
6018  * Class:     org_rocksdb_DBOptions
6019  * Method:    setEnablePipelinedWrite
6020  * Signature: (JZ)V
6021  */
6022 void Java_org_rocksdb_DBOptions_setEnablePipelinedWrite(
6023     JNIEnv*, jobject, jlong jhandle, jboolean jenable_pipelined_write) {
6024   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6025   opt->enable_pipelined_write = jenable_pipelined_write == JNI_TRUE;
6026 }
6027
6028 /*
6029  * Class:     org_rocksdb_DBOptions
6030  * Method:    enablePipelinedWrite
6031  * Signature: (J)Z
6032  */
6033 jboolean Java_org_rocksdb_DBOptions_enablePipelinedWrite(
6034     JNIEnv*, jobject, jlong jhandle) {
6035   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6036   return static_cast<jboolean>(opt->enable_pipelined_write);
6037 }
6038
6039 /*
6040  * Class:     org_rocksdb_DBOptions
6041  * Method:    setUnorderedWrite
6042  * Signature: (JZ)V
6043  */
6044 void Java_org_rocksdb_DBOptions_setUnorderedWrite(
6045         JNIEnv*, jobject, jlong jhandle, jboolean junordered_write) {
6046   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6047   opt->unordered_write = junordered_write == JNI_TRUE;
6048 }
6049
6050 /*
6051  * Class:     org_rocksdb_DBOptions
6052  * Method:    unorderedWrite
6053  * Signature: (J)Z
6054  */
6055 jboolean Java_org_rocksdb_DBOptions_unorderedWrite(
6056         JNIEnv*, jobject, jlong jhandle) {
6057   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6058   return static_cast<jboolean>(opt->unordered_write);
6059 }
6060
6061
6062 /*
6063  * Class:     org_rocksdb_DBOptions
6064  * Method:    setEnableThreadTracking
6065  * Signature: (JZ)V
6066  */
6067 void Java_org_rocksdb_DBOptions_setEnableThreadTracking(
6068     JNIEnv*, jobject, jlong jhandle, jboolean jenable_thread_tracking) {
6069   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6070   opt->enable_thread_tracking = jenable_thread_tracking == JNI_TRUE;
6071 }
6072
6073 /*
6074  * Class:     org_rocksdb_DBOptions
6075  * Method:    enableThreadTracking
6076  * Signature: (J)Z
6077  */
6078 jboolean Java_org_rocksdb_DBOptions_enableThreadTracking(
6079     JNIEnv*, jobject, jlong jhandle) {
6080   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6081   return static_cast<jboolean>(opt->enable_thread_tracking);
6082 }
6083
6084 /*
6085  * Class:     org_rocksdb_DBOptions
6086  * Method:    setAllowConcurrentMemtableWrite
6087  * Signature: (JZ)V
6088  */
6089 void Java_org_rocksdb_DBOptions_setAllowConcurrentMemtableWrite(
6090     JNIEnv*, jobject, jlong jhandle, jboolean allow) {
6091   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6092       ->allow_concurrent_memtable_write = static_cast<bool>(allow);
6093 }
6094
6095 /*
6096  * Class:     org_rocksdb_DBOptions
6097  * Method:    allowConcurrentMemtableWrite
6098  * Signature: (J)Z
6099  */
6100 jboolean Java_org_rocksdb_DBOptions_allowConcurrentMemtableWrite(
6101     JNIEnv*, jobject, jlong jhandle) {
6102   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6103       ->allow_concurrent_memtable_write;
6104 }
6105
6106 /*
6107  * Class:     org_rocksdb_DBOptions
6108  * Method:    setEnableWriteThreadAdaptiveYield
6109  * Signature: (JZ)V
6110  */
6111 void Java_org_rocksdb_DBOptions_setEnableWriteThreadAdaptiveYield(
6112     JNIEnv*, jobject, jlong jhandle, jboolean yield) {
6113   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6114       ->enable_write_thread_adaptive_yield = static_cast<bool>(yield);
6115 }
6116
6117 /*
6118  * Class:     org_rocksdb_DBOptions
6119  * Method:    enableWriteThreadAdaptiveYield
6120  * Signature: (J)Z
6121  */
6122 jboolean Java_org_rocksdb_DBOptions_enableWriteThreadAdaptiveYield(
6123     JNIEnv*, jobject, jlong jhandle) {
6124   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6125       ->enable_write_thread_adaptive_yield;
6126 }
6127
6128 /*
6129  * Class:     org_rocksdb_DBOptions
6130  * Method:    setWriteThreadMaxYieldUsec
6131  * Signature: (JJ)V
6132  */
6133 void Java_org_rocksdb_DBOptions_setWriteThreadMaxYieldUsec(
6134     JNIEnv*, jobject, jlong jhandle, jlong max) {
6135   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6136       ->write_thread_max_yield_usec = static_cast<int64_t>(max);
6137 }
6138
6139 /*
6140  * Class:     org_rocksdb_DBOptions
6141  * Method:    writeThreadMaxYieldUsec
6142  * Signature: (J)J
6143  */
6144 jlong Java_org_rocksdb_DBOptions_writeThreadMaxYieldUsec(
6145     JNIEnv*, jobject, jlong jhandle) {
6146   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6147       ->write_thread_max_yield_usec;
6148 }
6149
6150 /*
6151  * Class:     org_rocksdb_DBOptions
6152  * Method:    setWriteThreadSlowYieldUsec
6153  * Signature: (JJ)V
6154  */
6155 void Java_org_rocksdb_DBOptions_setWriteThreadSlowYieldUsec(
6156     JNIEnv*, jobject, jlong jhandle, jlong slow) {
6157   reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6158       ->write_thread_slow_yield_usec = static_cast<int64_t>(slow);
6159 }
6160
6161 /*
6162  * Class:     org_rocksdb_DBOptions
6163  * Method:    writeThreadSlowYieldUsec
6164  * Signature: (J)J
6165  */
6166 jlong Java_org_rocksdb_DBOptions_writeThreadSlowYieldUsec(
6167     JNIEnv*, jobject, jlong jhandle) {
6168   return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6169       ->write_thread_slow_yield_usec;
6170 }
6171
6172 /*
6173  * Class:     org_rocksdb_DBOptions
6174  * Method:    setSkipStatsUpdateOnDbOpen
6175  * Signature: (JZ)V
6176  */
6177 void Java_org_rocksdb_DBOptions_setSkipStatsUpdateOnDbOpen(
6178     JNIEnv*, jobject, jlong jhandle, jboolean jskip_stats_update_on_db_open) {
6179   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6180   opt->skip_stats_update_on_db_open =
6181       static_cast<bool>(jskip_stats_update_on_db_open);
6182 }
6183
6184 /*
6185  * Class:     org_rocksdb_DBOptions
6186  * Method:    skipStatsUpdateOnDbOpen
6187  * Signature: (J)Z
6188  */
6189 jboolean Java_org_rocksdb_DBOptions_skipStatsUpdateOnDbOpen(
6190     JNIEnv*, jobject, jlong jhandle) {
6191   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6192   return static_cast<jboolean>(opt->skip_stats_update_on_db_open);
6193 }
6194
6195 /*
6196  * Class:     org_rocksdb_DBOptions
6197  * Method:    setSkipCheckingSstFileSizesOnDbOpen
6198  * Signature: (JZ)V
6199  */
6200 void Java_org_rocksdb_DBOptions_setSkipCheckingSstFileSizesOnDbOpen(
6201     JNIEnv*, jobject, jlong jhandle,
6202     jboolean jskip_checking_sst_file_sizes_on_db_open) {
6203   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6204   opt->skip_checking_sst_file_sizes_on_db_open =
6205       static_cast<bool>(jskip_checking_sst_file_sizes_on_db_open);
6206 }
6207
6208 /*
6209  * Class:     org_rocksdb_DBOptions
6210  * Method:    skipCheckingSstFileSizesOnDbOpen
6211  * Signature: (J)Z
6212  */
6213 jboolean Java_org_rocksdb_DBOptions_skipCheckingSstFileSizesOnDbOpen(
6214     JNIEnv*, jobject, jlong jhandle) {
6215   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6216   return static_cast<jboolean>(opt->skip_checking_sst_file_sizes_on_db_open);
6217 }
6218
6219 /*
6220  * Class:     org_rocksdb_DBOptions
6221  * Method:    setWalRecoveryMode
6222  * Signature: (JB)V
6223  */
6224 void Java_org_rocksdb_DBOptions_setWalRecoveryMode(
6225     JNIEnv*, jobject, jlong jhandle, jbyte jwal_recovery_mode_value) {
6226   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6227   opt->wal_recovery_mode =
6228       ROCKSDB_NAMESPACE::WALRecoveryModeJni::toCppWALRecoveryMode(
6229           jwal_recovery_mode_value);
6230 }
6231
6232 /*
6233  * Class:     org_rocksdb_DBOptions
6234  * Method:    walRecoveryMode
6235  * Signature: (J)B
6236  */
6237 jbyte Java_org_rocksdb_DBOptions_walRecoveryMode(
6238     JNIEnv*, jobject, jlong jhandle) {
6239   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6240   return ROCKSDB_NAMESPACE::WALRecoveryModeJni::toJavaWALRecoveryMode(
6241       opt->wal_recovery_mode);
6242 }
6243
6244 /*
6245  * Class:     org_rocksdb_DBOptions
6246  * Method:    setAllow2pc
6247  * Signature: (JZ)V
6248  */
6249 void Java_org_rocksdb_DBOptions_setAllow2pc(
6250     JNIEnv*, jobject, jlong jhandle, jboolean jallow_2pc) {
6251   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6252   opt->allow_2pc = static_cast<bool>(jallow_2pc);
6253 }
6254
6255 /*
6256  * Class:     org_rocksdb_DBOptions
6257  * Method:    allow2pc
6258  * Signature: (J)Z
6259  */
6260 jboolean Java_org_rocksdb_DBOptions_allow2pc(
6261     JNIEnv*, jobject, jlong jhandle) {
6262   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6263   return static_cast<jboolean>(opt->allow_2pc);
6264 }
6265
6266 /*
6267  * Class:     org_rocksdb_DBOptions
6268  * Method:    setRowCache
6269  * Signature: (JJ)V
6270  */
6271 void Java_org_rocksdb_DBOptions_setRowCache(
6272     JNIEnv*, jobject, jlong jhandle, jlong jrow_cache_handle) {
6273   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6274   auto* row_cache =
6275       reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::Cache>*>(
6276           jrow_cache_handle);
6277   opt->row_cache = *row_cache;
6278 }
6279
6280 /*
6281  * Class:     org_rocksdb_DBOptions
6282  * Method:    setWalFilter
6283  * Signature: (JJ)V
6284  */
6285 void Java_org_rocksdb_DBOptions_setWalFilter(
6286     JNIEnv*, jobject, jlong jhandle, jlong jwal_filter_handle) {
6287   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6288   auto* wal_filter = reinterpret_cast<ROCKSDB_NAMESPACE::WalFilterJniCallback*>(
6289       jwal_filter_handle);
6290   opt->wal_filter = wal_filter;
6291 }
6292
6293 /*
6294  * Class:     org_rocksdb_DBOptions
6295  * Method:    setFailIfOptionsFileError
6296  * Signature: (JZ)V
6297  */
6298 void Java_org_rocksdb_DBOptions_setFailIfOptionsFileError(
6299     JNIEnv*, jobject, jlong jhandle, jboolean jfail_if_options_file_error) {
6300   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6301   opt->fail_if_options_file_error =
6302       static_cast<bool>(jfail_if_options_file_error);
6303 }
6304
6305 /*
6306  * Class:     org_rocksdb_DBOptions
6307  * Method:    failIfOptionsFileError
6308  * Signature: (J)Z
6309  */
6310 jboolean Java_org_rocksdb_DBOptions_failIfOptionsFileError(
6311     JNIEnv*, jobject, jlong jhandle) {
6312   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6313   return static_cast<jboolean>(opt->fail_if_options_file_error);
6314 }
6315
6316 /*
6317  * Class:     org_rocksdb_DBOptions
6318  * Method:    setDumpMallocStats
6319  * Signature: (JZ)V
6320  */
6321 void Java_org_rocksdb_DBOptions_setDumpMallocStats(
6322     JNIEnv*, jobject, jlong jhandle, jboolean jdump_malloc_stats) {
6323   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6324   opt->dump_malloc_stats = static_cast<bool>(jdump_malloc_stats);
6325 }
6326
6327 /*
6328  * Class:     org_rocksdb_DBOptions
6329  * Method:    dumpMallocStats
6330  * Signature: (J)Z
6331  */
6332 jboolean Java_org_rocksdb_DBOptions_dumpMallocStats(
6333     JNIEnv*, jobject, jlong jhandle) {
6334   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6335   return static_cast<jboolean>(opt->dump_malloc_stats);
6336 }
6337
6338 /*
6339  * Class:     org_rocksdb_DBOptions
6340  * Method:    setAvoidFlushDuringRecovery
6341  * Signature: (JZ)V
6342  */
6343 void Java_org_rocksdb_DBOptions_setAvoidFlushDuringRecovery(
6344     JNIEnv*, jobject, jlong jhandle, jboolean javoid_flush_during_recovery) {
6345   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6346   opt->avoid_flush_during_recovery =
6347       static_cast<bool>(javoid_flush_during_recovery);
6348 }
6349
6350 /*
6351  * Class:     org_rocksdb_DBOptions
6352  * Method:    avoidFlushDuringRecovery
6353  * Signature: (J)Z
6354  */
6355 jboolean Java_org_rocksdb_DBOptions_avoidFlushDuringRecovery(
6356     JNIEnv*, jobject, jlong jhandle) {
6357   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6358   return static_cast<jboolean>(opt->avoid_flush_during_recovery);
6359 }
6360
6361 /*
6362  * Class:     org_rocksdb_DBOptions
6363  * Method:    setAllowIngestBehind
6364  * Signature: (JZ)V
6365  */
6366 void Java_org_rocksdb_DBOptions_setAllowIngestBehind(
6367     JNIEnv*, jobject, jlong jhandle, jboolean jallow_ingest_behind) {
6368   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6369   opt->allow_ingest_behind = jallow_ingest_behind == JNI_TRUE;
6370 }
6371
6372 /*
6373  * Class:     org_rocksdb_DBOptions
6374  * Method:    allowIngestBehind
6375  * Signature: (J)Z
6376  */
6377 jboolean Java_org_rocksdb_DBOptions_allowIngestBehind(
6378     JNIEnv*, jobject, jlong jhandle) {
6379   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6380   return static_cast<jboolean>(opt->allow_ingest_behind);
6381 }
6382
6383 /*
6384  * Class:     org_rocksdb_DBOptions
6385  * Method:    setPreserveDeletes
6386  * Signature: (JZ)V
6387  */
6388 void Java_org_rocksdb_DBOptions_setPreserveDeletes(
6389     JNIEnv*, jobject, jlong jhandle, jboolean jpreserve_deletes) {
6390   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6391   opt->preserve_deletes = jpreserve_deletes == JNI_TRUE;
6392 }
6393
6394 /*
6395  * Class:     org_rocksdb_DBOptions
6396  * Method:    preserveDeletes
6397  * Signature: (J)Z
6398  */
6399 jboolean Java_org_rocksdb_DBOptions_preserveDeletes(
6400     JNIEnv*, jobject, jlong jhandle) {
6401   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6402   return static_cast<jboolean>(opt->preserve_deletes);
6403 }
6404
6405 /*
6406  * Class:     org_rocksdb_DBOptions
6407  * Method:    setTwoWriteQueues
6408  * Signature: (JZ)V
6409  */
6410 void Java_org_rocksdb_DBOptions_setTwoWriteQueues(
6411     JNIEnv*, jobject, jlong jhandle, jboolean jtwo_write_queues) {
6412   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6413   opt->two_write_queues = jtwo_write_queues == JNI_TRUE;
6414 }
6415
6416 /*
6417  * Class:     org_rocksdb_DBOptions
6418  * Method:    twoWriteQueues
6419  * Signature: (J)Z
6420  */
6421 jboolean Java_org_rocksdb_DBOptions_twoWriteQueues(
6422     JNIEnv*, jobject, jlong jhandle) {
6423   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6424   return static_cast<jboolean>(opt->two_write_queues);
6425 }
6426
6427 /*
6428  * Class:     org_rocksdb_DBOptions
6429  * Method:    setManualWalFlush
6430  * Signature: (JZ)V
6431  */
6432 void Java_org_rocksdb_DBOptions_setManualWalFlush(
6433     JNIEnv*, jobject, jlong jhandle, jboolean jmanual_wal_flush) {
6434   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6435   opt->manual_wal_flush = jmanual_wal_flush == JNI_TRUE;
6436 }
6437
6438 /*
6439  * Class:     org_rocksdb_DBOptions
6440  * Method:    manualWalFlush
6441  * Signature: (J)Z
6442  */
6443 jboolean Java_org_rocksdb_DBOptions_manualWalFlush(
6444     JNIEnv*, jobject, jlong jhandle) {
6445   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6446   return static_cast<jboolean>(opt->manual_wal_flush);
6447 }
6448
6449 /*
6450  * Class:     org_rocksdb_DBOptions
6451  * Method:    setAtomicFlush
6452  * Signature: (JZ)V
6453  */
6454 void Java_org_rocksdb_DBOptions_setAtomicFlush(
6455     JNIEnv*, jobject, jlong jhandle, jboolean jatomic_flush) {
6456   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6457   opt->atomic_flush = jatomic_flush == JNI_TRUE;
6458 }
6459
6460 /*
6461  * Class:     org_rocksdb_DBOptions
6462  * Method:    atomicFlush
6463  * Signature: (J)Z
6464  */
6465 jboolean Java_org_rocksdb_DBOptions_atomicFlush(
6466     JNIEnv *, jobject, jlong jhandle) {
6467   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6468   return static_cast<jboolean>(opt->atomic_flush);
6469 }
6470
6471 /*
6472  * Class:     org_rocksdb_DBOptions
6473  * Method:    setAvoidFlushDuringShutdown
6474  * Signature: (JZ)V
6475  */
6476 void Java_org_rocksdb_DBOptions_setAvoidFlushDuringShutdown(
6477     JNIEnv*, jobject, jlong jhandle, jboolean javoid_flush_during_shutdown) {
6478   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6479   opt->avoid_flush_during_shutdown =
6480       static_cast<bool>(javoid_flush_during_shutdown);
6481 }
6482
6483 /*
6484  * Class:     org_rocksdb_DBOptions
6485  * Method:    avoidFlushDuringShutdown
6486  * Signature: (J)Z
6487  */
6488 jboolean Java_org_rocksdb_DBOptions_avoidFlushDuringShutdown(
6489     JNIEnv*, jobject, jlong jhandle) {
6490   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6491   return static_cast<jboolean>(opt->avoid_flush_during_shutdown);
6492 }
6493
6494 //////////////////////////////////////////////////////////////////////////////
6495 // ROCKSDB_NAMESPACE::WriteOptions
6496
6497 /*
6498  * Class:     org_rocksdb_WriteOptions
6499  * Method:    newWriteOptions
6500  * Signature: ()J
6501  */
6502 jlong Java_org_rocksdb_WriteOptions_newWriteOptions(
6503     JNIEnv*, jclass) {
6504   auto* op = new ROCKSDB_NAMESPACE::WriteOptions();
6505   return reinterpret_cast<jlong>(op);
6506 }
6507
6508 /*
6509  * Class:     org_rocksdb_WriteOptions
6510  * Method:    copyWriteOptions
6511  * Signature: (J)J
6512  */
6513 jlong Java_org_rocksdb_WriteOptions_copyWriteOptions(
6514     JNIEnv*, jclass, jlong jhandle) {
6515   auto new_opt = new ROCKSDB_NAMESPACE::WriteOptions(
6516       *(reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)));
6517   return reinterpret_cast<jlong>(new_opt);
6518 }
6519
6520 /*
6521  * Class:     org_rocksdb_WriteOptions
6522  * Method:    disposeInternal
6523  * Signature: ()V
6524  */
6525 void Java_org_rocksdb_WriteOptions_disposeInternal(
6526     JNIEnv*, jobject, jlong jhandle) {
6527   auto* write_options =
6528       reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle);
6529   assert(write_options != nullptr);
6530   delete write_options;
6531 }
6532
6533 /*
6534  * Class:     org_rocksdb_WriteOptions
6535  * Method:    setSync
6536  * Signature: (JZ)V
6537  */
6538 void Java_org_rocksdb_WriteOptions_setSync(
6539     JNIEnv*, jobject, jlong jhandle, jboolean jflag) {
6540   reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->sync = jflag;
6541 }
6542
6543 /*
6544  * Class:     org_rocksdb_WriteOptions
6545  * Method:    sync
6546  * Signature: (J)Z
6547  */
6548 jboolean Java_org_rocksdb_WriteOptions_sync(
6549     JNIEnv*, jobject, jlong jhandle) {
6550   return reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->sync;
6551 }
6552
6553 /*
6554  * Class:     org_rocksdb_WriteOptions
6555  * Method:    setDisableWAL
6556  * Signature: (JZ)V
6557  */
6558 void Java_org_rocksdb_WriteOptions_setDisableWAL(
6559     JNIEnv*, jobject, jlong jhandle, jboolean jflag) {
6560   reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->disableWAL =
6561       jflag;
6562 }
6563
6564 /*
6565  * Class:     org_rocksdb_WriteOptions
6566  * Method:    disableWAL
6567  * Signature: (J)Z
6568  */
6569 jboolean Java_org_rocksdb_WriteOptions_disableWAL(
6570     JNIEnv*, jobject, jlong jhandle) {
6571   return reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)
6572       ->disableWAL;
6573 }
6574
6575 /*
6576  * Class:     org_rocksdb_WriteOptions
6577  * Method:    setIgnoreMissingColumnFamilies
6578  * Signature: (JZ)V
6579  */
6580 void Java_org_rocksdb_WriteOptions_setIgnoreMissingColumnFamilies(
6581     JNIEnv*, jobject, jlong jhandle,
6582     jboolean jignore_missing_column_families) {
6583   reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)
6584       ->ignore_missing_column_families =
6585       static_cast<bool>(jignore_missing_column_families);
6586 }
6587
6588 /*
6589  * Class:     org_rocksdb_WriteOptions
6590  * Method:    ignoreMissingColumnFamilies
6591  * Signature: (J)Z
6592  */
6593 jboolean Java_org_rocksdb_WriteOptions_ignoreMissingColumnFamilies(
6594     JNIEnv*, jobject, jlong jhandle) {
6595   return reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)
6596       ->ignore_missing_column_families;
6597 }
6598
6599 /*
6600  * Class:     org_rocksdb_WriteOptions
6601  * Method:    setNoSlowdown
6602  * Signature: (JZ)V
6603  */
6604 void Java_org_rocksdb_WriteOptions_setNoSlowdown(
6605     JNIEnv*, jobject, jlong jhandle, jboolean jno_slowdown) {
6606   reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->no_slowdown =
6607       static_cast<bool>(jno_slowdown);
6608 }
6609
6610 /*
6611  * Class:     org_rocksdb_WriteOptions
6612  * Method:    noSlowdown
6613  * Signature: (J)Z
6614  */
6615 jboolean Java_org_rocksdb_WriteOptions_noSlowdown(
6616     JNIEnv*, jobject, jlong jhandle) {
6617   return reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)
6618       ->no_slowdown;
6619 }
6620
6621 /*
6622  * Class:     org_rocksdb_WriteOptions
6623  * Method:    setLowPri
6624  * Signature: (JZ)V
6625  */
6626 void Java_org_rocksdb_WriteOptions_setLowPri(
6627     JNIEnv*, jobject, jlong jhandle, jboolean jlow_pri) {
6628   reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->low_pri =
6629       static_cast<bool>(jlow_pri);
6630 }
6631
6632 /*
6633  * Class:     org_rocksdb_WriteOptions
6634  * Method:    lowPri
6635  * Signature: (J)Z
6636  */
6637 jboolean Java_org_rocksdb_WriteOptions_lowPri(
6638     JNIEnv*, jobject, jlong jhandle) {
6639   return reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->low_pri;
6640 }
6641
6642 /////////////////////////////////////////////////////////////////////
6643 // ROCKSDB_NAMESPACE::ReadOptions
6644
6645 /*
6646  * Class:     org_rocksdb_ReadOptions
6647  * Method:    newReadOptions
6648  * Signature: ()J
6649  */
6650 jlong Java_org_rocksdb_ReadOptions_newReadOptions__(
6651     JNIEnv*, jclass) {
6652   auto* read_options = new ROCKSDB_NAMESPACE::ReadOptions();
6653   return reinterpret_cast<jlong>(read_options);
6654 }
6655
6656 /*
6657  * Class:     org_rocksdb_ReadOptions
6658  * Method:    newReadOptions
6659  * Signature: (ZZ)J
6660  */
6661 jlong Java_org_rocksdb_ReadOptions_newReadOptions__ZZ(
6662     JNIEnv*, jclass, jboolean jverify_checksums, jboolean jfill_cache) {
6663   auto* read_options = new ROCKSDB_NAMESPACE::ReadOptions(
6664       static_cast<bool>(jverify_checksums), static_cast<bool>(jfill_cache));
6665   return reinterpret_cast<jlong>(read_options);
6666 }
6667
6668 /*
6669  * Class:     org_rocksdb_ReadOptions
6670  * Method:    copyReadOptions
6671  * Signature: (J)J
6672  */
6673 jlong Java_org_rocksdb_ReadOptions_copyReadOptions(
6674     JNIEnv*, jclass, jlong jhandle) {
6675   auto new_opt = new ROCKSDB_NAMESPACE::ReadOptions(
6676       *(reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)));
6677   return reinterpret_cast<jlong>(new_opt);
6678 }
6679
6680 /*
6681  * Class:     org_rocksdb_ReadOptions
6682  * Method:    disposeInternal
6683  * Signature: (J)V
6684  */
6685 void Java_org_rocksdb_ReadOptions_disposeInternal(
6686     JNIEnv*, jobject, jlong jhandle) {
6687   auto* read_options =
6688       reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
6689   assert(read_options != nullptr);
6690   delete read_options;
6691 }
6692
6693 /*
6694  * Class:     org_rocksdb_ReadOptions
6695  * Method:    setVerifyChecksums
6696  * Signature: (JZ)V
6697  */
6698 void Java_org_rocksdb_ReadOptions_setVerifyChecksums(
6699     JNIEnv*, jobject, jlong jhandle, jboolean jverify_checksums) {
6700   reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->verify_checksums =
6701       static_cast<bool>(jverify_checksums);
6702 }
6703
6704 /*
6705  * Class:     org_rocksdb_ReadOptions
6706  * Method:    verifyChecksums
6707  * Signature: (J)Z
6708  */
6709 jboolean Java_org_rocksdb_ReadOptions_verifyChecksums(
6710     JNIEnv*, jobject, jlong jhandle) {
6711   return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
6712       ->verify_checksums;
6713 }
6714
6715 /*
6716  * Class:     org_rocksdb_ReadOptions
6717  * Method:    setFillCache
6718  * Signature: (JZ)V
6719  */
6720 void Java_org_rocksdb_ReadOptions_setFillCache(
6721     JNIEnv*, jobject, jlong jhandle, jboolean jfill_cache) {
6722   reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->fill_cache =
6723       static_cast<bool>(jfill_cache);
6724 }
6725
6726 /*
6727  * Class:     org_rocksdb_ReadOptions
6728  * Method:    fillCache
6729  * Signature: (J)Z
6730  */
6731 jboolean Java_org_rocksdb_ReadOptions_fillCache(
6732     JNIEnv*, jobject, jlong jhandle) {
6733   return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->fill_cache;
6734 }
6735
6736 /*
6737  * Class:     org_rocksdb_ReadOptions
6738  * Method:    setTailing
6739  * Signature: (JZ)V
6740  */
6741 void Java_org_rocksdb_ReadOptions_setTailing(
6742     JNIEnv*, jobject, jlong jhandle, jboolean jtailing) {
6743   reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->tailing =
6744       static_cast<bool>(jtailing);
6745 }
6746
6747 /*
6748  * Class:     org_rocksdb_ReadOptions
6749  * Method:    tailing
6750  * Signature: (J)Z
6751  */
6752 jboolean Java_org_rocksdb_ReadOptions_tailing(
6753     JNIEnv*, jobject, jlong jhandle) {
6754   return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->tailing;
6755 }
6756
6757 /*
6758  * Class:     org_rocksdb_ReadOptions
6759  * Method:    managed
6760  * Signature: (J)Z
6761  */
6762 jboolean Java_org_rocksdb_ReadOptions_managed(
6763     JNIEnv*, jobject, jlong jhandle) {
6764   return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->managed;
6765 }
6766
6767 /*
6768  * Class:     org_rocksdb_ReadOptions
6769  * Method:    setManaged
6770  * Signature: (JZ)V
6771  */
6772 void Java_org_rocksdb_ReadOptions_setManaged(
6773     JNIEnv*, jobject, jlong jhandle, jboolean jmanaged) {
6774   reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->managed =
6775       static_cast<bool>(jmanaged);
6776 }
6777
6778 /*
6779  * Class:     org_rocksdb_ReadOptions
6780  * Method:    totalOrderSeek
6781  * Signature: (J)Z
6782  */
6783 jboolean Java_org_rocksdb_ReadOptions_totalOrderSeek(
6784     JNIEnv*, jobject, jlong jhandle) {
6785   return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
6786       ->total_order_seek;
6787 }
6788
6789 /*
6790  * Class:     org_rocksdb_ReadOptions
6791  * Method:    setTotalOrderSeek
6792  * Signature: (JZ)V
6793  */
6794 void Java_org_rocksdb_ReadOptions_setTotalOrderSeek(
6795     JNIEnv*, jobject, jlong jhandle, jboolean jtotal_order_seek) {
6796   reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->total_order_seek =
6797       static_cast<bool>(jtotal_order_seek);
6798 }
6799
6800 /*
6801  * Class:     org_rocksdb_ReadOptions
6802  * Method:    prefixSameAsStart
6803  * Signature: (J)Z
6804  */
6805 jboolean Java_org_rocksdb_ReadOptions_prefixSameAsStart(
6806     JNIEnv*, jobject, jlong jhandle) {
6807   return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
6808       ->prefix_same_as_start;
6809 }
6810
6811 /*
6812  * Class:     org_rocksdb_ReadOptions
6813  * Method:    setPrefixSameAsStart
6814  * Signature: (JZ)V
6815  */
6816 void Java_org_rocksdb_ReadOptions_setPrefixSameAsStart(
6817     JNIEnv*, jobject, jlong jhandle, jboolean jprefix_same_as_start) {
6818   reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
6819       ->prefix_same_as_start = static_cast<bool>(jprefix_same_as_start);
6820 }
6821
6822 /*
6823  * Class:     org_rocksdb_ReadOptions
6824  * Method:    pinData
6825  * Signature: (J)Z
6826  */
6827 jboolean Java_org_rocksdb_ReadOptions_pinData(
6828     JNIEnv*, jobject, jlong jhandle) {
6829   return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->pin_data;
6830 }
6831
6832 /*
6833  * Class:     org_rocksdb_ReadOptions
6834  * Method:    setPinData
6835  * Signature: (JZ)V
6836  */
6837 void Java_org_rocksdb_ReadOptions_setPinData(
6838     JNIEnv*, jobject, jlong jhandle, jboolean jpin_data) {
6839   reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->pin_data =
6840       static_cast<bool>(jpin_data);
6841 }
6842
6843 /*
6844  * Class:     org_rocksdb_ReadOptions
6845  * Method:    backgroundPurgeOnIteratorCleanup
6846  * Signature: (J)Z
6847  */
6848 jboolean Java_org_rocksdb_ReadOptions_backgroundPurgeOnIteratorCleanup(
6849     JNIEnv*, jobject, jlong jhandle) {
6850   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
6851   return static_cast<jboolean>(opt->background_purge_on_iterator_cleanup);
6852 }
6853
6854 /*
6855  * Class:     org_rocksdb_ReadOptions
6856  * Method:    setBackgroundPurgeOnIteratorCleanup
6857  * Signature: (JZ)V
6858  */
6859 void Java_org_rocksdb_ReadOptions_setBackgroundPurgeOnIteratorCleanup(
6860     JNIEnv*, jobject, jlong jhandle,
6861     jboolean jbackground_purge_on_iterator_cleanup) {
6862   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
6863   opt->background_purge_on_iterator_cleanup =
6864       static_cast<bool>(jbackground_purge_on_iterator_cleanup);
6865 }
6866
6867 /*
6868  * Class:     org_rocksdb_ReadOptions
6869  * Method:    readaheadSize
6870  * Signature: (J)J
6871  */
6872 jlong Java_org_rocksdb_ReadOptions_readaheadSize(
6873     JNIEnv*, jobject, jlong jhandle) {
6874   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
6875   return static_cast<jlong>(opt->readahead_size);
6876 }
6877
6878 /*
6879  * Class:     org_rocksdb_ReadOptions
6880  * Method:    setReadaheadSize
6881  * Signature: (JJ)V
6882  */
6883 void Java_org_rocksdb_ReadOptions_setReadaheadSize(
6884     JNIEnv*, jobject, jlong jhandle, jlong jreadahead_size) {
6885   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
6886   opt->readahead_size = static_cast<size_t>(jreadahead_size);
6887 }
6888
6889 /*
6890  * Class:     org_rocksdb_ReadOptions
6891  * Method:    maxSkippableInternalKeys
6892  * Signature: (J)J
6893  */
6894 jlong Java_org_rocksdb_ReadOptions_maxSkippableInternalKeys(
6895     JNIEnv*, jobject, jlong jhandle) {
6896   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
6897   return static_cast<jlong>(opt->max_skippable_internal_keys);
6898 }
6899
6900 /*
6901  * Class:     org_rocksdb_ReadOptions
6902  * Method:    setMaxSkippableInternalKeys
6903  * Signature: (JJ)V
6904  */
6905 void Java_org_rocksdb_ReadOptions_setMaxSkippableInternalKeys(
6906     JNIEnv*, jobject, jlong jhandle, jlong jmax_skippable_internal_keys) {
6907   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
6908   opt->max_skippable_internal_keys =
6909       static_cast<uint64_t>(jmax_skippable_internal_keys);
6910 }
6911
6912 /*
6913  * Class:     org_rocksdb_ReadOptions
6914  * Method:    ignoreRangeDeletions
6915  * Signature: (J)Z
6916  */
6917 jboolean Java_org_rocksdb_ReadOptions_ignoreRangeDeletions(
6918     JNIEnv*, jobject, jlong jhandle) {
6919   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
6920   return static_cast<jboolean>(opt->ignore_range_deletions);
6921 }
6922
6923 /*
6924  * Class:     org_rocksdb_ReadOptions
6925  * Method:    setIgnoreRangeDeletions
6926  * Signature: (JZ)V
6927  */
6928 void Java_org_rocksdb_ReadOptions_setIgnoreRangeDeletions(
6929     JNIEnv*, jobject, jlong jhandle, jboolean jignore_range_deletions) {
6930   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
6931   opt->ignore_range_deletions = static_cast<bool>(jignore_range_deletions);
6932 }
6933
6934 /*
6935  * Class:     org_rocksdb_ReadOptions
6936  * Method:    setSnapshot
6937  * Signature: (JJ)V
6938  */
6939 void Java_org_rocksdb_ReadOptions_setSnapshot(
6940     JNIEnv*, jobject, jlong jhandle, jlong jsnapshot) {
6941   reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->snapshot =
6942       reinterpret_cast<ROCKSDB_NAMESPACE::Snapshot*>(jsnapshot);
6943 }
6944
6945 /*
6946  * Class:     org_rocksdb_ReadOptions
6947  * Method:    snapshot
6948  * Signature: (J)J
6949  */
6950 jlong Java_org_rocksdb_ReadOptions_snapshot(
6951     JNIEnv*, jobject, jlong jhandle) {
6952   auto& snapshot =
6953       reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->snapshot;
6954   return reinterpret_cast<jlong>(snapshot);
6955 }
6956
6957 /*
6958  * Class:     org_rocksdb_ReadOptions
6959  * Method:    readTier
6960  * Signature: (J)B
6961  */
6962 jbyte Java_org_rocksdb_ReadOptions_readTier(
6963     JNIEnv*, jobject, jlong jhandle) {
6964   return static_cast<jbyte>(
6965       reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->read_tier);
6966 }
6967
6968 /*
6969  * Class:     org_rocksdb_ReadOptions
6970  * Method:    setReadTier
6971  * Signature: (JB)V
6972  */
6973 void Java_org_rocksdb_ReadOptions_setReadTier(
6974     JNIEnv*, jobject, jlong jhandle, jbyte jread_tier) {
6975   reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->read_tier =
6976       static_cast<ROCKSDB_NAMESPACE::ReadTier>(jread_tier);
6977 }
6978
6979 /*
6980  * Class:     org_rocksdb_ReadOptions
6981  * Method:    setIterateUpperBound
6982  * Signature: (JJ)I
6983  */
6984 void Java_org_rocksdb_ReadOptions_setIterateUpperBound(
6985     JNIEnv*, jobject, jlong jhandle, jlong jupper_bound_slice_handle) {
6986   reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
6987       ->iterate_upper_bound =
6988       reinterpret_cast<ROCKSDB_NAMESPACE::Slice*>(jupper_bound_slice_handle);
6989 }
6990
6991 /*
6992  * Class:     org_rocksdb_ReadOptions
6993  * Method:    iterateUpperBound
6994  * Signature: (J)J
6995  */
6996 jlong Java_org_rocksdb_ReadOptions_iterateUpperBound(
6997     JNIEnv*, jobject, jlong jhandle) {
6998   auto& upper_bound_slice_handle =
6999       reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
7000           ->iterate_upper_bound;
7001   return reinterpret_cast<jlong>(upper_bound_slice_handle);
7002 }
7003
7004 /*
7005  * Class:     org_rocksdb_ReadOptions
7006  * Method:    setIterateLowerBound
7007  * Signature: (JJ)I
7008  */
7009 void Java_org_rocksdb_ReadOptions_setIterateLowerBound(
7010     JNIEnv*, jobject, jlong jhandle, jlong jlower_bound_slice_handle) {
7011   reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
7012       ->iterate_lower_bound =
7013       reinterpret_cast<ROCKSDB_NAMESPACE::Slice*>(jlower_bound_slice_handle);
7014 }
7015
7016 /*
7017  * Class:     org_rocksdb_ReadOptions
7018  * Method:    iterateLowerBound
7019  * Signature: (J)J
7020  */
7021 jlong Java_org_rocksdb_ReadOptions_iterateLowerBound(
7022     JNIEnv*, jobject, jlong jhandle) {
7023   auto& lower_bound_slice_handle =
7024       reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
7025           ->iterate_lower_bound;
7026   return reinterpret_cast<jlong>(lower_bound_slice_handle);
7027 }
7028
7029 /*
7030  * Class:     org_rocksdb_ReadOptions
7031  * Method:    setTableFilter
7032  * Signature: (JJ)V
7033  */
7034 void Java_org_rocksdb_ReadOptions_setTableFilter(
7035     JNIEnv*, jobject, jlong jhandle, jlong jjni_table_filter_handle) {
7036   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7037   auto* jni_table_filter =
7038       reinterpret_cast<ROCKSDB_NAMESPACE::TableFilterJniCallback*>(
7039           jjni_table_filter_handle);
7040   opt->table_filter = jni_table_filter->GetTableFilterFunction();
7041 }
7042
7043 /*
7044  * Class:     org_rocksdb_ReadOptions
7045  * Method:    setIterStartSeqnum
7046  * Signature: (JJ)V
7047  */
7048 void Java_org_rocksdb_ReadOptions_setIterStartSeqnum(
7049     JNIEnv*, jobject, jlong jhandle, jlong jiter_start_seqnum) {
7050   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7051   opt->iter_start_seqnum = static_cast<uint64_t>(jiter_start_seqnum);
7052 }
7053
7054 /*
7055  * Class:     org_rocksdb_ReadOptions
7056  * Method:    iterStartSeqnum
7057  * Signature: (J)J
7058  */
7059 jlong Java_org_rocksdb_ReadOptions_iterStartSeqnum(
7060     JNIEnv*, jobject, jlong jhandle) {
7061   auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7062   return static_cast<jlong>(opt->iter_start_seqnum);
7063 }
7064
7065 /////////////////////////////////////////////////////////////////////
7066 // ROCKSDB_NAMESPACE::ComparatorOptions
7067
7068 /*
7069  * Class:     org_rocksdb_ComparatorOptions
7070  * Method:    newComparatorOptions
7071  * Signature: ()J
7072  */
7073 jlong Java_org_rocksdb_ComparatorOptions_newComparatorOptions(
7074     JNIEnv*, jclass) {
7075   auto* comparator_opt = new ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions();
7076   return reinterpret_cast<jlong>(comparator_opt);
7077 }
7078
7079 /*
7080  * Class:     org_rocksdb_ComparatorOptions
7081  * Method:    reusedSynchronisationType
7082  * Signature: (J)B
7083  */
7084 jbyte Java_org_rocksdb_ComparatorOptions_reusedSynchronisationType(
7085     JNIEnv *, jobject, jlong jhandle) {
7086   auto* comparator_opt =
7087       reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(
7088           jhandle);
7089   return ROCKSDB_NAMESPACE::ReusedSynchronisationTypeJni::
7090       toJavaReusedSynchronisationType(
7091           comparator_opt->reused_synchronisation_type);
7092 }
7093
7094 /*
7095  * Class:     org_rocksdb_ComparatorOptions
7096  * Method:    setReusedSynchronisationType
7097  * Signature: (JB)V
7098  */
7099 void Java_org_rocksdb_ComparatorOptions_setReusedSynchronisationType(
7100     JNIEnv*, jobject, jlong jhandle, jbyte jreused_synhcronisation_type) {
7101   auto* comparator_opt =
7102       reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(
7103           jhandle);
7104   comparator_opt->reused_synchronisation_type =
7105       ROCKSDB_NAMESPACE::ReusedSynchronisationTypeJni::
7106           toCppReusedSynchronisationType(jreused_synhcronisation_type);
7107 }
7108
7109 /*
7110  * Class:     org_rocksdb_ComparatorOptions
7111  * Method:    useDirectBuffer
7112  * Signature: (J)Z
7113  */
7114 jboolean Java_org_rocksdb_ComparatorOptions_useDirectBuffer(
7115     JNIEnv*, jobject, jlong jhandle) {
7116   return static_cast<jboolean>(
7117       reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(
7118           jhandle)
7119           ->direct_buffer);
7120 }
7121
7122 /*
7123  * Class:     org_rocksdb_ComparatorOptions
7124  * Method:    setUseDirectBuffer
7125  * Signature: (JZ)V
7126  */
7127 void Java_org_rocksdb_ComparatorOptions_setUseDirectBuffer(
7128     JNIEnv*, jobject, jlong jhandle, jboolean jdirect_buffer) {
7129   reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(jhandle)
7130       ->direct_buffer = jdirect_buffer == JNI_TRUE;
7131 }
7132
7133 /*
7134  * Class:     org_rocksdb_ComparatorOptions
7135  * Method:    maxReusedBufferSize
7136  * Signature: (J)I
7137  */
7138 jint Java_org_rocksdb_ComparatorOptions_maxReusedBufferSize(
7139     JNIEnv*, jobject, jlong jhandle) {
7140   return static_cast<jint>(
7141       reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(
7142           jhandle)
7143           ->max_reused_buffer_size);
7144 }
7145
7146 /*
7147  * Class:     org_rocksdb_ComparatorOptions
7148  * Method:    setMaxReusedBufferSize
7149  * Signature: (JI)V
7150  */
7151 void Java_org_rocksdb_ComparatorOptions_setMaxReusedBufferSize(
7152     JNIEnv*, jobject, jlong jhandle, jint jmax_reused_buffer_size) {
7153   reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(jhandle)
7154       ->max_reused_buffer_size = static_cast<int32_t>(jmax_reused_buffer_size);
7155 }
7156
7157 /*
7158  * Class:     org_rocksdb_ComparatorOptions
7159  * Method:    disposeInternal
7160  * Signature: (J)V
7161  */
7162 void Java_org_rocksdb_ComparatorOptions_disposeInternal(
7163     JNIEnv*, jobject, jlong jhandle) {
7164   auto* comparator_opt =
7165       reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(
7166           jhandle);
7167   assert(comparator_opt != nullptr);
7168   delete comparator_opt;
7169 }
7170
7171 /////////////////////////////////////////////////////////////////////
7172 // ROCKSDB_NAMESPACE::FlushOptions
7173
7174 /*
7175  * Class:     org_rocksdb_FlushOptions
7176  * Method:    newFlushOptions
7177  * Signature: ()J
7178  */
7179 jlong Java_org_rocksdb_FlushOptions_newFlushOptions(
7180     JNIEnv*, jclass) {
7181   auto* flush_opt = new ROCKSDB_NAMESPACE::FlushOptions();
7182   return reinterpret_cast<jlong>(flush_opt);
7183 }
7184
7185 /*
7186  * Class:     org_rocksdb_FlushOptions
7187  * Method:    setWaitForFlush
7188  * Signature: (JZ)V
7189  */
7190 void Java_org_rocksdb_FlushOptions_setWaitForFlush(
7191     JNIEnv*, jobject, jlong jhandle, jboolean jwait) {
7192   reinterpret_cast<ROCKSDB_NAMESPACE::FlushOptions*>(jhandle)->wait =
7193       static_cast<bool>(jwait);
7194 }
7195
7196 /*
7197  * Class:     org_rocksdb_FlushOptions
7198  * Method:    waitForFlush
7199  * Signature: (J)Z
7200  */
7201 jboolean Java_org_rocksdb_FlushOptions_waitForFlush(
7202     JNIEnv*, jobject, jlong jhandle) {
7203   return reinterpret_cast<ROCKSDB_NAMESPACE::FlushOptions*>(jhandle)->wait;
7204 }
7205
7206 /*
7207  * Class:     org_rocksdb_FlushOptions
7208  * Method:    setAllowWriteStall
7209  * Signature: (JZ)V
7210  */
7211 void Java_org_rocksdb_FlushOptions_setAllowWriteStall(
7212     JNIEnv*, jobject, jlong jhandle, jboolean jallow_write_stall) {
7213   auto* flush_options =
7214       reinterpret_cast<ROCKSDB_NAMESPACE::FlushOptions*>(jhandle);
7215   flush_options->allow_write_stall = jallow_write_stall == JNI_TRUE;
7216 }
7217
7218 /*
7219  * Class:     org_rocksdb_FlushOptions
7220  * Method:    allowWriteStall
7221  * Signature: (J)Z
7222  */
7223 jboolean Java_org_rocksdb_FlushOptions_allowWriteStall(
7224     JNIEnv*, jobject, jlong jhandle) {
7225   auto* flush_options =
7226       reinterpret_cast<ROCKSDB_NAMESPACE::FlushOptions*>(jhandle);
7227   return static_cast<jboolean>(flush_options->allow_write_stall);
7228 }
7229
7230 /*
7231  * Class:     org_rocksdb_FlushOptions
7232  * Method:    disposeInternal
7233  * Signature: (J)V
7234  */
7235 void Java_org_rocksdb_FlushOptions_disposeInternal(
7236     JNIEnv*, jobject, jlong jhandle) {
7237   auto* flush_opt = reinterpret_cast<ROCKSDB_NAMESPACE::FlushOptions*>(jhandle);
7238   assert(flush_opt != nullptr);
7239   delete flush_opt;
7240 }