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: setCompactionOptionsUniversal
3630 * Signature: (JJ)V
3631 */
Java_org_rocksdb_Options_setCompactionOptionsUniversal(JNIEnv *,jobject,jlong jhandle,jlong jcompaction_options_universal_handle)3632 void Java_org_rocksdb_Options_setCompactionOptionsUniversal(
3633 JNIEnv*, jobject, jlong jhandle,
3634 jlong jcompaction_options_universal_handle) {
3635 auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3636 auto* opts_uni =
3637 reinterpret_cast<ROCKSDB_NAMESPACE::CompactionOptionsUniversal*>(
3638 jcompaction_options_universal_handle);
3639 opts->compaction_options_universal = *opts_uni;
3640 }
3641
3642 /*
3643 * Class: org_rocksdb_Options
3644 * Method: setCompactionOptionsFIFO
3645 * Signature: (JJ)V
3646 */
Java_org_rocksdb_Options_setCompactionOptionsFIFO(JNIEnv *,jobject,jlong jhandle,jlong jcompaction_options_fifo_handle)3647 void Java_org_rocksdb_Options_setCompactionOptionsFIFO(
3648 JNIEnv*, jobject, jlong jhandle, jlong jcompaction_options_fifo_handle) {
3649 auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3650 auto* opts_fifo = reinterpret_cast<ROCKSDB_NAMESPACE::CompactionOptionsFIFO*>(
3651 jcompaction_options_fifo_handle);
3652 opts->compaction_options_fifo = *opts_fifo;
3653 }
3654
3655 /*
3656 * Class: org_rocksdb_Options
3657 * Method: setForceConsistencyChecks
3658 * Signature: (JZ)V
3659 */
Java_org_rocksdb_Options_setForceConsistencyChecks(JNIEnv *,jobject,jlong jhandle,jboolean jforce_consistency_checks)3660 void Java_org_rocksdb_Options_setForceConsistencyChecks(
3661 JNIEnv*, jobject, jlong jhandle, jboolean jforce_consistency_checks) {
3662 auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3663 opts->force_consistency_checks = static_cast<bool>(jforce_consistency_checks);
3664 }
3665
3666 /*
3667 * Class: org_rocksdb_Options
3668 * Method: forceConsistencyChecks
3669 * Signature: (J)Z
3670 */
Java_org_rocksdb_Options_forceConsistencyChecks(JNIEnv *,jobject,jlong jhandle)3671 jboolean Java_org_rocksdb_Options_forceConsistencyChecks(
3672 JNIEnv*, jobject, jlong jhandle) {
3673 auto* opts = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
3674 return static_cast<bool>(opts->force_consistency_checks);
3675 }
3676
3677 //////////////////////////////////////////////////////////////////////////////
3678 // ROCKSDB_NAMESPACE::ColumnFamilyOptions
3679
3680 /*
3681 * Class: org_rocksdb_ColumnFamilyOptions
3682 * Method: newColumnFamilyOptions
3683 * Signature: ()J
3684 */
Java_org_rocksdb_ColumnFamilyOptions_newColumnFamilyOptions(JNIEnv *,jclass)3685 jlong Java_org_rocksdb_ColumnFamilyOptions_newColumnFamilyOptions(
3686 JNIEnv*, jclass) {
3687 auto* op = new ROCKSDB_NAMESPACE::ColumnFamilyOptions();
3688 return reinterpret_cast<jlong>(op);
3689 }
3690
3691 /*
3692 * Class: org_rocksdb_ColumnFamilyOptions
3693 * Method: copyColumnFamilyOptions
3694 * Signature: (J)J
3695 */
Java_org_rocksdb_ColumnFamilyOptions_copyColumnFamilyOptions(JNIEnv *,jclass,jlong jhandle)3696 jlong Java_org_rocksdb_ColumnFamilyOptions_copyColumnFamilyOptions(
3697 JNIEnv*, jclass, jlong jhandle) {
3698 auto new_opt = new ROCKSDB_NAMESPACE::ColumnFamilyOptions(
3699 *(reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)));
3700 return reinterpret_cast<jlong>(new_opt);
3701 }
3702
3703 /*
3704 * Class: org_rocksdb_ColumnFamilyOptions
3705 * Method: newColumnFamilyOptionsFromOptions
3706 * Signature: (J)J
3707 */
Java_org_rocksdb_ColumnFamilyOptions_newColumnFamilyOptionsFromOptions(JNIEnv *,jclass,jlong joptions_handle)3708 jlong Java_org_rocksdb_ColumnFamilyOptions_newColumnFamilyOptionsFromOptions(
3709 JNIEnv*, jclass, jlong joptions_handle) {
3710 auto new_opt = new ROCKSDB_NAMESPACE::ColumnFamilyOptions(
3711 *reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(joptions_handle));
3712 return reinterpret_cast<jlong>(new_opt);
3713 }
3714
3715 /*
3716 * Class: org_rocksdb_ColumnFamilyOptions
3717 * Method: getColumnFamilyOptionsFromProps
3718 * Signature: (JLjava/lang/String;)J
3719 */
Java_org_rocksdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__JLjava_lang_String_2(JNIEnv * env,jclass,jlong cfg_handle,jstring jopt_string)3720 jlong Java_org_rocksdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__JLjava_lang_String_2(
3721 JNIEnv* env, jclass, jlong cfg_handle, jstring jopt_string) {
3722 const char* opt_string = env->GetStringUTFChars(jopt_string, nullptr);
3723 if (opt_string == nullptr) {
3724 // exception thrown: OutOfMemoryError
3725 return 0;
3726 }
3727 auto* config_options =
3728 reinterpret_cast<ROCKSDB_NAMESPACE::ConfigOptions*>(cfg_handle);
3729 auto* cf_options = new ROCKSDB_NAMESPACE::ColumnFamilyOptions();
3730 ROCKSDB_NAMESPACE::Status status =
3731 ROCKSDB_NAMESPACE::GetColumnFamilyOptionsFromString(
3732 *config_options, ROCKSDB_NAMESPACE::ColumnFamilyOptions(), opt_string,
3733 cf_options);
3734
3735 env->ReleaseStringUTFChars(jopt_string, opt_string);
3736
3737 // Check if ColumnFamilyOptions creation was possible.
3738 jlong ret_value = 0;
3739 if (status.ok()) {
3740 ret_value = reinterpret_cast<jlong>(cf_options);
3741 } else {
3742 // if operation failed the ColumnFamilyOptions need to be deleted
3743 // again to prevent a memory leak.
3744 delete cf_options;
3745 }
3746 return ret_value;
3747 }
3748
3749 /*
3750 * Class: org_rocksdb_ColumnFamilyOptions
3751 * Method: getColumnFamilyOptionsFromProps
3752 * Signature: (Ljava/util/String;)J
3753 */
Java_org_rocksdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__Ljava_lang_String_2(JNIEnv * env,jclass,jstring jopt_string)3754 jlong Java_org_rocksdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__Ljava_lang_String_2(
3755 JNIEnv* env, jclass, jstring jopt_string) {
3756 const char* opt_string = env->GetStringUTFChars(jopt_string, nullptr);
3757 if (opt_string == nullptr) {
3758 // exception thrown: OutOfMemoryError
3759 return 0;
3760 }
3761
3762 auto* cf_options = new ROCKSDB_NAMESPACE::ColumnFamilyOptions();
3763 ROCKSDB_NAMESPACE::Status status =
3764 ROCKSDB_NAMESPACE::GetColumnFamilyOptionsFromString(
3765 ROCKSDB_NAMESPACE::ColumnFamilyOptions(), opt_string, cf_options);
3766
3767 env->ReleaseStringUTFChars(jopt_string, opt_string);
3768
3769 // Check if ColumnFamilyOptions creation was possible.
3770 jlong ret_value = 0;
3771 if (status.ok()) {
3772 ret_value = reinterpret_cast<jlong>(cf_options);
3773 } else {
3774 // if operation failed the ColumnFamilyOptions need to be deleted
3775 // again to prevent a memory leak.
3776 delete cf_options;
3777 }
3778 return ret_value;
3779 }
3780
3781 /*
3782 * Class: org_rocksdb_ColumnFamilyOptions
3783 * Method: disposeInternal
3784 * Signature: (J)V
3785 */
Java_org_rocksdb_ColumnFamilyOptions_disposeInternal(JNIEnv *,jobject,jlong handle)3786 void Java_org_rocksdb_ColumnFamilyOptions_disposeInternal(
3787 JNIEnv*, jobject, jlong handle) {
3788 auto* cfo = reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(handle);
3789 assert(cfo != nullptr);
3790 delete cfo;
3791 }
3792
3793 /*
3794 * Class: org_rocksdb_ColumnFamilyOptions
3795 * Method: oldDefaults
3796 * Signature: (JII)V
3797 */
Java_org_rocksdb_ColumnFamilyOptions_oldDefaults(JNIEnv *,jclass,jlong jhandle,jint major_version,jint minor_version)3798 void Java_org_rocksdb_ColumnFamilyOptions_oldDefaults(JNIEnv*, jclass,
3799 jlong jhandle,
3800 jint major_version,
3801 jint minor_version) {
3802 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3803 ->OldDefaults(major_version, minor_version);
3804 }
3805
3806 /*
3807 * Class: org_rocksdb_ColumnFamilyOptions
3808 * Method: optimizeForSmallDb
3809 * Signature: (J)V
3810 */
Java_org_rocksdb_ColumnFamilyOptions_optimizeForSmallDb__J(JNIEnv *,jobject,jlong jhandle)3811 void Java_org_rocksdb_ColumnFamilyOptions_optimizeForSmallDb__J(JNIEnv*,
3812 jobject,
3813 jlong jhandle) {
3814 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3815 ->OptimizeForSmallDb();
3816 }
3817
3818 /*
3819 * Class: org_rocksdb_ColumnFamilyOptions
3820 * Method: optimizeForSmallDb
3821 * Signature: (JJ)V
3822 */
Java_org_rocksdb_ColumnFamilyOptions_optimizeForSmallDb__JJ(JNIEnv *,jclass,jlong jhandle,jlong cache_handle)3823 void Java_org_rocksdb_ColumnFamilyOptions_optimizeForSmallDb__JJ(
3824 JNIEnv*, jclass, jlong jhandle, jlong cache_handle) {
3825 auto* cache_sptr_ptr =
3826 reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::Cache>*>(
3827 cache_handle);
3828 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3829 ->OptimizeForSmallDb(cache_sptr_ptr);
3830 }
3831
3832 /*
3833 * Class: org_rocksdb_ColumnFamilyOptions
3834 * Method: optimizeForPointLookup
3835 * Signature: (JJ)V
3836 */
Java_org_rocksdb_ColumnFamilyOptions_optimizeForPointLookup(JNIEnv *,jobject,jlong jhandle,jlong block_cache_size_mb)3837 void Java_org_rocksdb_ColumnFamilyOptions_optimizeForPointLookup(
3838 JNIEnv*, jobject, jlong jhandle, jlong block_cache_size_mb) {
3839 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3840 ->OptimizeForPointLookup(block_cache_size_mb);
3841 }
3842
3843 /*
3844 * Class: org_rocksdb_ColumnFamilyOptions
3845 * Method: optimizeLevelStyleCompaction
3846 * Signature: (JJ)V
3847 */
Java_org_rocksdb_ColumnFamilyOptions_optimizeLevelStyleCompaction(JNIEnv *,jobject,jlong jhandle,jlong memtable_memory_budget)3848 void Java_org_rocksdb_ColumnFamilyOptions_optimizeLevelStyleCompaction(
3849 JNIEnv*, jobject, jlong jhandle, jlong memtable_memory_budget) {
3850 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3851 ->OptimizeLevelStyleCompaction(memtable_memory_budget);
3852 }
3853
3854 /*
3855 * Class: org_rocksdb_ColumnFamilyOptions
3856 * Method: optimizeUniversalStyleCompaction
3857 * Signature: (JJ)V
3858 */
Java_org_rocksdb_ColumnFamilyOptions_optimizeUniversalStyleCompaction(JNIEnv *,jobject,jlong jhandle,jlong memtable_memory_budget)3859 void Java_org_rocksdb_ColumnFamilyOptions_optimizeUniversalStyleCompaction(
3860 JNIEnv*, jobject, jlong jhandle, jlong memtable_memory_budget) {
3861 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3862 ->OptimizeUniversalStyleCompaction(memtable_memory_budget);
3863 }
3864
3865 /*
3866 * Class: org_rocksdb_ColumnFamilyOptions
3867 * Method: setComparatorHandle
3868 * Signature: (JI)V
3869 */
Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JI(JNIEnv *,jobject,jlong jhandle,jint builtinComparator)3870 void Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JI(
3871 JNIEnv*, jobject, jlong jhandle, jint builtinComparator) {
3872 switch (builtinComparator) {
3873 case 1:
3874 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3875 ->comparator = ROCKSDB_NAMESPACE::ReverseBytewiseComparator();
3876 break;
3877 default:
3878 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3879 ->comparator = ROCKSDB_NAMESPACE::BytewiseComparator();
3880 break;
3881 }
3882 }
3883
3884 /*
3885 * Class: org_rocksdb_ColumnFamilyOptions
3886 * Method: setComparatorHandle
3887 * Signature: (JJB)V
3888 */
Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JJB(JNIEnv *,jobject,jlong jopt_handle,jlong jcomparator_handle,jbyte jcomparator_type)3889 void Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JJB(
3890 JNIEnv*, jobject, jlong jopt_handle, jlong jcomparator_handle,
3891 jbyte jcomparator_type) {
3892 ROCKSDB_NAMESPACE::Comparator* comparator = nullptr;
3893 switch (jcomparator_type) {
3894 // JAVA_COMPARATOR
3895 case 0x0:
3896 comparator = reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallback*>(
3897 jcomparator_handle);
3898 break;
3899
3900 // JAVA_NATIVE_COMPARATOR_WRAPPER
3901 case 0x1:
3902 comparator =
3903 reinterpret_cast<ROCKSDB_NAMESPACE::Comparator*>(jcomparator_handle);
3904 break;
3905 }
3906 auto* opt =
3907 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jopt_handle);
3908 opt->comparator = comparator;
3909 }
3910
3911 /*
3912 * Class: org_rocksdb_ColumnFamilyOptions
3913 * Method: setMergeOperatorName
3914 * Signature: (JJjava/lang/String)V
3915 */
Java_org_rocksdb_ColumnFamilyOptions_setMergeOperatorName(JNIEnv * env,jobject,jlong jhandle,jstring jop_name)3916 void Java_org_rocksdb_ColumnFamilyOptions_setMergeOperatorName(
3917 JNIEnv* env, jobject, jlong jhandle, jstring jop_name) {
3918 auto* options =
3919 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
3920 const char* op_name = env->GetStringUTFChars(jop_name, nullptr);
3921 if (op_name == nullptr) {
3922 // exception thrown: OutOfMemoryError
3923 return;
3924 }
3925
3926 options->merge_operator =
3927 ROCKSDB_NAMESPACE::MergeOperators::CreateFromStringId(op_name);
3928 env->ReleaseStringUTFChars(jop_name, op_name);
3929 }
3930
3931 /*
3932 * Class: org_rocksdb_ColumnFamilyOptions
3933 * Method: setMergeOperator
3934 * Signature: (JJjava/lang/String)V
3935 */
Java_org_rocksdb_ColumnFamilyOptions_setMergeOperator(JNIEnv *,jobject,jlong jhandle,jlong mergeOperatorHandle)3936 void Java_org_rocksdb_ColumnFamilyOptions_setMergeOperator(
3937 JNIEnv*, jobject, jlong jhandle, jlong mergeOperatorHandle) {
3938 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3939 ->merge_operator =
3940 *(reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::MergeOperator>*>(
3941 mergeOperatorHandle));
3942 }
3943
3944 /*
3945 * Class: org_rocksdb_ColumnFamilyOptions
3946 * Method: setCompactionFilterHandle
3947 * Signature: (JJ)V
3948 */
Java_org_rocksdb_ColumnFamilyOptions_setCompactionFilterHandle(JNIEnv *,jobject,jlong jopt_handle,jlong jcompactionfilter_handle)3949 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionFilterHandle(
3950 JNIEnv*, jobject, jlong jopt_handle, jlong jcompactionfilter_handle) {
3951 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jopt_handle)
3952 ->compaction_filter =
3953 reinterpret_cast<ROCKSDB_NAMESPACE::CompactionFilter*>(
3954 jcompactionfilter_handle);
3955 }
3956
3957 /*
3958 * Class: org_rocksdb_ColumnFamilyOptions
3959 * Method: setCompactionFilterFactoryHandle
3960 * Signature: (JJ)V
3961 */
Java_org_rocksdb_ColumnFamilyOptions_setCompactionFilterFactoryHandle(JNIEnv *,jobject,jlong jopt_handle,jlong jcompactionfilterfactory_handle)3962 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionFilterFactoryHandle(
3963 JNIEnv*, jobject, jlong jopt_handle,
3964 jlong jcompactionfilterfactory_handle) {
3965 auto* cff_factory = reinterpret_cast<
3966 std::shared_ptr<ROCKSDB_NAMESPACE::CompactionFilterFactoryJniCallback>*>(
3967 jcompactionfilterfactory_handle);
3968 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jopt_handle)
3969 ->compaction_filter_factory = *cff_factory;
3970 }
3971
3972 /*
3973 * Class: org_rocksdb_ColumnFamilyOptions
3974 * Method: setWriteBufferSize
3975 * Signature: (JJ)I
3976 */
Java_org_rocksdb_ColumnFamilyOptions_setWriteBufferSize(JNIEnv * env,jobject,jlong jhandle,jlong jwrite_buffer_size)3977 void Java_org_rocksdb_ColumnFamilyOptions_setWriteBufferSize(
3978 JNIEnv* env, jobject, jlong jhandle, jlong jwrite_buffer_size) {
3979 auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
3980 jwrite_buffer_size);
3981 if (s.ok()) {
3982 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3983 ->write_buffer_size = jwrite_buffer_size;
3984 } else {
3985 ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
3986 }
3987 }
3988
3989 /*
3990 * Class: org_rocksdb_ColumnFamilyOptions
3991 * Method: writeBufferSize
3992 * Signature: (J)J
3993 */
Java_org_rocksdb_ColumnFamilyOptions_writeBufferSize(JNIEnv *,jobject,jlong jhandle)3994 jlong Java_org_rocksdb_ColumnFamilyOptions_writeBufferSize(
3995 JNIEnv*, jobject, jlong jhandle) {
3996 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
3997 ->write_buffer_size;
3998 }
3999
4000 /*
4001 * Class: org_rocksdb_ColumnFamilyOptions
4002 * Method: setMaxWriteBufferNumber
4003 * Signature: (JI)V
4004 */
Java_org_rocksdb_ColumnFamilyOptions_setMaxWriteBufferNumber(JNIEnv *,jobject,jlong jhandle,jint jmax_write_buffer_number)4005 void Java_org_rocksdb_ColumnFamilyOptions_setMaxWriteBufferNumber(
4006 JNIEnv*, jobject, jlong jhandle, jint jmax_write_buffer_number) {
4007 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4008 ->max_write_buffer_number = jmax_write_buffer_number;
4009 }
4010
4011 /*
4012 * Class: org_rocksdb_ColumnFamilyOptions
4013 * Method: maxWriteBufferNumber
4014 * Signature: (J)I
4015 */
Java_org_rocksdb_ColumnFamilyOptions_maxWriteBufferNumber(JNIEnv *,jobject,jlong jhandle)4016 jint Java_org_rocksdb_ColumnFamilyOptions_maxWriteBufferNumber(
4017 JNIEnv*, jobject, jlong jhandle) {
4018 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4019 ->max_write_buffer_number;
4020 }
4021
4022 /*
4023 * Method: setMemTableFactory
4024 * Signature: (JJ)V
4025 */
Java_org_rocksdb_ColumnFamilyOptions_setMemTableFactory(JNIEnv *,jobject,jlong jhandle,jlong jfactory_handle)4026 void Java_org_rocksdb_ColumnFamilyOptions_setMemTableFactory(
4027 JNIEnv*, jobject, jlong jhandle, jlong jfactory_handle) {
4028 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4029 ->memtable_factory.reset(
4030 reinterpret_cast<ROCKSDB_NAMESPACE::MemTableRepFactory*>(
4031 jfactory_handle));
4032 }
4033
4034 /*
4035 * Class: org_rocksdb_ColumnFamilyOptions
4036 * Method: memTableFactoryName
4037 * Signature: (J)Ljava/lang/String
4038 */
Java_org_rocksdb_ColumnFamilyOptions_memTableFactoryName(JNIEnv * env,jobject,jlong jhandle)4039 jstring Java_org_rocksdb_ColumnFamilyOptions_memTableFactoryName(
4040 JNIEnv* env, jobject, jlong jhandle) {
4041 auto* opt =
4042 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4043 ROCKSDB_NAMESPACE::MemTableRepFactory* tf = opt->memtable_factory.get();
4044
4045 // Should never be nullptr.
4046 // Default memtable factory is SkipListFactory
4047 assert(tf);
4048
4049 // temporarly fix for the historical typo
4050 if (strcmp(tf->Name(), "HashLinkListRepFactory") == 0) {
4051 return env->NewStringUTF("HashLinkedListRepFactory");
4052 }
4053
4054 return env->NewStringUTF(tf->Name());
4055 }
4056
4057 /*
4058 * Method: useFixedLengthPrefixExtractor
4059 * Signature: (JI)V
4060 */
Java_org_rocksdb_ColumnFamilyOptions_useFixedLengthPrefixExtractor(JNIEnv *,jobject,jlong jhandle,jint jprefix_length)4061 void Java_org_rocksdb_ColumnFamilyOptions_useFixedLengthPrefixExtractor(
4062 JNIEnv*, jobject, jlong jhandle, jint jprefix_length) {
4063 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4064 ->prefix_extractor.reset(ROCKSDB_NAMESPACE::NewFixedPrefixTransform(
4065 static_cast<int>(jprefix_length)));
4066 }
4067
4068 /*
4069 * Method: useCappedPrefixExtractor
4070 * Signature: (JI)V
4071 */
Java_org_rocksdb_ColumnFamilyOptions_useCappedPrefixExtractor(JNIEnv *,jobject,jlong jhandle,jint jprefix_length)4072 void Java_org_rocksdb_ColumnFamilyOptions_useCappedPrefixExtractor(
4073 JNIEnv*, jobject, jlong jhandle, jint jprefix_length) {
4074 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4075 ->prefix_extractor.reset(ROCKSDB_NAMESPACE::NewCappedPrefixTransform(
4076 static_cast<int>(jprefix_length)));
4077 }
4078
4079 /*
4080 * Method: setTableFactory
4081 * Signature: (JJ)V
4082 */
Java_org_rocksdb_ColumnFamilyOptions_setTableFactory(JNIEnv *,jobject,jlong jhandle,jlong jfactory_handle)4083 void Java_org_rocksdb_ColumnFamilyOptions_setTableFactory(
4084 JNIEnv*, jobject, jlong jhandle, jlong jfactory_handle) {
4085 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4086 ->table_factory.reset(
4087 reinterpret_cast<ROCKSDB_NAMESPACE::TableFactory*>(jfactory_handle));
4088 }
4089
4090 /*
4091 * Method: setSstPartitionerFactory
4092 * Signature: (JJ)V
4093 */
Java_org_rocksdb_ColumnFamilyOptions_setSstPartitionerFactory(JNIEnv *,jobject,jlong jhandle,jlong factory_handle)4094 void Java_org_rocksdb_ColumnFamilyOptions_setSstPartitionerFactory(
4095 JNIEnv*, jobject, jlong jhandle, jlong factory_handle) {
4096 auto* options =
4097 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4098 auto* factory = reinterpret_cast<ROCKSDB_NAMESPACE::SstPartitionerFactory*>(
4099 factory_handle);
4100 options->sst_partitioner_factory.reset(factory);
4101 }
4102
4103 /*
4104 * Class: org_rocksdb_ColumnFamilyOptions
4105 * Method: setCompactionThreadLimiter
4106 * Signature: (JJ)V
4107 */
Java_org_rocksdb_ColumnFamilyOptions_setCompactionThreadLimiter(JNIEnv *,jclass,jlong jhandle,jlong jlimiter_handle)4108 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionThreadLimiter(
4109 JNIEnv*, jclass, jlong jhandle, jlong jlimiter_handle) {
4110 auto* options =
4111 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4112 auto* limiter = reinterpret_cast<
4113 std::shared_ptr<ROCKSDB_NAMESPACE::ConcurrentTaskLimiter>*>(
4114 jlimiter_handle);
4115 options->compaction_thread_limiter = *limiter;
4116 }
4117
4118 /*
4119 * Method: tableFactoryName
4120 * Signature: (J)Ljava/lang/String
4121 */
Java_org_rocksdb_ColumnFamilyOptions_tableFactoryName(JNIEnv * env,jobject,jlong jhandle)4122 jstring Java_org_rocksdb_ColumnFamilyOptions_tableFactoryName(
4123 JNIEnv* env, jobject, jlong jhandle) {
4124 auto* opt =
4125 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4126 ROCKSDB_NAMESPACE::TableFactory* tf = opt->table_factory.get();
4127
4128 // Should never be nullptr.
4129 // Default memtable factory is SkipListFactory
4130 assert(tf);
4131
4132 return env->NewStringUTF(tf->Name());
4133 }
4134
4135 /*
4136 * Class: org_rocksdb_ColumnFamilyOptions
4137 * Method: setCfPaths
4138 * Signature: (J[Ljava/lang/String;[J)V
4139 */
Java_org_rocksdb_ColumnFamilyOptions_setCfPaths(JNIEnv * env,jclass,jlong jhandle,jobjectArray path_array,jlongArray size_array)4140 void Java_org_rocksdb_ColumnFamilyOptions_setCfPaths(JNIEnv* env, jclass,
4141 jlong jhandle,
4142 jobjectArray path_array,
4143 jlongArray size_array) {
4144 auto* options =
4145 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4146 jboolean has_exception = JNI_FALSE;
4147 std::vector<ROCKSDB_NAMESPACE::DbPath> cf_paths =
4148 rocksdb_convert_cf_paths_from_java_helper(env, path_array, size_array,
4149 &has_exception);
4150 if (JNI_FALSE == has_exception) {
4151 options->cf_paths = std::move(cf_paths);
4152 }
4153 }
4154
4155 /*
4156 * Class: org_rocksdb_ColumnFamilyOptions
4157 * Method: cfPathsLen
4158 * Signature: (J)J
4159 */
Java_org_rocksdb_ColumnFamilyOptions_cfPathsLen(JNIEnv *,jclass,jlong jhandle)4160 jlong Java_org_rocksdb_ColumnFamilyOptions_cfPathsLen(JNIEnv*, jclass,
4161 jlong jhandle) {
4162 auto* opt =
4163 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4164 return static_cast<jlong>(opt->cf_paths.size());
4165 }
4166
4167 /*
4168 * Class: org_rocksdb_ColumnFamilyOptions
4169 * Method: cfPaths
4170 * Signature: (J[Ljava/lang/String;[J)V
4171 */
Java_org_rocksdb_ColumnFamilyOptions_cfPaths(JNIEnv * env,jclass,jlong jhandle,jobjectArray jpaths,jlongArray jtarget_sizes)4172 void Java_org_rocksdb_ColumnFamilyOptions_cfPaths(JNIEnv* env, jclass,
4173 jlong jhandle,
4174 jobjectArray jpaths,
4175 jlongArray jtarget_sizes) {
4176 rocksdb_convert_cf_paths_to_java_helper<
4177 ROCKSDB_NAMESPACE::ColumnFamilyOptions>(env, jhandle, jpaths,
4178 jtarget_sizes);
4179 }
4180
4181 /*
4182 * Class: org_rocksdb_ColumnFamilyOptions
4183 * Method: minWriteBufferNumberToMerge
4184 * Signature: (J)I
4185 */
Java_org_rocksdb_ColumnFamilyOptions_minWriteBufferNumberToMerge(JNIEnv *,jobject,jlong jhandle)4186 jint Java_org_rocksdb_ColumnFamilyOptions_minWriteBufferNumberToMerge(
4187 JNIEnv*, jobject, jlong jhandle) {
4188 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4189 ->min_write_buffer_number_to_merge;
4190 }
4191
4192 /*
4193 * Class: org_rocksdb_ColumnFamilyOptions
4194 * Method: setMinWriteBufferNumberToMerge
4195 * Signature: (JI)V
4196 */
Java_org_rocksdb_ColumnFamilyOptions_setMinWriteBufferNumberToMerge(JNIEnv *,jobject,jlong jhandle,jint jmin_write_buffer_number_to_merge)4197 void Java_org_rocksdb_ColumnFamilyOptions_setMinWriteBufferNumberToMerge(
4198 JNIEnv*, jobject, jlong jhandle, jint jmin_write_buffer_number_to_merge) {
4199 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4200 ->min_write_buffer_number_to_merge =
4201 static_cast<int>(jmin_write_buffer_number_to_merge);
4202 }
4203
4204 /*
4205 * Class: org_rocksdb_ColumnFamilyOptions
4206 * Method: maxWriteBufferNumberToMaintain
4207 * Signature: (J)I
4208 */
Java_org_rocksdb_ColumnFamilyOptions_maxWriteBufferNumberToMaintain(JNIEnv *,jobject,jlong jhandle)4209 jint Java_org_rocksdb_ColumnFamilyOptions_maxWriteBufferNumberToMaintain(
4210 JNIEnv*, jobject, jlong jhandle) {
4211 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4212 ->max_write_buffer_number_to_maintain;
4213 }
4214
4215 /*
4216 * Class: org_rocksdb_ColumnFamilyOptions
4217 * Method: setMaxWriteBufferNumberToMaintain
4218 * Signature: (JI)V
4219 */
Java_org_rocksdb_ColumnFamilyOptions_setMaxWriteBufferNumberToMaintain(JNIEnv *,jobject,jlong jhandle,jint jmax_write_buffer_number_to_maintain)4220 void Java_org_rocksdb_ColumnFamilyOptions_setMaxWriteBufferNumberToMaintain(
4221 JNIEnv*, jobject, jlong jhandle,
4222 jint jmax_write_buffer_number_to_maintain) {
4223 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4224 ->max_write_buffer_number_to_maintain =
4225 static_cast<int>(jmax_write_buffer_number_to_maintain);
4226 }
4227
4228 /*
4229 * Class: org_rocksdb_ColumnFamilyOptions
4230 * Method: setCompressionType
4231 * Signature: (JB)V
4232 */
Java_org_rocksdb_ColumnFamilyOptions_setCompressionType(JNIEnv *,jobject,jlong jhandle,jbyte jcompression_type_value)4233 void Java_org_rocksdb_ColumnFamilyOptions_setCompressionType(
4234 JNIEnv*, jobject, jlong jhandle, jbyte jcompression_type_value) {
4235 auto* cf_opts =
4236 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4237 cf_opts->compression =
4238 ROCKSDB_NAMESPACE::CompressionTypeJni::toCppCompressionType(
4239 jcompression_type_value);
4240 }
4241
4242 /*
4243 * Class: org_rocksdb_ColumnFamilyOptions
4244 * Method: compressionType
4245 * Signature: (J)B
4246 */
Java_org_rocksdb_ColumnFamilyOptions_compressionType(JNIEnv *,jobject,jlong jhandle)4247 jbyte Java_org_rocksdb_ColumnFamilyOptions_compressionType(
4248 JNIEnv*, jobject, jlong jhandle) {
4249 auto* cf_opts =
4250 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4251 return ROCKSDB_NAMESPACE::CompressionTypeJni::toJavaCompressionType(
4252 cf_opts->compression);
4253 }
4254
4255 /*
4256 * Class: org_rocksdb_ColumnFamilyOptions
4257 * Method: setCompressionPerLevel
4258 * Signature: (J[B)V
4259 */
Java_org_rocksdb_ColumnFamilyOptions_setCompressionPerLevel(JNIEnv * env,jobject,jlong jhandle,jbyteArray jcompressionLevels)4260 void Java_org_rocksdb_ColumnFamilyOptions_setCompressionPerLevel(
4261 JNIEnv* env, jobject, jlong jhandle, jbyteArray jcompressionLevels) {
4262 auto* options =
4263 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4264 auto uptr_compression_levels =
4265 rocksdb_compression_vector_helper(env, jcompressionLevels);
4266 if (!uptr_compression_levels) {
4267 // exception occurred
4268 return;
4269 }
4270 options->compression_per_level = *(uptr_compression_levels.get());
4271 }
4272
4273 /*
4274 * Class: org_rocksdb_ColumnFamilyOptions
4275 * Method: compressionPerLevel
4276 * Signature: (J)[B
4277 */
Java_org_rocksdb_ColumnFamilyOptions_compressionPerLevel(JNIEnv * env,jobject,jlong jhandle)4278 jbyteArray Java_org_rocksdb_ColumnFamilyOptions_compressionPerLevel(
4279 JNIEnv* env, jobject, jlong jhandle) {
4280 auto* cf_options =
4281 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4282 return rocksdb_compression_list_helper(env,
4283 cf_options->compression_per_level);
4284 }
4285
4286 /*
4287 * Class: org_rocksdb_ColumnFamilyOptions
4288 * Method: setBottommostCompressionType
4289 * Signature: (JB)V
4290 */
Java_org_rocksdb_ColumnFamilyOptions_setBottommostCompressionType(JNIEnv *,jobject,jlong jhandle,jbyte jcompression_type_value)4291 void Java_org_rocksdb_ColumnFamilyOptions_setBottommostCompressionType(
4292 JNIEnv*, jobject, jlong jhandle, jbyte jcompression_type_value) {
4293 auto* cf_options =
4294 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4295 cf_options->bottommost_compression =
4296 ROCKSDB_NAMESPACE::CompressionTypeJni::toCppCompressionType(
4297 jcompression_type_value);
4298 }
4299
4300 /*
4301 * Class: org_rocksdb_ColumnFamilyOptions
4302 * Method: bottommostCompressionType
4303 * Signature: (J)B
4304 */
Java_org_rocksdb_ColumnFamilyOptions_bottommostCompressionType(JNIEnv *,jobject,jlong jhandle)4305 jbyte Java_org_rocksdb_ColumnFamilyOptions_bottommostCompressionType(
4306 JNIEnv*, jobject, jlong jhandle) {
4307 auto* cf_options =
4308 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4309 return ROCKSDB_NAMESPACE::CompressionTypeJni::toJavaCompressionType(
4310 cf_options->bottommost_compression);
4311 }
4312 /*
4313 * Class: org_rocksdb_ColumnFamilyOptions
4314 * Method: setBottommostCompressionOptions
4315 * Signature: (JJ)V
4316 */
Java_org_rocksdb_ColumnFamilyOptions_setBottommostCompressionOptions(JNIEnv *,jobject,jlong jhandle,jlong jbottommost_compression_options_handle)4317 void Java_org_rocksdb_ColumnFamilyOptions_setBottommostCompressionOptions(
4318 JNIEnv*, jobject, jlong jhandle,
4319 jlong jbottommost_compression_options_handle) {
4320 auto* cf_options =
4321 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4322 auto* bottommost_compression_options =
4323 reinterpret_cast<ROCKSDB_NAMESPACE::CompressionOptions*>(
4324 jbottommost_compression_options_handle);
4325 cf_options->bottommost_compression_opts = *bottommost_compression_options;
4326 }
4327
4328 /*
4329 * Class: org_rocksdb_ColumnFamilyOptions
4330 * Method: setCompressionOptions
4331 * Signature: (JJ)V
4332 */
Java_org_rocksdb_ColumnFamilyOptions_setCompressionOptions(JNIEnv *,jobject,jlong jhandle,jlong jcompression_options_handle)4333 void Java_org_rocksdb_ColumnFamilyOptions_setCompressionOptions(
4334 JNIEnv*, jobject, jlong jhandle, jlong jcompression_options_handle) {
4335 auto* cf_options =
4336 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4337 auto* compression_options =
4338 reinterpret_cast<ROCKSDB_NAMESPACE::CompressionOptions*>(
4339 jcompression_options_handle);
4340 cf_options->compression_opts = *compression_options;
4341 }
4342
4343 /*
4344 * Class: org_rocksdb_ColumnFamilyOptions
4345 * Method: setCompactionStyle
4346 * Signature: (JB)V
4347 */
Java_org_rocksdb_ColumnFamilyOptions_setCompactionStyle(JNIEnv *,jobject,jlong jhandle,jbyte jcompaction_style)4348 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionStyle(
4349 JNIEnv*, jobject, jlong jhandle, jbyte jcompaction_style) {
4350 auto* cf_options =
4351 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4352 cf_options->compaction_style =
4353 ROCKSDB_NAMESPACE::CompactionStyleJni::toCppCompactionStyle(
4354 jcompaction_style);
4355 }
4356
4357 /*
4358 * Class: org_rocksdb_ColumnFamilyOptions
4359 * Method: compactionStyle
4360 * Signature: (J)B
4361 */
Java_org_rocksdb_ColumnFamilyOptions_compactionStyle(JNIEnv *,jobject,jlong jhandle)4362 jbyte Java_org_rocksdb_ColumnFamilyOptions_compactionStyle(
4363 JNIEnv*, jobject, jlong jhandle) {
4364 auto* cf_options =
4365 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
4366 return ROCKSDB_NAMESPACE::CompactionStyleJni::toJavaCompactionStyle(
4367 cf_options->compaction_style);
4368 }
4369
4370 /*
4371 * Class: org_rocksdb_ColumnFamilyOptions
4372 * Method: setMaxTableFilesSizeFIFO
4373 * Signature: (JJ)V
4374 */
Java_org_rocksdb_ColumnFamilyOptions_setMaxTableFilesSizeFIFO(JNIEnv *,jobject,jlong jhandle,jlong jmax_table_files_size)4375 void Java_org_rocksdb_ColumnFamilyOptions_setMaxTableFilesSizeFIFO(
4376 JNIEnv*, jobject, jlong jhandle, jlong jmax_table_files_size) {
4377 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4378 ->compaction_options_fifo.max_table_files_size =
4379 static_cast<uint64_t>(jmax_table_files_size);
4380 }
4381
4382 /*
4383 * Class: org_rocksdb_ColumnFamilyOptions
4384 * Method: maxTableFilesSizeFIFO
4385 * Signature: (J)J
4386 */
Java_org_rocksdb_ColumnFamilyOptions_maxTableFilesSizeFIFO(JNIEnv *,jobject,jlong jhandle)4387 jlong Java_org_rocksdb_ColumnFamilyOptions_maxTableFilesSizeFIFO(
4388 JNIEnv*, jobject, jlong jhandle) {
4389 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4390 ->compaction_options_fifo.max_table_files_size;
4391 }
4392
4393 /*
4394 * Class: org_rocksdb_ColumnFamilyOptions
4395 * Method: numLevels
4396 * Signature: (J)I
4397 */
Java_org_rocksdb_ColumnFamilyOptions_numLevels(JNIEnv *,jobject,jlong jhandle)4398 jint Java_org_rocksdb_ColumnFamilyOptions_numLevels(
4399 JNIEnv*, jobject, jlong jhandle) {
4400 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4401 ->num_levels;
4402 }
4403
4404 /*
4405 * Class: org_rocksdb_ColumnFamilyOptions
4406 * Method: setNumLevels
4407 * Signature: (JI)V
4408 */
Java_org_rocksdb_ColumnFamilyOptions_setNumLevels(JNIEnv *,jobject,jlong jhandle,jint jnum_levels)4409 void Java_org_rocksdb_ColumnFamilyOptions_setNumLevels(
4410 JNIEnv*, jobject, jlong jhandle, jint jnum_levels) {
4411 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4412 ->num_levels = static_cast<int>(jnum_levels);
4413 }
4414
4415 /*
4416 * Class: org_rocksdb_ColumnFamilyOptions
4417 * Method: levelZeroFileNumCompactionTrigger
4418 * Signature: (J)I
4419 */
Java_org_rocksdb_ColumnFamilyOptions_levelZeroFileNumCompactionTrigger(JNIEnv *,jobject,jlong jhandle)4420 jint Java_org_rocksdb_ColumnFamilyOptions_levelZeroFileNumCompactionTrigger(
4421 JNIEnv*, jobject, jlong jhandle) {
4422 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4423 ->level0_file_num_compaction_trigger;
4424 }
4425
4426 /*
4427 * Class: org_rocksdb_ColumnFamilyOptions
4428 * Method: setLevelZeroFileNumCompactionTrigger
4429 * Signature: (JI)V
4430 */
Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroFileNumCompactionTrigger(JNIEnv *,jobject,jlong jhandle,jint jlevel0_file_num_compaction_trigger)4431 void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroFileNumCompactionTrigger(
4432 JNIEnv*, jobject, jlong jhandle,
4433 jint jlevel0_file_num_compaction_trigger) {
4434 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4435 ->level0_file_num_compaction_trigger =
4436 static_cast<int>(jlevel0_file_num_compaction_trigger);
4437 }
4438
4439 /*
4440 * Class: org_rocksdb_ColumnFamilyOptions
4441 * Method: levelZeroSlowdownWritesTrigger
4442 * Signature: (J)I
4443 */
Java_org_rocksdb_ColumnFamilyOptions_levelZeroSlowdownWritesTrigger(JNIEnv *,jobject,jlong jhandle)4444 jint Java_org_rocksdb_ColumnFamilyOptions_levelZeroSlowdownWritesTrigger(
4445 JNIEnv*, jobject, jlong jhandle) {
4446 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4447 ->level0_slowdown_writes_trigger;
4448 }
4449
4450 /*
4451 * Class: org_rocksdb_ColumnFamilyOptions
4452 * Method: setLevelSlowdownWritesTrigger
4453 * Signature: (JI)V
4454 */
Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroSlowdownWritesTrigger(JNIEnv *,jobject,jlong jhandle,jint jlevel0_slowdown_writes_trigger)4455 void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroSlowdownWritesTrigger(
4456 JNIEnv*, jobject, jlong jhandle, jint jlevel0_slowdown_writes_trigger) {
4457 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4458 ->level0_slowdown_writes_trigger =
4459 static_cast<int>(jlevel0_slowdown_writes_trigger);
4460 }
4461
4462 /*
4463 * Class: org_rocksdb_ColumnFamilyOptions
4464 * Method: levelZeroStopWritesTrigger
4465 * Signature: (J)I
4466 */
Java_org_rocksdb_ColumnFamilyOptions_levelZeroStopWritesTrigger(JNIEnv *,jobject,jlong jhandle)4467 jint Java_org_rocksdb_ColumnFamilyOptions_levelZeroStopWritesTrigger(
4468 JNIEnv*, jobject, jlong jhandle) {
4469 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4470 ->level0_stop_writes_trigger;
4471 }
4472
4473 /*
4474 * Class: org_rocksdb_ColumnFamilyOptions
4475 * Method: setLevelStopWritesTrigger
4476 * Signature: (JI)V
4477 */
Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroStopWritesTrigger(JNIEnv *,jobject,jlong jhandle,jint jlevel0_stop_writes_trigger)4478 void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroStopWritesTrigger(
4479 JNIEnv*, jobject, jlong jhandle, jint jlevel0_stop_writes_trigger) {
4480 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4481 ->level0_stop_writes_trigger =
4482 static_cast<int>(jlevel0_stop_writes_trigger);
4483 }
4484
4485 /*
4486 * Class: org_rocksdb_ColumnFamilyOptions
4487 * Method: targetFileSizeBase
4488 * Signature: (J)J
4489 */
Java_org_rocksdb_ColumnFamilyOptions_targetFileSizeBase(JNIEnv *,jobject,jlong jhandle)4490 jlong Java_org_rocksdb_ColumnFamilyOptions_targetFileSizeBase(
4491 JNIEnv*, jobject, jlong jhandle) {
4492 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4493 ->target_file_size_base;
4494 }
4495
4496 /*
4497 * Class: org_rocksdb_ColumnFamilyOptions
4498 * Method: setTargetFileSizeBase
4499 * Signature: (JJ)V
4500 */
Java_org_rocksdb_ColumnFamilyOptions_setTargetFileSizeBase(JNIEnv *,jobject,jlong jhandle,jlong jtarget_file_size_base)4501 void Java_org_rocksdb_ColumnFamilyOptions_setTargetFileSizeBase(
4502 JNIEnv*, jobject, jlong jhandle, jlong jtarget_file_size_base) {
4503 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4504 ->target_file_size_base = static_cast<uint64_t>(jtarget_file_size_base);
4505 }
4506
4507 /*
4508 * Class: org_rocksdb_ColumnFamilyOptions
4509 * Method: targetFileSizeMultiplier
4510 * Signature: (J)I
4511 */
Java_org_rocksdb_ColumnFamilyOptions_targetFileSizeMultiplier(JNIEnv *,jobject,jlong jhandle)4512 jint Java_org_rocksdb_ColumnFamilyOptions_targetFileSizeMultiplier(
4513 JNIEnv*, jobject, jlong jhandle) {
4514 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4515 ->target_file_size_multiplier;
4516 }
4517
4518 /*
4519 * Class: org_rocksdb_ColumnFamilyOptions
4520 * Method: setTargetFileSizeMultiplier
4521 * Signature: (JI)V
4522 */
Java_org_rocksdb_ColumnFamilyOptions_setTargetFileSizeMultiplier(JNIEnv *,jobject,jlong jhandle,jint jtarget_file_size_multiplier)4523 void Java_org_rocksdb_ColumnFamilyOptions_setTargetFileSizeMultiplier(
4524 JNIEnv*, jobject, jlong jhandle, jint jtarget_file_size_multiplier) {
4525 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4526 ->target_file_size_multiplier =
4527 static_cast<int>(jtarget_file_size_multiplier);
4528 }
4529
4530 /*
4531 * Class: org_rocksdb_ColumnFamilyOptions
4532 * Method: maxBytesForLevelBase
4533 * Signature: (J)J
4534 */
Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelBase(JNIEnv *,jobject,jlong jhandle)4535 jlong Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelBase(
4536 JNIEnv*, jobject, jlong jhandle) {
4537 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4538 ->max_bytes_for_level_base;
4539 }
4540
4541 /*
4542 * Class: org_rocksdb_ColumnFamilyOptions
4543 * Method: setMaxBytesForLevelBase
4544 * Signature: (JJ)V
4545 */
Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelBase(JNIEnv *,jobject,jlong jhandle,jlong jmax_bytes_for_level_base)4546 void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelBase(
4547 JNIEnv*, jobject, jlong jhandle, jlong jmax_bytes_for_level_base) {
4548 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4549 ->max_bytes_for_level_base =
4550 static_cast<int64_t>(jmax_bytes_for_level_base);
4551 }
4552
4553 /*
4554 * Class: org_rocksdb_ColumnFamilyOptions
4555 * Method: levelCompactionDynamicLevelBytes
4556 * Signature: (J)Z
4557 */
Java_org_rocksdb_ColumnFamilyOptions_levelCompactionDynamicLevelBytes(JNIEnv *,jobject,jlong jhandle)4558 jboolean Java_org_rocksdb_ColumnFamilyOptions_levelCompactionDynamicLevelBytes(
4559 JNIEnv*, jobject, jlong jhandle) {
4560 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4561 ->level_compaction_dynamic_level_bytes;
4562 }
4563
4564 /*
4565 * Class: org_rocksdb_ColumnFamilyOptions
4566 * Method: setLevelCompactionDynamicLevelBytes
4567 * Signature: (JZ)V
4568 */
Java_org_rocksdb_ColumnFamilyOptions_setLevelCompactionDynamicLevelBytes(JNIEnv *,jobject,jlong jhandle,jboolean jenable_dynamic_level_bytes)4569 void Java_org_rocksdb_ColumnFamilyOptions_setLevelCompactionDynamicLevelBytes(
4570 JNIEnv*, jobject, jlong jhandle, jboolean jenable_dynamic_level_bytes) {
4571 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4572 ->level_compaction_dynamic_level_bytes = (jenable_dynamic_level_bytes);
4573 }
4574
4575 /*
4576 * Class: org_rocksdb_ColumnFamilyOptions
4577 * Method: maxBytesForLevelMultiplier
4578 * Signature: (J)D
4579 */
Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelMultiplier(JNIEnv *,jobject,jlong jhandle)4580 jdouble Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelMultiplier(
4581 JNIEnv*, jobject, jlong jhandle) {
4582 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4583 ->max_bytes_for_level_multiplier;
4584 }
4585
4586 /*
4587 * Class: org_rocksdb_ColumnFamilyOptions
4588 * Method: setMaxBytesForLevelMultiplier
4589 * Signature: (JD)V
4590 */
Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplier(JNIEnv *,jobject,jlong jhandle,jdouble jmax_bytes_for_level_multiplier)4591 void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplier(
4592 JNIEnv*, jobject, jlong jhandle, jdouble jmax_bytes_for_level_multiplier) {
4593 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4594 ->max_bytes_for_level_multiplier =
4595 static_cast<double>(jmax_bytes_for_level_multiplier);
4596 }
4597
4598 /*
4599 * Class: org_rocksdb_ColumnFamilyOptions
4600 * Method: maxCompactionBytes
4601 * Signature: (J)I
4602 */
Java_org_rocksdb_ColumnFamilyOptions_maxCompactionBytes(JNIEnv *,jobject,jlong jhandle)4603 jlong Java_org_rocksdb_ColumnFamilyOptions_maxCompactionBytes(
4604 JNIEnv*, jobject, jlong jhandle) {
4605 return static_cast<jlong>(
4606 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4607 ->max_compaction_bytes);
4608 }
4609
4610 /*
4611 * Class: org_rocksdb_ColumnFamilyOptions
4612 * Method: setMaxCompactionBytes
4613 * Signature: (JI)V
4614 */
Java_org_rocksdb_ColumnFamilyOptions_setMaxCompactionBytes(JNIEnv *,jobject,jlong jhandle,jlong jmax_compaction_bytes)4615 void Java_org_rocksdb_ColumnFamilyOptions_setMaxCompactionBytes(
4616 JNIEnv*, jobject, jlong jhandle, jlong jmax_compaction_bytes) {
4617 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4618 ->max_compaction_bytes = static_cast<uint64_t>(jmax_compaction_bytes);
4619 }
4620
4621 /*
4622 * Class: org_rocksdb_ColumnFamilyOptions
4623 * Method: arenaBlockSize
4624 * Signature: (J)J
4625 */
Java_org_rocksdb_ColumnFamilyOptions_arenaBlockSize(JNIEnv *,jobject,jlong jhandle)4626 jlong Java_org_rocksdb_ColumnFamilyOptions_arenaBlockSize(
4627 JNIEnv*, jobject, jlong jhandle) {
4628 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4629 ->arena_block_size;
4630 }
4631
4632 /*
4633 * Class: org_rocksdb_ColumnFamilyOptions
4634 * Method: setArenaBlockSize
4635 * Signature: (JJ)V
4636 */
Java_org_rocksdb_ColumnFamilyOptions_setArenaBlockSize(JNIEnv * env,jobject,jlong jhandle,jlong jarena_block_size)4637 void Java_org_rocksdb_ColumnFamilyOptions_setArenaBlockSize(
4638 JNIEnv* env, jobject, jlong jhandle, jlong jarena_block_size) {
4639 auto s =
4640 ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(jarena_block_size);
4641 if (s.ok()) {
4642 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4643 ->arena_block_size = jarena_block_size;
4644 } else {
4645 ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
4646 }
4647 }
4648
4649 /*
4650 * Class: org_rocksdb_ColumnFamilyOptions
4651 * Method: disableAutoCompactions
4652 * Signature: (J)Z
4653 */
Java_org_rocksdb_ColumnFamilyOptions_disableAutoCompactions(JNIEnv *,jobject,jlong jhandle)4654 jboolean Java_org_rocksdb_ColumnFamilyOptions_disableAutoCompactions(
4655 JNIEnv*, jobject, jlong jhandle) {
4656 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4657 ->disable_auto_compactions;
4658 }
4659
4660 /*
4661 * Class: org_rocksdb_ColumnFamilyOptions
4662 * Method: setDisableAutoCompactions
4663 * Signature: (JZ)V
4664 */
Java_org_rocksdb_ColumnFamilyOptions_setDisableAutoCompactions(JNIEnv *,jobject,jlong jhandle,jboolean jdisable_auto_compactions)4665 void Java_org_rocksdb_ColumnFamilyOptions_setDisableAutoCompactions(
4666 JNIEnv*, jobject, jlong jhandle, jboolean jdisable_auto_compactions) {
4667 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4668 ->disable_auto_compactions = static_cast<bool>(jdisable_auto_compactions);
4669 }
4670
4671 /*
4672 * Class: org_rocksdb_ColumnFamilyOptions
4673 * Method: maxSequentialSkipInIterations
4674 * Signature: (J)J
4675 */
Java_org_rocksdb_ColumnFamilyOptions_maxSequentialSkipInIterations(JNIEnv *,jobject,jlong jhandle)4676 jlong Java_org_rocksdb_ColumnFamilyOptions_maxSequentialSkipInIterations(
4677 JNIEnv*, jobject, jlong jhandle) {
4678 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4679 ->max_sequential_skip_in_iterations;
4680 }
4681
4682 /*
4683 * Class: org_rocksdb_ColumnFamilyOptions
4684 * Method: setMaxSequentialSkipInIterations
4685 * Signature: (JJ)V
4686 */
Java_org_rocksdb_ColumnFamilyOptions_setMaxSequentialSkipInIterations(JNIEnv *,jobject,jlong jhandle,jlong jmax_sequential_skip_in_iterations)4687 void Java_org_rocksdb_ColumnFamilyOptions_setMaxSequentialSkipInIterations(
4688 JNIEnv*, jobject, jlong jhandle,
4689 jlong jmax_sequential_skip_in_iterations) {
4690 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4691 ->max_sequential_skip_in_iterations =
4692 static_cast<int64_t>(jmax_sequential_skip_in_iterations);
4693 }
4694
4695 /*
4696 * Class: org_rocksdb_ColumnFamilyOptions
4697 * Method: inplaceUpdateSupport
4698 * Signature: (J)Z
4699 */
Java_org_rocksdb_ColumnFamilyOptions_inplaceUpdateSupport(JNIEnv *,jobject,jlong jhandle)4700 jboolean Java_org_rocksdb_ColumnFamilyOptions_inplaceUpdateSupport(
4701 JNIEnv*, jobject, jlong jhandle) {
4702 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4703 ->inplace_update_support;
4704 }
4705
4706 /*
4707 * Class: org_rocksdb_ColumnFamilyOptions
4708 * Method: setInplaceUpdateSupport
4709 * Signature: (JZ)V
4710 */
Java_org_rocksdb_ColumnFamilyOptions_setInplaceUpdateSupport(JNIEnv *,jobject,jlong jhandle,jboolean jinplace_update_support)4711 void Java_org_rocksdb_ColumnFamilyOptions_setInplaceUpdateSupport(
4712 JNIEnv*, jobject, jlong jhandle, jboolean jinplace_update_support) {
4713 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4714 ->inplace_update_support = static_cast<bool>(jinplace_update_support);
4715 }
4716
4717 /*
4718 * Class: org_rocksdb_ColumnFamilyOptions
4719 * Method: inplaceUpdateNumLocks
4720 * Signature: (J)J
4721 */
Java_org_rocksdb_ColumnFamilyOptions_inplaceUpdateNumLocks(JNIEnv *,jobject,jlong jhandle)4722 jlong Java_org_rocksdb_ColumnFamilyOptions_inplaceUpdateNumLocks(
4723 JNIEnv*, jobject, jlong jhandle) {
4724 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4725 ->inplace_update_num_locks;
4726 }
4727
4728 /*
4729 * Class: org_rocksdb_ColumnFamilyOptions
4730 * Method: setInplaceUpdateNumLocks
4731 * Signature: (JJ)V
4732 */
Java_org_rocksdb_ColumnFamilyOptions_setInplaceUpdateNumLocks(JNIEnv * env,jobject,jlong jhandle,jlong jinplace_update_num_locks)4733 void Java_org_rocksdb_ColumnFamilyOptions_setInplaceUpdateNumLocks(
4734 JNIEnv* env, jobject, jlong jhandle, jlong jinplace_update_num_locks) {
4735 auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
4736 jinplace_update_num_locks);
4737 if (s.ok()) {
4738 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4739 ->inplace_update_num_locks = jinplace_update_num_locks;
4740 } else {
4741 ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
4742 }
4743 }
4744
4745 /*
4746 * Class: org_rocksdb_ColumnFamilyOptions
4747 * Method: memtablePrefixBloomSizeRatio
4748 * Signature: (J)I
4749 */
Java_org_rocksdb_ColumnFamilyOptions_memtablePrefixBloomSizeRatio(JNIEnv *,jobject,jlong jhandle)4750 jdouble Java_org_rocksdb_ColumnFamilyOptions_memtablePrefixBloomSizeRatio(
4751 JNIEnv*, jobject, jlong jhandle) {
4752 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4753 ->memtable_prefix_bloom_size_ratio;
4754 }
4755
4756 /*
4757 * Class: org_rocksdb_ColumnFamilyOptions
4758 * Method: setMemtablePrefixBloomSizeRatio
4759 * Signature: (JI)V
4760 */
Java_org_rocksdb_ColumnFamilyOptions_setMemtablePrefixBloomSizeRatio(JNIEnv *,jobject,jlong jhandle,jdouble jmemtable_prefix_bloom_size_ratio)4761 void Java_org_rocksdb_ColumnFamilyOptions_setMemtablePrefixBloomSizeRatio(
4762 JNIEnv*, jobject, jlong jhandle,
4763 jdouble jmemtable_prefix_bloom_size_ratio) {
4764 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4765 ->memtable_prefix_bloom_size_ratio =
4766 static_cast<double>(jmemtable_prefix_bloom_size_ratio);
4767 }
4768
4769 /*
4770 * Class: org_rocksdb_ColumnFamilyOptions
4771 * Method: bloomLocality
4772 * Signature: (J)I
4773 */
Java_org_rocksdb_ColumnFamilyOptions_bloomLocality(JNIEnv *,jobject,jlong jhandle)4774 jint Java_org_rocksdb_ColumnFamilyOptions_bloomLocality(
4775 JNIEnv*, jobject, jlong jhandle) {
4776 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4777 ->bloom_locality;
4778 }
4779
4780 /*
4781 * Class: org_rocksdb_ColumnFamilyOptions
4782 * Method: setBloomLocality
4783 * Signature: (JI)V
4784 */
Java_org_rocksdb_ColumnFamilyOptions_setBloomLocality(JNIEnv *,jobject,jlong jhandle,jint jbloom_locality)4785 void Java_org_rocksdb_ColumnFamilyOptions_setBloomLocality(
4786 JNIEnv*, jobject, jlong jhandle, jint jbloom_locality) {
4787 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4788 ->bloom_locality = static_cast<int32_t>(jbloom_locality);
4789 }
4790
4791 /*
4792 * Class: org_rocksdb_ColumnFamilyOptions
4793 * Method: maxSuccessiveMerges
4794 * Signature: (J)J
4795 */
Java_org_rocksdb_ColumnFamilyOptions_maxSuccessiveMerges(JNIEnv *,jobject,jlong jhandle)4796 jlong Java_org_rocksdb_ColumnFamilyOptions_maxSuccessiveMerges(
4797 JNIEnv*, jobject, jlong jhandle) {
4798 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4799 ->max_successive_merges;
4800 }
4801
4802 /*
4803 * Class: org_rocksdb_ColumnFamilyOptions
4804 * Method: setMaxSuccessiveMerges
4805 * Signature: (JJ)V
4806 */
Java_org_rocksdb_ColumnFamilyOptions_setMaxSuccessiveMerges(JNIEnv * env,jobject,jlong jhandle,jlong jmax_successive_merges)4807 void Java_org_rocksdb_ColumnFamilyOptions_setMaxSuccessiveMerges(
4808 JNIEnv* env, jobject, jlong jhandle, jlong jmax_successive_merges) {
4809 auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
4810 jmax_successive_merges);
4811 if (s.ok()) {
4812 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4813 ->max_successive_merges = jmax_successive_merges;
4814 } else {
4815 ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
4816 }
4817 }
4818
4819 /*
4820 * Class: org_rocksdb_ColumnFamilyOptions
4821 * Method: optimizeFiltersForHits
4822 * Signature: (J)Z
4823 */
Java_org_rocksdb_ColumnFamilyOptions_optimizeFiltersForHits(JNIEnv *,jobject,jlong jhandle)4824 jboolean Java_org_rocksdb_ColumnFamilyOptions_optimizeFiltersForHits(
4825 JNIEnv*, jobject, jlong jhandle) {
4826 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4827 ->optimize_filters_for_hits;
4828 }
4829
4830 /*
4831 * Class: org_rocksdb_ColumnFamilyOptions
4832 * Method: setOptimizeFiltersForHits
4833 * Signature: (JZ)V
4834 */
Java_org_rocksdb_ColumnFamilyOptions_setOptimizeFiltersForHits(JNIEnv *,jobject,jlong jhandle,jboolean joptimize_filters_for_hits)4835 void Java_org_rocksdb_ColumnFamilyOptions_setOptimizeFiltersForHits(
4836 JNIEnv*, jobject, jlong jhandle, jboolean joptimize_filters_for_hits) {
4837 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4838 ->optimize_filters_for_hits =
4839 static_cast<bool>(joptimize_filters_for_hits);
4840 }
4841
4842 /*
4843 * Class: org_rocksdb_ColumnFamilyOptions
4844 * Method: memtableHugePageSize
4845 * Signature: (J)J
4846 */
Java_org_rocksdb_ColumnFamilyOptions_memtableHugePageSize(JNIEnv *,jobject,jlong jhandle)4847 jlong Java_org_rocksdb_ColumnFamilyOptions_memtableHugePageSize(
4848 JNIEnv*, jobject, jlong jhandle) {
4849 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4850 ->memtable_huge_page_size;
4851 }
4852
4853 /*
4854 * Class: org_rocksdb_ColumnFamilyOptions
4855 * Method: setMemtableHugePageSize
4856 * Signature: (JJ)V
4857 */
Java_org_rocksdb_ColumnFamilyOptions_setMemtableHugePageSize(JNIEnv * env,jobject,jlong jhandle,jlong jmemtable_huge_page_size)4858 void Java_org_rocksdb_ColumnFamilyOptions_setMemtableHugePageSize(
4859 JNIEnv* env, jobject, jlong jhandle, jlong jmemtable_huge_page_size) {
4860 auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
4861 jmemtable_huge_page_size);
4862 if (s.ok()) {
4863 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4864 ->memtable_huge_page_size = jmemtable_huge_page_size;
4865 } else {
4866 ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
4867 }
4868 }
4869
4870 /*
4871 * Class: org_rocksdb_ColumnFamilyOptions
4872 * Method: softPendingCompactionBytesLimit
4873 * Signature: (J)J
4874 */
Java_org_rocksdb_ColumnFamilyOptions_softPendingCompactionBytesLimit(JNIEnv *,jobject,jlong jhandle)4875 jlong Java_org_rocksdb_ColumnFamilyOptions_softPendingCompactionBytesLimit(
4876 JNIEnv*, jobject, jlong jhandle) {
4877 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4878 ->soft_pending_compaction_bytes_limit;
4879 }
4880
4881 /*
4882 * Class: org_rocksdb_ColumnFamilyOptions
4883 * Method: setSoftPendingCompactionBytesLimit
4884 * Signature: (JJ)V
4885 */
Java_org_rocksdb_ColumnFamilyOptions_setSoftPendingCompactionBytesLimit(JNIEnv *,jobject,jlong jhandle,jlong jsoft_pending_compaction_bytes_limit)4886 void Java_org_rocksdb_ColumnFamilyOptions_setSoftPendingCompactionBytesLimit(
4887 JNIEnv*, jobject, jlong jhandle,
4888 jlong jsoft_pending_compaction_bytes_limit) {
4889 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4890 ->soft_pending_compaction_bytes_limit =
4891 static_cast<int64_t>(jsoft_pending_compaction_bytes_limit);
4892 }
4893
4894 /*
4895 * Class: org_rocksdb_ColumnFamilyOptions
4896 * Method: softHardCompactionBytesLimit
4897 * Signature: (J)J
4898 */
Java_org_rocksdb_ColumnFamilyOptions_hardPendingCompactionBytesLimit(JNIEnv *,jobject,jlong jhandle)4899 jlong Java_org_rocksdb_ColumnFamilyOptions_hardPendingCompactionBytesLimit(
4900 JNIEnv*, jobject, jlong jhandle) {
4901 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4902 ->hard_pending_compaction_bytes_limit;
4903 }
4904
4905 /*
4906 * Class: org_rocksdb_ColumnFamilyOptions
4907 * Method: setHardPendingCompactionBytesLimit
4908 * Signature: (JJ)V
4909 */
Java_org_rocksdb_ColumnFamilyOptions_setHardPendingCompactionBytesLimit(JNIEnv *,jobject,jlong jhandle,jlong jhard_pending_compaction_bytes_limit)4910 void Java_org_rocksdb_ColumnFamilyOptions_setHardPendingCompactionBytesLimit(
4911 JNIEnv*, jobject, jlong jhandle,
4912 jlong jhard_pending_compaction_bytes_limit) {
4913 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4914 ->hard_pending_compaction_bytes_limit =
4915 static_cast<int64_t>(jhard_pending_compaction_bytes_limit);
4916 }
4917
4918 /*
4919 * Class: org_rocksdb_ColumnFamilyOptions
4920 * Method: level0FileNumCompactionTrigger
4921 * Signature: (J)I
4922 */
Java_org_rocksdb_ColumnFamilyOptions_level0FileNumCompactionTrigger(JNIEnv *,jobject,jlong jhandle)4923 jint Java_org_rocksdb_ColumnFamilyOptions_level0FileNumCompactionTrigger(
4924 JNIEnv*, jobject, jlong jhandle) {
4925 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4926 ->level0_file_num_compaction_trigger;
4927 }
4928
4929 /*
4930 * Class: org_rocksdb_ColumnFamilyOptions
4931 * Method: setLevel0FileNumCompactionTrigger
4932 * Signature: (JI)V
4933 */
Java_org_rocksdb_ColumnFamilyOptions_setLevel0FileNumCompactionTrigger(JNIEnv *,jobject,jlong jhandle,jint jlevel0_file_num_compaction_trigger)4934 void Java_org_rocksdb_ColumnFamilyOptions_setLevel0FileNumCompactionTrigger(
4935 JNIEnv*, jobject, jlong jhandle,
4936 jint jlevel0_file_num_compaction_trigger) {
4937 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4938 ->level0_file_num_compaction_trigger =
4939 static_cast<int32_t>(jlevel0_file_num_compaction_trigger);
4940 }
4941
4942 /*
4943 * Class: org_rocksdb_ColumnFamilyOptions
4944 * Method: level0SlowdownWritesTrigger
4945 * Signature: (J)I
4946 */
Java_org_rocksdb_ColumnFamilyOptions_level0SlowdownWritesTrigger(JNIEnv *,jobject,jlong jhandle)4947 jint Java_org_rocksdb_ColumnFamilyOptions_level0SlowdownWritesTrigger(
4948 JNIEnv*, jobject, jlong jhandle) {
4949 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4950 ->level0_slowdown_writes_trigger;
4951 }
4952
4953 /*
4954 * Class: org_rocksdb_ColumnFamilyOptions
4955 * Method: setLevel0SlowdownWritesTrigger
4956 * Signature: (JI)V
4957 */
Java_org_rocksdb_ColumnFamilyOptions_setLevel0SlowdownWritesTrigger(JNIEnv *,jobject,jlong jhandle,jint jlevel0_slowdown_writes_trigger)4958 void Java_org_rocksdb_ColumnFamilyOptions_setLevel0SlowdownWritesTrigger(
4959 JNIEnv*, jobject, jlong jhandle, jint jlevel0_slowdown_writes_trigger) {
4960 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4961 ->level0_slowdown_writes_trigger =
4962 static_cast<int32_t>(jlevel0_slowdown_writes_trigger);
4963 }
4964
4965 /*
4966 * Class: org_rocksdb_ColumnFamilyOptions
4967 * Method: level0StopWritesTrigger
4968 * Signature: (J)I
4969 */
Java_org_rocksdb_ColumnFamilyOptions_level0StopWritesTrigger(JNIEnv *,jobject,jlong jhandle)4970 jint Java_org_rocksdb_ColumnFamilyOptions_level0StopWritesTrigger(
4971 JNIEnv*, jobject, jlong jhandle) {
4972 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4973 ->level0_stop_writes_trigger;
4974 }
4975
4976 /*
4977 * Class: org_rocksdb_ColumnFamilyOptions
4978 * Method: setLevel0StopWritesTrigger
4979 * Signature: (JI)V
4980 */
Java_org_rocksdb_ColumnFamilyOptions_setLevel0StopWritesTrigger(JNIEnv *,jobject,jlong jhandle,jint jlevel0_stop_writes_trigger)4981 void Java_org_rocksdb_ColumnFamilyOptions_setLevel0StopWritesTrigger(
4982 JNIEnv*, jobject, jlong jhandle, jint jlevel0_stop_writes_trigger) {
4983 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4984 ->level0_stop_writes_trigger =
4985 static_cast<int32_t>(jlevel0_stop_writes_trigger);
4986 }
4987
4988 /*
4989 * Class: org_rocksdb_ColumnFamilyOptions
4990 * Method: maxBytesForLevelMultiplierAdditional
4991 * Signature: (J)[I
4992 */
Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelMultiplierAdditional(JNIEnv * env,jobject,jlong jhandle)4993 jintArray Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelMultiplierAdditional(
4994 JNIEnv* env, jobject, jlong jhandle) {
4995 auto mbflma =
4996 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
4997 ->max_bytes_for_level_multiplier_additional;
4998
4999 const size_t size = mbflma.size();
5000
5001 jint* additionals = new jint[size];
5002 for (size_t i = 0; i < size; i++) {
5003 additionals[i] = static_cast<jint>(mbflma[i]);
5004 }
5005
5006 jsize jlen = static_cast<jsize>(size);
5007 jintArray result = env->NewIntArray(jlen);
5008 if (result == nullptr) {
5009 // exception thrown: OutOfMemoryError
5010 delete[] additionals;
5011 return nullptr;
5012 }
5013 env->SetIntArrayRegion(result, 0, jlen, additionals);
5014 if (env->ExceptionCheck()) {
5015 // exception thrown: ArrayIndexOutOfBoundsException
5016 env->DeleteLocalRef(result);
5017 delete[] additionals;
5018 return nullptr;
5019 }
5020
5021 delete[] additionals;
5022
5023 return result;
5024 }
5025
5026 /*
5027 * Class: org_rocksdb_ColumnFamilyOptions
5028 * Method: setMaxBytesForLevelMultiplierAdditional
5029 * Signature: (J[I)V
5030 */
Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplierAdditional(JNIEnv * env,jobject,jlong jhandle,jintArray jmax_bytes_for_level_multiplier_additional)5031 void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplierAdditional(
5032 JNIEnv* env, jobject, jlong jhandle,
5033 jintArray jmax_bytes_for_level_multiplier_additional) {
5034 jsize len = env->GetArrayLength(jmax_bytes_for_level_multiplier_additional);
5035 jint* additionals = env->GetIntArrayElements(
5036 jmax_bytes_for_level_multiplier_additional, nullptr);
5037 if (additionals == nullptr) {
5038 // exception thrown: OutOfMemoryError
5039 return;
5040 }
5041
5042 auto* cf_opt =
5043 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
5044 cf_opt->max_bytes_for_level_multiplier_additional.clear();
5045 for (jsize i = 0; i < len; i++) {
5046 cf_opt->max_bytes_for_level_multiplier_additional.push_back(
5047 static_cast<int32_t>(additionals[i]));
5048 }
5049
5050 env->ReleaseIntArrayElements(jmax_bytes_for_level_multiplier_additional,
5051 additionals, JNI_ABORT);
5052 }
5053
5054 /*
5055 * Class: org_rocksdb_ColumnFamilyOptions
5056 * Method: paranoidFileChecks
5057 * Signature: (J)Z
5058 */
Java_org_rocksdb_ColumnFamilyOptions_paranoidFileChecks(JNIEnv *,jobject,jlong jhandle)5059 jboolean Java_org_rocksdb_ColumnFamilyOptions_paranoidFileChecks(
5060 JNIEnv*, jobject, jlong jhandle) {
5061 return reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
5062 ->paranoid_file_checks;
5063 }
5064
5065 /*
5066 * Class: org_rocksdb_ColumnFamilyOptions
5067 * Method: setParanoidFileChecks
5068 * Signature: (JZ)V
5069 */
Java_org_rocksdb_ColumnFamilyOptions_setParanoidFileChecks(JNIEnv *,jobject,jlong jhandle,jboolean jparanoid_file_checks)5070 void Java_org_rocksdb_ColumnFamilyOptions_setParanoidFileChecks(
5071 JNIEnv*, jobject, jlong jhandle, jboolean jparanoid_file_checks) {
5072 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle)
5073 ->paranoid_file_checks = static_cast<bool>(jparanoid_file_checks);
5074 }
5075
5076 /*
5077 * Class: org_rocksdb_ColumnFamilyOptions
5078 * Method: setCompactionPriority
5079 * Signature: (JB)V
5080 */
Java_org_rocksdb_ColumnFamilyOptions_setCompactionPriority(JNIEnv *,jobject,jlong jhandle,jbyte jcompaction_priority_value)5081 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionPriority(
5082 JNIEnv*, jobject, jlong jhandle, jbyte jcompaction_priority_value) {
5083 auto* cf_opts =
5084 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
5085 cf_opts->compaction_pri =
5086 ROCKSDB_NAMESPACE::CompactionPriorityJni::toCppCompactionPriority(
5087 jcompaction_priority_value);
5088 }
5089
5090 /*
5091 * Class: org_rocksdb_ColumnFamilyOptions
5092 * Method: compactionPriority
5093 * Signature: (J)B
5094 */
Java_org_rocksdb_ColumnFamilyOptions_compactionPriority(JNIEnv *,jobject,jlong jhandle)5095 jbyte Java_org_rocksdb_ColumnFamilyOptions_compactionPriority(
5096 JNIEnv*, jobject, jlong jhandle) {
5097 auto* cf_opts =
5098 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
5099 return ROCKSDB_NAMESPACE::CompactionPriorityJni::toJavaCompactionPriority(
5100 cf_opts->compaction_pri);
5101 }
5102
5103 /*
5104 * Class: org_rocksdb_ColumnFamilyOptions
5105 * Method: setReportBgIoStats
5106 * Signature: (JZ)V
5107 */
Java_org_rocksdb_ColumnFamilyOptions_setReportBgIoStats(JNIEnv *,jobject,jlong jhandle,jboolean jreport_bg_io_stats)5108 void Java_org_rocksdb_ColumnFamilyOptions_setReportBgIoStats(
5109 JNIEnv*, jobject, jlong jhandle, jboolean jreport_bg_io_stats) {
5110 auto* cf_opts =
5111 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
5112 cf_opts->report_bg_io_stats = static_cast<bool>(jreport_bg_io_stats);
5113 }
5114
5115 /*
5116 * Class: org_rocksdb_ColumnFamilyOptions
5117 * Method: reportBgIoStats
5118 * Signature: (J)Z
5119 */
Java_org_rocksdb_ColumnFamilyOptions_reportBgIoStats(JNIEnv *,jobject,jlong jhandle)5120 jboolean Java_org_rocksdb_ColumnFamilyOptions_reportBgIoStats(
5121 JNIEnv*, jobject, jlong jhandle) {
5122 auto* cf_opts =
5123 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
5124 return static_cast<bool>(cf_opts->report_bg_io_stats);
5125 }
5126
5127 /*
5128 * Class: org_rocksdb_ColumnFamilyOptions
5129 * Method: setTtl
5130 * Signature: (JJ)V
5131 */
Java_org_rocksdb_ColumnFamilyOptions_setTtl(JNIEnv *,jobject,jlong jhandle,jlong jttl)5132 void Java_org_rocksdb_ColumnFamilyOptions_setTtl(
5133 JNIEnv*, jobject, jlong jhandle, jlong jttl) {
5134 auto* cf_opts =
5135 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
5136 cf_opts->ttl = static_cast<uint64_t>(jttl);
5137 }
5138
5139 /*
5140 * Class: org_rocksdb_ColumnFamilyOptions
5141 * Method: ttl
5142 * Signature: (J)J
5143 */
Java_org_rocksdb_ColumnFamilyOptions_ttl(JNIEnv *,jobject,jlong jhandle)5144 JNIEXPORT jlong JNICALL Java_org_rocksdb_ColumnFamilyOptions_ttl(
5145 JNIEnv*, jobject, jlong jhandle) {
5146 auto* cf_opts =
5147 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
5148 return static_cast<jlong>(cf_opts->ttl);
5149 }
5150
5151 /*
5152 * Class: org_rocksdb_ColumnFamilyOptions
5153 * Method: setCompactionOptionsUniversal
5154 * Signature: (JJ)V
5155 */
Java_org_rocksdb_ColumnFamilyOptions_setCompactionOptionsUniversal(JNIEnv *,jobject,jlong jhandle,jlong jcompaction_options_universal_handle)5156 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionOptionsUniversal(
5157 JNIEnv*, jobject, jlong jhandle,
5158 jlong jcompaction_options_universal_handle) {
5159 auto* cf_opts =
5160 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
5161 auto* opts_uni =
5162 reinterpret_cast<ROCKSDB_NAMESPACE::CompactionOptionsUniversal*>(
5163 jcompaction_options_universal_handle);
5164 cf_opts->compaction_options_universal = *opts_uni;
5165 }
5166
5167 /*
5168 * Class: org_rocksdb_ColumnFamilyOptions
5169 * Method: setCompactionOptionsFIFO
5170 * Signature: (JJ)V
5171 */
Java_org_rocksdb_ColumnFamilyOptions_setCompactionOptionsFIFO(JNIEnv *,jobject,jlong jhandle,jlong jcompaction_options_fifo_handle)5172 void Java_org_rocksdb_ColumnFamilyOptions_setCompactionOptionsFIFO(
5173 JNIEnv*, jobject, jlong jhandle, jlong jcompaction_options_fifo_handle) {
5174 auto* cf_opts =
5175 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
5176 auto* opts_fifo = reinterpret_cast<ROCKSDB_NAMESPACE::CompactionOptionsFIFO*>(
5177 jcompaction_options_fifo_handle);
5178 cf_opts->compaction_options_fifo = *opts_fifo;
5179 }
5180
5181 /*
5182 * Class: org_rocksdb_ColumnFamilyOptions
5183 * Method: setForceConsistencyChecks
5184 * Signature: (JZ)V
5185 */
Java_org_rocksdb_ColumnFamilyOptions_setForceConsistencyChecks(JNIEnv *,jobject,jlong jhandle,jboolean jforce_consistency_checks)5186 void Java_org_rocksdb_ColumnFamilyOptions_setForceConsistencyChecks(
5187 JNIEnv*, jobject, jlong jhandle, jboolean jforce_consistency_checks) {
5188 auto* cf_opts =
5189 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
5190 cf_opts->force_consistency_checks =
5191 static_cast<bool>(jforce_consistency_checks);
5192 }
5193
5194 /*
5195 * Class: org_rocksdb_ColumnFamilyOptions
5196 * Method: forceConsistencyChecks
5197 * Signature: (J)Z
5198 */
Java_org_rocksdb_ColumnFamilyOptions_forceConsistencyChecks(JNIEnv *,jobject,jlong jhandle)5199 jboolean Java_org_rocksdb_ColumnFamilyOptions_forceConsistencyChecks(
5200 JNIEnv*, jobject, jlong jhandle) {
5201 auto* cf_opts =
5202 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jhandle);
5203 return static_cast<bool>(cf_opts->force_consistency_checks);
5204 }
5205
5206 /////////////////////////////////////////////////////////////////////
5207 // ROCKSDB_NAMESPACE::DBOptions
5208
5209 /*
5210 * Class: org_rocksdb_DBOptions
5211 * Method: newDBOptions
5212 * Signature: ()J
5213 */
Java_org_rocksdb_DBOptions_newDBOptions(JNIEnv *,jclass)5214 jlong Java_org_rocksdb_DBOptions_newDBOptions(
5215 JNIEnv*, jclass) {
5216 auto* dbop = new ROCKSDB_NAMESPACE::DBOptions();
5217 return reinterpret_cast<jlong>(dbop);
5218 }
5219
5220 /*
5221 * Class: org_rocksdb_DBOptions
5222 * Method: copyDBOptions
5223 * Signature: (J)J
5224 */
Java_org_rocksdb_DBOptions_copyDBOptions(JNIEnv *,jclass,jlong jhandle)5225 jlong Java_org_rocksdb_DBOptions_copyDBOptions(
5226 JNIEnv*, jclass, jlong jhandle) {
5227 auto new_opt = new ROCKSDB_NAMESPACE::DBOptions(
5228 *(reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)));
5229 return reinterpret_cast<jlong>(new_opt);
5230 }
5231
5232 /*
5233 * Class: org_rocksdb_DBOptions
5234 * Method: newDBOptionsFromOptions
5235 * Signature: (J)J
5236 */
Java_org_rocksdb_DBOptions_newDBOptionsFromOptions(JNIEnv *,jclass,jlong joptions_handle)5237 jlong Java_org_rocksdb_DBOptions_newDBOptionsFromOptions(
5238 JNIEnv*, jclass, jlong joptions_handle) {
5239 auto new_opt = new ROCKSDB_NAMESPACE::DBOptions(
5240 *reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(joptions_handle));
5241 return reinterpret_cast<jlong>(new_opt);
5242 }
5243
5244 /*
5245 * Class: org_rocksdb_DBOptions
5246 * Method: getDBOptionsFromProps
5247 * Signature: (JLjava/lang/String;)J
5248 */
Java_org_rocksdb_DBOptions_getDBOptionsFromProps__JLjava_lang_String_2(JNIEnv * env,jclass,jlong config_handle,jstring jopt_string)5249 jlong Java_org_rocksdb_DBOptions_getDBOptionsFromProps__JLjava_lang_String_2(
5250 JNIEnv* env, jclass, jlong config_handle, jstring jopt_string) {
5251 const char* opt_string = env->GetStringUTFChars(jopt_string, nullptr);
5252 if (opt_string == nullptr) {
5253 // exception thrown: OutOfMemoryError
5254 return 0;
5255 }
5256
5257 auto* config_options =
5258 reinterpret_cast<ROCKSDB_NAMESPACE::ConfigOptions*>(config_handle);
5259 auto* db_options = new ROCKSDB_NAMESPACE::DBOptions();
5260 ROCKSDB_NAMESPACE::Status status = ROCKSDB_NAMESPACE::GetDBOptionsFromString(
5261 *config_options, ROCKSDB_NAMESPACE::DBOptions(), opt_string, db_options);
5262
5263 env->ReleaseStringUTFChars(jopt_string, opt_string);
5264
5265 // Check if DBOptions creation was possible.
5266 jlong ret_value = 0;
5267 if (status.ok()) {
5268 ret_value = reinterpret_cast<jlong>(db_options);
5269 } else {
5270 // if operation failed the DBOptions need to be deleted
5271 // again to prevent a memory leak.
5272 delete db_options;
5273 }
5274 return ret_value;
5275 }
5276
5277 /*
5278 * Class: org_rocksdb_DBOptions
5279 * Method: getDBOptionsFromProps
5280 * Signature: (Ljava/util/String;)J
5281 */
Java_org_rocksdb_DBOptions_getDBOptionsFromProps__Ljava_lang_String_2(JNIEnv * env,jclass,jstring jopt_string)5282 jlong Java_org_rocksdb_DBOptions_getDBOptionsFromProps__Ljava_lang_String_2(
5283 JNIEnv* env, jclass, jstring jopt_string) {
5284 const char* opt_string = env->GetStringUTFChars(jopt_string, nullptr);
5285 if (opt_string == nullptr) {
5286 // exception thrown: OutOfMemoryError
5287 return 0;
5288 }
5289
5290 auto* db_options = new ROCKSDB_NAMESPACE::DBOptions();
5291 ROCKSDB_NAMESPACE::Status status = ROCKSDB_NAMESPACE::GetDBOptionsFromString(
5292 ROCKSDB_NAMESPACE::DBOptions(), opt_string, db_options);
5293
5294 env->ReleaseStringUTFChars(jopt_string, opt_string);
5295
5296 // Check if DBOptions creation was possible.
5297 jlong ret_value = 0;
5298 if (status.ok()) {
5299 ret_value = reinterpret_cast<jlong>(db_options);
5300 } else {
5301 // if operation failed the DBOptions need to be deleted
5302 // again to prevent a memory leak.
5303 delete db_options;
5304 }
5305 return ret_value;
5306 }
5307
5308 /*
5309 * Class: org_rocksdb_DBOptions
5310 * Method: disposeInternal
5311 * Signature: (J)V
5312 */
Java_org_rocksdb_DBOptions_disposeInternal(JNIEnv *,jobject,jlong handle)5313 void Java_org_rocksdb_DBOptions_disposeInternal(
5314 JNIEnv*, jobject, jlong handle) {
5315 auto* dbo = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(handle);
5316 assert(dbo != nullptr);
5317 delete dbo;
5318 }
5319
5320 /*
5321 * Class: org_rocksdb_DBOptions
5322 * Method: optimizeForSmallDb
5323 * Signature: (J)V
5324 */
Java_org_rocksdb_DBOptions_optimizeForSmallDb(JNIEnv *,jobject,jlong jhandle)5325 void Java_org_rocksdb_DBOptions_optimizeForSmallDb(
5326 JNIEnv*, jobject, jlong jhandle) {
5327 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5328 ->OptimizeForSmallDb();
5329 }
5330
5331 /*
5332 * Class: org_rocksdb_DBOptions
5333 * Method: setEnv
5334 * Signature: (JJ)V
5335 */
Java_org_rocksdb_DBOptions_setEnv(JNIEnv *,jobject,jlong jhandle,jlong jenv_handle)5336 void Java_org_rocksdb_DBOptions_setEnv(
5337 JNIEnv*, jobject, jlong jhandle, jlong jenv_handle) {
5338 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->env =
5339 reinterpret_cast<ROCKSDB_NAMESPACE::Env*>(jenv_handle);
5340 }
5341
5342 /*
5343 * Class: org_rocksdb_DBOptions
5344 * Method: setIncreaseParallelism
5345 * Signature: (JI)V
5346 */
Java_org_rocksdb_DBOptions_setIncreaseParallelism(JNIEnv *,jobject,jlong jhandle,jint totalThreads)5347 void Java_org_rocksdb_DBOptions_setIncreaseParallelism(
5348 JNIEnv*, jobject, jlong jhandle, jint totalThreads) {
5349 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->IncreaseParallelism(
5350 static_cast<int>(totalThreads));
5351 }
5352
5353 /*
5354 * Class: org_rocksdb_DBOptions
5355 * Method: setCreateIfMissing
5356 * Signature: (JZ)V
5357 */
Java_org_rocksdb_DBOptions_setCreateIfMissing(JNIEnv *,jobject,jlong jhandle,jboolean flag)5358 void Java_org_rocksdb_DBOptions_setCreateIfMissing(
5359 JNIEnv*, jobject, jlong jhandle, jboolean flag) {
5360 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->create_if_missing =
5361 flag;
5362 }
5363
5364 /*
5365 * Class: org_rocksdb_DBOptions
5366 * Method: createIfMissing
5367 * Signature: (J)Z
5368 */
Java_org_rocksdb_DBOptions_createIfMissing(JNIEnv *,jobject,jlong jhandle)5369 jboolean Java_org_rocksdb_DBOptions_createIfMissing(
5370 JNIEnv*, jobject, jlong jhandle) {
5371 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5372 ->create_if_missing;
5373 }
5374
5375 /*
5376 * Class: org_rocksdb_DBOptions
5377 * Method: setCreateMissingColumnFamilies
5378 * Signature: (JZ)V
5379 */
Java_org_rocksdb_DBOptions_setCreateMissingColumnFamilies(JNIEnv *,jobject,jlong jhandle,jboolean flag)5380 void Java_org_rocksdb_DBOptions_setCreateMissingColumnFamilies(
5381 JNIEnv*, jobject, jlong jhandle, jboolean flag) {
5382 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5383 ->create_missing_column_families = flag;
5384 }
5385
5386 /*
5387 * Class: org_rocksdb_DBOptions
5388 * Method: createMissingColumnFamilies
5389 * Signature: (J)Z
5390 */
Java_org_rocksdb_DBOptions_createMissingColumnFamilies(JNIEnv *,jobject,jlong jhandle)5391 jboolean Java_org_rocksdb_DBOptions_createMissingColumnFamilies(
5392 JNIEnv*, jobject, jlong jhandle) {
5393 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5394 ->create_missing_column_families;
5395 }
5396
5397 /*
5398 * Class: org_rocksdb_DBOptions
5399 * Method: setErrorIfExists
5400 * Signature: (JZ)V
5401 */
Java_org_rocksdb_DBOptions_setErrorIfExists(JNIEnv *,jobject,jlong jhandle,jboolean error_if_exists)5402 void Java_org_rocksdb_DBOptions_setErrorIfExists(
5403 JNIEnv*, jobject, jlong jhandle, jboolean error_if_exists) {
5404 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->error_if_exists =
5405 static_cast<bool>(error_if_exists);
5406 }
5407
5408 /*
5409 * Class: org_rocksdb_DBOptions
5410 * Method: errorIfExists
5411 * Signature: (J)Z
5412 */
Java_org_rocksdb_DBOptions_errorIfExists(JNIEnv *,jobject,jlong jhandle)5413 jboolean Java_org_rocksdb_DBOptions_errorIfExists(
5414 JNIEnv*, jobject, jlong jhandle) {
5415 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5416 ->error_if_exists;
5417 }
5418
5419 /*
5420 * Class: org_rocksdb_DBOptions
5421 * Method: setParanoidChecks
5422 * Signature: (JZ)V
5423 */
Java_org_rocksdb_DBOptions_setParanoidChecks(JNIEnv *,jobject,jlong jhandle,jboolean paranoid_checks)5424 void Java_org_rocksdb_DBOptions_setParanoidChecks(
5425 JNIEnv*, jobject, jlong jhandle, jboolean paranoid_checks) {
5426 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->paranoid_checks =
5427 static_cast<bool>(paranoid_checks);
5428 }
5429
5430 /*
5431 * Class: org_rocksdb_DBOptions
5432 * Method: paranoidChecks
5433 * Signature: (J)Z
5434 */
Java_org_rocksdb_DBOptions_paranoidChecks(JNIEnv *,jobject,jlong jhandle)5435 jboolean Java_org_rocksdb_DBOptions_paranoidChecks(
5436 JNIEnv*, jobject, jlong jhandle) {
5437 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5438 ->paranoid_checks;
5439 }
5440
5441 /*
5442 * Class: org_rocksdb_DBOptions
5443 * Method: setRateLimiter
5444 * Signature: (JJ)V
5445 */
Java_org_rocksdb_DBOptions_setRateLimiter(JNIEnv *,jobject,jlong jhandle,jlong jrate_limiter_handle)5446 void Java_org_rocksdb_DBOptions_setRateLimiter(
5447 JNIEnv*, jobject, jlong jhandle, jlong jrate_limiter_handle) {
5448 std::shared_ptr<ROCKSDB_NAMESPACE::RateLimiter>* pRateLimiter =
5449 reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::RateLimiter>*>(
5450 jrate_limiter_handle);
5451 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->rate_limiter =
5452 *pRateLimiter;
5453 }
5454
5455 /*
5456 * Class: org_rocksdb_DBOptions
5457 * Method: setSstFileManager
5458 * Signature: (JJ)V
5459 */
Java_org_rocksdb_DBOptions_setSstFileManager(JNIEnv *,jobject,jlong jhandle,jlong jsst_file_manager_handle)5460 void Java_org_rocksdb_DBOptions_setSstFileManager(
5461 JNIEnv*, jobject, jlong jhandle, jlong jsst_file_manager_handle) {
5462 auto* sptr_sst_file_manager =
5463 reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::SstFileManager>*>(
5464 jsst_file_manager_handle);
5465 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->sst_file_manager =
5466 *sptr_sst_file_manager;
5467 }
5468
5469 /*
5470 * Class: org_rocksdb_DBOptions
5471 * Method: setLogger
5472 * Signature: (JJ)V
5473 */
Java_org_rocksdb_DBOptions_setLogger(JNIEnv *,jobject,jlong jhandle,jlong jlogger_handle)5474 void Java_org_rocksdb_DBOptions_setLogger(
5475 JNIEnv*, jobject, jlong jhandle, jlong jlogger_handle) {
5476 std::shared_ptr<ROCKSDB_NAMESPACE::LoggerJniCallback>* pLogger =
5477 reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::LoggerJniCallback>*>(
5478 jlogger_handle);
5479 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->info_log = *pLogger;
5480 }
5481
5482 /*
5483 * Class: org_rocksdb_DBOptions
5484 * Method: setInfoLogLevel
5485 * Signature: (JB)V
5486 */
Java_org_rocksdb_DBOptions_setInfoLogLevel(JNIEnv *,jobject,jlong jhandle,jbyte jlog_level)5487 void Java_org_rocksdb_DBOptions_setInfoLogLevel(
5488 JNIEnv*, jobject, jlong jhandle, jbyte jlog_level) {
5489 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->info_log_level =
5490 static_cast<ROCKSDB_NAMESPACE::InfoLogLevel>(jlog_level);
5491 }
5492
5493 /*
5494 * Class: org_rocksdb_DBOptions
5495 * Method: infoLogLevel
5496 * Signature: (J)B
5497 */
Java_org_rocksdb_DBOptions_infoLogLevel(JNIEnv *,jobject,jlong jhandle)5498 jbyte Java_org_rocksdb_DBOptions_infoLogLevel(
5499 JNIEnv*, jobject, jlong jhandle) {
5500 return static_cast<jbyte>(
5501 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->info_log_level);
5502 }
5503
5504 /*
5505 * Class: org_rocksdb_DBOptions
5506 * Method: setMaxTotalWalSize
5507 * Signature: (JJ)V
5508 */
Java_org_rocksdb_DBOptions_setMaxTotalWalSize(JNIEnv *,jobject,jlong jhandle,jlong jmax_total_wal_size)5509 void Java_org_rocksdb_DBOptions_setMaxTotalWalSize(
5510 JNIEnv*, jobject, jlong jhandle, jlong jmax_total_wal_size) {
5511 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->max_total_wal_size =
5512 static_cast<jlong>(jmax_total_wal_size);
5513 }
5514
5515 /*
5516 * Class: org_rocksdb_DBOptions
5517 * Method: maxTotalWalSize
5518 * Signature: (J)J
5519 */
Java_org_rocksdb_DBOptions_maxTotalWalSize(JNIEnv *,jobject,jlong jhandle)5520 jlong Java_org_rocksdb_DBOptions_maxTotalWalSize(
5521 JNIEnv*, jobject, jlong jhandle) {
5522 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5523 ->max_total_wal_size;
5524 }
5525
5526 /*
5527 * Class: org_rocksdb_DBOptions
5528 * Method: setMaxOpenFiles
5529 * Signature: (JI)V
5530 */
Java_org_rocksdb_DBOptions_setMaxOpenFiles(JNIEnv *,jobject,jlong jhandle,jint max_open_files)5531 void Java_org_rocksdb_DBOptions_setMaxOpenFiles(
5532 JNIEnv*, jobject, jlong jhandle, jint max_open_files) {
5533 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->max_open_files =
5534 static_cast<int>(max_open_files);
5535 }
5536
5537 /*
5538 * Class: org_rocksdb_DBOptions
5539 * Method: maxOpenFiles
5540 * Signature: (J)I
5541 */
Java_org_rocksdb_DBOptions_maxOpenFiles(JNIEnv *,jobject,jlong jhandle)5542 jint Java_org_rocksdb_DBOptions_maxOpenFiles(
5543 JNIEnv*, jobject, jlong jhandle) {
5544 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5545 ->max_open_files;
5546 }
5547
5548 /*
5549 * Class: org_rocksdb_DBOptions
5550 * Method: setMaxFileOpeningThreads
5551 * Signature: (JI)V
5552 */
Java_org_rocksdb_DBOptions_setMaxFileOpeningThreads(JNIEnv *,jobject,jlong jhandle,jint jmax_file_opening_threads)5553 void Java_org_rocksdb_DBOptions_setMaxFileOpeningThreads(
5554 JNIEnv*, jobject, jlong jhandle, jint jmax_file_opening_threads) {
5555 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5556 ->max_file_opening_threads = static_cast<int>(jmax_file_opening_threads);
5557 }
5558
5559 /*
5560 * Class: org_rocksdb_DBOptions
5561 * Method: maxFileOpeningThreads
5562 * Signature: (J)I
5563 */
Java_org_rocksdb_DBOptions_maxFileOpeningThreads(JNIEnv *,jobject,jlong jhandle)5564 jint Java_org_rocksdb_DBOptions_maxFileOpeningThreads(
5565 JNIEnv*, jobject, jlong jhandle) {
5566 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5567 return static_cast<int>(opt->max_file_opening_threads);
5568 }
5569
5570 /*
5571 * Class: org_rocksdb_DBOptions
5572 * Method: setStatistics
5573 * Signature: (JJ)V
5574 */
Java_org_rocksdb_DBOptions_setStatistics(JNIEnv *,jobject,jlong jhandle,jlong jstatistics_handle)5575 void Java_org_rocksdb_DBOptions_setStatistics(
5576 JNIEnv*, jobject, jlong jhandle, jlong jstatistics_handle) {
5577 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5578 auto* pSptr =
5579 reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::StatisticsJni>*>(
5580 jstatistics_handle);
5581 opt->statistics = *pSptr;
5582 }
5583
5584 /*
5585 * Class: org_rocksdb_DBOptions
5586 * Method: statistics
5587 * Signature: (J)J
5588 */
Java_org_rocksdb_DBOptions_statistics(JNIEnv *,jobject,jlong jhandle)5589 jlong Java_org_rocksdb_DBOptions_statistics(
5590 JNIEnv*, jobject, jlong jhandle) {
5591 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5592 std::shared_ptr<ROCKSDB_NAMESPACE::Statistics> sptr = opt->statistics;
5593 if (sptr == nullptr) {
5594 return 0;
5595 } else {
5596 std::shared_ptr<ROCKSDB_NAMESPACE::Statistics>* pSptr =
5597 new std::shared_ptr<ROCKSDB_NAMESPACE::Statistics>(sptr);
5598 return reinterpret_cast<jlong>(pSptr);
5599 }
5600 }
5601
5602 /*
5603 * Class: org_rocksdb_DBOptions
5604 * Method: setUseFsync
5605 * Signature: (JZ)V
5606 */
Java_org_rocksdb_DBOptions_setUseFsync(JNIEnv *,jobject,jlong jhandle,jboolean use_fsync)5607 void Java_org_rocksdb_DBOptions_setUseFsync(
5608 JNIEnv*, jobject, jlong jhandle, jboolean use_fsync) {
5609 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->use_fsync =
5610 static_cast<bool>(use_fsync);
5611 }
5612
5613 /*
5614 * Class: org_rocksdb_DBOptions
5615 * Method: useFsync
5616 * Signature: (J)Z
5617 */
Java_org_rocksdb_DBOptions_useFsync(JNIEnv *,jobject,jlong jhandle)5618 jboolean Java_org_rocksdb_DBOptions_useFsync(
5619 JNIEnv*, jobject, jlong jhandle) {
5620 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->use_fsync;
5621 }
5622
5623 /*
5624 * Class: org_rocksdb_DBOptions
5625 * Method: setDbPaths
5626 * Signature: (J[Ljava/lang/String;[J)V
5627 */
Java_org_rocksdb_DBOptions_setDbPaths(JNIEnv * env,jobject,jlong jhandle,jobjectArray jpaths,jlongArray jtarget_sizes)5628 void Java_org_rocksdb_DBOptions_setDbPaths(
5629 JNIEnv* env, jobject, jlong jhandle, jobjectArray jpaths,
5630 jlongArray jtarget_sizes) {
5631 std::vector<ROCKSDB_NAMESPACE::DbPath> db_paths;
5632 jlong* ptr_jtarget_size = env->GetLongArrayElements(jtarget_sizes, nullptr);
5633 if (ptr_jtarget_size == nullptr) {
5634 // exception thrown: OutOfMemoryError
5635 return;
5636 }
5637
5638 jboolean has_exception = JNI_FALSE;
5639 const jsize len = env->GetArrayLength(jpaths);
5640 for (jsize i = 0; i < len; i++) {
5641 jobject jpath =
5642 reinterpret_cast<jstring>(env->GetObjectArrayElement(jpaths, i));
5643 if (env->ExceptionCheck()) {
5644 // exception thrown: ArrayIndexOutOfBoundsException
5645 env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
5646 return;
5647 }
5648 std::string path = ROCKSDB_NAMESPACE::JniUtil::copyStdString(
5649 env, static_cast<jstring>(jpath), &has_exception);
5650 env->DeleteLocalRef(jpath);
5651
5652 if (has_exception == JNI_TRUE) {
5653 env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
5654 return;
5655 }
5656
5657 jlong jtarget_size = ptr_jtarget_size[i];
5658
5659 db_paths.push_back(
5660 ROCKSDB_NAMESPACE::DbPath(path, static_cast<uint64_t>(jtarget_size)));
5661 }
5662
5663 env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
5664
5665 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5666 opt->db_paths = db_paths;
5667 }
5668
5669 /*
5670 * Class: org_rocksdb_DBOptions
5671 * Method: dbPathsLen
5672 * Signature: (J)J
5673 */
Java_org_rocksdb_DBOptions_dbPathsLen(JNIEnv *,jobject,jlong jhandle)5674 jlong Java_org_rocksdb_DBOptions_dbPathsLen(
5675 JNIEnv*, jobject, jlong jhandle) {
5676 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5677 return static_cast<jlong>(opt->db_paths.size());
5678 }
5679
5680 /*
5681 * Class: org_rocksdb_DBOptions
5682 * Method: dbPaths
5683 * Signature: (J[Ljava/lang/String;[J)V
5684 */
Java_org_rocksdb_DBOptions_dbPaths(JNIEnv * env,jobject,jlong jhandle,jobjectArray jpaths,jlongArray jtarget_sizes)5685 void Java_org_rocksdb_DBOptions_dbPaths(
5686 JNIEnv* env, jobject, jlong jhandle, jobjectArray jpaths,
5687 jlongArray jtarget_sizes) {
5688 jboolean is_copy;
5689 jlong* ptr_jtarget_size = env->GetLongArrayElements(jtarget_sizes, &is_copy);
5690 if (ptr_jtarget_size == nullptr) {
5691 // exception thrown: OutOfMemoryError
5692 return;
5693 }
5694
5695 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
5696 const jsize len = env->GetArrayLength(jpaths);
5697 for (jsize i = 0; i < len; i++) {
5698 ROCKSDB_NAMESPACE::DbPath db_path = opt->db_paths[i];
5699
5700 jstring jpath = env->NewStringUTF(db_path.path.c_str());
5701 if (jpath == nullptr) {
5702 // exception thrown: OutOfMemoryError
5703 env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
5704 return;
5705 }
5706 env->SetObjectArrayElement(jpaths, i, jpath);
5707 if (env->ExceptionCheck()) {
5708 // exception thrown: ArrayIndexOutOfBoundsException
5709 env->DeleteLocalRef(jpath);
5710 env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size, JNI_ABORT);
5711 return;
5712 }
5713
5714 ptr_jtarget_size[i] = static_cast<jint>(db_path.target_size);
5715 }
5716
5717 env->ReleaseLongArrayElements(jtarget_sizes, ptr_jtarget_size,
5718 is_copy == JNI_TRUE ? 0 : JNI_ABORT);
5719 }
5720
5721 /*
5722 * Class: org_rocksdb_DBOptions
5723 * Method: setDbLogDir
5724 * Signature: (JLjava/lang/String)V
5725 */
Java_org_rocksdb_DBOptions_setDbLogDir(JNIEnv * env,jobject,jlong jhandle,jstring jdb_log_dir)5726 void Java_org_rocksdb_DBOptions_setDbLogDir(
5727 JNIEnv* env, jobject, jlong jhandle, jstring jdb_log_dir) {
5728 const char* log_dir = env->GetStringUTFChars(jdb_log_dir, nullptr);
5729 if (log_dir == nullptr) {
5730 // exception thrown: OutOfMemoryError
5731 return;
5732 }
5733
5734 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->db_log_dir.assign(
5735 log_dir);
5736 env->ReleaseStringUTFChars(jdb_log_dir, log_dir);
5737 }
5738
5739 /*
5740 * Class: org_rocksdb_DBOptions
5741 * Method: dbLogDir
5742 * Signature: (J)Ljava/lang/String
5743 */
Java_org_rocksdb_DBOptions_dbLogDir(JNIEnv * env,jobject,jlong jhandle)5744 jstring Java_org_rocksdb_DBOptions_dbLogDir(
5745 JNIEnv* env, jobject, jlong jhandle) {
5746 return env->NewStringUTF(
5747 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5748 ->db_log_dir.c_str());
5749 }
5750
5751 /*
5752 * Class: org_rocksdb_DBOptions
5753 * Method: setWalDir
5754 * Signature: (JLjava/lang/String)V
5755 */
Java_org_rocksdb_DBOptions_setWalDir(JNIEnv * env,jobject,jlong jhandle,jstring jwal_dir)5756 void Java_org_rocksdb_DBOptions_setWalDir(
5757 JNIEnv* env, jobject, jlong jhandle, jstring jwal_dir) {
5758 const char* wal_dir = env->GetStringUTFChars(jwal_dir, 0);
5759 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->wal_dir.assign(
5760 wal_dir);
5761 env->ReleaseStringUTFChars(jwal_dir, wal_dir);
5762 }
5763
5764 /*
5765 * Class: org_rocksdb_DBOptions
5766 * Method: walDir
5767 * Signature: (J)Ljava/lang/String
5768 */
Java_org_rocksdb_DBOptions_walDir(JNIEnv * env,jobject,jlong jhandle)5769 jstring Java_org_rocksdb_DBOptions_walDir(
5770 JNIEnv* env, jobject, jlong jhandle) {
5771 return env->NewStringUTF(
5772 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5773 ->wal_dir.c_str());
5774 }
5775
5776 /*
5777 * Class: org_rocksdb_DBOptions
5778 * Method: setDeleteObsoleteFilesPeriodMicros
5779 * Signature: (JJ)V
5780 */
Java_org_rocksdb_DBOptions_setDeleteObsoleteFilesPeriodMicros(JNIEnv *,jobject,jlong jhandle,jlong micros)5781 void Java_org_rocksdb_DBOptions_setDeleteObsoleteFilesPeriodMicros(
5782 JNIEnv*, jobject, jlong jhandle, jlong micros) {
5783 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5784 ->delete_obsolete_files_period_micros = static_cast<int64_t>(micros);
5785 }
5786
5787 /*
5788 * Class: org_rocksdb_DBOptions
5789 * Method: deleteObsoleteFilesPeriodMicros
5790 * Signature: (J)J
5791 */
Java_org_rocksdb_DBOptions_deleteObsoleteFilesPeriodMicros(JNIEnv *,jobject,jlong jhandle)5792 jlong Java_org_rocksdb_DBOptions_deleteObsoleteFilesPeriodMicros(
5793 JNIEnv*, jobject, jlong jhandle) {
5794 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5795 ->delete_obsolete_files_period_micros;
5796 }
5797
5798 /*
5799 * Class: org_rocksdb_DBOptions
5800 * Method: setBaseBackgroundCompactions
5801 * Signature: (JI)V
5802 */
Java_org_rocksdb_DBOptions_setBaseBackgroundCompactions(JNIEnv *,jobject,jlong jhandle,jint max)5803 void Java_org_rocksdb_DBOptions_setBaseBackgroundCompactions(
5804 JNIEnv*, jobject, jlong jhandle, jint max) {
5805 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5806 ->base_background_compactions = static_cast<int>(max);
5807 }
5808
5809 /*
5810 * Class: org_rocksdb_DBOptions
5811 * Method: baseBackgroundCompactions
5812 * Signature: (J)I
5813 */
Java_org_rocksdb_DBOptions_baseBackgroundCompactions(JNIEnv *,jobject,jlong jhandle)5814 jint Java_org_rocksdb_DBOptions_baseBackgroundCompactions(
5815 JNIEnv*, jobject, jlong jhandle) {
5816 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5817 ->base_background_compactions;
5818 }
5819
5820 /*
5821 * Class: org_rocksdb_DBOptions
5822 * Method: setMaxBackgroundCompactions
5823 * Signature: (JI)V
5824 */
Java_org_rocksdb_DBOptions_setMaxBackgroundCompactions(JNIEnv *,jobject,jlong jhandle,jint max)5825 void Java_org_rocksdb_DBOptions_setMaxBackgroundCompactions(
5826 JNIEnv*, jobject, jlong jhandle, jint max) {
5827 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5828 ->max_background_compactions = static_cast<int>(max);
5829 }
5830
5831 /*
5832 * Class: org_rocksdb_DBOptions
5833 * Method: maxBackgroundCompactions
5834 * Signature: (J)I
5835 */
Java_org_rocksdb_DBOptions_maxBackgroundCompactions(JNIEnv *,jobject,jlong jhandle)5836 jint Java_org_rocksdb_DBOptions_maxBackgroundCompactions(
5837 JNIEnv*, jobject, jlong jhandle) {
5838 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5839 ->max_background_compactions;
5840 }
5841
5842 /*
5843 * Class: org_rocksdb_DBOptions
5844 * Method: setMaxSubcompactions
5845 * Signature: (JI)V
5846 */
Java_org_rocksdb_DBOptions_setMaxSubcompactions(JNIEnv *,jobject,jlong jhandle,jint max)5847 void Java_org_rocksdb_DBOptions_setMaxSubcompactions(
5848 JNIEnv*, jobject, jlong jhandle, jint max) {
5849 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->max_subcompactions =
5850 static_cast<int32_t>(max);
5851 }
5852
5853 /*
5854 * Class: org_rocksdb_DBOptions
5855 * Method: maxSubcompactions
5856 * Signature: (J)I
5857 */
Java_org_rocksdb_DBOptions_maxSubcompactions(JNIEnv *,jobject,jlong jhandle)5858 jint Java_org_rocksdb_DBOptions_maxSubcompactions(
5859 JNIEnv*, jobject, jlong jhandle) {
5860 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5861 ->max_subcompactions;
5862 }
5863
5864 /*
5865 * Class: org_rocksdb_DBOptions
5866 * Method: setMaxBackgroundFlushes
5867 * Signature: (JI)V
5868 */
Java_org_rocksdb_DBOptions_setMaxBackgroundFlushes(JNIEnv *,jobject,jlong jhandle,jint max_background_flushes)5869 void Java_org_rocksdb_DBOptions_setMaxBackgroundFlushes(
5870 JNIEnv*, jobject, jlong jhandle, jint max_background_flushes) {
5871 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5872 ->max_background_flushes = static_cast<int>(max_background_flushes);
5873 }
5874
5875 /*
5876 * Class: org_rocksdb_DBOptions
5877 * Method: maxBackgroundFlushes
5878 * Signature: (J)I
5879 */
Java_org_rocksdb_DBOptions_maxBackgroundFlushes(JNIEnv *,jobject,jlong jhandle)5880 jint Java_org_rocksdb_DBOptions_maxBackgroundFlushes(
5881 JNIEnv*, jobject, jlong jhandle) {
5882 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5883 ->max_background_flushes;
5884 }
5885
5886 /*
5887 * Class: org_rocksdb_DBOptions
5888 * Method: setMaxBackgroundJobs
5889 * Signature: (JI)V
5890 */
Java_org_rocksdb_DBOptions_setMaxBackgroundJobs(JNIEnv *,jobject,jlong jhandle,jint max_background_jobs)5891 void Java_org_rocksdb_DBOptions_setMaxBackgroundJobs(
5892 JNIEnv*, jobject, jlong jhandle, jint max_background_jobs) {
5893 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5894 ->max_background_jobs = static_cast<int>(max_background_jobs);
5895 }
5896
5897 /*
5898 * Class: org_rocksdb_DBOptions
5899 * Method: maxBackgroundJobs
5900 * Signature: (J)I
5901 */
Java_org_rocksdb_DBOptions_maxBackgroundJobs(JNIEnv *,jobject,jlong jhandle)5902 jint Java_org_rocksdb_DBOptions_maxBackgroundJobs(
5903 JNIEnv*, jobject, jlong jhandle) {
5904 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5905 ->max_background_jobs;
5906 }
5907
5908 /*
5909 * Class: org_rocksdb_DBOptions
5910 * Method: setMaxLogFileSize
5911 * Signature: (JJ)V
5912 */
Java_org_rocksdb_DBOptions_setMaxLogFileSize(JNIEnv * env,jobject,jlong jhandle,jlong max_log_file_size)5913 void Java_org_rocksdb_DBOptions_setMaxLogFileSize(
5914 JNIEnv* env, jobject, jlong jhandle, jlong max_log_file_size) {
5915 auto s =
5916 ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(max_log_file_size);
5917 if (s.ok()) {
5918 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5919 ->max_log_file_size = max_log_file_size;
5920 } else {
5921 ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
5922 }
5923 }
5924
5925 /*
5926 * Class: org_rocksdb_DBOptions
5927 * Method: maxLogFileSize
5928 * Signature: (J)J
5929 */
Java_org_rocksdb_DBOptions_maxLogFileSize(JNIEnv *,jobject,jlong jhandle)5930 jlong Java_org_rocksdb_DBOptions_maxLogFileSize(
5931 JNIEnv*, jobject, jlong jhandle) {
5932 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5933 ->max_log_file_size;
5934 }
5935
5936 /*
5937 * Class: org_rocksdb_DBOptions
5938 * Method: setLogFileTimeToRoll
5939 * Signature: (JJ)V
5940 */
Java_org_rocksdb_DBOptions_setLogFileTimeToRoll(JNIEnv * env,jobject,jlong jhandle,jlong log_file_time_to_roll)5941 void Java_org_rocksdb_DBOptions_setLogFileTimeToRoll(
5942 JNIEnv* env, jobject, jlong jhandle, jlong log_file_time_to_roll) {
5943 auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
5944 log_file_time_to_roll);
5945 if (s.ok()) {
5946 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5947 ->log_file_time_to_roll = log_file_time_to_roll;
5948 } else {
5949 ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
5950 }
5951 }
5952
5953 /*
5954 * Class: org_rocksdb_DBOptions
5955 * Method: logFileTimeToRoll
5956 * Signature: (J)J
5957 */
Java_org_rocksdb_DBOptions_logFileTimeToRoll(JNIEnv *,jobject,jlong jhandle)5958 jlong Java_org_rocksdb_DBOptions_logFileTimeToRoll(
5959 JNIEnv*, jobject, jlong jhandle) {
5960 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5961 ->log_file_time_to_roll;
5962 }
5963
5964 /*
5965 * Class: org_rocksdb_DBOptions
5966 * Method: setKeepLogFileNum
5967 * Signature: (JJ)V
5968 */
Java_org_rocksdb_DBOptions_setKeepLogFileNum(JNIEnv * env,jobject,jlong jhandle,jlong keep_log_file_num)5969 void Java_org_rocksdb_DBOptions_setKeepLogFileNum(
5970 JNIEnv* env, jobject, jlong jhandle, jlong keep_log_file_num) {
5971 auto s =
5972 ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(keep_log_file_num);
5973 if (s.ok()) {
5974 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5975 ->keep_log_file_num = keep_log_file_num;
5976 } else {
5977 ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
5978 }
5979 }
5980
5981 /*
5982 * Class: org_rocksdb_DBOptions
5983 * Method: keepLogFileNum
5984 * Signature: (J)J
5985 */
Java_org_rocksdb_DBOptions_keepLogFileNum(JNIEnv *,jobject,jlong jhandle)5986 jlong Java_org_rocksdb_DBOptions_keepLogFileNum(
5987 JNIEnv*, jobject, jlong jhandle) {
5988 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
5989 ->keep_log_file_num;
5990 }
5991
5992 /*
5993 * Class: org_rocksdb_DBOptions
5994 * Method: setRecycleLogFileNum
5995 * Signature: (JJ)V
5996 */
Java_org_rocksdb_DBOptions_setRecycleLogFileNum(JNIEnv * env,jobject,jlong jhandle,jlong recycle_log_file_num)5997 void Java_org_rocksdb_DBOptions_setRecycleLogFileNum(
5998 JNIEnv* env, jobject, jlong jhandle, jlong recycle_log_file_num) {
5999 auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
6000 recycle_log_file_num);
6001 if (s.ok()) {
6002 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6003 ->recycle_log_file_num = recycle_log_file_num;
6004 } else {
6005 ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
6006 }
6007 }
6008
6009 /*
6010 * Class: org_rocksdb_DBOptions
6011 * Method: recycleLogFileNum
6012 * Signature: (J)J
6013 */
Java_org_rocksdb_DBOptions_recycleLogFileNum(JNIEnv *,jobject,jlong jhandle)6014 jlong Java_org_rocksdb_DBOptions_recycleLogFileNum(
6015 JNIEnv*, jobject, jlong jhandle) {
6016 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6017 ->recycle_log_file_num;
6018 }
6019
6020 /*
6021 * Class: org_rocksdb_DBOptions
6022 * Method: setMaxManifestFileSize
6023 * Signature: (JJ)V
6024 */
Java_org_rocksdb_DBOptions_setMaxManifestFileSize(JNIEnv *,jobject,jlong jhandle,jlong max_manifest_file_size)6025 void Java_org_rocksdb_DBOptions_setMaxManifestFileSize(
6026 JNIEnv*, jobject, jlong jhandle, jlong max_manifest_file_size) {
6027 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6028 ->max_manifest_file_size = static_cast<int64_t>(max_manifest_file_size);
6029 }
6030
6031 /*
6032 * Class: org_rocksdb_DBOptions
6033 * Method: maxManifestFileSize
6034 * Signature: (J)J
6035 */
Java_org_rocksdb_DBOptions_maxManifestFileSize(JNIEnv *,jobject,jlong jhandle)6036 jlong Java_org_rocksdb_DBOptions_maxManifestFileSize(
6037 JNIEnv*, jobject, jlong jhandle) {
6038 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6039 ->max_manifest_file_size;
6040 }
6041
6042 /*
6043 * Class: org_rocksdb_DBOptions
6044 * Method: setTableCacheNumshardbits
6045 * Signature: (JI)V
6046 */
Java_org_rocksdb_DBOptions_setTableCacheNumshardbits(JNIEnv *,jobject,jlong jhandle,jint table_cache_numshardbits)6047 void Java_org_rocksdb_DBOptions_setTableCacheNumshardbits(
6048 JNIEnv*, jobject, jlong jhandle, jint table_cache_numshardbits) {
6049 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6050 ->table_cache_numshardbits = static_cast<int>(table_cache_numshardbits);
6051 }
6052
6053 /*
6054 * Class: org_rocksdb_DBOptions
6055 * Method: tableCacheNumshardbits
6056 * Signature: (J)I
6057 */
Java_org_rocksdb_DBOptions_tableCacheNumshardbits(JNIEnv *,jobject,jlong jhandle)6058 jint Java_org_rocksdb_DBOptions_tableCacheNumshardbits(
6059 JNIEnv*, jobject, jlong jhandle) {
6060 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6061 ->table_cache_numshardbits;
6062 }
6063
6064 /*
6065 * Class: org_rocksdb_DBOptions
6066 * Method: setWalTtlSeconds
6067 * Signature: (JJ)V
6068 */
Java_org_rocksdb_DBOptions_setWalTtlSeconds(JNIEnv *,jobject,jlong jhandle,jlong WAL_ttl_seconds)6069 void Java_org_rocksdb_DBOptions_setWalTtlSeconds(
6070 JNIEnv*, jobject, jlong jhandle, jlong WAL_ttl_seconds) {
6071 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->WAL_ttl_seconds =
6072 static_cast<int64_t>(WAL_ttl_seconds);
6073 }
6074
6075 /*
6076 * Class: org_rocksdb_DBOptions
6077 * Method: walTtlSeconds
6078 * Signature: (J)J
6079 */
Java_org_rocksdb_DBOptions_walTtlSeconds(JNIEnv *,jobject,jlong jhandle)6080 jlong Java_org_rocksdb_DBOptions_walTtlSeconds(
6081 JNIEnv*, jobject, jlong jhandle) {
6082 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6083 ->WAL_ttl_seconds;
6084 }
6085
6086 /*
6087 * Class: org_rocksdb_DBOptions
6088 * Method: setWalSizeLimitMB
6089 * Signature: (JJ)V
6090 */
Java_org_rocksdb_DBOptions_setWalSizeLimitMB(JNIEnv *,jobject,jlong jhandle,jlong WAL_size_limit_MB)6091 void Java_org_rocksdb_DBOptions_setWalSizeLimitMB(
6092 JNIEnv*, jobject, jlong jhandle, jlong WAL_size_limit_MB) {
6093 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->WAL_size_limit_MB =
6094 static_cast<int64_t>(WAL_size_limit_MB);
6095 }
6096
6097 /*
6098 * Class: org_rocksdb_DBOptions
6099 * Method: walTtlSeconds
6100 * Signature: (J)J
6101 */
Java_org_rocksdb_DBOptions_walSizeLimitMB(JNIEnv *,jobject,jlong jhandle)6102 jlong Java_org_rocksdb_DBOptions_walSizeLimitMB(
6103 JNIEnv*, jobject, jlong jhandle) {
6104 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6105 ->WAL_size_limit_MB;
6106 }
6107
6108 /*
6109 * Class: org_rocksdb_DBOptions
6110 * Method: setMaxWriteBatchGroupSizeBytes
6111 * Signature: (JJ)V
6112 */
Java_org_rocksdb_DBOptions_setMaxWriteBatchGroupSizeBytes(JNIEnv *,jclass,jlong jhandle,jlong jmax_write_batch_group_size_bytes)6113 void Java_org_rocksdb_DBOptions_setMaxWriteBatchGroupSizeBytes(
6114 JNIEnv*, jclass, jlong jhandle, jlong jmax_write_batch_group_size_bytes) {
6115 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6116 opt->max_write_batch_group_size_bytes =
6117 static_cast<uint64_t>(jmax_write_batch_group_size_bytes);
6118 }
6119
6120 /*
6121 * Class: org_rocksdb_DBOptions
6122 * Method: maxWriteBatchGroupSizeBytes
6123 * Signature: (J)J
6124 */
Java_org_rocksdb_DBOptions_maxWriteBatchGroupSizeBytes(JNIEnv *,jclass,jlong jhandle)6125 jlong Java_org_rocksdb_DBOptions_maxWriteBatchGroupSizeBytes(JNIEnv*, jclass,
6126 jlong jhandle) {
6127 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6128 return static_cast<jlong>(opt->max_write_batch_group_size_bytes);
6129 }
6130
6131 /*
6132 * Class: org_rocksdb_DBOptions
6133 * Method: setManifestPreallocationSize
6134 * Signature: (JJ)V
6135 */
Java_org_rocksdb_DBOptions_setManifestPreallocationSize(JNIEnv * env,jobject,jlong jhandle,jlong preallocation_size)6136 void Java_org_rocksdb_DBOptions_setManifestPreallocationSize(
6137 JNIEnv* env, jobject, jlong jhandle, jlong preallocation_size) {
6138 auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(
6139 preallocation_size);
6140 if (s.ok()) {
6141 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6142 ->manifest_preallocation_size = preallocation_size;
6143 } else {
6144 ROCKSDB_NAMESPACE::IllegalArgumentExceptionJni::ThrowNew(env, s);
6145 }
6146 }
6147
6148 /*
6149 * Class: org_rocksdb_DBOptions
6150 * Method: manifestPreallocationSize
6151 * Signature: (J)J
6152 */
Java_org_rocksdb_DBOptions_manifestPreallocationSize(JNIEnv *,jobject,jlong jhandle)6153 jlong Java_org_rocksdb_DBOptions_manifestPreallocationSize(
6154 JNIEnv*, jobject, jlong jhandle) {
6155 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6156 ->manifest_preallocation_size;
6157 }
6158
6159 /*
6160 * Class: org_rocksdb_DBOptions
6161 * Method: useDirectReads
6162 * Signature: (J)Z
6163 */
Java_org_rocksdb_DBOptions_useDirectReads(JNIEnv *,jobject,jlong jhandle)6164 jboolean Java_org_rocksdb_DBOptions_useDirectReads(
6165 JNIEnv*, jobject, jlong jhandle) {
6166 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6167 ->use_direct_reads;
6168 }
6169
6170 /*
6171 * Class: org_rocksdb_DBOptions
6172 * Method: setUseDirectReads
6173 * Signature: (JZ)V
6174 */
Java_org_rocksdb_DBOptions_setUseDirectReads(JNIEnv *,jobject,jlong jhandle,jboolean use_direct_reads)6175 void Java_org_rocksdb_DBOptions_setUseDirectReads(
6176 JNIEnv*, jobject, jlong jhandle, jboolean use_direct_reads) {
6177 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->use_direct_reads =
6178 static_cast<bool>(use_direct_reads);
6179 }
6180
6181 /*
6182 * Class: org_rocksdb_DBOptions
6183 * Method: useDirectIoForFlushAndCompaction
6184 * Signature: (J)Z
6185 */
Java_org_rocksdb_DBOptions_useDirectIoForFlushAndCompaction(JNIEnv *,jobject,jlong jhandle)6186 jboolean Java_org_rocksdb_DBOptions_useDirectIoForFlushAndCompaction(
6187 JNIEnv*, jobject, jlong jhandle) {
6188 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6189 ->use_direct_io_for_flush_and_compaction;
6190 }
6191
6192 /*
6193 * Class: org_rocksdb_DBOptions
6194 * Method: setUseDirectReads
6195 * Signature: (JZ)V
6196 */
Java_org_rocksdb_DBOptions_setUseDirectIoForFlushAndCompaction(JNIEnv *,jobject,jlong jhandle,jboolean use_direct_io_for_flush_and_compaction)6197 void Java_org_rocksdb_DBOptions_setUseDirectIoForFlushAndCompaction(
6198 JNIEnv*, jobject, jlong jhandle,
6199 jboolean use_direct_io_for_flush_and_compaction) {
6200 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6201 ->use_direct_io_for_flush_and_compaction =
6202 static_cast<bool>(use_direct_io_for_flush_and_compaction);
6203 }
6204
6205 /*
6206 * Class: org_rocksdb_DBOptions
6207 * Method: setAllowFAllocate
6208 * Signature: (JZ)V
6209 */
Java_org_rocksdb_DBOptions_setAllowFAllocate(JNIEnv *,jobject,jlong jhandle,jboolean jallow_fallocate)6210 void Java_org_rocksdb_DBOptions_setAllowFAllocate(
6211 JNIEnv*, jobject, jlong jhandle, jboolean jallow_fallocate) {
6212 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->allow_fallocate =
6213 static_cast<bool>(jallow_fallocate);
6214 }
6215
6216 /*
6217 * Class: org_rocksdb_DBOptions
6218 * Method: allowFAllocate
6219 * Signature: (J)Z
6220 */
Java_org_rocksdb_DBOptions_allowFAllocate(JNIEnv *,jobject,jlong jhandle)6221 jboolean Java_org_rocksdb_DBOptions_allowFAllocate(
6222 JNIEnv*, jobject, jlong jhandle) {
6223 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6224 return static_cast<jboolean>(opt->allow_fallocate);
6225 }
6226
6227 /*
6228 * Class: org_rocksdb_DBOptions
6229 * Method: setAllowMmapReads
6230 * Signature: (JZ)V
6231 */
Java_org_rocksdb_DBOptions_setAllowMmapReads(JNIEnv *,jobject,jlong jhandle,jboolean allow_mmap_reads)6232 void Java_org_rocksdb_DBOptions_setAllowMmapReads(
6233 JNIEnv*, jobject, jlong jhandle, jboolean allow_mmap_reads) {
6234 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->allow_mmap_reads =
6235 static_cast<bool>(allow_mmap_reads);
6236 }
6237
6238 /*
6239 * Class: org_rocksdb_DBOptions
6240 * Method: allowMmapReads
6241 * Signature: (J)Z
6242 */
Java_org_rocksdb_DBOptions_allowMmapReads(JNIEnv *,jobject,jlong jhandle)6243 jboolean Java_org_rocksdb_DBOptions_allowMmapReads(
6244 JNIEnv*, jobject, jlong jhandle) {
6245 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6246 ->allow_mmap_reads;
6247 }
6248
6249 /*
6250 * Class: org_rocksdb_DBOptions
6251 * Method: setAllowMmapWrites
6252 * Signature: (JZ)V
6253 */
Java_org_rocksdb_DBOptions_setAllowMmapWrites(JNIEnv *,jobject,jlong jhandle,jboolean allow_mmap_writes)6254 void Java_org_rocksdb_DBOptions_setAllowMmapWrites(
6255 JNIEnv*, jobject, jlong jhandle, jboolean allow_mmap_writes) {
6256 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->allow_mmap_writes =
6257 static_cast<bool>(allow_mmap_writes);
6258 }
6259
6260 /*
6261 * Class: org_rocksdb_DBOptions
6262 * Method: allowMmapWrites
6263 * Signature: (J)Z
6264 */
Java_org_rocksdb_DBOptions_allowMmapWrites(JNIEnv *,jobject,jlong jhandle)6265 jboolean Java_org_rocksdb_DBOptions_allowMmapWrites(
6266 JNIEnv*, jobject, jlong jhandle) {
6267 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6268 ->allow_mmap_writes;
6269 }
6270
6271 /*
6272 * Class: org_rocksdb_DBOptions
6273 * Method: setIsFdCloseOnExec
6274 * Signature: (JZ)V
6275 */
Java_org_rocksdb_DBOptions_setIsFdCloseOnExec(JNIEnv *,jobject,jlong jhandle,jboolean is_fd_close_on_exec)6276 void Java_org_rocksdb_DBOptions_setIsFdCloseOnExec(
6277 JNIEnv*, jobject, jlong jhandle, jboolean is_fd_close_on_exec) {
6278 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6279 ->is_fd_close_on_exec = static_cast<bool>(is_fd_close_on_exec);
6280 }
6281
6282 /*
6283 * Class: org_rocksdb_DBOptions
6284 * Method: isFdCloseOnExec
6285 * Signature: (J)Z
6286 */
Java_org_rocksdb_DBOptions_isFdCloseOnExec(JNIEnv *,jobject,jlong jhandle)6287 jboolean Java_org_rocksdb_DBOptions_isFdCloseOnExec(
6288 JNIEnv*, jobject, jlong jhandle) {
6289 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6290 ->is_fd_close_on_exec;
6291 }
6292
6293 /*
6294 * Class: org_rocksdb_DBOptions
6295 * Method: setStatsDumpPeriodSec
6296 * Signature: (JI)V
6297 */
Java_org_rocksdb_DBOptions_setStatsDumpPeriodSec(JNIEnv *,jobject,jlong jhandle,jint jstats_dump_period_sec)6298 void Java_org_rocksdb_DBOptions_setStatsDumpPeriodSec(
6299 JNIEnv*, jobject, jlong jhandle, jint jstats_dump_period_sec) {
6300 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6301 ->stats_dump_period_sec =
6302 static_cast<unsigned int>(jstats_dump_period_sec);
6303 }
6304
6305 /*
6306 * Class: org_rocksdb_DBOptions
6307 * Method: statsDumpPeriodSec
6308 * Signature: (J)I
6309 */
Java_org_rocksdb_DBOptions_statsDumpPeriodSec(JNIEnv *,jobject,jlong jhandle)6310 jint Java_org_rocksdb_DBOptions_statsDumpPeriodSec(
6311 JNIEnv*, jobject, jlong jhandle) {
6312 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6313 ->stats_dump_period_sec;
6314 }
6315
6316 /*
6317 * Class: org_rocksdb_DBOptions
6318 * Method: setStatsPersistPeriodSec
6319 * Signature: (JI)V
6320 */
Java_org_rocksdb_DBOptions_setStatsPersistPeriodSec(JNIEnv *,jobject,jlong jhandle,jint jstats_persist_period_sec)6321 void Java_org_rocksdb_DBOptions_setStatsPersistPeriodSec(
6322 JNIEnv*, jobject, jlong jhandle, jint jstats_persist_period_sec) {
6323 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6324 ->stats_persist_period_sec =
6325 static_cast<unsigned int>(jstats_persist_period_sec);
6326 }
6327
6328 /*
6329 * Class: org_rocksdb_DBOptions
6330 * Method: statsPersistPeriodSec
6331 * Signature: (J)I
6332 */
Java_org_rocksdb_DBOptions_statsPersistPeriodSec(JNIEnv *,jobject,jlong jhandle)6333 jint Java_org_rocksdb_DBOptions_statsPersistPeriodSec(
6334 JNIEnv*, jobject, jlong jhandle) {
6335 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6336 ->stats_persist_period_sec;
6337 }
6338
6339 /*
6340 * Class: org_rocksdb_DBOptions
6341 * Method: setStatsHistoryBufferSize
6342 * Signature: (JJ)V
6343 */
Java_org_rocksdb_DBOptions_setStatsHistoryBufferSize(JNIEnv *,jobject,jlong jhandle,jlong jstats_history_buffer_size)6344 void Java_org_rocksdb_DBOptions_setStatsHistoryBufferSize(
6345 JNIEnv*, jobject, jlong jhandle, jlong jstats_history_buffer_size) {
6346 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6347 ->stats_history_buffer_size =
6348 static_cast<size_t>(jstats_history_buffer_size);
6349 }
6350
6351 /*
6352 * Class: org_rocksdb_DBOptions
6353 * Method: statsHistoryBufferSize
6354 * Signature: (J)J
6355 */
Java_org_rocksdb_DBOptions_statsHistoryBufferSize(JNIEnv *,jobject,jlong jhandle)6356 jlong Java_org_rocksdb_DBOptions_statsHistoryBufferSize(
6357 JNIEnv*, jobject, jlong jhandle) {
6358 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6359 ->stats_history_buffer_size;
6360 }
6361
6362 /*
6363 * Class: org_rocksdb_DBOptions
6364 * Method: setAdviseRandomOnOpen
6365 * Signature: (JZ)V
6366 */
Java_org_rocksdb_DBOptions_setAdviseRandomOnOpen(JNIEnv *,jobject,jlong jhandle,jboolean advise_random_on_open)6367 void Java_org_rocksdb_DBOptions_setAdviseRandomOnOpen(
6368 JNIEnv*, jobject, jlong jhandle, jboolean advise_random_on_open) {
6369 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6370 ->advise_random_on_open = static_cast<bool>(advise_random_on_open);
6371 }
6372
6373 /*
6374 * Class: org_rocksdb_DBOptions
6375 * Method: adviseRandomOnOpen
6376 * Signature: (J)Z
6377 */
Java_org_rocksdb_DBOptions_adviseRandomOnOpen(JNIEnv *,jobject,jlong jhandle)6378 jboolean Java_org_rocksdb_DBOptions_adviseRandomOnOpen(
6379 JNIEnv*, jobject, jlong jhandle) {
6380 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6381 ->advise_random_on_open;
6382 }
6383
6384 /*
6385 * Class: org_rocksdb_DBOptions
6386 * Method: setDbWriteBufferSize
6387 * Signature: (JJ)V
6388 */
Java_org_rocksdb_DBOptions_setDbWriteBufferSize(JNIEnv *,jobject,jlong jhandle,jlong jdb_write_buffer_size)6389 void Java_org_rocksdb_DBOptions_setDbWriteBufferSize(
6390 JNIEnv*, jobject, jlong jhandle, jlong jdb_write_buffer_size) {
6391 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6392 opt->db_write_buffer_size = static_cast<size_t>(jdb_write_buffer_size);
6393 }
6394
6395 /*
6396 * Class: org_rocksdb_DBOptions
6397 * Method: setWriteBufferManager
6398 * Signature: (JJ)V
6399 */
Java_org_rocksdb_DBOptions_setWriteBufferManager(JNIEnv *,jobject,jlong jdb_options_handle,jlong jwrite_buffer_manager_handle)6400 void Java_org_rocksdb_DBOptions_setWriteBufferManager(
6401 JNIEnv*, jobject, jlong jdb_options_handle,
6402 jlong jwrite_buffer_manager_handle) {
6403 auto* write_buffer_manager =
6404 reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::WriteBufferManager>*>(
6405 jwrite_buffer_manager_handle);
6406 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jdb_options_handle)
6407 ->write_buffer_manager = *write_buffer_manager;
6408 }
6409
6410 /*
6411 * Class: org_rocksdb_DBOptions
6412 * Method: dbWriteBufferSize
6413 * Signature: (J)J
6414 */
Java_org_rocksdb_DBOptions_dbWriteBufferSize(JNIEnv *,jobject,jlong jhandle)6415 jlong Java_org_rocksdb_DBOptions_dbWriteBufferSize(
6416 JNIEnv*, jobject, jlong jhandle) {
6417 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6418 return static_cast<jlong>(opt->db_write_buffer_size);
6419 }
6420
6421 /*
6422 * Class: org_rocksdb_DBOptions
6423 * Method: setAccessHintOnCompactionStart
6424 * Signature: (JB)V
6425 */
Java_org_rocksdb_DBOptions_setAccessHintOnCompactionStart(JNIEnv *,jobject,jlong jhandle,jbyte jaccess_hint_value)6426 void Java_org_rocksdb_DBOptions_setAccessHintOnCompactionStart(
6427 JNIEnv*, jobject, jlong jhandle, jbyte jaccess_hint_value) {
6428 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6429 opt->access_hint_on_compaction_start =
6430 ROCKSDB_NAMESPACE::AccessHintJni::toCppAccessHint(jaccess_hint_value);
6431 }
6432
6433 /*
6434 * Class: org_rocksdb_DBOptions
6435 * Method: accessHintOnCompactionStart
6436 * Signature: (J)B
6437 */
Java_org_rocksdb_DBOptions_accessHintOnCompactionStart(JNIEnv *,jobject,jlong jhandle)6438 jbyte Java_org_rocksdb_DBOptions_accessHintOnCompactionStart(
6439 JNIEnv*, jobject, jlong jhandle) {
6440 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6441 return ROCKSDB_NAMESPACE::AccessHintJni::toJavaAccessHint(
6442 opt->access_hint_on_compaction_start);
6443 }
6444
6445 /*
6446 * Class: org_rocksdb_DBOptions
6447 * Method: setNewTableReaderForCompactionInputs
6448 * Signature: (JZ)V
6449 */
Java_org_rocksdb_DBOptions_setNewTableReaderForCompactionInputs(JNIEnv *,jobject,jlong jhandle,jboolean jnew_table_reader_for_compaction_inputs)6450 void Java_org_rocksdb_DBOptions_setNewTableReaderForCompactionInputs(
6451 JNIEnv*, jobject, jlong jhandle,
6452 jboolean jnew_table_reader_for_compaction_inputs) {
6453 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6454 opt->new_table_reader_for_compaction_inputs =
6455 static_cast<bool>(jnew_table_reader_for_compaction_inputs);
6456 }
6457
6458 /*
6459 * Class: org_rocksdb_DBOptions
6460 * Method: newTableReaderForCompactionInputs
6461 * Signature: (J)Z
6462 */
Java_org_rocksdb_DBOptions_newTableReaderForCompactionInputs(JNIEnv *,jobject,jlong jhandle)6463 jboolean Java_org_rocksdb_DBOptions_newTableReaderForCompactionInputs(
6464 JNIEnv*, jobject, jlong jhandle) {
6465 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6466 return static_cast<bool>(opt->new_table_reader_for_compaction_inputs);
6467 }
6468
6469 /*
6470 * Class: org_rocksdb_DBOptions
6471 * Method: setCompactionReadaheadSize
6472 * Signature: (JJ)V
6473 */
Java_org_rocksdb_DBOptions_setCompactionReadaheadSize(JNIEnv *,jobject,jlong jhandle,jlong jcompaction_readahead_size)6474 void Java_org_rocksdb_DBOptions_setCompactionReadaheadSize(
6475 JNIEnv*, jobject, jlong jhandle, jlong jcompaction_readahead_size) {
6476 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6477 opt->compaction_readahead_size =
6478 static_cast<size_t>(jcompaction_readahead_size);
6479 }
6480
6481 /*
6482 * Class: org_rocksdb_DBOptions
6483 * Method: compactionReadaheadSize
6484 * Signature: (J)J
6485 */
Java_org_rocksdb_DBOptions_compactionReadaheadSize(JNIEnv *,jobject,jlong jhandle)6486 jlong Java_org_rocksdb_DBOptions_compactionReadaheadSize(
6487 JNIEnv*, jobject, jlong jhandle) {
6488 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6489 return static_cast<jlong>(opt->compaction_readahead_size);
6490 }
6491
6492 /*
6493 * Class: org_rocksdb_DBOptions
6494 * Method: setRandomAccessMaxBufferSize
6495 * Signature: (JJ)V
6496 */
Java_org_rocksdb_DBOptions_setRandomAccessMaxBufferSize(JNIEnv *,jobject,jlong jhandle,jlong jrandom_access_max_buffer_size)6497 void Java_org_rocksdb_DBOptions_setRandomAccessMaxBufferSize(
6498 JNIEnv*, jobject, jlong jhandle, jlong jrandom_access_max_buffer_size) {
6499 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6500 opt->random_access_max_buffer_size =
6501 static_cast<size_t>(jrandom_access_max_buffer_size);
6502 }
6503
6504 /*
6505 * Class: org_rocksdb_DBOptions
6506 * Method: randomAccessMaxBufferSize
6507 * Signature: (J)J
6508 */
Java_org_rocksdb_DBOptions_randomAccessMaxBufferSize(JNIEnv *,jobject,jlong jhandle)6509 jlong Java_org_rocksdb_DBOptions_randomAccessMaxBufferSize(
6510 JNIEnv*, jobject, jlong jhandle) {
6511 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6512 return static_cast<jlong>(opt->random_access_max_buffer_size);
6513 }
6514
6515 /*
6516 * Class: org_rocksdb_DBOptions
6517 * Method: setWritableFileMaxBufferSize
6518 * Signature: (JJ)V
6519 */
Java_org_rocksdb_DBOptions_setWritableFileMaxBufferSize(JNIEnv *,jobject,jlong jhandle,jlong jwritable_file_max_buffer_size)6520 void Java_org_rocksdb_DBOptions_setWritableFileMaxBufferSize(
6521 JNIEnv*, jobject, jlong jhandle, jlong jwritable_file_max_buffer_size) {
6522 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6523 opt->writable_file_max_buffer_size =
6524 static_cast<size_t>(jwritable_file_max_buffer_size);
6525 }
6526
6527 /*
6528 * Class: org_rocksdb_DBOptions
6529 * Method: writableFileMaxBufferSize
6530 * Signature: (J)J
6531 */
Java_org_rocksdb_DBOptions_writableFileMaxBufferSize(JNIEnv *,jobject,jlong jhandle)6532 jlong Java_org_rocksdb_DBOptions_writableFileMaxBufferSize(
6533 JNIEnv*, jobject, jlong jhandle) {
6534 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6535 return static_cast<jlong>(opt->writable_file_max_buffer_size);
6536 }
6537
6538 /*
6539 * Class: org_rocksdb_DBOptions
6540 * Method: setUseAdaptiveMutex
6541 * Signature: (JZ)V
6542 */
Java_org_rocksdb_DBOptions_setUseAdaptiveMutex(JNIEnv *,jobject,jlong jhandle,jboolean use_adaptive_mutex)6543 void Java_org_rocksdb_DBOptions_setUseAdaptiveMutex(
6544 JNIEnv*, jobject, jlong jhandle, jboolean use_adaptive_mutex) {
6545 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->use_adaptive_mutex =
6546 static_cast<bool>(use_adaptive_mutex);
6547 }
6548
6549 /*
6550 * Class: org_rocksdb_DBOptions
6551 * Method: useAdaptiveMutex
6552 * Signature: (J)Z
6553 */
Java_org_rocksdb_DBOptions_useAdaptiveMutex(JNIEnv *,jobject,jlong jhandle)6554 jboolean Java_org_rocksdb_DBOptions_useAdaptiveMutex(
6555 JNIEnv*, jobject, jlong jhandle) {
6556 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6557 ->use_adaptive_mutex;
6558 }
6559
6560 /*
6561 * Class: org_rocksdb_DBOptions
6562 * Method: setBytesPerSync
6563 * Signature: (JJ)V
6564 */
Java_org_rocksdb_DBOptions_setBytesPerSync(JNIEnv *,jobject,jlong jhandle,jlong bytes_per_sync)6565 void Java_org_rocksdb_DBOptions_setBytesPerSync(
6566 JNIEnv*, jobject, jlong jhandle, jlong bytes_per_sync) {
6567 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->bytes_per_sync =
6568 static_cast<int64_t>(bytes_per_sync);
6569 }
6570
6571 /*
6572 * Class: org_rocksdb_DBOptions
6573 * Method: bytesPerSync
6574 * Signature: (J)J
6575 */
Java_org_rocksdb_DBOptions_bytesPerSync(JNIEnv *,jobject,jlong jhandle)6576 jlong Java_org_rocksdb_DBOptions_bytesPerSync(
6577 JNIEnv*, jobject, jlong jhandle) {
6578 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6579 ->bytes_per_sync;
6580 }
6581
6582 /*
6583 * Class: org_rocksdb_DBOptions
6584 * Method: setWalBytesPerSync
6585 * Signature: (JJ)V
6586 */
Java_org_rocksdb_DBOptions_setWalBytesPerSync(JNIEnv *,jobject,jlong jhandle,jlong jwal_bytes_per_sync)6587 void Java_org_rocksdb_DBOptions_setWalBytesPerSync(
6588 JNIEnv*, jobject, jlong jhandle, jlong jwal_bytes_per_sync) {
6589 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)->wal_bytes_per_sync =
6590 static_cast<int64_t>(jwal_bytes_per_sync);
6591 }
6592
6593 /*
6594 * Class: org_rocksdb_DBOptions
6595 * Method: walBytesPerSync
6596 * Signature: (J)J
6597 */
Java_org_rocksdb_DBOptions_walBytesPerSync(JNIEnv *,jobject,jlong jhandle)6598 jlong Java_org_rocksdb_DBOptions_walBytesPerSync(
6599 JNIEnv*, jobject, jlong jhandle) {
6600 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6601 return static_cast<jlong>(opt->wal_bytes_per_sync);
6602 }
6603
6604 /*
6605 * Class: org_rocksdb_DBOptions
6606 * Method: setStrictBytesPerSync
6607 * Signature: (JZ)V
6608 */
Java_org_rocksdb_DBOptions_setStrictBytesPerSync(JNIEnv *,jobject,jlong jhandle,jboolean jstrict_bytes_per_sync)6609 void Java_org_rocksdb_DBOptions_setStrictBytesPerSync(
6610 JNIEnv*, jobject, jlong jhandle, jboolean jstrict_bytes_per_sync) {
6611 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6612 ->strict_bytes_per_sync = jstrict_bytes_per_sync == JNI_TRUE;
6613 }
6614
6615 /*
6616 * Class: org_rocksdb_DBOptions
6617 * Method: strictBytesPerSync
6618 * Signature: (J)Z
6619 */
Java_org_rocksdb_DBOptions_strictBytesPerSync(JNIEnv *,jobject,jlong jhandle)6620 jboolean Java_org_rocksdb_DBOptions_strictBytesPerSync(
6621 JNIEnv*, jobject, jlong jhandle) {
6622 return static_cast<jboolean>(
6623 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6624 ->strict_bytes_per_sync);
6625 }
6626
6627 /*
6628 * Class: org_rocksdb_DBOptions
6629 * Method: setEventListeners
6630 * Signature: (J[J)V
6631 */
Java_org_rocksdb_DBOptions_setEventListeners(JNIEnv * env,jclass,jlong jhandle,jlongArray jlistener_array)6632 void Java_org_rocksdb_DBOptions_setEventListeners(JNIEnv* env, jclass,
6633 jlong jhandle,
6634 jlongArray jlistener_array) {
6635 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6636 rocksdb_set_event_listeners_helper(env, jlistener_array, opt->listeners);
6637 }
6638
6639 /*
6640 * Class: org_rocksdb_DBOptions
6641 * Method: eventListeners
6642 * Signature: (J)[Lorg/rocksdb/AbstractEventListener;
6643 */
Java_org_rocksdb_DBOptions_eventListeners(JNIEnv * env,jclass,jlong jhandle)6644 jobjectArray Java_org_rocksdb_DBOptions_eventListeners(JNIEnv* env, jclass,
6645 jlong jhandle) {
6646 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6647 return rocksdb_get_event_listeners_helper(env, opt->listeners);
6648 }
6649
6650 /*
6651 * Class: org_rocksdb_DBOptions
6652 * Method: setDelayedWriteRate
6653 * Signature: (JJ)V
6654 */
Java_org_rocksdb_DBOptions_setDelayedWriteRate(JNIEnv *,jobject,jlong jhandle,jlong jdelayed_write_rate)6655 void Java_org_rocksdb_DBOptions_setDelayedWriteRate(
6656 JNIEnv*, jobject, jlong jhandle, jlong jdelayed_write_rate) {
6657 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6658 opt->delayed_write_rate = static_cast<uint64_t>(jdelayed_write_rate);
6659 }
6660
6661 /*
6662 * Class: org_rocksdb_DBOptions
6663 * Method: delayedWriteRate
6664 * Signature: (J)J
6665 */
Java_org_rocksdb_DBOptions_delayedWriteRate(JNIEnv *,jobject,jlong jhandle)6666 jlong Java_org_rocksdb_DBOptions_delayedWriteRate(
6667 JNIEnv*, jobject, jlong jhandle) {
6668 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6669 return static_cast<jlong>(opt->delayed_write_rate);
6670 }
6671
6672 /*
6673 * Class: org_rocksdb_DBOptions
6674 * Method: setEnablePipelinedWrite
6675 * Signature: (JZ)V
6676 */
Java_org_rocksdb_DBOptions_setEnablePipelinedWrite(JNIEnv *,jobject,jlong jhandle,jboolean jenable_pipelined_write)6677 void Java_org_rocksdb_DBOptions_setEnablePipelinedWrite(
6678 JNIEnv*, jobject, jlong jhandle, jboolean jenable_pipelined_write) {
6679 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6680 opt->enable_pipelined_write = jenable_pipelined_write == JNI_TRUE;
6681 }
6682
6683 /*
6684 * Class: org_rocksdb_DBOptions
6685 * Method: enablePipelinedWrite
6686 * Signature: (J)Z
6687 */
Java_org_rocksdb_DBOptions_enablePipelinedWrite(JNIEnv *,jobject,jlong jhandle)6688 jboolean Java_org_rocksdb_DBOptions_enablePipelinedWrite(
6689 JNIEnv*, jobject, jlong jhandle) {
6690 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6691 return static_cast<jboolean>(opt->enable_pipelined_write);
6692 }
6693
6694 /*
6695 * Class: org_rocksdb_DBOptions
6696 * Method: setUnorderedWrite
6697 * Signature: (JZ)V
6698 */
Java_org_rocksdb_DBOptions_setUnorderedWrite(JNIEnv *,jobject,jlong jhandle,jboolean junordered_write)6699 void Java_org_rocksdb_DBOptions_setUnorderedWrite(
6700 JNIEnv*, jobject, jlong jhandle, jboolean junordered_write) {
6701 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6702 opt->unordered_write = junordered_write == JNI_TRUE;
6703 }
6704
6705 /*
6706 * Class: org_rocksdb_DBOptions
6707 * Method: unorderedWrite
6708 * Signature: (J)Z
6709 */
Java_org_rocksdb_DBOptions_unorderedWrite(JNIEnv *,jobject,jlong jhandle)6710 jboolean Java_org_rocksdb_DBOptions_unorderedWrite(
6711 JNIEnv*, jobject, jlong jhandle) {
6712 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6713 return static_cast<jboolean>(opt->unordered_write);
6714 }
6715
6716
6717 /*
6718 * Class: org_rocksdb_DBOptions
6719 * Method: setEnableThreadTracking
6720 * Signature: (JZ)V
6721 */
Java_org_rocksdb_DBOptions_setEnableThreadTracking(JNIEnv *,jobject,jlong jhandle,jboolean jenable_thread_tracking)6722 void Java_org_rocksdb_DBOptions_setEnableThreadTracking(
6723 JNIEnv*, jobject, jlong jhandle, jboolean jenable_thread_tracking) {
6724 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6725 opt->enable_thread_tracking = jenable_thread_tracking == JNI_TRUE;
6726 }
6727
6728 /*
6729 * Class: org_rocksdb_DBOptions
6730 * Method: enableThreadTracking
6731 * Signature: (J)Z
6732 */
Java_org_rocksdb_DBOptions_enableThreadTracking(JNIEnv *,jobject,jlong jhandle)6733 jboolean Java_org_rocksdb_DBOptions_enableThreadTracking(
6734 JNIEnv*, jobject, jlong jhandle) {
6735 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6736 return static_cast<jboolean>(opt->enable_thread_tracking);
6737 }
6738
6739 /*
6740 * Class: org_rocksdb_DBOptions
6741 * Method: setAllowConcurrentMemtableWrite
6742 * Signature: (JZ)V
6743 */
Java_org_rocksdb_DBOptions_setAllowConcurrentMemtableWrite(JNIEnv *,jobject,jlong jhandle,jboolean allow)6744 void Java_org_rocksdb_DBOptions_setAllowConcurrentMemtableWrite(
6745 JNIEnv*, jobject, jlong jhandle, jboolean allow) {
6746 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6747 ->allow_concurrent_memtable_write = static_cast<bool>(allow);
6748 }
6749
6750 /*
6751 * Class: org_rocksdb_DBOptions
6752 * Method: allowConcurrentMemtableWrite
6753 * Signature: (J)Z
6754 */
Java_org_rocksdb_DBOptions_allowConcurrentMemtableWrite(JNIEnv *,jobject,jlong jhandle)6755 jboolean Java_org_rocksdb_DBOptions_allowConcurrentMemtableWrite(
6756 JNIEnv*, jobject, jlong jhandle) {
6757 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6758 ->allow_concurrent_memtable_write;
6759 }
6760
6761 /*
6762 * Class: org_rocksdb_DBOptions
6763 * Method: setEnableWriteThreadAdaptiveYield
6764 * Signature: (JZ)V
6765 */
Java_org_rocksdb_DBOptions_setEnableWriteThreadAdaptiveYield(JNIEnv *,jobject,jlong jhandle,jboolean yield)6766 void Java_org_rocksdb_DBOptions_setEnableWriteThreadAdaptiveYield(
6767 JNIEnv*, jobject, jlong jhandle, jboolean yield) {
6768 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6769 ->enable_write_thread_adaptive_yield = static_cast<bool>(yield);
6770 }
6771
6772 /*
6773 * Class: org_rocksdb_DBOptions
6774 * Method: enableWriteThreadAdaptiveYield
6775 * Signature: (J)Z
6776 */
Java_org_rocksdb_DBOptions_enableWriteThreadAdaptiveYield(JNIEnv *,jobject,jlong jhandle)6777 jboolean Java_org_rocksdb_DBOptions_enableWriteThreadAdaptiveYield(
6778 JNIEnv*, jobject, jlong jhandle) {
6779 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6780 ->enable_write_thread_adaptive_yield;
6781 }
6782
6783 /*
6784 * Class: org_rocksdb_DBOptions
6785 * Method: setWriteThreadMaxYieldUsec
6786 * Signature: (JJ)V
6787 */
Java_org_rocksdb_DBOptions_setWriteThreadMaxYieldUsec(JNIEnv *,jobject,jlong jhandle,jlong max)6788 void Java_org_rocksdb_DBOptions_setWriteThreadMaxYieldUsec(
6789 JNIEnv*, jobject, jlong jhandle, jlong max) {
6790 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6791 ->write_thread_max_yield_usec = static_cast<int64_t>(max);
6792 }
6793
6794 /*
6795 * Class: org_rocksdb_DBOptions
6796 * Method: writeThreadMaxYieldUsec
6797 * Signature: (J)J
6798 */
Java_org_rocksdb_DBOptions_writeThreadMaxYieldUsec(JNIEnv *,jobject,jlong jhandle)6799 jlong Java_org_rocksdb_DBOptions_writeThreadMaxYieldUsec(
6800 JNIEnv*, jobject, jlong jhandle) {
6801 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6802 ->write_thread_max_yield_usec;
6803 }
6804
6805 /*
6806 * Class: org_rocksdb_DBOptions
6807 * Method: setWriteThreadSlowYieldUsec
6808 * Signature: (JJ)V
6809 */
Java_org_rocksdb_DBOptions_setWriteThreadSlowYieldUsec(JNIEnv *,jobject,jlong jhandle,jlong slow)6810 void Java_org_rocksdb_DBOptions_setWriteThreadSlowYieldUsec(
6811 JNIEnv*, jobject, jlong jhandle, jlong slow) {
6812 reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6813 ->write_thread_slow_yield_usec = static_cast<int64_t>(slow);
6814 }
6815
6816 /*
6817 * Class: org_rocksdb_DBOptions
6818 * Method: writeThreadSlowYieldUsec
6819 * Signature: (J)J
6820 */
Java_org_rocksdb_DBOptions_writeThreadSlowYieldUsec(JNIEnv *,jobject,jlong jhandle)6821 jlong Java_org_rocksdb_DBOptions_writeThreadSlowYieldUsec(
6822 JNIEnv*, jobject, jlong jhandle) {
6823 return reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle)
6824 ->write_thread_slow_yield_usec;
6825 }
6826
6827 /*
6828 * Class: org_rocksdb_DBOptions
6829 * Method: setSkipStatsUpdateOnDbOpen
6830 * Signature: (JZ)V
6831 */
Java_org_rocksdb_DBOptions_setSkipStatsUpdateOnDbOpen(JNIEnv *,jobject,jlong jhandle,jboolean jskip_stats_update_on_db_open)6832 void Java_org_rocksdb_DBOptions_setSkipStatsUpdateOnDbOpen(
6833 JNIEnv*, jobject, jlong jhandle, jboolean jskip_stats_update_on_db_open) {
6834 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6835 opt->skip_stats_update_on_db_open =
6836 static_cast<bool>(jskip_stats_update_on_db_open);
6837 }
6838
6839 /*
6840 * Class: org_rocksdb_DBOptions
6841 * Method: skipStatsUpdateOnDbOpen
6842 * Signature: (J)Z
6843 */
Java_org_rocksdb_DBOptions_skipStatsUpdateOnDbOpen(JNIEnv *,jobject,jlong jhandle)6844 jboolean Java_org_rocksdb_DBOptions_skipStatsUpdateOnDbOpen(
6845 JNIEnv*, jobject, jlong jhandle) {
6846 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6847 return static_cast<jboolean>(opt->skip_stats_update_on_db_open);
6848 }
6849
6850 /*
6851 * Class: org_rocksdb_DBOptions
6852 * Method: setSkipCheckingSstFileSizesOnDbOpen
6853 * Signature: (JZ)V
6854 */
Java_org_rocksdb_DBOptions_setSkipCheckingSstFileSizesOnDbOpen(JNIEnv *,jclass,jlong jhandle,jboolean jskip_checking_sst_file_sizes_on_db_open)6855 void Java_org_rocksdb_DBOptions_setSkipCheckingSstFileSizesOnDbOpen(
6856 JNIEnv*, jclass, jlong jhandle,
6857 jboolean jskip_checking_sst_file_sizes_on_db_open) {
6858 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6859 opt->skip_checking_sst_file_sizes_on_db_open =
6860 static_cast<bool>(jskip_checking_sst_file_sizes_on_db_open);
6861 }
6862
6863 /*
6864 * Class: org_rocksdb_DBOptions
6865 * Method: skipCheckingSstFileSizesOnDbOpen
6866 * Signature: (J)Z
6867 */
Java_org_rocksdb_DBOptions_skipCheckingSstFileSizesOnDbOpen(JNIEnv *,jclass,jlong jhandle)6868 jboolean Java_org_rocksdb_DBOptions_skipCheckingSstFileSizesOnDbOpen(
6869 JNIEnv*, jclass, jlong jhandle) {
6870 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6871 return static_cast<jboolean>(opt->skip_checking_sst_file_sizes_on_db_open);
6872 }
6873
6874 /*
6875 * Class: org_rocksdb_DBOptions
6876 * Method: setWalRecoveryMode
6877 * Signature: (JB)V
6878 */
Java_org_rocksdb_DBOptions_setWalRecoveryMode(JNIEnv *,jobject,jlong jhandle,jbyte jwal_recovery_mode_value)6879 void Java_org_rocksdb_DBOptions_setWalRecoveryMode(
6880 JNIEnv*, jobject, jlong jhandle, jbyte jwal_recovery_mode_value) {
6881 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6882 opt->wal_recovery_mode =
6883 ROCKSDB_NAMESPACE::WALRecoveryModeJni::toCppWALRecoveryMode(
6884 jwal_recovery_mode_value);
6885 }
6886
6887 /*
6888 * Class: org_rocksdb_DBOptions
6889 * Method: walRecoveryMode
6890 * Signature: (J)B
6891 */
Java_org_rocksdb_DBOptions_walRecoveryMode(JNIEnv *,jobject,jlong jhandle)6892 jbyte Java_org_rocksdb_DBOptions_walRecoveryMode(
6893 JNIEnv*, jobject, jlong jhandle) {
6894 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6895 return ROCKSDB_NAMESPACE::WALRecoveryModeJni::toJavaWALRecoveryMode(
6896 opt->wal_recovery_mode);
6897 }
6898
6899 /*
6900 * Class: org_rocksdb_DBOptions
6901 * Method: setAllow2pc
6902 * Signature: (JZ)V
6903 */
Java_org_rocksdb_DBOptions_setAllow2pc(JNIEnv *,jobject,jlong jhandle,jboolean jallow_2pc)6904 void Java_org_rocksdb_DBOptions_setAllow2pc(
6905 JNIEnv*, jobject, jlong jhandle, jboolean jallow_2pc) {
6906 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6907 opt->allow_2pc = static_cast<bool>(jallow_2pc);
6908 }
6909
6910 /*
6911 * Class: org_rocksdb_DBOptions
6912 * Method: allow2pc
6913 * Signature: (J)Z
6914 */
Java_org_rocksdb_DBOptions_allow2pc(JNIEnv *,jobject,jlong jhandle)6915 jboolean Java_org_rocksdb_DBOptions_allow2pc(
6916 JNIEnv*, jobject, jlong jhandle) {
6917 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6918 return static_cast<jboolean>(opt->allow_2pc);
6919 }
6920
6921 /*
6922 * Class: org_rocksdb_DBOptions
6923 * Method: setRowCache
6924 * Signature: (JJ)V
6925 */
Java_org_rocksdb_DBOptions_setRowCache(JNIEnv *,jobject,jlong jhandle,jlong jrow_cache_handle)6926 void Java_org_rocksdb_DBOptions_setRowCache(
6927 JNIEnv*, jobject, jlong jhandle, jlong jrow_cache_handle) {
6928 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6929 auto* row_cache =
6930 reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::Cache>*>(
6931 jrow_cache_handle);
6932 opt->row_cache = *row_cache;
6933 }
6934
6935 /*
6936 * Class: org_rocksdb_DBOptions
6937 * Method: setWalFilter
6938 * Signature: (JJ)V
6939 */
Java_org_rocksdb_DBOptions_setWalFilter(JNIEnv *,jobject,jlong jhandle,jlong jwal_filter_handle)6940 void Java_org_rocksdb_DBOptions_setWalFilter(
6941 JNIEnv*, jobject, jlong jhandle, jlong jwal_filter_handle) {
6942 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6943 auto* wal_filter = reinterpret_cast<ROCKSDB_NAMESPACE::WalFilterJniCallback*>(
6944 jwal_filter_handle);
6945 opt->wal_filter = wal_filter;
6946 }
6947
6948 /*
6949 * Class: org_rocksdb_DBOptions
6950 * Method: setFailIfOptionsFileError
6951 * Signature: (JZ)V
6952 */
Java_org_rocksdb_DBOptions_setFailIfOptionsFileError(JNIEnv *,jobject,jlong jhandle,jboolean jfail_if_options_file_error)6953 void Java_org_rocksdb_DBOptions_setFailIfOptionsFileError(
6954 JNIEnv*, jobject, jlong jhandle, jboolean jfail_if_options_file_error) {
6955 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6956 opt->fail_if_options_file_error =
6957 static_cast<bool>(jfail_if_options_file_error);
6958 }
6959
6960 /*
6961 * Class: org_rocksdb_DBOptions
6962 * Method: failIfOptionsFileError
6963 * Signature: (J)Z
6964 */
Java_org_rocksdb_DBOptions_failIfOptionsFileError(JNIEnv *,jobject,jlong jhandle)6965 jboolean Java_org_rocksdb_DBOptions_failIfOptionsFileError(
6966 JNIEnv*, jobject, jlong jhandle) {
6967 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6968 return static_cast<jboolean>(opt->fail_if_options_file_error);
6969 }
6970
6971 /*
6972 * Class: org_rocksdb_DBOptions
6973 * Method: setDumpMallocStats
6974 * Signature: (JZ)V
6975 */
Java_org_rocksdb_DBOptions_setDumpMallocStats(JNIEnv *,jobject,jlong jhandle,jboolean jdump_malloc_stats)6976 void Java_org_rocksdb_DBOptions_setDumpMallocStats(
6977 JNIEnv*, jobject, jlong jhandle, jboolean jdump_malloc_stats) {
6978 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6979 opt->dump_malloc_stats = static_cast<bool>(jdump_malloc_stats);
6980 }
6981
6982 /*
6983 * Class: org_rocksdb_DBOptions
6984 * Method: dumpMallocStats
6985 * Signature: (J)Z
6986 */
Java_org_rocksdb_DBOptions_dumpMallocStats(JNIEnv *,jobject,jlong jhandle)6987 jboolean Java_org_rocksdb_DBOptions_dumpMallocStats(
6988 JNIEnv*, jobject, jlong jhandle) {
6989 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
6990 return static_cast<jboolean>(opt->dump_malloc_stats);
6991 }
6992
6993 /*
6994 * Class: org_rocksdb_DBOptions
6995 * Method: setAvoidFlushDuringRecovery
6996 * Signature: (JZ)V
6997 */
Java_org_rocksdb_DBOptions_setAvoidFlushDuringRecovery(JNIEnv *,jobject,jlong jhandle,jboolean javoid_flush_during_recovery)6998 void Java_org_rocksdb_DBOptions_setAvoidFlushDuringRecovery(
6999 JNIEnv*, jobject, jlong jhandle, jboolean javoid_flush_during_recovery) {
7000 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7001 opt->avoid_flush_during_recovery =
7002 static_cast<bool>(javoid_flush_during_recovery);
7003 }
7004
7005 /*
7006 * Class: org_rocksdb_DBOptions
7007 * Method: avoidFlushDuringRecovery
7008 * Signature: (J)Z
7009 */
Java_org_rocksdb_DBOptions_avoidFlushDuringRecovery(JNIEnv *,jobject,jlong jhandle)7010 jboolean Java_org_rocksdb_DBOptions_avoidFlushDuringRecovery(
7011 JNIEnv*, jobject, jlong jhandle) {
7012 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7013 return static_cast<jboolean>(opt->avoid_flush_during_recovery);
7014 }
7015
7016 /*
7017 * Class: org_rocksdb_DBOptions
7018 * Method: setAllowIngestBehind
7019 * Signature: (JZ)V
7020 */
Java_org_rocksdb_DBOptions_setAllowIngestBehind(JNIEnv *,jobject,jlong jhandle,jboolean jallow_ingest_behind)7021 void Java_org_rocksdb_DBOptions_setAllowIngestBehind(
7022 JNIEnv*, jobject, jlong jhandle, jboolean jallow_ingest_behind) {
7023 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7024 opt->allow_ingest_behind = jallow_ingest_behind == JNI_TRUE;
7025 }
7026
7027 /*
7028 * Class: org_rocksdb_DBOptions
7029 * Method: allowIngestBehind
7030 * Signature: (J)Z
7031 */
Java_org_rocksdb_DBOptions_allowIngestBehind(JNIEnv *,jobject,jlong jhandle)7032 jboolean Java_org_rocksdb_DBOptions_allowIngestBehind(
7033 JNIEnv*, jobject, jlong jhandle) {
7034 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7035 return static_cast<jboolean>(opt->allow_ingest_behind);
7036 }
7037
7038 /*
7039 * Class: org_rocksdb_DBOptions
7040 * Method: setPreserveDeletes
7041 * Signature: (JZ)V
7042 */
Java_org_rocksdb_DBOptions_setPreserveDeletes(JNIEnv *,jobject,jlong jhandle,jboolean jpreserve_deletes)7043 void Java_org_rocksdb_DBOptions_setPreserveDeletes(
7044 JNIEnv*, jobject, jlong jhandle, jboolean jpreserve_deletes) {
7045 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7046 opt->preserve_deletes = jpreserve_deletes == JNI_TRUE;
7047 }
7048
7049 /*
7050 * Class: org_rocksdb_DBOptions
7051 * Method: preserveDeletes
7052 * Signature: (J)Z
7053 */
Java_org_rocksdb_DBOptions_preserveDeletes(JNIEnv *,jobject,jlong jhandle)7054 jboolean Java_org_rocksdb_DBOptions_preserveDeletes(
7055 JNIEnv*, jobject, jlong jhandle) {
7056 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7057 return static_cast<jboolean>(opt->preserve_deletes);
7058 }
7059
7060 /*
7061 * Class: org_rocksdb_DBOptions
7062 * Method: setTwoWriteQueues
7063 * Signature: (JZ)V
7064 */
Java_org_rocksdb_DBOptions_setTwoWriteQueues(JNIEnv *,jobject,jlong jhandle,jboolean jtwo_write_queues)7065 void Java_org_rocksdb_DBOptions_setTwoWriteQueues(
7066 JNIEnv*, jobject, jlong jhandle, jboolean jtwo_write_queues) {
7067 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7068 opt->two_write_queues = jtwo_write_queues == JNI_TRUE;
7069 }
7070
7071 /*
7072 * Class: org_rocksdb_DBOptions
7073 * Method: twoWriteQueues
7074 * Signature: (J)Z
7075 */
Java_org_rocksdb_DBOptions_twoWriteQueues(JNIEnv *,jobject,jlong jhandle)7076 jboolean Java_org_rocksdb_DBOptions_twoWriteQueues(
7077 JNIEnv*, jobject, jlong jhandle) {
7078 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7079 return static_cast<jboolean>(opt->two_write_queues);
7080 }
7081
7082 /*
7083 * Class: org_rocksdb_DBOptions
7084 * Method: setManualWalFlush
7085 * Signature: (JZ)V
7086 */
Java_org_rocksdb_DBOptions_setManualWalFlush(JNIEnv *,jobject,jlong jhandle,jboolean jmanual_wal_flush)7087 void Java_org_rocksdb_DBOptions_setManualWalFlush(
7088 JNIEnv*, jobject, jlong jhandle, jboolean jmanual_wal_flush) {
7089 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7090 opt->manual_wal_flush = jmanual_wal_flush == JNI_TRUE;
7091 }
7092
7093 /*
7094 * Class: org_rocksdb_DBOptions
7095 * Method: manualWalFlush
7096 * Signature: (J)Z
7097 */
Java_org_rocksdb_DBOptions_manualWalFlush(JNIEnv *,jobject,jlong jhandle)7098 jboolean Java_org_rocksdb_DBOptions_manualWalFlush(
7099 JNIEnv*, jobject, jlong jhandle) {
7100 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7101 return static_cast<jboolean>(opt->manual_wal_flush);
7102 }
7103
7104 /*
7105 * Class: org_rocksdb_DBOptions
7106 * Method: setAtomicFlush
7107 * Signature: (JZ)V
7108 */
Java_org_rocksdb_DBOptions_setAtomicFlush(JNIEnv *,jobject,jlong jhandle,jboolean jatomic_flush)7109 void Java_org_rocksdb_DBOptions_setAtomicFlush(
7110 JNIEnv*, jobject, jlong jhandle, jboolean jatomic_flush) {
7111 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7112 opt->atomic_flush = jatomic_flush == JNI_TRUE;
7113 }
7114
7115 /*
7116 * Class: org_rocksdb_DBOptions
7117 * Method: atomicFlush
7118 * Signature: (J)Z
7119 */
Java_org_rocksdb_DBOptions_atomicFlush(JNIEnv *,jobject,jlong jhandle)7120 jboolean Java_org_rocksdb_DBOptions_atomicFlush(
7121 JNIEnv *, jobject, jlong jhandle) {
7122 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7123 return static_cast<jboolean>(opt->atomic_flush);
7124 }
7125
7126 /*
7127 * Class: org_rocksdb_DBOptions
7128 * Method: setAvoidFlushDuringShutdown
7129 * Signature: (JZ)V
7130 */
Java_org_rocksdb_DBOptions_setAvoidFlushDuringShutdown(JNIEnv *,jobject,jlong jhandle,jboolean javoid_flush_during_shutdown)7131 void Java_org_rocksdb_DBOptions_setAvoidFlushDuringShutdown(
7132 JNIEnv*, jobject, jlong jhandle, jboolean javoid_flush_during_shutdown) {
7133 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7134 opt->avoid_flush_during_shutdown =
7135 static_cast<bool>(javoid_flush_during_shutdown);
7136 }
7137
7138 /*
7139 * Class: org_rocksdb_DBOptions
7140 * Method: avoidFlushDuringShutdown
7141 * Signature: (J)Z
7142 */
Java_org_rocksdb_DBOptions_avoidFlushDuringShutdown(JNIEnv *,jobject,jlong jhandle)7143 jboolean Java_org_rocksdb_DBOptions_avoidFlushDuringShutdown(
7144 JNIEnv*, jobject, jlong jhandle) {
7145 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7146 return static_cast<jboolean>(opt->avoid_flush_during_shutdown);
7147 }
7148
7149 /*
7150 * Class: org_rocksdb_DBOptions
7151 * Method: setAvoidUnnecessaryBlockingIO
7152 * Signature: (JZ)V
7153 */
Java_org_rocksdb_DBOptions_setAvoidUnnecessaryBlockingIO(JNIEnv *,jclass,jlong jhandle,jboolean avoid_blocking_io)7154 void Java_org_rocksdb_DBOptions_setAvoidUnnecessaryBlockingIO(
7155 JNIEnv*, jclass, jlong jhandle, jboolean avoid_blocking_io) {
7156 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7157 opt->avoid_unnecessary_blocking_io = static_cast<bool>(avoid_blocking_io);
7158 }
7159
7160 /*
7161 * Class: org_rocksdb_DBOptions
7162 * Method: avoidUnnecessaryBlockingIO
7163 * Signature: (J)Z
7164 */
Java_org_rocksdb_DBOptions_avoidUnnecessaryBlockingIO(JNIEnv *,jclass,jlong jhandle)7165 jboolean Java_org_rocksdb_DBOptions_avoidUnnecessaryBlockingIO(JNIEnv*, jclass,
7166 jlong jhandle) {
7167 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7168 return static_cast<jboolean>(opt->avoid_unnecessary_blocking_io);
7169 }
7170
7171 /*
7172 * Class: org_rocksdb_DBOptions
7173 * Method: setPersistStatsToDisk
7174 * Signature: (JZ)V
7175 */
Java_org_rocksdb_DBOptions_setPersistStatsToDisk(JNIEnv *,jclass,jlong jhandle,jboolean persist_stats_to_disk)7176 void Java_org_rocksdb_DBOptions_setPersistStatsToDisk(
7177 JNIEnv*, jclass, jlong jhandle, jboolean persist_stats_to_disk) {
7178 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7179 opt->persist_stats_to_disk = static_cast<bool>(persist_stats_to_disk);
7180 }
7181
7182 /*
7183 * Class: org_rocksdb_DBOptions
7184 * Method: persistStatsToDisk
7185 * Signature: (J)Z
7186 */
Java_org_rocksdb_DBOptions_persistStatsToDisk(JNIEnv *,jclass,jlong jhandle)7187 jboolean Java_org_rocksdb_DBOptions_persistStatsToDisk(JNIEnv*, jclass,
7188 jlong jhandle) {
7189 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7190 return static_cast<jboolean>(opt->persist_stats_to_disk);
7191 }
7192
7193 /*
7194 * Class: org_rocksdb_DBOptions
7195 * Method: setWriteDbidToManifest
7196 * Signature: (JZ)V
7197 */
Java_org_rocksdb_DBOptions_setWriteDbidToManifest(JNIEnv *,jclass,jlong jhandle,jboolean jwrite_dbid_to_manifest)7198 void Java_org_rocksdb_DBOptions_setWriteDbidToManifest(
7199 JNIEnv*, jclass, jlong jhandle, jboolean jwrite_dbid_to_manifest) {
7200 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7201 opt->write_dbid_to_manifest = static_cast<bool>(jwrite_dbid_to_manifest);
7202 }
7203
7204 /*
7205 * Class: org_rocksdb_DBOptions
7206 * Method: writeDbidToManifest
7207 * Signature: (J)Z
7208 */
Java_org_rocksdb_DBOptions_writeDbidToManifest(JNIEnv *,jclass,jlong jhandle)7209 jboolean Java_org_rocksdb_DBOptions_writeDbidToManifest(JNIEnv*, jclass,
7210 jlong jhandle) {
7211 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7212 return static_cast<jboolean>(opt->write_dbid_to_manifest);
7213 }
7214
7215 /*
7216 * Class: org_rocksdb_DBOptions
7217 * Method: setLogReadaheadSize
7218 * Signature: (JJ)V
7219 */
Java_org_rocksdb_DBOptions_setLogReadaheadSize(JNIEnv *,jclass,jlong jhandle,jlong jlog_readahead_size)7220 void Java_org_rocksdb_DBOptions_setLogReadaheadSize(JNIEnv*, jclass,
7221 jlong jhandle,
7222 jlong jlog_readahead_size) {
7223 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7224 opt->log_readahead_size = static_cast<size_t>(jlog_readahead_size);
7225 }
7226
7227 /*
7228 * Class: org_rocksdb_DBOptions
7229 * Method: logReasaheadSize
7230 * Signature: (J)J
7231 */
Java_org_rocksdb_DBOptions_logReadaheadSize(JNIEnv *,jclass,jlong jhandle)7232 jlong Java_org_rocksdb_DBOptions_logReadaheadSize(JNIEnv*, jclass,
7233 jlong jhandle) {
7234 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7235 return static_cast<jlong>(opt->log_readahead_size);
7236 }
7237
7238 /*
7239 * Class: org_rocksdb_DBOptions
7240 * Method: setBestEffortsRecovery
7241 * Signature: (JZ)V
7242 */
Java_org_rocksdb_DBOptions_setBestEffortsRecovery(JNIEnv *,jclass,jlong jhandle,jboolean jbest_efforts_recovery)7243 void Java_org_rocksdb_DBOptions_setBestEffortsRecovery(
7244 JNIEnv*, jclass, jlong jhandle, jboolean jbest_efforts_recovery) {
7245 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7246 opt->best_efforts_recovery = static_cast<bool>(jbest_efforts_recovery);
7247 }
7248
7249 /*
7250 * Class: org_rocksdb_DBOptions
7251 * Method: bestEffortsRecovery
7252 * Signature: (J)Z
7253 */
Java_org_rocksdb_DBOptions_bestEffortsRecovery(JNIEnv *,jclass,jlong jhandle)7254 jboolean Java_org_rocksdb_DBOptions_bestEffortsRecovery(JNIEnv*, jclass,
7255 jlong jhandle) {
7256 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7257 return static_cast<jlong>(opt->best_efforts_recovery);
7258 }
7259
7260 /*
7261 * Class: org_rocksdb_DBOptions
7262 * Method: setMaxBgErrorResumeCount
7263 * Signature: (JI)V
7264 */
Java_org_rocksdb_DBOptions_setMaxBgErrorResumeCount(JNIEnv *,jclass,jlong jhandle,jint jmax_bgerror_resume_count)7265 void Java_org_rocksdb_DBOptions_setMaxBgErrorResumeCount(
7266 JNIEnv*, jclass, jlong jhandle, jint jmax_bgerror_resume_count) {
7267 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7268 opt->max_bgerror_resume_count = static_cast<int>(jmax_bgerror_resume_count);
7269 }
7270
7271 /*
7272 * Class: org_rocksdb_DBOptions
7273 * Method: maxBgerrorResumeCount
7274 * Signature: (J)I
7275 */
Java_org_rocksdb_DBOptions_maxBgerrorResumeCount(JNIEnv *,jclass,jlong jhandle)7276 jint Java_org_rocksdb_DBOptions_maxBgerrorResumeCount(JNIEnv*, jclass,
7277 jlong jhandle) {
7278 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7279 return static_cast<jint>(opt->max_bgerror_resume_count);
7280 }
7281
7282 /*
7283 * Class: org_rocksdb_DBOptions
7284 * Method: setBgerrorResumeRetryInterval
7285 * Signature: (JJ)V
7286 */
Java_org_rocksdb_DBOptions_setBgerrorResumeRetryInterval(JNIEnv *,jclass,jlong jhandle,jlong jbgerror_resume_retry_interval)7287 void Java_org_rocksdb_DBOptions_setBgerrorResumeRetryInterval(
7288 JNIEnv*, jclass, jlong jhandle, jlong jbgerror_resume_retry_interval) {
7289 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7290 opt->bgerror_resume_retry_interval =
7291 static_cast<uint64_t>(jbgerror_resume_retry_interval);
7292 }
7293
7294 /*
7295 * Class: org_rocksdb_DBOptions
7296 * Method: bgerrorResumeRetryInterval
7297 * Signature: (J)J
7298 */
Java_org_rocksdb_DBOptions_bgerrorResumeRetryInterval(JNIEnv *,jclass,jlong jhandle)7299 jlong Java_org_rocksdb_DBOptions_bgerrorResumeRetryInterval(JNIEnv*, jclass,
7300 jlong jhandle) {
7301 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
7302 return static_cast<jlong>(opt->bgerror_resume_retry_interval);
7303 }
7304
7305 //////////////////////////////////////////////////////////////////////////////
7306 // ROCKSDB_NAMESPACE::WriteOptions
7307
7308 /*
7309 * Class: org_rocksdb_WriteOptions
7310 * Method: newWriteOptions
7311 * Signature: ()J
7312 */
Java_org_rocksdb_WriteOptions_newWriteOptions(JNIEnv *,jclass)7313 jlong Java_org_rocksdb_WriteOptions_newWriteOptions(
7314 JNIEnv*, jclass) {
7315 auto* op = new ROCKSDB_NAMESPACE::WriteOptions();
7316 return reinterpret_cast<jlong>(op);
7317 }
7318
7319 /*
7320 * Class: org_rocksdb_WriteOptions
7321 * Method: copyWriteOptions
7322 * Signature: (J)J
7323 */
Java_org_rocksdb_WriteOptions_copyWriteOptions(JNIEnv *,jclass,jlong jhandle)7324 jlong Java_org_rocksdb_WriteOptions_copyWriteOptions(
7325 JNIEnv*, jclass, jlong jhandle) {
7326 auto new_opt = new ROCKSDB_NAMESPACE::WriteOptions(
7327 *(reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)));
7328 return reinterpret_cast<jlong>(new_opt);
7329 }
7330
7331 /*
7332 * Class: org_rocksdb_WriteOptions
7333 * Method: disposeInternal
7334 * Signature: ()V
7335 */
Java_org_rocksdb_WriteOptions_disposeInternal(JNIEnv *,jobject,jlong jhandle)7336 void Java_org_rocksdb_WriteOptions_disposeInternal(
7337 JNIEnv*, jobject, jlong jhandle) {
7338 auto* write_options =
7339 reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle);
7340 assert(write_options != nullptr);
7341 delete write_options;
7342 }
7343
7344 /*
7345 * Class: org_rocksdb_WriteOptions
7346 * Method: setSync
7347 * Signature: (JZ)V
7348 */
Java_org_rocksdb_WriteOptions_setSync(JNIEnv *,jobject,jlong jhandle,jboolean jflag)7349 void Java_org_rocksdb_WriteOptions_setSync(
7350 JNIEnv*, jobject, jlong jhandle, jboolean jflag) {
7351 reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->sync = jflag;
7352 }
7353
7354 /*
7355 * Class: org_rocksdb_WriteOptions
7356 * Method: sync
7357 * Signature: (J)Z
7358 */
Java_org_rocksdb_WriteOptions_sync(JNIEnv *,jobject,jlong jhandle)7359 jboolean Java_org_rocksdb_WriteOptions_sync(
7360 JNIEnv*, jobject, jlong jhandle) {
7361 return reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->sync;
7362 }
7363
7364 /*
7365 * Class: org_rocksdb_WriteOptions
7366 * Method: setDisableWAL
7367 * Signature: (JZ)V
7368 */
Java_org_rocksdb_WriteOptions_setDisableWAL(JNIEnv *,jobject,jlong jhandle,jboolean jflag)7369 void Java_org_rocksdb_WriteOptions_setDisableWAL(
7370 JNIEnv*, jobject, jlong jhandle, jboolean jflag) {
7371 reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->disableWAL =
7372 jflag;
7373 }
7374
7375 /*
7376 * Class: org_rocksdb_WriteOptions
7377 * Method: disableWAL
7378 * Signature: (J)Z
7379 */
Java_org_rocksdb_WriteOptions_disableWAL(JNIEnv *,jobject,jlong jhandle)7380 jboolean Java_org_rocksdb_WriteOptions_disableWAL(
7381 JNIEnv*, jobject, jlong jhandle) {
7382 return reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)
7383 ->disableWAL;
7384 }
7385
7386 /*
7387 * Class: org_rocksdb_WriteOptions
7388 * Method: setIgnoreMissingColumnFamilies
7389 * Signature: (JZ)V
7390 */
Java_org_rocksdb_WriteOptions_setIgnoreMissingColumnFamilies(JNIEnv *,jobject,jlong jhandle,jboolean jignore_missing_column_families)7391 void Java_org_rocksdb_WriteOptions_setIgnoreMissingColumnFamilies(
7392 JNIEnv*, jobject, jlong jhandle,
7393 jboolean jignore_missing_column_families) {
7394 reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)
7395 ->ignore_missing_column_families =
7396 static_cast<bool>(jignore_missing_column_families);
7397 }
7398
7399 /*
7400 * Class: org_rocksdb_WriteOptions
7401 * Method: ignoreMissingColumnFamilies
7402 * Signature: (J)Z
7403 */
Java_org_rocksdb_WriteOptions_ignoreMissingColumnFamilies(JNIEnv *,jobject,jlong jhandle)7404 jboolean Java_org_rocksdb_WriteOptions_ignoreMissingColumnFamilies(
7405 JNIEnv*, jobject, jlong jhandle) {
7406 return reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)
7407 ->ignore_missing_column_families;
7408 }
7409
7410 /*
7411 * Class: org_rocksdb_WriteOptions
7412 * Method: setNoSlowdown
7413 * Signature: (JZ)V
7414 */
Java_org_rocksdb_WriteOptions_setNoSlowdown(JNIEnv *,jobject,jlong jhandle,jboolean jno_slowdown)7415 void Java_org_rocksdb_WriteOptions_setNoSlowdown(
7416 JNIEnv*, jobject, jlong jhandle, jboolean jno_slowdown) {
7417 reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->no_slowdown =
7418 static_cast<bool>(jno_slowdown);
7419 }
7420
7421 /*
7422 * Class: org_rocksdb_WriteOptions
7423 * Method: noSlowdown
7424 * Signature: (J)Z
7425 */
Java_org_rocksdb_WriteOptions_noSlowdown(JNIEnv *,jobject,jlong jhandle)7426 jboolean Java_org_rocksdb_WriteOptions_noSlowdown(
7427 JNIEnv*, jobject, jlong jhandle) {
7428 return reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)
7429 ->no_slowdown;
7430 }
7431
7432 /*
7433 * Class: org_rocksdb_WriteOptions
7434 * Method: setLowPri
7435 * Signature: (JZ)V
7436 */
Java_org_rocksdb_WriteOptions_setLowPri(JNIEnv *,jobject,jlong jhandle,jboolean jlow_pri)7437 void Java_org_rocksdb_WriteOptions_setLowPri(
7438 JNIEnv*, jobject, jlong jhandle, jboolean jlow_pri) {
7439 reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->low_pri =
7440 static_cast<bool>(jlow_pri);
7441 }
7442
7443 /*
7444 * Class: org_rocksdb_WriteOptions
7445 * Method: lowPri
7446 * Signature: (J)Z
7447 */
Java_org_rocksdb_WriteOptions_lowPri(JNIEnv *,jobject,jlong jhandle)7448 jboolean Java_org_rocksdb_WriteOptions_lowPri(
7449 JNIEnv*, jobject, jlong jhandle) {
7450 return reinterpret_cast<ROCKSDB_NAMESPACE::WriteOptions*>(jhandle)->low_pri;
7451 }
7452
7453 /////////////////////////////////////////////////////////////////////
7454 // ROCKSDB_NAMESPACE::ReadOptions
7455
7456 /*
7457 * Class: org_rocksdb_ReadOptions
7458 * Method: newReadOptions
7459 * Signature: ()J
7460 */
Java_org_rocksdb_ReadOptions_newReadOptions__(JNIEnv *,jclass)7461 jlong Java_org_rocksdb_ReadOptions_newReadOptions__(
7462 JNIEnv*, jclass) {
7463 auto* read_options = new ROCKSDB_NAMESPACE::ReadOptions();
7464 return reinterpret_cast<jlong>(read_options);
7465 }
7466
7467 /*
7468 * Class: org_rocksdb_ReadOptions
7469 * Method: newReadOptions
7470 * Signature: (ZZ)J
7471 */
Java_org_rocksdb_ReadOptions_newReadOptions__ZZ(JNIEnv *,jclass,jboolean jverify_checksums,jboolean jfill_cache)7472 jlong Java_org_rocksdb_ReadOptions_newReadOptions__ZZ(
7473 JNIEnv*, jclass, jboolean jverify_checksums, jboolean jfill_cache) {
7474 auto* read_options = new ROCKSDB_NAMESPACE::ReadOptions(
7475 static_cast<bool>(jverify_checksums), static_cast<bool>(jfill_cache));
7476 return reinterpret_cast<jlong>(read_options);
7477 }
7478
7479 /*
7480 * Class: org_rocksdb_ReadOptions
7481 * Method: copyReadOptions
7482 * Signature: (J)J
7483 */
Java_org_rocksdb_ReadOptions_copyReadOptions(JNIEnv *,jclass,jlong jhandle)7484 jlong Java_org_rocksdb_ReadOptions_copyReadOptions(
7485 JNIEnv*, jclass, jlong jhandle) {
7486 auto new_opt = new ROCKSDB_NAMESPACE::ReadOptions(
7487 *(reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)));
7488 return reinterpret_cast<jlong>(new_opt);
7489 }
7490
7491 /*
7492 * Class: org_rocksdb_ReadOptions
7493 * Method: disposeInternal
7494 * Signature: (J)V
7495 */
Java_org_rocksdb_ReadOptions_disposeInternal(JNIEnv *,jobject,jlong jhandle)7496 void Java_org_rocksdb_ReadOptions_disposeInternal(
7497 JNIEnv*, jobject, jlong jhandle) {
7498 auto* read_options =
7499 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7500 assert(read_options != nullptr);
7501 delete read_options;
7502 }
7503
7504 /*
7505 * Class: org_rocksdb_ReadOptions
7506 * Method: setVerifyChecksums
7507 * Signature: (JZ)V
7508 */
Java_org_rocksdb_ReadOptions_setVerifyChecksums(JNIEnv *,jobject,jlong jhandle,jboolean jverify_checksums)7509 void Java_org_rocksdb_ReadOptions_setVerifyChecksums(
7510 JNIEnv*, jobject, jlong jhandle, jboolean jverify_checksums) {
7511 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->verify_checksums =
7512 static_cast<bool>(jverify_checksums);
7513 }
7514
7515 /*
7516 * Class: org_rocksdb_ReadOptions
7517 * Method: verifyChecksums
7518 * Signature: (J)Z
7519 */
Java_org_rocksdb_ReadOptions_verifyChecksums(JNIEnv *,jobject,jlong jhandle)7520 jboolean Java_org_rocksdb_ReadOptions_verifyChecksums(
7521 JNIEnv*, jobject, jlong jhandle) {
7522 return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
7523 ->verify_checksums;
7524 }
7525
7526 /*
7527 * Class: org_rocksdb_ReadOptions
7528 * Method: setFillCache
7529 * Signature: (JZ)V
7530 */
Java_org_rocksdb_ReadOptions_setFillCache(JNIEnv *,jobject,jlong jhandle,jboolean jfill_cache)7531 void Java_org_rocksdb_ReadOptions_setFillCache(
7532 JNIEnv*, jobject, jlong jhandle, jboolean jfill_cache) {
7533 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->fill_cache =
7534 static_cast<bool>(jfill_cache);
7535 }
7536
7537 /*
7538 * Class: org_rocksdb_ReadOptions
7539 * Method: fillCache
7540 * Signature: (J)Z
7541 */
Java_org_rocksdb_ReadOptions_fillCache(JNIEnv *,jobject,jlong jhandle)7542 jboolean Java_org_rocksdb_ReadOptions_fillCache(
7543 JNIEnv*, jobject, jlong jhandle) {
7544 return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->fill_cache;
7545 }
7546
7547 /*
7548 * Class: org_rocksdb_ReadOptions
7549 * Method: setTailing
7550 * Signature: (JZ)V
7551 */
Java_org_rocksdb_ReadOptions_setTailing(JNIEnv *,jobject,jlong jhandle,jboolean jtailing)7552 void Java_org_rocksdb_ReadOptions_setTailing(
7553 JNIEnv*, jobject, jlong jhandle, jboolean jtailing) {
7554 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->tailing =
7555 static_cast<bool>(jtailing);
7556 }
7557
7558 /*
7559 * Class: org_rocksdb_ReadOptions
7560 * Method: tailing
7561 * Signature: (J)Z
7562 */
Java_org_rocksdb_ReadOptions_tailing(JNIEnv *,jobject,jlong jhandle)7563 jboolean Java_org_rocksdb_ReadOptions_tailing(
7564 JNIEnv*, jobject, jlong jhandle) {
7565 return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->tailing;
7566 }
7567
7568 /*
7569 * Class: org_rocksdb_ReadOptions
7570 * Method: managed
7571 * Signature: (J)Z
7572 */
Java_org_rocksdb_ReadOptions_managed(JNIEnv *,jobject,jlong jhandle)7573 jboolean Java_org_rocksdb_ReadOptions_managed(
7574 JNIEnv*, jobject, jlong jhandle) {
7575 return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->managed;
7576 }
7577
7578 /*
7579 * Class: org_rocksdb_ReadOptions
7580 * Method: setManaged
7581 * Signature: (JZ)V
7582 */
Java_org_rocksdb_ReadOptions_setManaged(JNIEnv *,jobject,jlong jhandle,jboolean jmanaged)7583 void Java_org_rocksdb_ReadOptions_setManaged(
7584 JNIEnv*, jobject, jlong jhandle, jboolean jmanaged) {
7585 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->managed =
7586 static_cast<bool>(jmanaged);
7587 }
7588
7589 /*
7590 * Class: org_rocksdb_ReadOptions
7591 * Method: totalOrderSeek
7592 * Signature: (J)Z
7593 */
Java_org_rocksdb_ReadOptions_totalOrderSeek(JNIEnv *,jobject,jlong jhandle)7594 jboolean Java_org_rocksdb_ReadOptions_totalOrderSeek(
7595 JNIEnv*, jobject, jlong jhandle) {
7596 return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
7597 ->total_order_seek;
7598 }
7599
7600 /*
7601 * Class: org_rocksdb_ReadOptions
7602 * Method: setTotalOrderSeek
7603 * Signature: (JZ)V
7604 */
Java_org_rocksdb_ReadOptions_setTotalOrderSeek(JNIEnv *,jobject,jlong jhandle,jboolean jtotal_order_seek)7605 void Java_org_rocksdb_ReadOptions_setTotalOrderSeek(
7606 JNIEnv*, jobject, jlong jhandle, jboolean jtotal_order_seek) {
7607 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->total_order_seek =
7608 static_cast<bool>(jtotal_order_seek);
7609 }
7610
7611 /*
7612 * Class: org_rocksdb_ReadOptions
7613 * Method: prefixSameAsStart
7614 * Signature: (J)Z
7615 */
Java_org_rocksdb_ReadOptions_prefixSameAsStart(JNIEnv *,jobject,jlong jhandle)7616 jboolean Java_org_rocksdb_ReadOptions_prefixSameAsStart(
7617 JNIEnv*, jobject, jlong jhandle) {
7618 return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
7619 ->prefix_same_as_start;
7620 }
7621
7622 /*
7623 * Class: org_rocksdb_ReadOptions
7624 * Method: setPrefixSameAsStart
7625 * Signature: (JZ)V
7626 */
Java_org_rocksdb_ReadOptions_setPrefixSameAsStart(JNIEnv *,jobject,jlong jhandle,jboolean jprefix_same_as_start)7627 void Java_org_rocksdb_ReadOptions_setPrefixSameAsStart(
7628 JNIEnv*, jobject, jlong jhandle, jboolean jprefix_same_as_start) {
7629 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
7630 ->prefix_same_as_start = static_cast<bool>(jprefix_same_as_start);
7631 }
7632
7633 /*
7634 * Class: org_rocksdb_ReadOptions
7635 * Method: pinData
7636 * Signature: (J)Z
7637 */
Java_org_rocksdb_ReadOptions_pinData(JNIEnv *,jobject,jlong jhandle)7638 jboolean Java_org_rocksdb_ReadOptions_pinData(
7639 JNIEnv*, jobject, jlong jhandle) {
7640 return reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->pin_data;
7641 }
7642
7643 /*
7644 * Class: org_rocksdb_ReadOptions
7645 * Method: setPinData
7646 * Signature: (JZ)V
7647 */
Java_org_rocksdb_ReadOptions_setPinData(JNIEnv *,jobject,jlong jhandle,jboolean jpin_data)7648 void Java_org_rocksdb_ReadOptions_setPinData(
7649 JNIEnv*, jobject, jlong jhandle, jboolean jpin_data) {
7650 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->pin_data =
7651 static_cast<bool>(jpin_data);
7652 }
7653
7654 /*
7655 * Class: org_rocksdb_ReadOptions
7656 * Method: backgroundPurgeOnIteratorCleanup
7657 * Signature: (J)Z
7658 */
Java_org_rocksdb_ReadOptions_backgroundPurgeOnIteratorCleanup(JNIEnv *,jobject,jlong jhandle)7659 jboolean Java_org_rocksdb_ReadOptions_backgroundPurgeOnIteratorCleanup(
7660 JNIEnv*, jobject, jlong jhandle) {
7661 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7662 return static_cast<jboolean>(opt->background_purge_on_iterator_cleanup);
7663 }
7664
7665 /*
7666 * Class: org_rocksdb_ReadOptions
7667 * Method: setBackgroundPurgeOnIteratorCleanup
7668 * Signature: (JZ)V
7669 */
Java_org_rocksdb_ReadOptions_setBackgroundPurgeOnIteratorCleanup(JNIEnv *,jobject,jlong jhandle,jboolean jbackground_purge_on_iterator_cleanup)7670 void Java_org_rocksdb_ReadOptions_setBackgroundPurgeOnIteratorCleanup(
7671 JNIEnv*, jobject, jlong jhandle,
7672 jboolean jbackground_purge_on_iterator_cleanup) {
7673 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7674 opt->background_purge_on_iterator_cleanup =
7675 static_cast<bool>(jbackground_purge_on_iterator_cleanup);
7676 }
7677
7678 /*
7679 * Class: org_rocksdb_ReadOptions
7680 * Method: readaheadSize
7681 * Signature: (J)J
7682 */
Java_org_rocksdb_ReadOptions_readaheadSize(JNIEnv *,jobject,jlong jhandle)7683 jlong Java_org_rocksdb_ReadOptions_readaheadSize(
7684 JNIEnv*, jobject, jlong jhandle) {
7685 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7686 return static_cast<jlong>(opt->readahead_size);
7687 }
7688
7689 /*
7690 * Class: org_rocksdb_ReadOptions
7691 * Method: setReadaheadSize
7692 * Signature: (JJ)V
7693 */
Java_org_rocksdb_ReadOptions_setReadaheadSize(JNIEnv *,jobject,jlong jhandle,jlong jreadahead_size)7694 void Java_org_rocksdb_ReadOptions_setReadaheadSize(
7695 JNIEnv*, jobject, jlong jhandle, jlong jreadahead_size) {
7696 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7697 opt->readahead_size = static_cast<size_t>(jreadahead_size);
7698 }
7699
7700 /*
7701 * Class: org_rocksdb_ReadOptions
7702 * Method: maxSkippableInternalKeys
7703 * Signature: (J)J
7704 */
Java_org_rocksdb_ReadOptions_maxSkippableInternalKeys(JNIEnv *,jobject,jlong jhandle)7705 jlong Java_org_rocksdb_ReadOptions_maxSkippableInternalKeys(
7706 JNIEnv*, jobject, jlong jhandle) {
7707 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7708 return static_cast<jlong>(opt->max_skippable_internal_keys);
7709 }
7710
7711 /*
7712 * Class: org_rocksdb_ReadOptions
7713 * Method: setMaxSkippableInternalKeys
7714 * Signature: (JJ)V
7715 */
Java_org_rocksdb_ReadOptions_setMaxSkippableInternalKeys(JNIEnv *,jobject,jlong jhandle,jlong jmax_skippable_internal_keys)7716 void Java_org_rocksdb_ReadOptions_setMaxSkippableInternalKeys(
7717 JNIEnv*, jobject, jlong jhandle, jlong jmax_skippable_internal_keys) {
7718 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7719 opt->max_skippable_internal_keys =
7720 static_cast<uint64_t>(jmax_skippable_internal_keys);
7721 }
7722
7723 /*
7724 * Class: org_rocksdb_ReadOptions
7725 * Method: ignoreRangeDeletions
7726 * Signature: (J)Z
7727 */
Java_org_rocksdb_ReadOptions_ignoreRangeDeletions(JNIEnv *,jobject,jlong jhandle)7728 jboolean Java_org_rocksdb_ReadOptions_ignoreRangeDeletions(
7729 JNIEnv*, jobject, jlong jhandle) {
7730 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7731 return static_cast<jboolean>(opt->ignore_range_deletions);
7732 }
7733
7734 /*
7735 * Class: org_rocksdb_ReadOptions
7736 * Method: setIgnoreRangeDeletions
7737 * Signature: (JZ)V
7738 */
Java_org_rocksdb_ReadOptions_setIgnoreRangeDeletions(JNIEnv *,jobject,jlong jhandle,jboolean jignore_range_deletions)7739 void Java_org_rocksdb_ReadOptions_setIgnoreRangeDeletions(
7740 JNIEnv*, jobject, jlong jhandle, jboolean jignore_range_deletions) {
7741 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7742 opt->ignore_range_deletions = static_cast<bool>(jignore_range_deletions);
7743 }
7744
7745 /*
7746 * Class: org_rocksdb_ReadOptions
7747 * Method: setSnapshot
7748 * Signature: (JJ)V
7749 */
Java_org_rocksdb_ReadOptions_setSnapshot(JNIEnv *,jobject,jlong jhandle,jlong jsnapshot)7750 void Java_org_rocksdb_ReadOptions_setSnapshot(
7751 JNIEnv*, jobject, jlong jhandle, jlong jsnapshot) {
7752 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->snapshot =
7753 reinterpret_cast<ROCKSDB_NAMESPACE::Snapshot*>(jsnapshot);
7754 }
7755
7756 /*
7757 * Class: org_rocksdb_ReadOptions
7758 * Method: snapshot
7759 * Signature: (J)J
7760 */
Java_org_rocksdb_ReadOptions_snapshot(JNIEnv *,jobject,jlong jhandle)7761 jlong Java_org_rocksdb_ReadOptions_snapshot(
7762 JNIEnv*, jobject, jlong jhandle) {
7763 auto& snapshot =
7764 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->snapshot;
7765 return reinterpret_cast<jlong>(snapshot);
7766 }
7767
7768 /*
7769 * Class: org_rocksdb_ReadOptions
7770 * Method: readTier
7771 * Signature: (J)B
7772 */
Java_org_rocksdb_ReadOptions_readTier(JNIEnv *,jobject,jlong jhandle)7773 jbyte Java_org_rocksdb_ReadOptions_readTier(
7774 JNIEnv*, jobject, jlong jhandle) {
7775 return static_cast<jbyte>(
7776 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->read_tier);
7777 }
7778
7779 /*
7780 * Class: org_rocksdb_ReadOptions
7781 * Method: setReadTier
7782 * Signature: (JB)V
7783 */
Java_org_rocksdb_ReadOptions_setReadTier(JNIEnv *,jobject,jlong jhandle,jbyte jread_tier)7784 void Java_org_rocksdb_ReadOptions_setReadTier(
7785 JNIEnv*, jobject, jlong jhandle, jbyte jread_tier) {
7786 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)->read_tier =
7787 static_cast<ROCKSDB_NAMESPACE::ReadTier>(jread_tier);
7788 }
7789
7790 /*
7791 * Class: org_rocksdb_ReadOptions
7792 * Method: setIterateUpperBound
7793 * Signature: (JJ)I
7794 */
Java_org_rocksdb_ReadOptions_setIterateUpperBound(JNIEnv *,jobject,jlong jhandle,jlong jupper_bound_slice_handle)7795 void Java_org_rocksdb_ReadOptions_setIterateUpperBound(
7796 JNIEnv*, jobject, jlong jhandle, jlong jupper_bound_slice_handle) {
7797 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
7798 ->iterate_upper_bound =
7799 reinterpret_cast<ROCKSDB_NAMESPACE::Slice*>(jupper_bound_slice_handle);
7800 }
7801
7802 /*
7803 * Class: org_rocksdb_ReadOptions
7804 * Method: iterateUpperBound
7805 * Signature: (J)J
7806 */
Java_org_rocksdb_ReadOptions_iterateUpperBound(JNIEnv *,jobject,jlong jhandle)7807 jlong Java_org_rocksdb_ReadOptions_iterateUpperBound(
7808 JNIEnv*, jobject, jlong jhandle) {
7809 auto& upper_bound_slice_handle =
7810 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
7811 ->iterate_upper_bound;
7812 return reinterpret_cast<jlong>(upper_bound_slice_handle);
7813 }
7814
7815 /*
7816 * Class: org_rocksdb_ReadOptions
7817 * Method: setIterateLowerBound
7818 * Signature: (JJ)I
7819 */
Java_org_rocksdb_ReadOptions_setIterateLowerBound(JNIEnv *,jobject,jlong jhandle,jlong jlower_bound_slice_handle)7820 void Java_org_rocksdb_ReadOptions_setIterateLowerBound(
7821 JNIEnv*, jobject, jlong jhandle, jlong jlower_bound_slice_handle) {
7822 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
7823 ->iterate_lower_bound =
7824 reinterpret_cast<ROCKSDB_NAMESPACE::Slice*>(jlower_bound_slice_handle);
7825 }
7826
7827 /*
7828 * Class: org_rocksdb_ReadOptions
7829 * Method: iterateLowerBound
7830 * Signature: (J)J
7831 */
Java_org_rocksdb_ReadOptions_iterateLowerBound(JNIEnv *,jobject,jlong jhandle)7832 jlong Java_org_rocksdb_ReadOptions_iterateLowerBound(
7833 JNIEnv*, jobject, jlong jhandle) {
7834 auto& lower_bound_slice_handle =
7835 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle)
7836 ->iterate_lower_bound;
7837 return reinterpret_cast<jlong>(lower_bound_slice_handle);
7838 }
7839
7840 /*
7841 * Class: org_rocksdb_ReadOptions
7842 * Method: setTableFilter
7843 * Signature: (JJ)V
7844 */
Java_org_rocksdb_ReadOptions_setTableFilter(JNIEnv *,jobject,jlong jhandle,jlong jjni_table_filter_handle)7845 void Java_org_rocksdb_ReadOptions_setTableFilter(
7846 JNIEnv*, jobject, jlong jhandle, jlong jjni_table_filter_handle) {
7847 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7848 auto* jni_table_filter =
7849 reinterpret_cast<ROCKSDB_NAMESPACE::TableFilterJniCallback*>(
7850 jjni_table_filter_handle);
7851 opt->table_filter = jni_table_filter->GetTableFilterFunction();
7852 }
7853
7854 /*
7855 * Class: org_rocksdb_ReadOptions
7856 * Method: setIterStartSeqnum
7857 * Signature: (JJ)V
7858 */
Java_org_rocksdb_ReadOptions_setIterStartSeqnum(JNIEnv *,jobject,jlong jhandle,jlong jiter_start_seqnum)7859 void Java_org_rocksdb_ReadOptions_setIterStartSeqnum(
7860 JNIEnv*, jobject, jlong jhandle, jlong jiter_start_seqnum) {
7861 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7862 opt->iter_start_seqnum = static_cast<uint64_t>(jiter_start_seqnum);
7863 }
7864
7865 /*
7866 * Class: org_rocksdb_ReadOptions
7867 * Method: iterStartSeqnum
7868 * Signature: (J)J
7869 */
Java_org_rocksdb_ReadOptions_iterStartSeqnum(JNIEnv *,jobject,jlong jhandle)7870 jlong Java_org_rocksdb_ReadOptions_iterStartSeqnum(
7871 JNIEnv*, jobject, jlong jhandle) {
7872 auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions*>(jhandle);
7873 return static_cast<jlong>(opt->iter_start_seqnum);
7874 }
7875
7876 /////////////////////////////////////////////////////////////////////
7877 // ROCKSDB_NAMESPACE::ComparatorOptions
7878
7879 /*
7880 * Class: org_rocksdb_ComparatorOptions
7881 * Method: newComparatorOptions
7882 * Signature: ()J
7883 */
Java_org_rocksdb_ComparatorOptions_newComparatorOptions(JNIEnv *,jclass)7884 jlong Java_org_rocksdb_ComparatorOptions_newComparatorOptions(
7885 JNIEnv*, jclass) {
7886 auto* comparator_opt = new ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions();
7887 return reinterpret_cast<jlong>(comparator_opt);
7888 }
7889
7890 /*
7891 * Class: org_rocksdb_ComparatorOptions
7892 * Method: reusedSynchronisationType
7893 * Signature: (J)B
7894 */
Java_org_rocksdb_ComparatorOptions_reusedSynchronisationType(JNIEnv *,jobject,jlong jhandle)7895 jbyte Java_org_rocksdb_ComparatorOptions_reusedSynchronisationType(
7896 JNIEnv *, jobject, jlong jhandle) {
7897 auto* comparator_opt =
7898 reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(
7899 jhandle);
7900 return ROCKSDB_NAMESPACE::ReusedSynchronisationTypeJni::
7901 toJavaReusedSynchronisationType(
7902 comparator_opt->reused_synchronisation_type);
7903 }
7904
7905 /*
7906 * Class: org_rocksdb_ComparatorOptions
7907 * Method: setReusedSynchronisationType
7908 * Signature: (JB)V
7909 */
Java_org_rocksdb_ComparatorOptions_setReusedSynchronisationType(JNIEnv *,jobject,jlong jhandle,jbyte jreused_synhcronisation_type)7910 void Java_org_rocksdb_ComparatorOptions_setReusedSynchronisationType(
7911 JNIEnv*, jobject, jlong jhandle, jbyte jreused_synhcronisation_type) {
7912 auto* comparator_opt =
7913 reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(
7914 jhandle);
7915 comparator_opt->reused_synchronisation_type =
7916 ROCKSDB_NAMESPACE::ReusedSynchronisationTypeJni::
7917 toCppReusedSynchronisationType(jreused_synhcronisation_type);
7918 }
7919
7920 /*
7921 * Class: org_rocksdb_ComparatorOptions
7922 * Method: useDirectBuffer
7923 * Signature: (J)Z
7924 */
Java_org_rocksdb_ComparatorOptions_useDirectBuffer(JNIEnv *,jobject,jlong jhandle)7925 jboolean Java_org_rocksdb_ComparatorOptions_useDirectBuffer(
7926 JNIEnv*, jobject, jlong jhandle) {
7927 return static_cast<jboolean>(
7928 reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(
7929 jhandle)
7930 ->direct_buffer);
7931 }
7932
7933 /*
7934 * Class: org_rocksdb_ComparatorOptions
7935 * Method: setUseDirectBuffer
7936 * Signature: (JZ)V
7937 */
Java_org_rocksdb_ComparatorOptions_setUseDirectBuffer(JNIEnv *,jobject,jlong jhandle,jboolean jdirect_buffer)7938 void Java_org_rocksdb_ComparatorOptions_setUseDirectBuffer(
7939 JNIEnv*, jobject, jlong jhandle, jboolean jdirect_buffer) {
7940 reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(jhandle)
7941 ->direct_buffer = jdirect_buffer == JNI_TRUE;
7942 }
7943
7944 /*
7945 * Class: org_rocksdb_ComparatorOptions
7946 * Method: maxReusedBufferSize
7947 * Signature: (J)I
7948 */
Java_org_rocksdb_ComparatorOptions_maxReusedBufferSize(JNIEnv *,jobject,jlong jhandle)7949 jint Java_org_rocksdb_ComparatorOptions_maxReusedBufferSize(
7950 JNIEnv*, jobject, jlong jhandle) {
7951 return static_cast<jint>(
7952 reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(
7953 jhandle)
7954 ->max_reused_buffer_size);
7955 }
7956
7957 /*
7958 * Class: org_rocksdb_ComparatorOptions
7959 * Method: setMaxReusedBufferSize
7960 * Signature: (JI)V
7961 */
Java_org_rocksdb_ComparatorOptions_setMaxReusedBufferSize(JNIEnv *,jobject,jlong jhandle,jint jmax_reused_buffer_size)7962 void Java_org_rocksdb_ComparatorOptions_setMaxReusedBufferSize(
7963 JNIEnv*, jobject, jlong jhandle, jint jmax_reused_buffer_size) {
7964 reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(jhandle)
7965 ->max_reused_buffer_size = static_cast<int32_t>(jmax_reused_buffer_size);
7966 }
7967
7968 /*
7969 * Class: org_rocksdb_ComparatorOptions
7970 * Method: disposeInternal
7971 * Signature: (J)V
7972 */
Java_org_rocksdb_ComparatorOptions_disposeInternal(JNIEnv *,jobject,jlong jhandle)7973 void Java_org_rocksdb_ComparatorOptions_disposeInternal(
7974 JNIEnv*, jobject, jlong jhandle) {
7975 auto* comparator_opt =
7976 reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*>(
7977 jhandle);
7978 assert(comparator_opt != nullptr);
7979 delete comparator_opt;
7980 }
7981
7982 /////////////////////////////////////////////////////////////////////
7983 // ROCKSDB_NAMESPACE::FlushOptions
7984
7985 /*
7986 * Class: org_rocksdb_FlushOptions
7987 * Method: newFlushOptions
7988 * Signature: ()J
7989 */
Java_org_rocksdb_FlushOptions_newFlushOptions(JNIEnv *,jclass)7990 jlong Java_org_rocksdb_FlushOptions_newFlushOptions(
7991 JNIEnv*, jclass) {
7992 auto* flush_opt = new ROCKSDB_NAMESPACE::FlushOptions();
7993 return reinterpret_cast<jlong>(flush_opt);
7994 }
7995
7996 /*
7997 * Class: org_rocksdb_FlushOptions
7998 * Method: setWaitForFlush
7999 * Signature: (JZ)V
8000 */
Java_org_rocksdb_FlushOptions_setWaitForFlush(JNIEnv *,jobject,jlong jhandle,jboolean jwait)8001 void Java_org_rocksdb_FlushOptions_setWaitForFlush(
8002 JNIEnv*, jobject, jlong jhandle, jboolean jwait) {
8003 reinterpret_cast<ROCKSDB_NAMESPACE::FlushOptions*>(jhandle)->wait =
8004 static_cast<bool>(jwait);
8005 }
8006
8007 /*
8008 * Class: org_rocksdb_FlushOptions
8009 * Method: waitForFlush
8010 * Signature: (J)Z
8011 */
Java_org_rocksdb_FlushOptions_waitForFlush(JNIEnv *,jobject,jlong jhandle)8012 jboolean Java_org_rocksdb_FlushOptions_waitForFlush(
8013 JNIEnv*, jobject, jlong jhandle) {
8014 return reinterpret_cast<ROCKSDB_NAMESPACE::FlushOptions*>(jhandle)->wait;
8015 }
8016
8017 /*
8018 * Class: org_rocksdb_FlushOptions
8019 * Method: setAllowWriteStall
8020 * Signature: (JZ)V
8021 */
Java_org_rocksdb_FlushOptions_setAllowWriteStall(JNIEnv *,jobject,jlong jhandle,jboolean jallow_write_stall)8022 void Java_org_rocksdb_FlushOptions_setAllowWriteStall(
8023 JNIEnv*, jobject, jlong jhandle, jboolean jallow_write_stall) {
8024 auto* flush_options =
8025 reinterpret_cast<ROCKSDB_NAMESPACE::FlushOptions*>(jhandle);
8026 flush_options->allow_write_stall = jallow_write_stall == JNI_TRUE;
8027 }
8028
8029 /*
8030 * Class: org_rocksdb_FlushOptions
8031 * Method: allowWriteStall
8032 * Signature: (J)Z
8033 */
Java_org_rocksdb_FlushOptions_allowWriteStall(JNIEnv *,jobject,jlong jhandle)8034 jboolean Java_org_rocksdb_FlushOptions_allowWriteStall(
8035 JNIEnv*, jobject, jlong jhandle) {
8036 auto* flush_options =
8037 reinterpret_cast<ROCKSDB_NAMESPACE::FlushOptions*>(jhandle);
8038 return static_cast<jboolean>(flush_options->allow_write_stall);
8039 }
8040
8041 /*
8042 * Class: org_rocksdb_FlushOptions
8043 * Method: disposeInternal
8044 * Signature: (J)V
8045 */
Java_org_rocksdb_FlushOptions_disposeInternal(JNIEnv *,jobject,jlong jhandle)8046 void Java_org_rocksdb_FlushOptions_disposeInternal(
8047 JNIEnv*, jobject, jlong jhandle) {
8048 auto* flush_opt = reinterpret_cast<ROCKSDB_NAMESPACE::FlushOptions*>(jhandle);
8049 assert(flush_opt != nullptr);
8050 delete flush_opt;
8051 }
8052