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