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).
6 // This file is designed for caching those frequently used IDs and provide
7 // efficient portal (i.e, a set of static functions) to access java code
10 #ifndef JAVA_ROCKSJNI_PORTAL_H_
11 #define JAVA_ROCKSJNI_PORTAL_H_
24 #include <type_traits>
27 #include "rocksdb/convenience.h"
28 #include "rocksdb/db.h"
29 #include "rocksdb/filter_policy.h"
30 #include "rocksdb/rate_limiter.h"
31 #include "rocksdb/status.h"
32 #include "rocksdb/table.h"
33 #include "rocksdb/utilities/backupable_db.h"
34 #include "rocksdb/utilities/memory_util.h"
35 #include "rocksdb/utilities/transaction_db.h"
36 #include "rocksdb/utilities/write_batch_with_index.h"
37 #include "rocksjni/compaction_filter_factory_jnicallback.h"
38 #include "rocksjni/comparatorjnicallback.h"
39 #include "rocksjni/event_listener_jnicallback.h"
40 #include "rocksjni/loggerjnicallback.h"
41 #include "rocksjni/table_filter_jnicallback.h"
42 #include "rocksjni/trace_writer_jnicallback.h"
43 #include "rocksjni/transaction_notifier_jnicallback.h"
44 #include "rocksjni/wal_filter_jnicallback.h"
45 #include "rocksjni/writebatchhandlerjnicallback.h"
47 // Remove macro on windows
52 namespace ROCKSDB_NAMESPACE
{
57 * Gets and initializes a Java Class
59 * @param env A pointer to the Java environment
60 * @param jclazz_name The fully qualified JNI name of the Java Class
61 * e.g. "java/lang/String"
63 * @return The Java Class or nullptr if one of the
64 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
65 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
67 static jclass
getJClass(JNIEnv
* env
, const char* jclazz_name
) {
68 jclass jclazz
= env
->FindClass(jclazz_name
);
69 assert(jclazz
!= nullptr);
74 // Native class template
75 template<class PTR
, class DERIVED
> class RocksDBNativeClass
: public JavaClass
{
78 // Native class template for sub-classes of RocksMutableObject
79 template<class PTR
, class DERIVED
> class NativeRocksMutableObject
80 : public RocksDBNativeClass
<PTR
, DERIVED
> {
84 * Gets the Java Method ID for the
85 * RocksMutableObject#setNativeHandle(long, boolean) method
87 * @param env A pointer to the Java environment
88 * @return The Java Method ID or nullptr the RocksMutableObject class cannot
89 * be accessed, or if one of the NoSuchMethodError,
90 * ExceptionInInitializerError or OutOfMemoryError exceptions is thrown
92 static jmethodID
getSetNativeHandleMethod(JNIEnv
* env
) {
93 static jclass jclazz
= DERIVED::getJClass(env
);
94 if(jclazz
== nullptr) {
98 static jmethodID mid
= env
->GetMethodID(
99 jclazz
, "setNativeHandle", "(JZ)V");
100 assert(mid
!= nullptr);
105 * Sets the C++ object pointer handle in the Java object
107 * @param env A pointer to the Java environment
108 * @param jobj The Java object on which to set the pointer handle
109 * @param ptr The C++ object pointer
110 * @param java_owns_handle JNI_TRUE if ownership of the C++ object is
111 * managed by the Java object
113 * @return true if a Java exception is pending, false otherwise
115 static bool setHandle(JNIEnv
* env
, jobject jobj
, PTR ptr
,
116 jboolean java_owns_handle
) {
117 assert(jobj
!= nullptr);
118 static jmethodID mid
= getSetNativeHandleMethod(env
);
120 return true; // signal exception
123 env
->CallVoidMethod(jobj
, mid
, reinterpret_cast<jlong
>(ptr
), java_owns_handle
);
124 if(env
->ExceptionCheck()) {
125 return true; // signal exception
132 // Java Exception template
133 template<class DERIVED
> class JavaException
: public JavaClass
{
136 * Create and throw a java exception with the provided message
138 * @param env A pointer to the Java environment
139 * @param msg The message for the exception
141 * @return true if an exception was thrown, false otherwise
143 static bool ThrowNew(JNIEnv
* env
, const std::string
& msg
) {
144 jclass jclazz
= DERIVED::getJClass(env
);
145 if(jclazz
== nullptr) {
146 // exception occurred accessing class
147 std::cerr
<< "JavaException::ThrowNew - Error: unexpected exception!" << std::endl
;
148 return env
->ExceptionCheck();
151 const jint rs
= env
->ThrowNew(jclazz
, msg
.c_str());
153 // exception could not be thrown
154 std::cerr
<< "JavaException::ThrowNew - Fatal: could not throw exception!" << std::endl
;
155 return env
->ExceptionCheck();
162 // The portal class for java.lang.IllegalArgumentException
163 class IllegalArgumentExceptionJni
:
164 public JavaException
<IllegalArgumentExceptionJni
> {
167 * Get the Java Class java.lang.IllegalArgumentException
169 * @param env A pointer to the Java environment
171 * @return The Java Class or nullptr if one of the
172 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
173 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
175 static jclass
getJClass(JNIEnv
* env
) {
176 return JavaException::getJClass(env
, "java/lang/IllegalArgumentException");
180 * Create and throw a Java IllegalArgumentException with the provided status
182 * If s.ok() == true, then this function will not throw any exception.
184 * @param env A pointer to the Java environment
185 * @param s The status for the exception
187 * @return true if an exception was thrown, false otherwise
189 static bool ThrowNew(JNIEnv
* env
, const Status
& s
) {
195 // get the IllegalArgumentException class
196 jclass jclazz
= getJClass(env
);
197 if(jclazz
== nullptr) {
198 // exception occurred accessing class
199 std::cerr
<< "IllegalArgumentExceptionJni::ThrowNew/class - Error: unexpected exception!" << std::endl
;
200 return env
->ExceptionCheck();
203 return JavaException::ThrowNew(env
, s
.ToString());
207 // The portal class for org.rocksdb.Status.Code
208 class CodeJni
: public JavaClass
{
211 * Get the Java Class org.rocksdb.Status.Code
213 * @param env A pointer to the Java environment
215 * @return The Java Class or nullptr if one of the
216 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
217 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
219 static jclass
getJClass(JNIEnv
* env
) {
220 return JavaClass::getJClass(env
, "org/rocksdb/Status$Code");
224 * Get the Java Method: Status.Code#getValue
226 * @param env A pointer to the Java environment
228 * @return The Java Method ID or nullptr if the class or method id could not
231 static jmethodID
getValueMethod(JNIEnv
* env
) {
232 jclass jclazz
= getJClass(env
);
233 if(jclazz
== nullptr) {
234 // exception occurred accessing class
238 static jmethodID mid
=
239 env
->GetMethodID(jclazz
, "getValue", "()b");
240 assert(mid
!= nullptr);
245 // The portal class for org.rocksdb.Status.SubCode
246 class SubCodeJni
: public JavaClass
{
249 * Get the Java Class org.rocksdb.Status.SubCode
251 * @param env A pointer to the Java environment
253 * @return The Java Class or nullptr if one of the
254 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
255 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
257 static jclass
getJClass(JNIEnv
* env
) {
258 return JavaClass::getJClass(env
, "org/rocksdb/Status$SubCode");
262 * Get the Java Method: Status.SubCode#getValue
264 * @param env A pointer to the Java environment
266 * @return The Java Method ID or nullptr if the class or method id could not
269 static jmethodID
getValueMethod(JNIEnv
* env
) {
270 jclass jclazz
= getJClass(env
);
271 if(jclazz
== nullptr) {
272 // exception occurred accessing class
276 static jmethodID mid
=
277 env
->GetMethodID(jclazz
, "getValue", "()b");
278 assert(mid
!= nullptr);
282 static ROCKSDB_NAMESPACE::Status::SubCode
toCppSubCode(
283 const jbyte jsub_code
) {
286 return ROCKSDB_NAMESPACE::Status::SubCode::kNone
;
288 return ROCKSDB_NAMESPACE::Status::SubCode::kMutexTimeout
;
290 return ROCKSDB_NAMESPACE::Status::SubCode::kLockTimeout
;
292 return ROCKSDB_NAMESPACE::Status::SubCode::kLockLimit
;
294 return ROCKSDB_NAMESPACE::Status::SubCode::kNoSpace
;
296 return ROCKSDB_NAMESPACE::Status::SubCode::kDeadlock
;
298 return ROCKSDB_NAMESPACE::Status::SubCode::kStaleFile
;
300 return ROCKSDB_NAMESPACE::Status::SubCode::kMemoryLimit
;
304 return ROCKSDB_NAMESPACE::Status::SubCode::kNone
;
309 // The portal class for org.rocksdb.Status
311 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::Status
*, StatusJni
> {
314 * Get the Java Class org.rocksdb.Status
316 * @param env A pointer to the Java environment
318 * @return The Java Class or nullptr if one of the
319 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
320 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
322 static jclass
getJClass(JNIEnv
* env
) {
323 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/Status");
327 * Get the Java Method: Status#getCode
329 * @param env A pointer to the Java environment
331 * @return The Java Method ID or nullptr if the class or method id could not
334 static jmethodID
getCodeMethod(JNIEnv
* env
) {
335 jclass jclazz
= getJClass(env
);
336 if(jclazz
== nullptr) {
337 // exception occurred accessing class
341 static jmethodID mid
=
342 env
->GetMethodID(jclazz
, "getCode", "()Lorg/rocksdb/Status$Code;");
343 assert(mid
!= nullptr);
348 * Get the Java Method: Status#getSubCode
350 * @param env A pointer to the Java environment
352 * @return The Java Method ID or nullptr if the class or method id could not
355 static jmethodID
getSubCodeMethod(JNIEnv
* env
) {
356 jclass jclazz
= getJClass(env
);
357 if(jclazz
== nullptr) {
358 // exception occurred accessing class
362 static jmethodID mid
=
363 env
->GetMethodID(jclazz
, "getSubCode", "()Lorg/rocksdb/Status$SubCode;");
364 assert(mid
!= nullptr);
369 * Get the Java Method: Status#getState
371 * @param env A pointer to the Java environment
373 * @return The Java Method ID or nullptr if the class or method id could not
376 static jmethodID
getStateMethod(JNIEnv
* env
) {
377 jclass jclazz
= getJClass(env
);
378 if(jclazz
== nullptr) {
379 // exception occurred accessing class
383 static jmethodID mid
=
384 env
->GetMethodID(jclazz
, "getState", "()Ljava/lang/String;");
385 assert(mid
!= nullptr);
390 * Create a new Java org.rocksdb.Status object with the same properties as
391 * the provided C++ ROCKSDB_NAMESPACE::Status object
393 * @param env A pointer to the Java environment
394 * @param status The ROCKSDB_NAMESPACE::Status object
396 * @return A reference to a Java org.rocksdb.Status object, or nullptr
397 * if an an exception occurs
399 static jobject
construct(JNIEnv
* env
, const Status
& status
) {
400 jclass jclazz
= getJClass(env
);
401 if(jclazz
== nullptr) {
402 // exception occurred accessing class
407 env
->GetMethodID(jclazz
, "<init>", "(BBLjava/lang/String;)V");
409 // exception thrown: NoSuchMethodException or OutOfMemoryError
413 // convert the Status state for Java
414 jstring jstate
= nullptr;
415 if (status
.getState() != nullptr) {
416 const char* const state
= status
.getState();
417 jstate
= env
->NewStringUTF(state
);
418 if(env
->ExceptionCheck()) {
419 if(jstate
!= nullptr) {
420 env
->DeleteLocalRef(jstate
);
427 env
->NewObject(jclazz
, mid
, toJavaStatusCode(status
.code()),
428 toJavaStatusSubCode(status
.subcode()), jstate
);
429 if(env
->ExceptionCheck()) {
430 // exception occurred
431 if(jstate
!= nullptr) {
432 env
->DeleteLocalRef(jstate
);
437 if(jstate
!= nullptr) {
438 env
->DeleteLocalRef(jstate
);
444 static jobject
construct(JNIEnv
* env
, const Status
* status
) {
445 return construct(env
, *status
);
448 // Returns the equivalent org.rocksdb.Status.Code for the provided
449 // C++ ROCKSDB_NAMESPACE::Status::Code enum
450 static jbyte
toJavaStatusCode(const ROCKSDB_NAMESPACE::Status::Code
& code
) {
452 case ROCKSDB_NAMESPACE::Status::Code::kOk
:
454 case ROCKSDB_NAMESPACE::Status::Code::kNotFound
:
456 case ROCKSDB_NAMESPACE::Status::Code::kCorruption
:
458 case ROCKSDB_NAMESPACE::Status::Code::kNotSupported
:
460 case ROCKSDB_NAMESPACE::Status::Code::kInvalidArgument
:
462 case ROCKSDB_NAMESPACE::Status::Code::kIOError
:
464 case ROCKSDB_NAMESPACE::Status::Code::kMergeInProgress
:
466 case ROCKSDB_NAMESPACE::Status::Code::kIncomplete
:
468 case ROCKSDB_NAMESPACE::Status::Code::kShutdownInProgress
:
470 case ROCKSDB_NAMESPACE::Status::Code::kTimedOut
:
472 case ROCKSDB_NAMESPACE::Status::Code::kAborted
:
474 case ROCKSDB_NAMESPACE::Status::Code::kBusy
:
476 case ROCKSDB_NAMESPACE::Status::Code::kExpired
:
478 case ROCKSDB_NAMESPACE::Status::Code::kTryAgain
:
480 case ROCKSDB_NAMESPACE::Status::Code::kColumnFamilyDropped
:
483 return 0x7F; // undefined
487 // Returns the equivalent org.rocksdb.Status.SubCode for the provided
488 // C++ ROCKSDB_NAMESPACE::Status::SubCode enum
489 static jbyte
toJavaStatusSubCode(
490 const ROCKSDB_NAMESPACE::Status::SubCode
& subCode
) {
492 case ROCKSDB_NAMESPACE::Status::SubCode::kNone
:
494 case ROCKSDB_NAMESPACE::Status::SubCode::kMutexTimeout
:
496 case ROCKSDB_NAMESPACE::Status::SubCode::kLockTimeout
:
498 case ROCKSDB_NAMESPACE::Status::SubCode::kLockLimit
:
500 case ROCKSDB_NAMESPACE::Status::SubCode::kNoSpace
:
502 case ROCKSDB_NAMESPACE::Status::SubCode::kDeadlock
:
504 case ROCKSDB_NAMESPACE::Status::SubCode::kStaleFile
:
506 case ROCKSDB_NAMESPACE::Status::SubCode::kMemoryLimit
:
509 return 0x7F; // undefined
513 static std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> toCppStatus(
514 const jbyte jcode_value
, const jbyte jsub_code_value
) {
515 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
;
516 switch (jcode_value
) {
519 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
520 new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::OK()));
524 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
525 new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::NotFound(
526 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value
))));
530 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
531 new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::Corruption(
532 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value
))));
536 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
537 new ROCKSDB_NAMESPACE::Status(
538 ROCKSDB_NAMESPACE::Status::NotSupported(
539 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(
544 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
545 new ROCKSDB_NAMESPACE::Status(
546 ROCKSDB_NAMESPACE::Status::InvalidArgument(
547 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(
552 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
553 new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::IOError(
554 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value
))));
558 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
559 new ROCKSDB_NAMESPACE::Status(
560 ROCKSDB_NAMESPACE::Status::MergeInProgress(
561 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(
566 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
567 new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::Incomplete(
568 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value
))));
572 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
573 new ROCKSDB_NAMESPACE::Status(
574 ROCKSDB_NAMESPACE::Status::ShutdownInProgress(
575 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(
580 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
581 new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::TimedOut(
582 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value
))));
586 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
587 new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::Aborted(
588 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value
))));
592 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
593 new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::Busy(
594 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value
))));
598 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
599 new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::Expired(
600 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value
))));
604 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
605 new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::TryAgain(
606 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value
))));
609 // ColumnFamilyDropped
610 status
= std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
611 new ROCKSDB_NAMESPACE::Status(
612 ROCKSDB_NAMESPACE::Status::ColumnFamilyDropped(
613 ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(
623 // Returns the equivalent ROCKSDB_NAMESPACE::Status for the Java
624 // org.rocksdb.Status
625 static std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> toCppStatus(
626 JNIEnv
* env
, const jobject jstatus
) {
627 jmethodID mid_code
= getCodeMethod(env
);
628 if (mid_code
== nullptr) {
629 // exception occurred
632 jobject jcode
= env
->CallObjectMethod(jstatus
, mid_code
);
633 if (env
->ExceptionCheck()) {
634 // exception occurred
638 jmethodID mid_code_value
= ROCKSDB_NAMESPACE::CodeJni::getValueMethod(env
);
639 if (mid_code_value
== nullptr) {
640 // exception occurred
643 jbyte jcode_value
= env
->CallByteMethod(jcode
, mid_code_value
);
644 if (env
->ExceptionCheck()) {
645 // exception occurred
646 if (jcode
!= nullptr) {
647 env
->DeleteLocalRef(jcode
);
652 jmethodID mid_subCode
= getSubCodeMethod(env
);
653 if (mid_subCode
== nullptr) {
654 // exception occurred
657 jobject jsubCode
= env
->CallObjectMethod(jstatus
, mid_subCode
);
658 if (env
->ExceptionCheck()) {
659 // exception occurred
660 if (jcode
!= nullptr) {
661 env
->DeleteLocalRef(jcode
);
666 jbyte jsub_code_value
= 0x0; // None
667 if (jsubCode
!= nullptr) {
668 jmethodID mid_subCode_value
=
669 ROCKSDB_NAMESPACE::SubCodeJni::getValueMethod(env
);
670 if (mid_subCode_value
== nullptr) {
671 // exception occurred
674 jsub_code_value
= env
->CallByteMethod(jsubCode
, mid_subCode_value
);
675 if (env
->ExceptionCheck()) {
676 // exception occurred
677 if (jcode
!= nullptr) {
678 env
->DeleteLocalRef(jcode
);
684 jmethodID mid_state
= getStateMethod(env
);
685 if (mid_state
== nullptr) {
686 // exception occurred
689 jobject jstate
= env
->CallObjectMethod(jstatus
, mid_state
);
690 if (env
->ExceptionCheck()) {
691 // exception occurred
692 if (jsubCode
!= nullptr) {
693 env
->DeleteLocalRef(jsubCode
);
695 if (jcode
!= nullptr) {
696 env
->DeleteLocalRef(jcode
);
701 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
702 toCppStatus(jcode_value
, jsub_code_value
);
704 // delete all local refs
705 if (jstate
!= nullptr) {
706 env
->DeleteLocalRef(jstate
);
708 if (jsubCode
!= nullptr) {
709 env
->DeleteLocalRef(jsubCode
);
711 if (jcode
!= nullptr) {
712 env
->DeleteLocalRef(jcode
);
719 // The portal class for org.rocksdb.RocksDBException
720 class RocksDBExceptionJni
:
721 public JavaException
<RocksDBExceptionJni
> {
724 * Get the Java Class org.rocksdb.RocksDBException
726 * @param env A pointer to the Java environment
728 * @return The Java Class or nullptr if one of the
729 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
730 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
732 static jclass
getJClass(JNIEnv
* env
) {
733 return JavaException::getJClass(env
, "org/rocksdb/RocksDBException");
737 * Create and throw a Java RocksDBException with the provided message
739 * @param env A pointer to the Java environment
740 * @param msg The message for the exception
742 * @return true if an exception was thrown, false otherwise
744 static bool ThrowNew(JNIEnv
* env
, const std::string
& msg
) {
745 return JavaException::ThrowNew(env
, msg
);
749 * Create and throw a Java RocksDBException with the provided status
751 * If s->ok() == true, then this function will not throw any exception.
753 * @param env A pointer to the Java environment
754 * @param s The status for the exception
756 * @return true if an exception was thrown, false otherwise
758 static bool ThrowNew(JNIEnv
* env
, std::unique_ptr
<Status
>& s
) {
759 return ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, *(s
.get()));
763 * Create and throw a Java RocksDBException with the provided status
765 * If s.ok() == true, then this function will not throw any exception.
767 * @param env A pointer to the Java environment
768 * @param s The status for the exception
770 * @return true if an exception was thrown, false otherwise
772 static bool ThrowNew(JNIEnv
* env
, const Status
& s
) {
777 // get the RocksDBException class
778 jclass jclazz
= getJClass(env
);
779 if(jclazz
== nullptr) {
780 // exception occurred accessing class
781 std::cerr
<< "RocksDBExceptionJni::ThrowNew/class - Error: unexpected exception!" << std::endl
;
782 return env
->ExceptionCheck();
785 // get the constructor of org.rocksdb.RocksDBException
787 env
->GetMethodID(jclazz
, "<init>", "(Lorg/rocksdb/Status;)V");
789 // exception thrown: NoSuchMethodException or OutOfMemoryError
790 std::cerr
<< "RocksDBExceptionJni::ThrowNew/cstr - Error: unexpected exception!" << std::endl
;
791 return env
->ExceptionCheck();
794 // get the Java status object
795 jobject jstatus
= StatusJni::construct(env
, s
);
796 if(jstatus
== nullptr) {
797 // exception occcurred
798 std::cerr
<< "RocksDBExceptionJni::ThrowNew/StatusJni - Error: unexpected exception!" << std::endl
;
799 return env
->ExceptionCheck();
802 // construct the RocksDBException
803 jthrowable rocksdb_exception
= reinterpret_cast<jthrowable
>(env
->NewObject(jclazz
, mid
, jstatus
));
804 if(env
->ExceptionCheck()) {
805 if(jstatus
!= nullptr) {
806 env
->DeleteLocalRef(jstatus
);
808 if(rocksdb_exception
!= nullptr) {
809 env
->DeleteLocalRef(rocksdb_exception
);
811 std::cerr
<< "RocksDBExceptionJni::ThrowNew/NewObject - Error: unexpected exception!" << std::endl
;
815 // throw the RocksDBException
816 const jint rs
= env
->Throw(rocksdb_exception
);
818 // exception could not be thrown
819 std::cerr
<< "RocksDBExceptionJni::ThrowNew - Fatal: could not throw exception!" << std::endl
;
820 if(jstatus
!= nullptr) {
821 env
->DeleteLocalRef(jstatus
);
823 if(rocksdb_exception
!= nullptr) {
824 env
->DeleteLocalRef(rocksdb_exception
);
826 return env
->ExceptionCheck();
829 if(jstatus
!= nullptr) {
830 env
->DeleteLocalRef(jstatus
);
832 if(rocksdb_exception
!= nullptr) {
833 env
->DeleteLocalRef(rocksdb_exception
);
840 * Create and throw a Java RocksDBException with the provided message
843 * If s.ok() == true, then this function will not throw any exception.
845 * @param env A pointer to the Java environment
846 * @param msg The message for the exception
847 * @param s The status for the exception
849 * @return true if an exception was thrown, false otherwise
851 static bool ThrowNew(JNIEnv
* env
, const std::string
& msg
, const Status
& s
) {
857 // get the RocksDBException class
858 jclass jclazz
= getJClass(env
);
859 if(jclazz
== nullptr) {
860 // exception occurred accessing class
861 std::cerr
<< "RocksDBExceptionJni::ThrowNew/class - Error: unexpected exception!" << std::endl
;
862 return env
->ExceptionCheck();
865 // get the constructor of org.rocksdb.RocksDBException
867 env
->GetMethodID(jclazz
, "<init>", "(Ljava/lang/String;Lorg/rocksdb/Status;)V");
869 // exception thrown: NoSuchMethodException or OutOfMemoryError
870 std::cerr
<< "RocksDBExceptionJni::ThrowNew/cstr - Error: unexpected exception!" << std::endl
;
871 return env
->ExceptionCheck();
874 jstring jmsg
= env
->NewStringUTF(msg
.c_str());
875 if(jmsg
== nullptr) {
876 // exception thrown: OutOfMemoryError
877 std::cerr
<< "RocksDBExceptionJni::ThrowNew/msg - Error: unexpected exception!" << std::endl
;
878 return env
->ExceptionCheck();
881 // get the Java status object
882 jobject jstatus
= StatusJni::construct(env
, s
);
883 if(jstatus
== nullptr) {
884 // exception occcurred
885 std::cerr
<< "RocksDBExceptionJni::ThrowNew/StatusJni - Error: unexpected exception!" << std::endl
;
886 if(jmsg
!= nullptr) {
887 env
->DeleteLocalRef(jmsg
);
889 return env
->ExceptionCheck();
892 // construct the RocksDBException
893 jthrowable rocksdb_exception
= reinterpret_cast<jthrowable
>(env
->NewObject(jclazz
, mid
, jmsg
, jstatus
));
894 if(env
->ExceptionCheck()) {
895 if(jstatus
!= nullptr) {
896 env
->DeleteLocalRef(jstatus
);
898 if(jmsg
!= nullptr) {
899 env
->DeleteLocalRef(jmsg
);
901 if(rocksdb_exception
!= nullptr) {
902 env
->DeleteLocalRef(rocksdb_exception
);
904 std::cerr
<< "RocksDBExceptionJni::ThrowNew/NewObject - Error: unexpected exception!" << std::endl
;
908 // throw the RocksDBException
909 const jint rs
= env
->Throw(rocksdb_exception
);
911 // exception could not be thrown
912 std::cerr
<< "RocksDBExceptionJni::ThrowNew - Fatal: could not throw exception!" << std::endl
;
913 if(jstatus
!= nullptr) {
914 env
->DeleteLocalRef(jstatus
);
916 if(jmsg
!= nullptr) {
917 env
->DeleteLocalRef(jmsg
);
919 if(rocksdb_exception
!= nullptr) {
920 env
->DeleteLocalRef(rocksdb_exception
);
922 return env
->ExceptionCheck();
925 if(jstatus
!= nullptr) {
926 env
->DeleteLocalRef(jstatus
);
928 if(jmsg
!= nullptr) {
929 env
->DeleteLocalRef(jmsg
);
931 if(rocksdb_exception
!= nullptr) {
932 env
->DeleteLocalRef(rocksdb_exception
);
939 * Get the Java Method: RocksDBException#getStatus
941 * @param env A pointer to the Java environment
943 * @return The Java Method ID or nullptr if the class or method id could not
946 static jmethodID
getStatusMethod(JNIEnv
* env
) {
947 jclass jclazz
= getJClass(env
);
948 if(jclazz
== nullptr) {
949 // exception occurred accessing class
953 static jmethodID mid
=
954 env
->GetMethodID(jclazz
, "getStatus", "()Lorg/rocksdb/Status;");
955 assert(mid
!= nullptr);
959 static std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> toCppStatus(
960 JNIEnv
* env
, jthrowable jrocksdb_exception
) {
961 if(!env
->IsInstanceOf(jrocksdb_exception
, getJClass(env
))) {
962 // not an instance of RocksDBException
966 // get the java status object
967 jmethodID mid
= getStatusMethod(env
);
969 // exception occurred accessing class or method
973 jobject jstatus
= env
->CallObjectMethod(jrocksdb_exception
, mid
);
974 if(env
->ExceptionCheck()) {
975 // exception occurred
979 if(jstatus
== nullptr) {
980 return nullptr; // no status available
983 return ROCKSDB_NAMESPACE::StatusJni::toCppStatus(env
, jstatus
);
987 // The portal class for java.util.List
988 class ListJni
: public JavaClass
{
991 * Get the Java Class java.util.List
993 * @param env A pointer to the Java environment
995 * @return The Java Class or nullptr if one of the
996 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
997 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
999 static jclass
getListClass(JNIEnv
* env
) {
1000 return JavaClass::getJClass(env
, "java/util/List");
1004 * Get the Java Class java.util.ArrayList
1006 * @param env A pointer to the Java environment
1008 * @return The Java Class or nullptr if one of the
1009 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
1010 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
1012 static jclass
getArrayListClass(JNIEnv
* env
) {
1013 return JavaClass::getJClass(env
, "java/util/ArrayList");
1017 * Get the Java Class java.util.Iterator
1019 * @param env A pointer to the Java environment
1021 * @return The Java Class or nullptr if one of the
1022 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
1023 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
1025 static jclass
getIteratorClass(JNIEnv
* env
) {
1026 return JavaClass::getJClass(env
, "java/util/Iterator");
1030 * Get the Java Method: List#iterator
1032 * @param env A pointer to the Java environment
1034 * @return The Java Method ID or nullptr if the class or method id could not
1037 static jmethodID
getIteratorMethod(JNIEnv
* env
) {
1038 jclass jlist_clazz
= getListClass(env
);
1039 if(jlist_clazz
== nullptr) {
1040 // exception occurred accessing class
1044 static jmethodID mid
=
1045 env
->GetMethodID(jlist_clazz
, "iterator", "()Ljava/util/Iterator;");
1046 assert(mid
!= nullptr);
1051 * Get the Java Method: Iterator#hasNext
1053 * @param env A pointer to the Java environment
1055 * @return The Java Method ID or nullptr if the class or method id could not
1058 static jmethodID
getHasNextMethod(JNIEnv
* env
) {
1059 jclass jiterator_clazz
= getIteratorClass(env
);
1060 if(jiterator_clazz
== nullptr) {
1061 // exception occurred accessing class
1065 static jmethodID mid
= env
->GetMethodID(jiterator_clazz
, "hasNext", "()Z");
1066 assert(mid
!= nullptr);
1071 * Get the Java Method: Iterator#next
1073 * @param env A pointer to the Java environment
1075 * @return The Java Method ID or nullptr if the class or method id could not
1078 static jmethodID
getNextMethod(JNIEnv
* env
) {
1079 jclass jiterator_clazz
= getIteratorClass(env
);
1080 if(jiterator_clazz
== nullptr) {
1081 // exception occurred accessing class
1085 static jmethodID mid
=
1086 env
->GetMethodID(jiterator_clazz
, "next", "()Ljava/lang/Object;");
1087 assert(mid
!= nullptr);
1092 * Get the Java Method: ArrayList constructor
1094 * @param env A pointer to the Java environment
1096 * @return The Java Method ID or nullptr if the class or method id could not
1099 static jmethodID
getArrayListConstructorMethodId(JNIEnv
* env
) {
1100 jclass jarray_list_clazz
= getArrayListClass(env
);
1101 if(jarray_list_clazz
== nullptr) {
1102 // exception occurred accessing class
1105 static jmethodID mid
=
1106 env
->GetMethodID(jarray_list_clazz
, "<init>", "(I)V");
1107 assert(mid
!= nullptr);
1112 * Get the Java Method: List#add
1114 * @param env A pointer to the Java environment
1116 * @return The Java Method ID or nullptr if the class or method id could not
1119 static jmethodID
getListAddMethodId(JNIEnv
* env
) {
1120 jclass jlist_clazz
= getListClass(env
);
1121 if(jlist_clazz
== nullptr) {
1122 // exception occurred accessing class
1126 static jmethodID mid
=
1127 env
->GetMethodID(jlist_clazz
, "add", "(Ljava/lang/Object;)Z");
1128 assert(mid
!= nullptr);
1133 // The portal class for java.lang.Byte
1134 class ByteJni
: public JavaClass
{
1137 * Get the Java Class java.lang.Byte
1139 * @param env A pointer to the Java environment
1141 * @return The Java Class or nullptr if one of the
1142 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
1143 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
1145 static jclass
getJClass(JNIEnv
* env
) {
1146 return JavaClass::getJClass(env
, "java/lang/Byte");
1150 * Get the Java Class byte[]
1152 * @param env A pointer to the Java environment
1154 * @return The Java Class or nullptr if one of the
1155 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
1156 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
1158 static jclass
getArrayJClass(JNIEnv
* env
) {
1159 return JavaClass::getJClass(env
, "[B");
1163 * Creates a new 2-dimensional Java Byte Array byte[][]
1165 * @param env A pointer to the Java environment
1166 * @param len The size of the first dimension
1168 * @return A reference to the Java byte[][] or nullptr if an exception occurs
1170 static jobjectArray
new2dByteArray(JNIEnv
* env
, const jsize len
) {
1171 jclass clazz
= getArrayJClass(env
);
1172 if(clazz
== nullptr) {
1173 // exception occurred accessing class
1177 return env
->NewObjectArray(len
, clazz
, nullptr);
1181 * Get the Java Method: Byte#byteValue
1183 * @param env A pointer to the Java environment
1185 * @return The Java Method ID or nullptr if the class or method id could not
1188 static jmethodID
getByteValueMethod(JNIEnv
* env
) {
1189 jclass clazz
= getJClass(env
);
1190 if(clazz
== nullptr) {
1191 // exception occurred accessing class
1195 static jmethodID mid
= env
->GetMethodID(clazz
, "byteValue", "()B");
1196 assert(mid
!= nullptr);
1201 * Calls the Java Method: Byte#valueOf, returning a constructed Byte jobject
1203 * @param env A pointer to the Java environment
1205 * @return A constructing Byte object or nullptr if the class or method id could not
1206 * be retrieved, or an exception occurred
1208 static jobject
valueOf(JNIEnv
* env
, jbyte jprimitive_byte
) {
1209 jclass clazz
= getJClass(env
);
1210 if (clazz
== nullptr) {
1211 // exception occurred accessing class
1215 static jmethodID mid
=
1216 env
->GetStaticMethodID(clazz
, "valueOf", "(B)Ljava/lang/Byte;");
1217 if (mid
== nullptr) {
1218 // exception thrown: NoSuchMethodException or OutOfMemoryError
1222 const jobject jbyte_obj
=
1223 env
->CallStaticObjectMethod(clazz
, mid
, jprimitive_byte
);
1224 if (env
->ExceptionCheck()) {
1225 // exception occurred
1234 // The portal class for java.nio.ByteBuffer
1235 class ByteBufferJni
: public JavaClass
{
1238 * Get the Java Class java.nio.ByteBuffer
1240 * @param env A pointer to the Java environment
1242 * @return The Java Class or nullptr if one of the
1243 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
1244 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
1246 static jclass
getJClass(JNIEnv
* env
) {
1247 return JavaClass::getJClass(env
, "java/nio/ByteBuffer");
1251 * Get the Java Method: ByteBuffer#allocate
1253 * @param env A pointer to the Java environment
1254 * @param jbytebuffer_clazz if you have a reference to a ByteBuffer class, or
1257 * @return The Java Method ID or nullptr if the class or method id could not
1260 static jmethodID
getAllocateMethodId(JNIEnv
* env
,
1261 jclass jbytebuffer_clazz
= nullptr) {
1262 const jclass jclazz
=
1263 jbytebuffer_clazz
== nullptr ? getJClass(env
) : jbytebuffer_clazz
;
1264 if (jclazz
== nullptr) {
1265 // exception occurred accessing class
1269 static jmethodID mid
= env
->GetStaticMethodID(
1270 jclazz
, "allocate", "(I)Ljava/nio/ByteBuffer;");
1271 assert(mid
!= nullptr);
1276 * Get the Java Method: ByteBuffer#array
1278 * @param env A pointer to the Java environment
1280 * @return The Java Method ID or nullptr if the class or method id could not
1283 static jmethodID
getArrayMethodId(JNIEnv
* env
,
1284 jclass jbytebuffer_clazz
= nullptr) {
1285 const jclass jclazz
=
1286 jbytebuffer_clazz
== nullptr ? getJClass(env
) : jbytebuffer_clazz
;
1287 if(jclazz
== nullptr) {
1288 // exception occurred accessing class
1292 static jmethodID mid
= env
->GetMethodID(jclazz
, "array", "()[B");
1293 assert(mid
!= nullptr);
1297 static jobject
construct(
1298 JNIEnv
* env
, const bool direct
, const size_t capacity
,
1299 jclass jbytebuffer_clazz
= nullptr) {
1300 return constructWith(env
, direct
, nullptr, capacity
, jbytebuffer_clazz
);
1303 static jobject
constructWith(JNIEnv
* env
, const bool direct
, const char* buf
,
1304 const size_t capacity
,
1305 jclass jbytebuffer_clazz
= nullptr) {
1307 bool allocated
= false;
1308 if (buf
== nullptr) {
1309 buf
= new char[capacity
];
1312 jobject jbuf
= env
->NewDirectByteBuffer(const_cast<char*>(buf
), static_cast<jlong
>(capacity
));
1313 if (jbuf
== nullptr) {
1314 // exception occurred
1316 delete[] static_cast<const char*>(buf
);
1322 const jclass jclazz
=
1323 jbytebuffer_clazz
== nullptr ? getJClass(env
) : jbytebuffer_clazz
;
1324 if (jclazz
== nullptr) {
1325 // exception occurred accessing class
1328 const jmethodID jmid_allocate
= getAllocateMethodId(env
, jbytebuffer_clazz
);
1329 if (jmid_allocate
== nullptr) {
1330 // exception occurred accessing class, or NoSuchMethodException or OutOfMemoryError
1333 const jobject jbuf
= env
->CallStaticObjectMethod(
1334 jclazz
, jmid_allocate
, static_cast<jint
>(capacity
));
1335 if (env
->ExceptionCheck()) {
1336 // exception occurred
1341 if (buf
!= nullptr) {
1342 jbyteArray jarray
= array(env
, jbuf
, jbytebuffer_clazz
);
1343 if (jarray
== nullptr) {
1344 // exception occurred
1345 env
->DeleteLocalRef(jbuf
);
1349 jboolean is_copy
= JNI_FALSE
;
1350 jbyte
* ja
= reinterpret_cast<jbyte
*>(
1351 env
->GetPrimitiveArrayCritical(jarray
, &is_copy
));
1352 if (ja
== nullptr) {
1353 // exception occurred
1354 env
->DeleteLocalRef(jarray
);
1355 env
->DeleteLocalRef(jbuf
);
1359 memcpy(ja
, const_cast<char*>(buf
), capacity
);
1361 env
->ReleasePrimitiveArrayCritical(jarray
, ja
, 0);
1363 env
->DeleteLocalRef(jarray
);
1370 static jbyteArray
array(JNIEnv
* env
, const jobject
& jbyte_buffer
,
1371 jclass jbytebuffer_clazz
= nullptr) {
1372 const jmethodID mid
= getArrayMethodId(env
, jbytebuffer_clazz
);
1373 if (mid
== nullptr) {
1374 // exception occurred accessing class, or NoSuchMethodException or OutOfMemoryError
1377 const jobject jarray
= env
->CallObjectMethod(jbyte_buffer
, mid
);
1378 if (env
->ExceptionCheck()) {
1379 // exception occurred
1382 return static_cast<jbyteArray
>(jarray
);
1386 // The portal class for java.lang.Integer
1387 class IntegerJni
: public JavaClass
{
1390 * Get the Java Class java.lang.Integer
1392 * @param env A pointer to the Java environment
1394 * @return The Java Class or nullptr if one of the
1395 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
1396 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
1398 static jclass
getJClass(JNIEnv
* env
) {
1399 return JavaClass::getJClass(env
, "java/lang/Integer");
1402 static jobject
valueOf(JNIEnv
* env
, jint jprimitive_int
) {
1403 jclass jclazz
= getJClass(env
);
1404 if (jclazz
== nullptr) {
1405 // exception occurred accessing class
1410 env
->GetStaticMethodID(jclazz
, "valueOf", "(I)Ljava/lang/Integer;");
1411 if (mid
== nullptr) {
1412 // exception thrown: NoSuchMethodException or OutOfMemoryError
1416 const jobject jinteger_obj
=
1417 env
->CallStaticObjectMethod(jclazz
, mid
, jprimitive_int
);
1418 if (env
->ExceptionCheck()) {
1419 // exception occurred
1423 return jinteger_obj
;
1427 // The portal class for java.lang.Long
1428 class LongJni
: public JavaClass
{
1431 * Get the Java Class java.lang.Long
1433 * @param env A pointer to the Java environment
1435 * @return The Java Class or nullptr if one of the
1436 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
1437 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
1439 static jclass
getJClass(JNIEnv
* env
) {
1440 return JavaClass::getJClass(env
, "java/lang/Long");
1443 static jobject
valueOf(JNIEnv
* env
, jlong jprimitive_long
) {
1444 jclass jclazz
= getJClass(env
);
1445 if (jclazz
== nullptr) {
1446 // exception occurred accessing class
1451 env
->GetStaticMethodID(jclazz
, "valueOf", "(J)Ljava/lang/Long;");
1452 if (mid
== nullptr) {
1453 // exception thrown: NoSuchMethodException or OutOfMemoryError
1457 const jobject jlong_obj
=
1458 env
->CallStaticObjectMethod(jclazz
, mid
, jprimitive_long
);
1459 if (env
->ExceptionCheck()) {
1460 // exception occurred
1468 // The portal class for java.lang.StringBuilder
1469 class StringBuilderJni
: public JavaClass
{
1472 * Get the Java Class java.lang.StringBuilder
1474 * @param env A pointer to the Java environment
1476 * @return The Java Class or nullptr if one of the
1477 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
1478 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
1480 static jclass
getJClass(JNIEnv
* env
) {
1481 return JavaClass::getJClass(env
, "java/lang/StringBuilder");
1485 * Get the Java Method: StringBuilder#append
1487 * @param env A pointer to the Java environment
1489 * @return The Java Method ID or nullptr if the class or method id could not
1492 static jmethodID
getListAddMethodId(JNIEnv
* env
) {
1493 jclass jclazz
= getJClass(env
);
1494 if(jclazz
== nullptr) {
1495 // exception occurred accessing class
1499 static jmethodID mid
=
1500 env
->GetMethodID(jclazz
, "append",
1501 "(Ljava/lang/String;)Ljava/lang/StringBuilder;");
1502 assert(mid
!= nullptr);
1507 * Appends a C-style string to a StringBuilder
1509 * @param env A pointer to the Java environment
1510 * @param jstring_builder Reference to a java.lang.StringBuilder
1511 * @param c_str A C-style string to append to the StringBuilder
1513 * @return A reference to the updated StringBuilder, or a nullptr if
1514 * an exception occurs
1516 static jobject
append(JNIEnv
* env
, jobject jstring_builder
,
1517 const char* c_str
) {
1518 jmethodID mid
= getListAddMethodId(env
);
1519 if(mid
== nullptr) {
1520 // exception occurred accessing class or method
1524 jstring new_value_str
= env
->NewStringUTF(c_str
);
1525 if(new_value_str
== nullptr) {
1526 // exception thrown: OutOfMemoryError
1530 jobject jresult_string_builder
=
1531 env
->CallObjectMethod(jstring_builder
, mid
, new_value_str
);
1532 if(env
->ExceptionCheck()) {
1533 // exception occurred
1534 env
->DeleteLocalRef(new_value_str
);
1538 return jresult_string_builder
;
1542 // various utility functions for working with RocksDB and JNI
1546 * Detect if jlong overflows size_t
1548 * @param jvalue the jlong value
1552 inline static Status
check_if_jlong_fits_size_t(const jlong
& jvalue
) {
1553 Status s
= Status::OK();
1554 if (static_cast<uint64_t>(jvalue
) > std::numeric_limits
<size_t>::max()) {
1555 s
= Status::InvalidArgument(Slice("jlong overflows 32 bit value."));
1561 * Obtains a reference to the JNIEnv from
1564 * If the current thread is not attached to the JavaVM
1565 * then it will be attached so as to retrieve the JNIEnv
1567 * If a thread is attached, it must later be manually
1568 * released by calling JavaVM::DetachCurrentThread.
1569 * This can be handled by always matching calls to this
1570 * function with calls to {@link JniUtil::releaseJniEnv(JavaVM*, jboolean)}
1572 * @param jvm (IN) A pointer to the JavaVM instance
1573 * @param attached (OUT) A pointer to a boolean which
1574 * will be set to JNI_TRUE if we had to attach the thread
1576 * @return A pointer to the JNIEnv or nullptr if a fatal error
1577 * occurs and the JNIEnv cannot be retrieved
1579 static JNIEnv
* getJniEnv(JavaVM
* jvm
, jboolean
* attached
) {
1580 assert(jvm
!= nullptr);
1583 const jint env_rs
= jvm
->GetEnv(reinterpret_cast<void**>(&env
),
1586 if(env_rs
== JNI_OK
) {
1587 // current thread is already attached, return the JNIEnv
1588 *attached
= JNI_FALSE
;
1590 } else if(env_rs
== JNI_EDETACHED
) {
1591 // current thread is not attached, attempt to attach
1592 const jint rs_attach
= jvm
->AttachCurrentThread(reinterpret_cast<void**>(&env
), NULL
);
1593 if(rs_attach
== JNI_OK
) {
1594 *attached
= JNI_TRUE
;
1597 // error, could not attach the thread
1598 std::cerr
<< "JniUtil::getJniEnv - Fatal: could not attach current thread to JVM!" << std::endl
;
1601 } else if(env_rs
== JNI_EVERSION
) {
1602 // error, JDK does not support JNI_VERSION_1_6+
1603 std::cerr
<< "JniUtil::getJniEnv - Fatal: JDK does not support JNI_VERSION_1_6" << std::endl
;
1606 std::cerr
<< "JniUtil::getJniEnv - Fatal: Unknown error: env_rs=" << env_rs
<< std::endl
;
1612 * Counterpart to {@link JniUtil::getJniEnv(JavaVM*, jboolean*)}
1614 * Detachess the current thread from the JVM if it was previously
1617 * @param jvm (IN) A pointer to the JavaVM instance
1618 * @param attached (IN) JNI_TRUE if we previously had to attach the thread
1619 * to the JavaVM to get the JNIEnv
1621 static void releaseJniEnv(JavaVM
* jvm
, jboolean
& attached
) {
1622 assert(jvm
!= nullptr);
1623 if(attached
== JNI_TRUE
) {
1624 const jint rs_detach
= jvm
->DetachCurrentThread();
1625 assert(rs_detach
== JNI_OK
);
1626 if(rs_detach
!= JNI_OK
) {
1627 std::cerr
<< "JniUtil::getJniEnv - Warn: Unable to detach current thread from JVM!" << std::endl
;
1633 * Copies a Java String[] to a C++ std::vector<std::string>
1635 * @param env (IN) A pointer to the java environment
1636 * @param jss (IN) The Java String array to copy
1637 * @param has_exception (OUT) will be set to JNI_TRUE
1638 * if an OutOfMemoryError or ArrayIndexOutOfBoundsException
1641 * @return A std::vector<std:string> containing copies of the Java strings
1643 static std::vector
<std::string
> copyStrings(JNIEnv
* env
,
1644 jobjectArray jss
, jboolean
* has_exception
) {
1645 return ROCKSDB_NAMESPACE::JniUtil::copyStrings(
1646 env
, jss
, env
->GetArrayLength(jss
), has_exception
);
1650 * Copies a Java String[] to a C++ std::vector<std::string>
1652 * @param env (IN) A pointer to the java environment
1653 * @param jss (IN) The Java String array to copy
1654 * @param jss_len (IN) The length of the Java String array to copy
1655 * @param has_exception (OUT) will be set to JNI_TRUE
1656 * if an OutOfMemoryError or ArrayIndexOutOfBoundsException
1659 * @return A std::vector<std:string> containing copies of the Java strings
1661 static std::vector
<std::string
> copyStrings(JNIEnv
* env
,
1662 jobjectArray jss
, const jsize jss_len
, jboolean
* has_exception
) {
1663 std::vector
<std::string
> strs
;
1664 strs
.reserve(jss_len
);
1665 for (jsize i
= 0; i
< jss_len
; i
++) {
1666 jobject js
= env
->GetObjectArrayElement(jss
, i
);
1667 if(env
->ExceptionCheck()) {
1668 // exception thrown: ArrayIndexOutOfBoundsException
1669 *has_exception
= JNI_TRUE
;
1673 jstring jstr
= static_cast<jstring
>(js
);
1674 const char* str
= env
->GetStringUTFChars(jstr
, nullptr);
1675 if(str
== nullptr) {
1676 // exception thrown: OutOfMemoryError
1677 env
->DeleteLocalRef(js
);
1678 *has_exception
= JNI_TRUE
;
1682 strs
.push_back(std::string(str
));
1684 env
->ReleaseStringUTFChars(jstr
, str
);
1685 env
->DeleteLocalRef(js
);
1688 *has_exception
= JNI_FALSE
;
1693 * Copies a jstring to a C-style null-terminated byte string
1694 * and releases the original jstring
1696 * The jstring is copied as UTF-8
1698 * If an exception occurs, then JNIEnv::ExceptionCheck()
1699 * will have been called
1701 * @param env (IN) A pointer to the java environment
1702 * @param js (IN) The java string to copy
1703 * @param has_exception (OUT) will be set to JNI_TRUE
1704 * if an OutOfMemoryError exception occurs
1706 * @return A pointer to the copied string, or a
1707 * nullptr if has_exception == JNI_TRUE
1709 static std::unique_ptr
<char[]> copyString(JNIEnv
* env
, jstring js
,
1710 jboolean
* has_exception
) {
1711 const char *utf
= env
->GetStringUTFChars(js
, nullptr);
1712 if(utf
== nullptr) {
1713 // exception thrown: OutOfMemoryError
1714 env
->ExceptionCheck();
1715 *has_exception
= JNI_TRUE
;
1717 } else if(env
->ExceptionCheck()) {
1719 env
->ReleaseStringUTFChars(js
, utf
);
1720 *has_exception
= JNI_TRUE
;
1724 const jsize utf_len
= env
->GetStringUTFLength(js
);
1725 std::unique_ptr
<char[]> str(new char[utf_len
+ 1]); // Note: + 1 is needed for the c_str null terminator
1726 std::strcpy(str
.get(), utf
);
1727 env
->ReleaseStringUTFChars(js
, utf
);
1728 *has_exception
= JNI_FALSE
;
1733 * Copies a jstring to a std::string
1734 * and releases the original jstring
1736 * If an exception occurs, then JNIEnv::ExceptionCheck()
1737 * will have been called
1739 * @param env (IN) A pointer to the java environment
1740 * @param js (IN) The java string to copy
1741 * @param has_exception (OUT) will be set to JNI_TRUE
1742 * if an OutOfMemoryError exception occurs
1744 * @return A std:string copy of the jstring, or an
1745 * empty std::string if has_exception == JNI_TRUE
1747 static std::string
copyStdString(JNIEnv
* env
, jstring js
,
1748 jboolean
* has_exception
) {
1749 const char *utf
= env
->GetStringUTFChars(js
, nullptr);
1750 if(utf
== nullptr) {
1751 // exception thrown: OutOfMemoryError
1752 env
->ExceptionCheck();
1753 *has_exception
= JNI_TRUE
;
1754 return std::string();
1755 } else if(env
->ExceptionCheck()) {
1757 env
->ReleaseStringUTFChars(js
, utf
);
1758 *has_exception
= JNI_TRUE
;
1759 return std::string();
1762 std::string
name(utf
);
1763 env
->ReleaseStringUTFChars(js
, utf
);
1764 *has_exception
= JNI_FALSE
;
1769 * Copies bytes from a std::string to a jByteArray
1771 * @param env A pointer to the java environment
1772 * @param bytes The bytes to copy
1774 * @return the Java byte[], or nullptr if an exception occurs
1776 * @throws RocksDBException thrown
1777 * if memory size to copy exceeds general java specific array size limitation.
1779 static jbyteArray
copyBytes(JNIEnv
* env
, std::string bytes
) {
1780 return createJavaByteArrayWithSizeCheck(env
, bytes
.c_str(), bytes
.size());
1784 * Given a Java byte[][] which is an array of java.lang.Strings
1785 * where each String is a byte[], the passed function `string_fn`
1786 * will be called on each String, the result is the collected by
1787 * calling the passed function `collector_fn`
1789 * @param env (IN) A pointer to the java environment
1790 * @param jbyte_strings (IN) A Java array of Strings expressed as bytes
1791 * @param string_fn (IN) A transform function to call for each String
1792 * @param collector_fn (IN) A collector which is called for the result
1793 * of each `string_fn`
1794 * @param has_exception (OUT) will be set to JNI_TRUE
1795 * if an ArrayIndexOutOfBoundsException or OutOfMemoryError
1798 template <typename T
> static void byteStrings(JNIEnv
* env
,
1799 jobjectArray jbyte_strings
,
1800 std::function
<T(const char*, const size_t)> string_fn
,
1801 std::function
<void(size_t, T
)> collector_fn
,
1802 jboolean
*has_exception
) {
1803 const jsize jlen
= env
->GetArrayLength(jbyte_strings
);
1805 for(jsize i
= 0; i
< jlen
; i
++) {
1806 jobject jbyte_string_obj
= env
->GetObjectArrayElement(jbyte_strings
, i
);
1807 if(env
->ExceptionCheck()) {
1808 // exception thrown: ArrayIndexOutOfBoundsException
1809 *has_exception
= JNI_TRUE
; // signal error
1813 jbyteArray jbyte_string_ary
=
1814 reinterpret_cast<jbyteArray
>(jbyte_string_obj
);
1815 T result
= byteString(env
, jbyte_string_ary
, string_fn
, has_exception
);
1817 env
->DeleteLocalRef(jbyte_string_obj
);
1819 if(*has_exception
== JNI_TRUE
) {
1820 // exception thrown: OutOfMemoryError
1824 collector_fn(i
, result
);
1827 *has_exception
= JNI_FALSE
;
1831 * Given a Java String which is expressed as a Java Byte Array byte[],
1832 * the passed function `string_fn` will be called on the String
1833 * and the result returned
1835 * @param env (IN) A pointer to the java environment
1836 * @param jbyte_string_ary (IN) A Java String expressed in bytes
1837 * @param string_fn (IN) A transform function to call on the String
1838 * @param has_exception (OUT) will be set to JNI_TRUE
1839 * if an OutOfMemoryError exception occurs
1841 template <typename T
> static T
byteString(JNIEnv
* env
,
1842 jbyteArray jbyte_string_ary
,
1843 std::function
<T(const char*, const size_t)> string_fn
,
1844 jboolean
* has_exception
) {
1845 const jsize jbyte_string_len
= env
->GetArrayLength(jbyte_string_ary
);
1846 return byteString
<T
>(env
, jbyte_string_ary
, jbyte_string_len
, string_fn
,
1851 * Given a Java String which is expressed as a Java Byte Array byte[],
1852 * the passed function `string_fn` will be called on the String
1853 * and the result returned
1855 * @param env (IN) A pointer to the java environment
1856 * @param jbyte_string_ary (IN) A Java String expressed in bytes
1857 * @param jbyte_string_len (IN) The length of the Java String
1858 * expressed in bytes
1859 * @param string_fn (IN) A transform function to call on the String
1860 * @param has_exception (OUT) will be set to JNI_TRUE
1861 * if an OutOfMemoryError exception occurs
1863 template <typename T
> static T
byteString(JNIEnv
* env
,
1864 jbyteArray jbyte_string_ary
, const jsize jbyte_string_len
,
1865 std::function
<T(const char*, const size_t)> string_fn
,
1866 jboolean
* has_exception
) {
1867 jbyte
* jbyte_string
=
1868 env
->GetByteArrayElements(jbyte_string_ary
, nullptr);
1869 if(jbyte_string
== nullptr) {
1870 // exception thrown: OutOfMemoryError
1871 *has_exception
= JNI_TRUE
;
1872 return nullptr; // signal error
1876 string_fn(reinterpret_cast<char *>(jbyte_string
), jbyte_string_len
);
1878 env
->ReleaseByteArrayElements(jbyte_string_ary
, jbyte_string
, JNI_ABORT
);
1880 *has_exception
= JNI_FALSE
;
1885 * Converts a std::vector<string> to a Java byte[][] where each Java String
1886 * is expressed as a Java Byte Array byte[].
1888 * @param env A pointer to the java environment
1889 * @param strings A vector of Strings
1891 * @return A Java array of Strings expressed as bytes,
1892 * or nullptr if an exception is thrown
1894 static jobjectArray
stringsBytes(JNIEnv
* env
, std::vector
<std::string
> strings
) {
1895 jclass jcls_ba
= ByteJni::getArrayJClass(env
);
1896 if(jcls_ba
== nullptr) {
1897 // exception occurred
1901 const jsize len
= static_cast<jsize
>(strings
.size());
1903 jobjectArray jbyte_strings
= env
->NewObjectArray(len
, jcls_ba
, nullptr);
1904 if(jbyte_strings
== nullptr) {
1905 // exception thrown: OutOfMemoryError
1909 for (jsize i
= 0; i
< len
; i
++) {
1910 std::string
*str
= &strings
[i
];
1911 const jsize str_len
= static_cast<jsize
>(str
->size());
1913 jbyteArray jbyte_string_ary
= env
->NewByteArray(str_len
);
1914 if(jbyte_string_ary
== nullptr) {
1915 // exception thrown: OutOfMemoryError
1916 env
->DeleteLocalRef(jbyte_strings
);
1920 env
->SetByteArrayRegion(
1921 jbyte_string_ary
, 0, str_len
,
1922 const_cast<jbyte
*>(reinterpret_cast<const jbyte
*>(str
->c_str())));
1923 if(env
->ExceptionCheck()) {
1924 // exception thrown: ArrayIndexOutOfBoundsException
1925 env
->DeleteLocalRef(jbyte_string_ary
);
1926 env
->DeleteLocalRef(jbyte_strings
);
1930 env
->SetObjectArrayElement(jbyte_strings
, i
, jbyte_string_ary
);
1931 if(env
->ExceptionCheck()) {
1932 // exception thrown: ArrayIndexOutOfBoundsException
1933 // or ArrayStoreException
1934 env
->DeleteLocalRef(jbyte_string_ary
);
1935 env
->DeleteLocalRef(jbyte_strings
);
1939 env
->DeleteLocalRef(jbyte_string_ary
);
1942 return jbyte_strings
;
1946 * Converts a std::vector<std::string> to a Java String[].
1948 * @param env A pointer to the java environment
1949 * @param strings A vector of Strings
1951 * @return A Java array of Strings,
1952 * or nullptr if an exception is thrown
1954 static jobjectArray
toJavaStrings(JNIEnv
* env
,
1955 const std::vector
<std::string
>* strings
) {
1956 jclass jcls_str
= env
->FindClass("java/lang/String");
1957 if(jcls_str
== nullptr) {
1958 // exception occurred
1962 const jsize len
= static_cast<jsize
>(strings
->size());
1964 jobjectArray jstrings
= env
->NewObjectArray(len
, jcls_str
, nullptr);
1965 if(jstrings
== nullptr) {
1966 // exception thrown: OutOfMemoryError
1970 for (jsize i
= 0; i
< len
; i
++) {
1971 const std::string
*str
= &((*strings
)[i
]);
1972 jstring js
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(env
, str
);
1973 if (js
== nullptr) {
1974 env
->DeleteLocalRef(jstrings
);
1978 env
->SetObjectArrayElement(jstrings
, i
, js
);
1979 if(env
->ExceptionCheck()) {
1980 // exception thrown: ArrayIndexOutOfBoundsException
1981 // or ArrayStoreException
1982 env
->DeleteLocalRef(js
);
1983 env
->DeleteLocalRef(jstrings
);
1992 * Creates a Java UTF String from a C++ std::string
1994 * @param env A pointer to the java environment
1995 * @param string the C++ std::string
1996 * @param treat_empty_as_null true if empty strings should be treated as null
1998 * @return the Java UTF string, or nullptr if the provided string
1999 * is null (or empty and treat_empty_as_null is set), or if an
2000 * exception occurs allocating the Java String.
2002 static jstring
toJavaString(JNIEnv
* env
, const std::string
* string
,
2003 const bool treat_empty_as_null
= false) {
2004 if (string
== nullptr) {
2008 if (treat_empty_as_null
&& string
->empty()) {
2012 return env
->NewStringUTF(string
->c_str());
2016 * Copies bytes to a new jByteArray with the check of java array size limitation.
2018 * @param bytes pointer to memory to copy to a new jByteArray
2019 * @param size number of bytes to copy
2021 * @return the Java byte[], or nullptr if an exception occurs
2023 * @throws RocksDBException thrown
2024 * if memory size to copy exceeds general java array size limitation to avoid overflow.
2026 static jbyteArray
createJavaByteArrayWithSizeCheck(JNIEnv
* env
, const char* bytes
, const size_t size
) {
2027 // Limitation for java array size is vm specific
2028 // In general it cannot exceed Integer.MAX_VALUE (2^31 - 1)
2029 // Current HotSpot VM limitation for array size is Integer.MAX_VALUE - 5 (2^31 - 1 - 5)
2030 // It means that the next call to env->NewByteArray can still end with
2031 // OutOfMemoryError("Requested array size exceeds VM limit") coming from VM
2032 static const size_t MAX_JARRAY_SIZE
= (static_cast<size_t>(1)) << 31;
2033 if(size
> MAX_JARRAY_SIZE
) {
2034 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(
2035 env
, "Requested array size exceeds VM limit");
2039 const jsize jlen
= static_cast<jsize
>(size
);
2040 jbyteArray jbytes
= env
->NewByteArray(jlen
);
2041 if(jbytes
== nullptr) {
2042 // exception thrown: OutOfMemoryError
2046 env
->SetByteArrayRegion(jbytes
, 0, jlen
,
2047 const_cast<jbyte
*>(reinterpret_cast<const jbyte
*>(bytes
)));
2048 if(env
->ExceptionCheck()) {
2049 // exception thrown: ArrayIndexOutOfBoundsException
2050 env
->DeleteLocalRef(jbytes
);
2058 * Copies bytes from a ROCKSDB_NAMESPACE::Slice to a jByteArray
2060 * @param env A pointer to the java environment
2061 * @param bytes The bytes to copy
2063 * @return the Java byte[] or nullptr if an exception occurs
2065 * @throws RocksDBException thrown
2066 * if memory size to copy exceeds general java specific array size
2069 static jbyteArray
copyBytes(JNIEnv
* env
, const Slice
& bytes
) {
2070 return createJavaByteArrayWithSizeCheck(env
, bytes
.data(), bytes
.size());
2074 * Helper for operations on a key and value
2075 * for example WriteBatch->Put
2077 * TODO(AR) could be used for RocksDB->Put etc.
2079 static std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> kv_op(
2080 std::function
<ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Slice
,
2081 ROCKSDB_NAMESPACE::Slice
)>
2083 JNIEnv
* env
, jobject
/*jobj*/, jbyteArray jkey
, jint jkey_len
,
2084 jbyteArray jvalue
, jint jvalue_len
) {
2085 jbyte
* key
= env
->GetByteArrayElements(jkey
, nullptr);
2086 if(env
->ExceptionCheck()) {
2087 // exception thrown: OutOfMemoryError
2091 jbyte
* value
= env
->GetByteArrayElements(jvalue
, nullptr);
2092 if(env
->ExceptionCheck()) {
2093 // exception thrown: OutOfMemoryError
2094 if(key
!= nullptr) {
2095 env
->ReleaseByteArrayElements(jkey
, key
, JNI_ABORT
);
2100 ROCKSDB_NAMESPACE::Slice
key_slice(reinterpret_cast<char*>(key
),
2102 ROCKSDB_NAMESPACE::Slice
value_slice(reinterpret_cast<char*>(value
),
2105 auto status
= op(key_slice
, value_slice
);
2107 if(value
!= nullptr) {
2108 env
->ReleaseByteArrayElements(jvalue
, value
, JNI_ABORT
);
2110 if(key
!= nullptr) {
2111 env
->ReleaseByteArrayElements(jkey
, key
, JNI_ABORT
);
2114 return std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
2115 new ROCKSDB_NAMESPACE::Status(status
));
2119 * Helper for operations on a key
2120 * for example WriteBatch->Delete
2122 * TODO(AR) could be used for RocksDB->Delete etc.
2124 static std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> k_op(
2125 std::function
<ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Slice
)> op
,
2126 JNIEnv
* env
, jobject
/*jobj*/, jbyteArray jkey
, jint jkey_len
) {
2127 jbyte
* key
= env
->GetByteArrayElements(jkey
, nullptr);
2128 if(env
->ExceptionCheck()) {
2129 // exception thrown: OutOfMemoryError
2133 ROCKSDB_NAMESPACE::Slice
key_slice(reinterpret_cast<char*>(key
),
2136 auto status
= op(key_slice
);
2138 if(key
!= nullptr) {
2139 env
->ReleaseByteArrayElements(jkey
, key
, JNI_ABORT
);
2142 return std::unique_ptr
<ROCKSDB_NAMESPACE::Status
>(
2143 new ROCKSDB_NAMESPACE::Status(status
));
2147 * Helper for operations on a value
2148 * for example WriteBatchWithIndex->GetFromBatch
2150 static jbyteArray
v_op(std::function
<ROCKSDB_NAMESPACE::Status(
2151 ROCKSDB_NAMESPACE::Slice
, std::string
*)>
2153 JNIEnv
* env
, jbyteArray jkey
, jint jkey_len
) {
2154 jbyte
* key
= env
->GetByteArrayElements(jkey
, nullptr);
2155 if(env
->ExceptionCheck()) {
2156 // exception thrown: OutOfMemoryError
2160 ROCKSDB_NAMESPACE::Slice
key_slice(reinterpret_cast<char*>(key
),
2164 ROCKSDB_NAMESPACE::Status s
= op(key_slice
, &value
);
2166 if(key
!= nullptr) {
2167 env
->ReleaseByteArrayElements(jkey
, key
, JNI_ABORT
);
2170 if (s
.IsNotFound()) {
2175 jbyteArray jret_value
=
2176 env
->NewByteArray(static_cast<jsize
>(value
.size()));
2177 if(jret_value
== nullptr) {
2178 // exception thrown: OutOfMemoryError
2182 env
->SetByteArrayRegion(jret_value
, 0, static_cast<jsize
>(value
.size()),
2183 const_cast<jbyte
*>(reinterpret_cast<const jbyte
*>(value
.c_str())));
2184 if(env
->ExceptionCheck()) {
2185 // exception thrown: ArrayIndexOutOfBoundsException
2186 if(jret_value
!= nullptr) {
2187 env
->DeleteLocalRef(jret_value
);
2195 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, s
);
2200 * Creates a vector<T*> of C++ pointers from
2201 * a Java array of C++ pointer addresses.
2203 * @param env (IN) A pointer to the java environment
2204 * @param pointers (IN) A Java array of C++ pointer addresses
2205 * @param has_exception (OUT) will be set to JNI_TRUE
2206 * if an ArrayIndexOutOfBoundsException or OutOfMemoryError
2209 * @return A vector of C++ pointers.
2211 template<typename T
> static std::vector
<T
*> fromJPointers(
2212 JNIEnv
* env
, jlongArray jptrs
, jboolean
*has_exception
) {
2213 const jsize jptrs_len
= env
->GetArrayLength(jptrs
);
2214 std::vector
<T
*> ptrs
;
2215 jlong
* jptr
= env
->GetLongArrayElements(jptrs
, nullptr);
2216 if (jptr
== nullptr) {
2217 // exception thrown: OutOfMemoryError
2218 *has_exception
= JNI_TRUE
;
2221 ptrs
.reserve(jptrs_len
);
2222 for (jsize i
= 0; i
< jptrs_len
; i
++) {
2223 ptrs
.push_back(reinterpret_cast<T
*>(jptr
[i
]));
2225 env
->ReleaseLongArrayElements(jptrs
, jptr
, JNI_ABORT
);
2230 * Creates a Java array of C++ pointer addresses
2231 * from a vector of C++ pointers.
2233 * @param env (IN) A pointer to the java environment
2234 * @param pointers (IN) A vector of C++ pointers
2235 * @param has_exception (OUT) will be set to JNI_TRUE
2236 * if an ArrayIndexOutOfBoundsException or OutOfMemoryError
2239 * @return Java array of C++ pointer addresses.
2241 template<typename T
> static jlongArray
toJPointers(JNIEnv
* env
,
2242 const std::vector
<T
*> &pointers
,
2243 jboolean
*has_exception
) {
2244 const jsize len
= static_cast<jsize
>(pointers
.size());
2245 std::unique_ptr
<jlong
[]> results(new jlong
[len
]);
2246 std::transform(pointers
.begin(), pointers
.end(), results
.get(), [](T
* pointer
) -> jlong
{
2247 return reinterpret_cast<jlong
>(pointer
);
2250 jlongArray jpointers
= env
->NewLongArray(len
);
2251 if (jpointers
== nullptr) {
2252 // exception thrown: OutOfMemoryError
2253 *has_exception
= JNI_TRUE
;
2257 env
->SetLongArrayRegion(jpointers
, 0, len
, results
.get());
2258 if (env
->ExceptionCheck()) {
2259 // exception thrown: ArrayIndexOutOfBoundsException
2260 *has_exception
= JNI_TRUE
;
2261 env
->DeleteLocalRef(jpointers
);
2265 *has_exception
= JNI_FALSE
;
2271 * Helper for operations on a key and value
2272 * for example WriteBatch->Put
2274 * TODO(AR) could be extended to cover returning ROCKSDB_NAMESPACE::Status
2275 * from `op` and used for RocksDB->Put etc.
2277 static void kv_op_direct(std::function
<void(ROCKSDB_NAMESPACE::Slice
&,
2278 ROCKSDB_NAMESPACE::Slice
&)>
2280 JNIEnv
* env
, jobject jkey
, jint jkey_off
,
2281 jint jkey_len
, jobject jval
, jint jval_off
,
2283 char* key
= reinterpret_cast<char*>(env
->GetDirectBufferAddress(jkey
));
2284 if (key
== nullptr ||
2285 env
->GetDirectBufferCapacity(jkey
) < (jkey_off
+ jkey_len
)) {
2286 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(
2287 env
, "Invalid key argument");
2291 char* value
= reinterpret_cast<char*>(env
->GetDirectBufferAddress(jval
));
2292 if (value
== nullptr ||
2293 env
->GetDirectBufferCapacity(jval
) < (jval_off
+ jval_len
)) {
2294 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(
2295 env
, "Invalid value argument");
2302 ROCKSDB_NAMESPACE::Slice
key_slice(key
, jkey_len
);
2303 ROCKSDB_NAMESPACE::Slice
value_slice(value
, jval_len
);
2305 op(key_slice
, value_slice
);
2309 * Helper for operations on a key and value
2310 * for example WriteBatch->Delete
2312 * TODO(AR) could be extended to cover returning ROCKSDB_NAMESPACE::Status
2313 * from `op` and used for RocksDB->Delete etc.
2315 static void k_op_direct(std::function
<void(ROCKSDB_NAMESPACE::Slice
&)> op
,
2316 JNIEnv
* env
, jobject jkey
, jint jkey_off
,
2318 char* key
= reinterpret_cast<char*>(env
->GetDirectBufferAddress(jkey
));
2319 if (key
== nullptr ||
2320 env
->GetDirectBufferCapacity(jkey
) < (jkey_off
+ jkey_len
)) {
2321 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(
2322 env
, "Invalid key argument");
2328 ROCKSDB_NAMESPACE::Slice
key_slice(key
, jkey_len
);
2330 return op(key_slice
);
2334 static jint
copyToDirect(JNIEnv
* env
, T
& source
, jobject jtarget
,
2335 jint jtarget_off
, jint jtarget_len
) {
2337 reinterpret_cast<char*>(env
->GetDirectBufferAddress(jtarget
));
2338 if (target
== nullptr ||
2339 env
->GetDirectBufferCapacity(jtarget
) < (jtarget_off
+ jtarget_len
)) {
2340 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(
2341 env
, "Invalid target argument");
2345 target
+= jtarget_off
;
2347 const jint cvalue_len
= static_cast<jint
>(source
.size());
2348 const jint length
= std::min(jtarget_len
, cvalue_len
);
2350 memcpy(target
, source
.data(), length
);
2356 class MapJni
: public JavaClass
{
2359 * Get the Java Class java.util.Map
2361 * @param env A pointer to the Java environment
2363 * @return The Java Class or nullptr if one of the
2364 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
2365 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
2367 static jclass
getJClass(JNIEnv
* env
) {
2368 return JavaClass::getJClass(env
, "java/util/Map");
2372 * Get the Java Method: Map#put
2374 * @param env A pointer to the Java environment
2376 * @return The Java Method ID or nullptr if the class or method id could not
2379 static jmethodID
getMapPutMethodId(JNIEnv
* env
) {
2380 jclass jlist_clazz
= getJClass(env
);
2381 if(jlist_clazz
== nullptr) {
2382 // exception occurred accessing class
2386 static jmethodID mid
=
2387 env
->GetMethodID(jlist_clazz
, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
2388 assert(mid
!= nullptr);
2393 class HashMapJni
: public JavaClass
{
2396 * Get the Java Class java.util.HashMap
2398 * @param env A pointer to the Java environment
2400 * @return The Java Class or nullptr if one of the
2401 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
2402 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
2404 static jclass
getJClass(JNIEnv
* env
) {
2405 return JavaClass::getJClass(env
, "java/util/HashMap");
2409 * Create a new Java java.util.HashMap object.
2411 * @param env A pointer to the Java environment
2413 * @return A reference to a Java java.util.HashMap object, or
2414 * nullptr if an an exception occurs
2416 static jobject
construct(JNIEnv
* env
, const uint32_t initial_capacity
= 16) {
2417 jclass jclazz
= getJClass(env
);
2418 if (jclazz
== nullptr) {
2419 // exception occurred accessing class
2423 jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "(I)V");
2424 if (mid
== nullptr) {
2425 // exception thrown: NoSuchMethodException or OutOfMemoryError
2429 jobject jhash_map
= env
->NewObject(jclazz
, mid
, static_cast<jint
>(initial_capacity
));
2430 if (env
->ExceptionCheck()) {
2438 * A function which maps a std::pair<K,V> to a std::pair<JK, JV>
2440 * @return Either a pointer to a std::pair<jobject, jobject>, or nullptr
2441 * if an error occurs during the mapping
2443 template <typename K
, typename V
, typename JK
, typename JV
>
2444 using FnMapKV
= std::function
<std::unique_ptr
<std::pair
<JK
, JV
>> (const std::pair
<K
, V
>&)>;
2446 // template <class I, typename K, typename V, typename K1, typename V1, typename std::enable_if<std::is_same<typename std::iterator_traits<I>::value_type, std::pair<const K,V>>::value, int32_t>::type = 0>
2447 // static void putAll(JNIEnv* env, const jobject jhash_map, I iterator, const FnMapKV<const K,V,K1,V1> &fn_map_kv) {
2449 * Returns true if it succeeds, false if an error occurs
2451 template<class iterator_type
, typename K
, typename V
>
2452 static bool putAll(JNIEnv
* env
, const jobject jhash_map
, iterator_type iterator
, iterator_type end
, const FnMapKV
<K
, V
, jobject
, jobject
> &fn_map_kv
) {
2453 const jmethodID jmid_put
=
2454 ROCKSDB_NAMESPACE::MapJni::getMapPutMethodId(env
);
2455 if (jmid_put
== nullptr) {
2459 for (auto it
= iterator
; it
!= end
; ++it
) {
2460 const std::unique_ptr
<std::pair
<jobject
, jobject
>> result
= fn_map_kv(*it
);
2461 if (result
== nullptr) {
2462 // an error occurred during fn_map_kv
2465 env
->CallObjectMethod(jhash_map
, jmid_put
, result
->first
, result
->second
);
2466 if (env
->ExceptionCheck()) {
2467 // exception occurred
2468 env
->DeleteLocalRef(result
->second
);
2469 env
->DeleteLocalRef(result
->first
);
2473 // release local references
2474 env
->DeleteLocalRef(result
->second
);
2475 env
->DeleteLocalRef(result
->first
);
2482 * Creates a java.util.Map<String, String> from a std::map<std::string, std::string>
2484 * @param env A pointer to the Java environment
2485 * @param map the Cpp map
2487 * @return a reference to the Java java.util.Map object, or nullptr if an exception occcurred
2489 static jobject
fromCppMap(JNIEnv
* env
, const std::map
<std::string
, std::string
>* map
) {
2490 if (map
== nullptr) {
2494 jobject jhash_map
= construct(env
, static_cast<uint32_t>(map
->size()));
2495 if (jhash_map
== nullptr) {
2496 // exception occurred
2500 const ROCKSDB_NAMESPACE::HashMapJni::FnMapKV
<
2501 const std::string
, const std::string
, jobject
, jobject
>
2503 [env
](const std::pair
<const std::string
, const std::string
>& kv
) {
2504 jstring jkey
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
2505 env
, &(kv
.first
), false);
2506 if (env
->ExceptionCheck()) {
2507 // an error occurred
2508 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(nullptr);
2511 jstring jvalue
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
2512 env
, &(kv
.second
), true);
2513 if (env
->ExceptionCheck()) {
2514 // an error occurred
2515 env
->DeleteLocalRef(jkey
);
2516 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(nullptr);
2519 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(
2520 new std::pair
<jobject
, jobject
>(
2521 static_cast<jobject
>(jkey
),
2522 static_cast<jobject
>(jvalue
)));
2525 if (!putAll(env
, jhash_map
, map
->begin(), map
->end(), fn_map_kv
)) {
2526 // exception occurred
2534 * Creates a java.util.Map<String, Long> from a std::map<std::string, uint32_t>
2536 * @param env A pointer to the Java environment
2537 * @param map the Cpp map
2539 * @return a reference to the Java java.util.Map object, or nullptr if an exception occcurred
2541 static jobject
fromCppMap(JNIEnv
* env
, const std::map
<std::string
, uint32_t>* map
) {
2542 if (map
== nullptr) {
2546 if (map
== nullptr) {
2550 jobject jhash_map
= construct(env
, static_cast<uint32_t>(map
->size()));
2551 if (jhash_map
== nullptr) {
2552 // exception occurred
2556 const ROCKSDB_NAMESPACE::HashMapJni::FnMapKV
<
2557 const std::string
, const uint32_t, jobject
, jobject
>
2559 [env
](const std::pair
<const std::string
, const uint32_t>& kv
) {
2560 jstring jkey
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
2561 env
, &(kv
.first
), false);
2562 if (env
->ExceptionCheck()) {
2563 // an error occurred
2564 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(nullptr);
2567 jobject jvalue
= ROCKSDB_NAMESPACE::IntegerJni::valueOf(
2568 env
, static_cast<jint
>(kv
.second
));
2569 if (env
->ExceptionCheck()) {
2570 // an error occurred
2571 env
->DeleteLocalRef(jkey
);
2572 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(nullptr);
2575 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(
2576 new std::pair
<jobject
, jobject
>(static_cast<jobject
>(jkey
),
2580 if (!putAll(env
, jhash_map
, map
->begin(), map
->end(), fn_map_kv
)) {
2581 // exception occurred
2589 * Creates a java.util.Map<String, Long> from a std::map<std::string, uint64_t>
2591 * @param env A pointer to the Java environment
2592 * @param map the Cpp map
2594 * @return a reference to the Java java.util.Map object, or nullptr if an exception occcurred
2596 static jobject
fromCppMap(JNIEnv
* env
, const std::map
<std::string
, uint64_t>* map
) {
2597 if (map
== nullptr) {
2601 jobject jhash_map
= construct(env
, static_cast<uint32_t>(map
->size()));
2602 if (jhash_map
== nullptr) {
2603 // exception occurred
2607 const ROCKSDB_NAMESPACE::HashMapJni::FnMapKV
<
2608 const std::string
, const uint64_t, jobject
, jobject
>
2610 [env
](const std::pair
<const std::string
, const uint64_t>& kv
) {
2611 jstring jkey
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
2612 env
, &(kv
.first
), false);
2613 if (env
->ExceptionCheck()) {
2614 // an error occurred
2615 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(nullptr);
2618 jobject jvalue
= ROCKSDB_NAMESPACE::LongJni::valueOf(
2619 env
, static_cast<jlong
>(kv
.second
));
2620 if (env
->ExceptionCheck()) {
2621 // an error occurred
2622 env
->DeleteLocalRef(jkey
);
2623 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(nullptr);
2626 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(
2627 new std::pair
<jobject
, jobject
>(static_cast<jobject
>(jkey
),
2631 if (!putAll(env
, jhash_map
, map
->begin(), map
->end(), fn_map_kv
)) {
2632 // exception occurred
2640 * Creates a java.util.Map<String, Long> from a std::map<uint32_t, uint64_t>
2642 * @param env A pointer to the Java environment
2643 * @param map the Cpp map
2645 * @return a reference to the Java java.util.Map object, or nullptr if an exception occcurred
2647 static jobject
fromCppMap(JNIEnv
* env
, const std::map
<uint32_t, uint64_t>* map
) {
2648 if (map
== nullptr) {
2652 jobject jhash_map
= construct(env
, static_cast<uint32_t>(map
->size()));
2653 if (jhash_map
== nullptr) {
2654 // exception occurred
2658 const ROCKSDB_NAMESPACE::HashMapJni::FnMapKV
<const uint32_t, const uint64_t,
2660 fn_map_kv
= [env
](const std::pair
<const uint32_t, const uint64_t>& kv
) {
2661 jobject jkey
= ROCKSDB_NAMESPACE::IntegerJni::valueOf(
2662 env
, static_cast<jint
>(kv
.first
));
2663 if (env
->ExceptionCheck()) {
2664 // an error occurred
2665 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(nullptr);
2668 jobject jvalue
= ROCKSDB_NAMESPACE::LongJni::valueOf(
2669 env
, static_cast<jlong
>(kv
.second
));
2670 if (env
->ExceptionCheck()) {
2671 // an error occurred
2672 env
->DeleteLocalRef(jkey
);
2673 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(nullptr);
2676 return std::unique_ptr
<std::pair
<jobject
, jobject
>>(
2677 new std::pair
<jobject
, jobject
>(static_cast<jobject
>(jkey
),
2681 if (!putAll(env
, jhash_map
, map
->begin(), map
->end(), fn_map_kv
)) {
2682 // exception occurred
2690 // The portal class for org.rocksdb.RocksDB
2692 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::DB
*, RocksDBJni
> {
2695 * Get the Java Class org.rocksdb.RocksDB
2697 * @param env A pointer to the Java environment
2699 * @return The Java Class or nullptr if one of the
2700 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
2701 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
2703 static jclass
getJClass(JNIEnv
* env
) {
2704 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/RocksDB");
2708 // The portal class for org.rocksdb.Options
2710 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::Options
*, OptionsJni
> {
2713 * Get the Java Class org.rocksdb.Options
2715 * @param env A pointer to the Java environment
2717 * @return The Java Class or nullptr if one of the
2718 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
2719 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
2721 static jclass
getJClass(JNIEnv
* env
) {
2722 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/Options");
2726 // The portal class for org.rocksdb.DBOptions
2728 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::DBOptions
*, DBOptionsJni
> {
2731 * Get the Java Class org.rocksdb.DBOptions
2733 * @param env A pointer to the Java environment
2735 * @return The Java Class or nullptr if one of the
2736 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
2737 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
2739 static jclass
getJClass(JNIEnv
* env
) {
2740 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/DBOptions");
2744 // The portal class for org.rocksdb.ColumnFamilyOptions
2745 class ColumnFamilyOptionsJni
2746 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::ColumnFamilyOptions
*,
2747 ColumnFamilyOptionsJni
> {
2750 * Get the Java Class org.rocksdb.ColumnFamilyOptions
2752 * @param env A pointer to the Java environment
2754 * @return The Java Class or nullptr if one of the
2755 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
2756 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
2758 static jclass
getJClass(JNIEnv
* env
) {
2759 return RocksDBNativeClass::getJClass(env
,
2760 "org/rocksdb/ColumnFamilyOptions");
2764 * Create a new Java org.rocksdb.ColumnFamilyOptions object with the same
2765 * properties as the provided C++ ROCKSDB_NAMESPACE::ColumnFamilyOptions
2768 * @param env A pointer to the Java environment
2769 * @param cfoptions A pointer to ROCKSDB_NAMESPACE::ColumnFamilyOptions object
2771 * @return A reference to a Java org.rocksdb.ColumnFamilyOptions object, or
2772 * nullptr if an an exception occurs
2774 static jobject
construct(JNIEnv
* env
, const ColumnFamilyOptions
* cfoptions
) {
2775 auto* cfo
= new ROCKSDB_NAMESPACE::ColumnFamilyOptions(*cfoptions
);
2776 jclass jclazz
= getJClass(env
);
2777 if(jclazz
== nullptr) {
2778 // exception occurred accessing class
2782 jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "(J)V");
2783 if (mid
== nullptr) {
2784 // exception thrown: NoSuchMethodException or OutOfMemoryError
2788 jobject jcfd
= env
->NewObject(jclazz
, mid
, reinterpret_cast<jlong
>(cfo
));
2789 if (env
->ExceptionCheck()) {
2797 // The portal class for org.rocksdb.WriteOptions
2798 class WriteOptionsJni
2799 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::WriteOptions
*,
2803 * Get the Java Class org.rocksdb.WriteOptions
2805 * @param env A pointer to the Java environment
2807 * @return The Java Class or nullptr if one of the
2808 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
2809 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
2811 static jclass
getJClass(JNIEnv
* env
) {
2812 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/WriteOptions");
2816 // The portal class for org.rocksdb.ReadOptions
2817 class ReadOptionsJni
2818 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::ReadOptions
*,
2822 * Get the Java Class org.rocksdb.ReadOptions
2824 * @param env A pointer to the Java environment
2826 * @return The Java Class or nullptr if one of the
2827 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
2828 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
2830 static jclass
getJClass(JNIEnv
* env
) {
2831 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/ReadOptions");
2835 // The portal class for org.rocksdb.WriteBatch
2837 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::WriteBatch
*, WriteBatchJni
> {
2840 * Get the Java Class org.rocksdb.WriteBatch
2842 * @param env A pointer to the Java environment
2844 * @return The Java Class or nullptr if one of the
2845 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
2846 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
2848 static jclass
getJClass(JNIEnv
* env
) {
2849 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/WriteBatch");
2853 * Create a new Java org.rocksdb.WriteBatch object
2855 * @param env A pointer to the Java environment
2856 * @param wb A pointer to ROCKSDB_NAMESPACE::WriteBatch object
2858 * @return A reference to a Java org.rocksdb.WriteBatch object, or
2859 * nullptr if an an exception occurs
2861 static jobject
construct(JNIEnv
* env
, const WriteBatch
* wb
) {
2862 jclass jclazz
= getJClass(env
);
2863 if(jclazz
== nullptr) {
2864 // exception occurred accessing class
2868 jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "(J)V");
2869 if (mid
== nullptr) {
2870 // exception thrown: NoSuchMethodException or OutOfMemoryError
2874 jobject jwb
= env
->NewObject(jclazz
, mid
, reinterpret_cast<jlong
>(wb
));
2875 if (env
->ExceptionCheck()) {
2883 // The portal class for org.rocksdb.WriteBatch.Handler
2884 class WriteBatchHandlerJni
2885 : public RocksDBNativeClass
<
2886 const ROCKSDB_NAMESPACE::WriteBatchHandlerJniCallback
*,
2887 WriteBatchHandlerJni
> {
2890 * Get the Java Class org.rocksdb.WriteBatch.Handler
2892 * @param env A pointer to the Java environment
2894 * @return The Java Class or nullptr if one of the
2895 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
2896 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
2898 static jclass
getJClass(JNIEnv
* env
) {
2899 return RocksDBNativeClass::getJClass(env
,
2900 "org/rocksdb/WriteBatch$Handler");
2904 * Get the Java Method: WriteBatch.Handler#put
2906 * @param env A pointer to the Java environment
2908 * @return The Java Method ID or nullptr if the class or method id could not
2911 static jmethodID
getPutCfMethodId(JNIEnv
* env
) {
2912 jclass jclazz
= getJClass(env
);
2913 if(jclazz
== nullptr) {
2914 // exception occurred accessing class
2918 static jmethodID mid
= env
->GetMethodID(jclazz
, "put", "(I[B[B)V");
2919 assert(mid
!= nullptr);
2924 * Get the Java Method: WriteBatch.Handler#put
2926 * @param env A pointer to the Java environment
2928 * @return The Java Method ID or nullptr if the class or method id could not
2931 static jmethodID
getPutMethodId(JNIEnv
* env
) {
2932 jclass jclazz
= getJClass(env
);
2933 if(jclazz
== nullptr) {
2934 // exception occurred accessing class
2938 static jmethodID mid
= env
->GetMethodID(jclazz
, "put", "([B[B)V");
2939 assert(mid
!= nullptr);
2944 * Get the Java Method: WriteBatch.Handler#merge
2946 * @param env A pointer to the Java environment
2948 * @return The Java Method ID or nullptr if the class or method id could not
2951 static jmethodID
getMergeCfMethodId(JNIEnv
* env
) {
2952 jclass jclazz
= getJClass(env
);
2953 if(jclazz
== nullptr) {
2954 // exception occurred accessing class
2958 static jmethodID mid
= env
->GetMethodID(jclazz
, "merge", "(I[B[B)V");
2959 assert(mid
!= nullptr);
2964 * Get the Java Method: WriteBatch.Handler#merge
2966 * @param env A pointer to the Java environment
2968 * @return The Java Method ID or nullptr if the class or method id could not
2971 static jmethodID
getMergeMethodId(JNIEnv
* env
) {
2972 jclass jclazz
= getJClass(env
);
2973 if(jclazz
== nullptr) {
2974 // exception occurred accessing class
2978 static jmethodID mid
= env
->GetMethodID(jclazz
, "merge", "([B[B)V");
2979 assert(mid
!= nullptr);
2984 * Get the Java Method: WriteBatch.Handler#delete
2986 * @param env A pointer to the Java environment
2988 * @return The Java Method ID or nullptr if the class or method id could not
2991 static jmethodID
getDeleteCfMethodId(JNIEnv
* env
) {
2992 jclass jclazz
= getJClass(env
);
2993 if(jclazz
== nullptr) {
2994 // exception occurred accessing class
2998 static jmethodID mid
= env
->GetMethodID(jclazz
, "delete", "(I[B)V");
2999 assert(mid
!= nullptr);
3004 * Get the Java Method: WriteBatch.Handler#delete
3006 * @param env A pointer to the Java environment
3008 * @return The Java Method ID or nullptr if the class or method id could not
3011 static jmethodID
getDeleteMethodId(JNIEnv
* env
) {
3012 jclass jclazz
= getJClass(env
);
3013 if(jclazz
== nullptr) {
3014 // exception occurred accessing class
3018 static jmethodID mid
= env
->GetMethodID(jclazz
, "delete", "([B)V");
3019 assert(mid
!= nullptr);
3024 * Get the Java Method: WriteBatch.Handler#singleDelete
3026 * @param env A pointer to the Java environment
3028 * @return The Java Method ID or nullptr if the class or method id could not
3031 static jmethodID
getSingleDeleteCfMethodId(JNIEnv
* env
) {
3032 jclass jclazz
= getJClass(env
);
3033 if(jclazz
== nullptr) {
3034 // exception occurred accessing class
3038 static jmethodID mid
= env
->GetMethodID(jclazz
, "singleDelete", "(I[B)V");
3039 assert(mid
!= nullptr);
3044 * Get the Java Method: WriteBatch.Handler#singleDelete
3046 * @param env A pointer to the Java environment
3048 * @return The Java Method ID or nullptr if the class or method id could not
3051 static jmethodID
getSingleDeleteMethodId(JNIEnv
* env
) {
3052 jclass jclazz
= getJClass(env
);
3053 if(jclazz
== nullptr) {
3054 // exception occurred accessing class
3058 static jmethodID mid
= env
->GetMethodID(jclazz
, "singleDelete", "([B)V");
3059 assert(mid
!= nullptr);
3064 * Get the Java Method: WriteBatch.Handler#deleteRange
3066 * @param env A pointer to the Java environment
3068 * @return The Java Method ID or nullptr if the class or method id could not
3071 static jmethodID
getDeleteRangeCfMethodId(JNIEnv
* env
) {
3072 jclass jclazz
= getJClass(env
);
3073 if (jclazz
== nullptr) {
3074 // exception occurred accessing class
3078 static jmethodID mid
= env
->GetMethodID(jclazz
, "deleteRange", "(I[B[B)V");
3079 assert(mid
!= nullptr);
3084 * Get the Java Method: WriteBatch.Handler#deleteRange
3086 * @param env A pointer to the Java environment
3088 * @return The Java Method ID or nullptr if the class or method id could not
3091 static jmethodID
getDeleteRangeMethodId(JNIEnv
* env
) {
3092 jclass jclazz
= getJClass(env
);
3093 if (jclazz
== nullptr) {
3094 // exception occurred accessing class
3098 static jmethodID mid
= env
->GetMethodID(jclazz
, "deleteRange", "([B[B)V");
3099 assert(mid
!= nullptr);
3104 * Get the Java Method: WriteBatch.Handler#logData
3106 * @param env A pointer to the Java environment
3108 * @return The Java Method ID or nullptr if the class or method id could not
3111 static jmethodID
getLogDataMethodId(JNIEnv
* env
) {
3112 jclass jclazz
= getJClass(env
);
3113 if(jclazz
== nullptr) {
3114 // exception occurred accessing class
3118 static jmethodID mid
= env
->GetMethodID(jclazz
, "logData", "([B)V");
3119 assert(mid
!= nullptr);
3124 * Get the Java Method: WriteBatch.Handler#putBlobIndex
3126 * @param env A pointer to the Java environment
3128 * @return The Java Method ID or nullptr if the class or method id could not
3131 static jmethodID
getPutBlobIndexCfMethodId(JNIEnv
* env
) {
3132 jclass jclazz
= getJClass(env
);
3133 if(jclazz
== nullptr) {
3134 // exception occurred accessing class
3138 static jmethodID mid
= env
->GetMethodID(jclazz
, "putBlobIndex", "(I[B[B)V");
3139 assert(mid
!= nullptr);
3144 * Get the Java Method: WriteBatch.Handler#markBeginPrepare
3146 * @param env A pointer to the Java environment
3148 * @return The Java Method ID or nullptr if the class or method id could not
3151 static jmethodID
getMarkBeginPrepareMethodId(JNIEnv
* env
) {
3152 jclass jclazz
= getJClass(env
);
3153 if(jclazz
== nullptr) {
3154 // exception occurred accessing class
3158 static jmethodID mid
= env
->GetMethodID(jclazz
, "markBeginPrepare", "()V");
3159 assert(mid
!= nullptr);
3164 * Get the Java Method: WriteBatch.Handler#markEndPrepare
3166 * @param env A pointer to the Java environment
3168 * @return The Java Method ID or nullptr if the class or method id could not
3171 static jmethodID
getMarkEndPrepareMethodId(JNIEnv
* env
) {
3172 jclass jclazz
= getJClass(env
);
3173 if(jclazz
== nullptr) {
3174 // exception occurred accessing class
3178 static jmethodID mid
= env
->GetMethodID(jclazz
, "markEndPrepare", "([B)V");
3179 assert(mid
!= nullptr);
3184 * Get the Java Method: WriteBatch.Handler#markNoop
3186 * @param env A pointer to the Java environment
3188 * @return The Java Method ID or nullptr if the class or method id could not
3191 static jmethodID
getMarkNoopMethodId(JNIEnv
* env
) {
3192 jclass jclazz
= getJClass(env
);
3193 if(jclazz
== nullptr) {
3194 // exception occurred accessing class
3198 static jmethodID mid
= env
->GetMethodID(jclazz
, "markNoop", "(Z)V");
3199 assert(mid
!= nullptr);
3204 * Get the Java Method: WriteBatch.Handler#markRollback
3206 * @param env A pointer to the Java environment
3208 * @return The Java Method ID or nullptr if the class or method id could not
3211 static jmethodID
getMarkRollbackMethodId(JNIEnv
* env
) {
3212 jclass jclazz
= getJClass(env
);
3213 if(jclazz
== nullptr) {
3214 // exception occurred accessing class
3218 static jmethodID mid
= env
->GetMethodID(jclazz
, "markRollback", "([B)V");
3219 assert(mid
!= nullptr);
3224 * Get the Java Method: WriteBatch.Handler#markCommit
3226 * @param env A pointer to the Java environment
3228 * @return The Java Method ID or nullptr if the class or method id could not
3231 static jmethodID
getMarkCommitMethodId(JNIEnv
* env
) {
3232 jclass jclazz
= getJClass(env
);
3233 if(jclazz
== nullptr) {
3234 // exception occurred accessing class
3238 static jmethodID mid
= env
->GetMethodID(jclazz
, "markCommit", "([B)V");
3239 assert(mid
!= nullptr);
3244 * Get the Java Method: WriteBatch.Handler#shouldContinue
3246 * @param env A pointer to the Java environment
3248 * @return The Java Method ID or nullptr if the class or method id could not
3251 static jmethodID
getContinueMethodId(JNIEnv
* env
) {
3252 jclass jclazz
= getJClass(env
);
3253 if(jclazz
== nullptr) {
3254 // exception occurred accessing class
3258 static jmethodID mid
= env
->GetMethodID(jclazz
, "shouldContinue", "()Z");
3259 assert(mid
!= nullptr);
3264 class WriteBatchSavePointJni
: public JavaClass
{
3267 * Get the Java Class org.rocksdb.WriteBatch.SavePoint
3269 * @param env A pointer to the Java environment
3271 * @return The Java Class or nullptr if one of the
3272 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3273 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3275 static jclass
getJClass(JNIEnv
* env
) {
3276 return JavaClass::getJClass(env
, "org/rocksdb/WriteBatch$SavePoint");
3280 * Get the Java Method: HistogramData constructor
3282 * @param env A pointer to the Java environment
3284 * @return The Java Method ID or nullptr if the class or method id could not
3287 static jmethodID
getConstructorMethodId(JNIEnv
* env
) {
3288 jclass jclazz
= getJClass(env
);
3289 if(jclazz
== nullptr) {
3290 // exception occurred accessing class
3294 static jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "(JJJ)V");
3295 assert(mid
!= nullptr);
3300 * Create a new Java org.rocksdb.WriteBatch.SavePoint object
3302 * @param env A pointer to the Java environment
3303 * @param savePoint A pointer to ROCKSDB_NAMESPACE::WriteBatch::SavePoint
3306 * @return A reference to a Java org.rocksdb.WriteBatch.SavePoint object, or
3307 * nullptr if an an exception occurs
3309 static jobject
construct(JNIEnv
* env
, const SavePoint
&save_point
) {
3310 jclass jclazz
= getJClass(env
);
3311 if(jclazz
== nullptr) {
3312 // exception occurred accessing class
3316 jmethodID mid
= getConstructorMethodId(env
);
3317 if (mid
== nullptr) {
3318 // exception thrown: NoSuchMethodException or OutOfMemoryError
3322 jobject jsave_point
= env
->NewObject(jclazz
, mid
,
3323 static_cast<jlong
>(save_point
.size
),
3324 static_cast<jlong
>(save_point
.count
),
3325 static_cast<jlong
>(save_point
.content_flags
));
3326 if (env
->ExceptionCheck()) {
3334 // The portal class for org.rocksdb.WriteBatchWithIndex
3335 class WriteBatchWithIndexJni
3336 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*,
3337 WriteBatchWithIndexJni
> {
3340 * Get the Java Class org.rocksdb.WriteBatchWithIndex
3342 * @param env A pointer to the Java environment
3344 * @return The Java Class or nullptr if one of the
3345 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3346 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3348 static jclass
getJClass(JNIEnv
* env
) {
3349 return RocksDBNativeClass::getJClass(env
,
3350 "org/rocksdb/WriteBatchWithIndex");
3354 // The portal class for org.rocksdb.HistogramData
3355 class HistogramDataJni
: public JavaClass
{
3358 * Get the Java Class org.rocksdb.HistogramData
3360 * @param env A pointer to the Java environment
3362 * @return The Java Class or nullptr if one of the
3363 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3364 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3366 static jclass
getJClass(JNIEnv
* env
) {
3367 return JavaClass::getJClass(env
, "org/rocksdb/HistogramData");
3371 * Get the Java Method: HistogramData constructor
3373 * @param env A pointer to the Java environment
3375 * @return The Java Method ID or nullptr if the class or method id could not
3378 static jmethodID
getConstructorMethodId(JNIEnv
* env
) {
3379 jclass jclazz
= getJClass(env
);
3380 if(jclazz
== nullptr) {
3381 // exception occurred accessing class
3385 static jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "(DDDDDDJJD)V");
3386 assert(mid
!= nullptr);
3391 // The portal class for org.rocksdb.BackupableDBOptions
3392 class BackupableDBOptionsJni
3393 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::BackupableDBOptions
*,
3394 BackupableDBOptionsJni
> {
3397 * Get the Java Class org.rocksdb.BackupableDBOptions
3399 * @param env A pointer to the Java environment
3401 * @return The Java Class or nullptr if one of the
3402 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3403 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3405 static jclass
getJClass(JNIEnv
* env
) {
3406 return RocksDBNativeClass::getJClass(env
,
3407 "org/rocksdb/BackupableDBOptions");
3411 // The portal class for org.rocksdb.BackupEngine
3412 class BackupEngineJni
3413 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::BackupEngine
*,
3417 * Get the Java Class org.rocksdb.BackupableEngine
3419 * @param env A pointer to the Java environment
3421 * @return The Java Class or nullptr if one of the
3422 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3423 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3425 static jclass
getJClass(JNIEnv
* env
) {
3426 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/BackupEngine");
3430 // The portal class for org.rocksdb.RocksIterator
3432 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::Iterator
*, IteratorJni
> {
3435 * Get the Java Class org.rocksdb.RocksIterator
3437 * @param env A pointer to the Java environment
3439 * @return The Java Class or nullptr if one of the
3440 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3441 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3443 static jclass
getJClass(JNIEnv
* env
) {
3444 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/RocksIterator");
3448 // The portal class for org.rocksdb.Filter
3450 : public RocksDBNativeClass
<
3451 std::shared_ptr
<ROCKSDB_NAMESPACE::FilterPolicy
>*, FilterJni
> {
3454 * Get the Java Class org.rocksdb.Filter
3456 * @param env A pointer to the Java environment
3458 * @return The Java Class or nullptr if one of the
3459 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3460 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3462 static jclass
getJClass(JNIEnv
* env
) {
3463 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/Filter");
3467 // The portal class for org.rocksdb.ColumnFamilyHandle
3468 class ColumnFamilyHandleJni
3469 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*,
3470 ColumnFamilyHandleJni
> {
3472 static jobject
fromCppColumnFamilyHandle(
3473 JNIEnv
* env
, const ROCKSDB_NAMESPACE::ColumnFamilyHandle
* info
) {
3474 jclass jclazz
= getJClass(env
);
3475 assert(jclazz
!= nullptr);
3476 static jmethodID ctor
= getConstructorMethodId(env
, jclazz
);
3477 assert(ctor
!= nullptr);
3478 return env
->NewObject(jclazz
, ctor
, reinterpret_cast<jlong
>(info
));
3481 static jmethodID
getConstructorMethodId(JNIEnv
* env
, jclass clazz
) {
3482 return env
->GetMethodID(clazz
, "<init>", "(J)V");
3486 * Get the Java Class org.rocksdb.ColumnFamilyHandle
3488 * @param env A pointer to the Java environment
3490 * @return The Java Class or nullptr if one of the
3491 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3492 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3494 static jclass
getJClass(JNIEnv
* env
) {
3495 return RocksDBNativeClass::getJClass(env
,
3496 "org/rocksdb/ColumnFamilyHandle");
3500 // The portal class for org.rocksdb.FlushOptions
3501 class FlushOptionsJni
3502 : public RocksDBNativeClass
<ROCKSDB_NAMESPACE::FlushOptions
*,
3506 * Get the Java Class org.rocksdb.FlushOptions
3508 * @param env A pointer to the Java environment
3510 * @return The Java Class or nullptr if one of the
3511 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3512 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3514 static jclass
getJClass(JNIEnv
* env
) {
3515 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/FlushOptions");
3519 // The portal class for org.rocksdb.ComparatorOptions
3520 class ComparatorOptionsJni
3521 : public RocksDBNativeClass
<
3522 ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions
*,
3523 ComparatorOptionsJni
> {
3526 * Get the Java Class org.rocksdb.ComparatorOptions
3528 * @param env A pointer to the Java environment
3530 * @return The Java Class or nullptr if one of the
3531 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3532 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3534 static jclass
getJClass(JNIEnv
* env
) {
3535 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/ComparatorOptions");
3539 // The portal class for org.rocksdb.AbstractCompactionFilterFactory
3540 class AbstractCompactionFilterFactoryJni
3541 : public RocksDBNativeClass
<
3542 const ROCKSDB_NAMESPACE::CompactionFilterFactoryJniCallback
*,
3543 AbstractCompactionFilterFactoryJni
> {
3546 * Get the Java Class org.rocksdb.AbstractCompactionFilterFactory
3548 * @param env A pointer to the Java environment
3550 * @return The Java Class or nullptr if one of the
3551 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3552 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3554 static jclass
getJClass(JNIEnv
* env
) {
3555 return RocksDBNativeClass::getJClass(env
,
3556 "org/rocksdb/AbstractCompactionFilterFactory");
3560 * Get the Java Method: AbstractCompactionFilterFactory#name
3562 * @param env A pointer to the Java environment
3564 * @return The Java Method ID or nullptr if the class or method id could not
3567 static jmethodID
getNameMethodId(JNIEnv
* env
) {
3568 jclass jclazz
= getJClass(env
);
3569 if(jclazz
== nullptr) {
3570 // exception occurred accessing class
3574 static jmethodID mid
= env
->GetMethodID(
3575 jclazz
, "name", "()Ljava/lang/String;");
3576 assert(mid
!= nullptr);
3581 * Get the Java Method: AbstractCompactionFilterFactory#createCompactionFilter
3583 * @param env A pointer to the Java environment
3585 * @return The Java Method ID or nullptr if the class or method id could not
3588 static jmethodID
getCreateCompactionFilterMethodId(JNIEnv
* env
) {
3589 jclass jclazz
= getJClass(env
);
3590 if(jclazz
== nullptr) {
3591 // exception occurred accessing class
3595 static jmethodID mid
= env
->GetMethodID(jclazz
,
3596 "createCompactionFilter",
3598 assert(mid
!= nullptr);
3603 // The portal class for org.rocksdb.AbstractTransactionNotifier
3604 class AbstractTransactionNotifierJni
3605 : public RocksDBNativeClass
<
3606 const ROCKSDB_NAMESPACE::TransactionNotifierJniCallback
*,
3607 AbstractTransactionNotifierJni
> {
3609 static jclass
getJClass(JNIEnv
* env
) {
3610 return RocksDBNativeClass::getJClass(env
,
3611 "org/rocksdb/AbstractTransactionNotifier");
3614 // Get the java method `snapshotCreated`
3615 // of org.rocksdb.AbstractTransactionNotifier.
3616 static jmethodID
getSnapshotCreatedMethodId(JNIEnv
* env
) {
3617 jclass jclazz
= getJClass(env
);
3618 if(jclazz
== nullptr) {
3619 // exception occurred accessing class
3623 static jmethodID mid
= env
->GetMethodID(jclazz
, "snapshotCreated", "(J)V");
3624 assert(mid
!= nullptr);
3629 // The portal class for org.rocksdb.AbstractComparatorJniBridge
3630 class AbstractComparatorJniBridge
: public JavaClass
{
3633 * Get the Java Class org.rocksdb.AbstractComparatorJniBridge
3635 * @param env A pointer to the Java environment
3637 * @return The Java Class or nullptr if one of the
3638 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3639 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3641 static jclass
getJClass(JNIEnv
* env
) {
3642 return JavaClass::getJClass(env
,
3643 "org/rocksdb/AbstractComparatorJniBridge");
3647 * Get the Java Method: Comparator#compareInternal
3649 * @param env A pointer to the Java environment
3650 * @param jclazz the AbstractComparatorJniBridge class
3652 * @return The Java Method ID or nullptr if the class or method id could not
3655 static jmethodID
getCompareInternalMethodId(JNIEnv
* env
, jclass jclazz
) {
3656 static jmethodID mid
=
3657 env
->GetStaticMethodID(jclazz
, "compareInternal",
3658 "(Lorg/rocksdb/AbstractComparator;Ljava/nio/ByteBuffer;ILjava/nio/ByteBuffer;I)I");
3659 assert(mid
!= nullptr);
3664 * Get the Java Method: Comparator#findShortestSeparatorInternal
3666 * @param env A pointer to the Java environment
3667 * @param jclazz the AbstractComparatorJniBridge class
3669 * @return The Java Method ID or nullptr if the class or method id could not
3672 static jmethodID
getFindShortestSeparatorInternalMethodId(JNIEnv
* env
, jclass jclazz
) {
3673 static jmethodID mid
=
3674 env
->GetStaticMethodID(jclazz
, "findShortestSeparatorInternal",
3675 "(Lorg/rocksdb/AbstractComparator;Ljava/nio/ByteBuffer;ILjava/nio/ByteBuffer;I)I");
3676 assert(mid
!= nullptr);
3681 * Get the Java Method: Comparator#findShortSuccessorInternal
3683 * @param env A pointer to the Java environment
3684 * @param jclazz the AbstractComparatorJniBridge class
3686 * @return The Java Method ID or nullptr if the class or method id could not
3689 static jmethodID
getFindShortSuccessorInternalMethodId(JNIEnv
* env
, jclass jclazz
) {
3690 static jmethodID mid
=
3691 env
->GetStaticMethodID(jclazz
, "findShortSuccessorInternal",
3692 "(Lorg/rocksdb/AbstractComparator;Ljava/nio/ByteBuffer;I)I");
3693 assert(mid
!= nullptr);
3698 // The portal class for org.rocksdb.AbstractComparator
3699 class AbstractComparatorJni
3700 : public RocksDBNativeClass
<const ROCKSDB_NAMESPACE::ComparatorJniCallback
*,
3701 AbstractComparatorJni
> {
3704 * Get the Java Class org.rocksdb.AbstractComparator
3706 * @param env A pointer to the Java environment
3708 * @return The Java Class or nullptr if one of the
3709 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3710 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3712 static jclass
getJClass(JNIEnv
* env
) {
3713 return RocksDBNativeClass::getJClass(env
,
3714 "org/rocksdb/AbstractComparator");
3718 * Get the Java Method: Comparator#name
3720 * @param env A pointer to the Java environment
3722 * @return The Java Method ID or nullptr if the class or method id could not
3725 static jmethodID
getNameMethodId(JNIEnv
* env
) {
3726 jclass jclazz
= getJClass(env
);
3727 if(jclazz
== nullptr) {
3728 // exception occurred accessing class
3732 static jmethodID mid
=
3733 env
->GetMethodID(jclazz
, "name", "()Ljava/lang/String;");
3734 assert(mid
!= nullptr);
3739 // The portal class for org.rocksdb.AbstractSlice
3740 class AbstractSliceJni
3741 : public NativeRocksMutableObject
<const ROCKSDB_NAMESPACE::Slice
*,
3745 * Get the Java Class org.rocksdb.AbstractSlice
3747 * @param env A pointer to the Java environment
3749 * @return The Java Class or nullptr if one of the
3750 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3751 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3753 static jclass
getJClass(JNIEnv
* env
) {
3754 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/AbstractSlice");
3758 // The portal class for org.rocksdb.Slice
3760 : public NativeRocksMutableObject
<const ROCKSDB_NAMESPACE::Slice
*,
3764 * Get the Java Class org.rocksdb.Slice
3766 * @param env A pointer to the Java environment
3768 * @return The Java Class or nullptr if one of the
3769 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3770 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3772 static jclass
getJClass(JNIEnv
* env
) {
3773 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/Slice");
3777 * Constructs a Slice object
3779 * @param env A pointer to the Java environment
3781 * @return A reference to a Java Slice object, or a nullptr if an
3784 static jobject
construct0(JNIEnv
* env
) {
3785 jclass jclazz
= getJClass(env
);
3786 if(jclazz
== nullptr) {
3787 // exception occurred accessing class
3791 static jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "()V");
3792 if(mid
== nullptr) {
3793 // exception occurred accessing method
3797 jobject jslice
= env
->NewObject(jclazz
, mid
);
3798 if(env
->ExceptionCheck()) {
3806 // The portal class for org.rocksdb.DirectSlice
3807 class DirectSliceJni
3808 : public NativeRocksMutableObject
<const ROCKSDB_NAMESPACE::Slice
*,
3812 * Get the Java Class org.rocksdb.DirectSlice
3814 * @param env A pointer to the Java environment
3816 * @return The Java Class or nullptr if one of the
3817 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3818 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3820 static jclass
getJClass(JNIEnv
* env
) {
3821 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/DirectSlice");
3825 * Constructs a DirectSlice object
3827 * @param env A pointer to the Java environment
3829 * @return A reference to a Java DirectSlice object, or a nullptr if an
3832 static jobject
construct0(JNIEnv
* env
) {
3833 jclass jclazz
= getJClass(env
);
3834 if(jclazz
== nullptr) {
3835 // exception occurred accessing class
3839 static jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "()V");
3840 if(mid
== nullptr) {
3841 // exception occurred accessing method
3845 jobject jdirect_slice
= env
->NewObject(jclazz
, mid
);
3846 if(env
->ExceptionCheck()) {
3850 return jdirect_slice
;
3854 // The portal class for org.rocksdb.BackupInfo
3855 class BackupInfoJni
: public JavaClass
{
3858 * Get the Java Class org.rocksdb.BackupInfo
3860 * @param env A pointer to the Java environment
3862 * @return The Java Class or nullptr if one of the
3863 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
3864 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
3866 static jclass
getJClass(JNIEnv
* env
) {
3867 return JavaClass::getJClass(env
, "org/rocksdb/BackupInfo");
3871 * Constructs a BackupInfo object
3873 * @param env A pointer to the Java environment
3874 * @param backup_id id of the backup
3875 * @param timestamp timestamp of the backup
3876 * @param size size of the backup
3877 * @param number_files number of files related to the backup
3878 * @param app_metadata application specific metadata
3880 * @return A reference to a Java BackupInfo object, or a nullptr if an
3883 static jobject
construct0(JNIEnv
* env
, uint32_t backup_id
, int64_t timestamp
,
3884 uint64_t size
, uint32_t number_files
,
3885 const std::string
& app_metadata
) {
3886 jclass jclazz
= getJClass(env
);
3887 if(jclazz
== nullptr) {
3888 // exception occurred accessing class
3892 static jmethodID mid
=
3893 env
->GetMethodID(jclazz
, "<init>", "(IJJILjava/lang/String;)V");
3894 if(mid
== nullptr) {
3895 // exception occurred accessing method
3899 jstring japp_metadata
= nullptr;
3900 if (app_metadata
!= nullptr) {
3901 japp_metadata
= env
->NewStringUTF(app_metadata
.c_str());
3902 if (japp_metadata
== nullptr) {
3903 // exception occurred creating java string
3908 jobject jbackup_info
= env
->NewObject(jclazz
, mid
, backup_id
, timestamp
,
3909 size
, number_files
, japp_metadata
);
3910 if(env
->ExceptionCheck()) {
3911 env
->DeleteLocalRef(japp_metadata
);
3915 return jbackup_info
;
3919 class BackupInfoListJni
{
3922 * Converts a C++ std::vector<BackupInfo> object to
3923 * a Java ArrayList<org.rocksdb.BackupInfo> object
3925 * @param env A pointer to the Java environment
3926 * @param backup_infos A vector of BackupInfo
3928 * @return Either a reference to a Java ArrayList object, or a nullptr
3929 * if an exception occurs
3931 static jobject
getBackupInfo(JNIEnv
* env
,
3932 std::vector
<BackupInfo
> backup_infos
) {
3933 jclass jarray_list_clazz
=
3934 ROCKSDB_NAMESPACE::ListJni::getArrayListClass(env
);
3935 if(jarray_list_clazz
== nullptr) {
3936 // exception occurred accessing class
3940 jmethodID cstr_mid
=
3941 ROCKSDB_NAMESPACE::ListJni::getArrayListConstructorMethodId(env
);
3942 if(cstr_mid
== nullptr) {
3943 // exception occurred accessing method
3947 jmethodID add_mid
= ROCKSDB_NAMESPACE::ListJni::getListAddMethodId(env
);
3948 if(add_mid
== nullptr) {
3949 // exception occurred accessing method
3954 jobject jbackup_info_handle_list
=
3955 env
->NewObject(jarray_list_clazz
, cstr_mid
, backup_infos
.size());
3956 if(env
->ExceptionCheck()) {
3957 // exception occurred constructing object
3961 // insert in java list
3962 auto end
= backup_infos
.end();
3963 for (auto it
= backup_infos
.begin(); it
!= end
; ++it
) {
3964 auto backup_info
= *it
;
3966 jobject obj
= ROCKSDB_NAMESPACE::BackupInfoJni::construct0(
3967 env
, backup_info
.backup_id
, backup_info
.timestamp
, backup_info
.size
,
3968 backup_info
.number_files
, backup_info
.app_metadata
);
3969 if(env
->ExceptionCheck()) {
3970 // exception occurred constructing object
3971 if(obj
!= nullptr) {
3972 env
->DeleteLocalRef(obj
);
3974 if(jbackup_info_handle_list
!= nullptr) {
3975 env
->DeleteLocalRef(jbackup_info_handle_list
);
3981 env
->CallBooleanMethod(jbackup_info_handle_list
, add_mid
, obj
);
3982 if(env
->ExceptionCheck() || rs
== JNI_FALSE
) {
3983 // exception occurred calling method, or could not add
3984 if(obj
!= nullptr) {
3985 env
->DeleteLocalRef(obj
);
3987 if(jbackup_info_handle_list
!= nullptr) {
3988 env
->DeleteLocalRef(jbackup_info_handle_list
);
3994 return jbackup_info_handle_list
;
3998 // The portal class for org.rocksdb.WBWIRocksIterator
3999 class WBWIRocksIteratorJni
: public JavaClass
{
4002 * Get the Java Class org.rocksdb.WBWIRocksIterator
4004 * @param env A pointer to the Java environment
4006 * @return The Java Class or nullptr if one of the
4007 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
4008 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
4010 static jclass
getJClass(JNIEnv
* env
) {
4011 return JavaClass::getJClass(env
, "org/rocksdb/WBWIRocksIterator");
4015 * Get the Java Field: WBWIRocksIterator#entry
4017 * @param env A pointer to the Java environment
4019 * @return The Java Field ID or nullptr if the class or field id could not
4022 static jfieldID
getWriteEntryField(JNIEnv
* env
) {
4023 jclass jclazz
= getJClass(env
);
4024 if(jclazz
== nullptr) {
4025 // exception occurred accessing class
4029 static jfieldID fid
=
4030 env
->GetFieldID(jclazz
, "entry",
4031 "Lorg/rocksdb/WBWIRocksIterator$WriteEntry;");
4032 assert(fid
!= nullptr);
4037 * Gets the value of the WBWIRocksIterator#entry
4039 * @param env A pointer to the Java environment
4040 * @param jwbwi_rocks_iterator A reference to a WBWIIterator
4042 * @return A reference to a Java WBWIRocksIterator.WriteEntry object, or
4043 * a nullptr if an exception occurs
4045 static jobject
getWriteEntry(JNIEnv
* env
, jobject jwbwi_rocks_iterator
) {
4046 assert(jwbwi_rocks_iterator
!= nullptr);
4048 jfieldID jwrite_entry_field
= getWriteEntryField(env
);
4049 if(jwrite_entry_field
== nullptr) {
4050 // exception occurred accessing the field
4054 jobject jwe
= env
->GetObjectField(jwbwi_rocks_iterator
, jwrite_entry_field
);
4055 assert(jwe
!= nullptr);
4060 // The portal class for org.rocksdb.WBWIRocksIterator.WriteType
4061 class WriteTypeJni
: public JavaClass
{
4064 * Get the PUT enum field value of WBWIRocksIterator.WriteType
4066 * @param env A pointer to the Java environment
4068 * @return A reference to the enum field value or a nullptr if
4069 * the enum field value could not be retrieved
4071 static jobject
PUT(JNIEnv
* env
) {
4072 return getEnum(env
, "PUT");
4076 * Get the MERGE enum field value of WBWIRocksIterator.WriteType
4078 * @param env A pointer to the Java environment
4080 * @return A reference to the enum field value or a nullptr if
4081 * the enum field value could not be retrieved
4083 static jobject
MERGE(JNIEnv
* env
) {
4084 return getEnum(env
, "MERGE");
4088 * Get the DELETE enum field value of WBWIRocksIterator.WriteType
4090 * @param env A pointer to the Java environment
4092 * @return A reference to the enum field value or a nullptr if
4093 * the enum field value could not be retrieved
4095 static jobject
DELETE(JNIEnv
* env
) {
4096 return getEnum(env
, "DELETE");
4100 * Get the LOG enum field value of WBWIRocksIterator.WriteType
4102 * @param env A pointer to the Java environment
4104 * @return A reference to the enum field value or a nullptr if
4105 * the enum field value could not be retrieved
4107 static jobject
LOG(JNIEnv
* env
) {
4108 return getEnum(env
, "LOG");
4111 // Returns the equivalent org.rocksdb.WBWIRocksIterator.WriteType for the
4112 // provided C++ ROCKSDB_NAMESPACE::WriteType enum
4113 static jbyte
toJavaWriteType(const ROCKSDB_NAMESPACE::WriteType
& writeType
) {
4114 switch (writeType
) {
4115 case ROCKSDB_NAMESPACE::WriteType::kPutRecord
:
4117 case ROCKSDB_NAMESPACE::WriteType::kMergeRecord
:
4119 case ROCKSDB_NAMESPACE::WriteType::kDeleteRecord
:
4121 case ROCKSDB_NAMESPACE::WriteType::kSingleDeleteRecord
:
4123 case ROCKSDB_NAMESPACE::WriteType::kDeleteRangeRecord
:
4125 case ROCKSDB_NAMESPACE::WriteType::kLogDataRecord
:
4127 case ROCKSDB_NAMESPACE::WriteType::kXIDRecord
:
4130 return 0x7F; // undefined
4136 * Get the Java Class org.rocksdb.WBWIRocksIterator.WriteType
4138 * @param env A pointer to the Java environment
4140 * @return The Java Class or nullptr if one of the
4141 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
4142 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
4144 static jclass
getJClass(JNIEnv
* env
) {
4145 return JavaClass::getJClass(env
, "org/rocksdb/WBWIRocksIterator$WriteType");
4149 * Get an enum field of org.rocksdb.WBWIRocksIterator.WriteType
4151 * @param env A pointer to the Java environment
4152 * @param name The name of the enum field
4154 * @return A reference to the enum field value or a nullptr if
4155 * the enum field value could not be retrieved
4157 static jobject
getEnum(JNIEnv
* env
, const char name
[]) {
4158 jclass jclazz
= getJClass(env
);
4159 if(jclazz
== nullptr) {
4160 // exception occurred accessing class
4165 env
->GetStaticFieldID(jclazz
, name
,
4166 "Lorg/rocksdb/WBWIRocksIterator$WriteType;");
4167 if(env
->ExceptionCheck()) {
4168 // exception occurred while getting field
4170 } else if(jfid
== nullptr) {
4174 jobject jwrite_type
= env
->GetStaticObjectField(jclazz
, jfid
);
4175 assert(jwrite_type
!= nullptr);
4180 // The portal class for org.rocksdb.WBWIRocksIterator.WriteEntry
4181 class WriteEntryJni
: public JavaClass
{
4184 * Get the Java Class org.rocksdb.WBWIRocksIterator.WriteEntry
4186 * @param env A pointer to the Java environment
4188 * @return The Java Class or nullptr if one of the
4189 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
4190 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
4192 static jclass
getJClass(JNIEnv
* env
) {
4193 return JavaClass::getJClass(env
, "org/rocksdb/WBWIRocksIterator$WriteEntry");
4197 // The portal class for org.rocksdb.InfoLogLevel
4198 class InfoLogLevelJni
: public JavaClass
{
4201 * Get the DEBUG_LEVEL enum field value of InfoLogLevel
4203 * @param env A pointer to the Java environment
4205 * @return A reference to the enum field value or a nullptr if
4206 * the enum field value could not be retrieved
4208 static jobject
DEBUG_LEVEL(JNIEnv
* env
) {
4209 return getEnum(env
, "DEBUG_LEVEL");
4213 * Get the INFO_LEVEL enum field value of InfoLogLevel
4215 * @param env A pointer to the Java environment
4217 * @return A reference to the enum field value or a nullptr if
4218 * the enum field value could not be retrieved
4220 static jobject
INFO_LEVEL(JNIEnv
* env
) {
4221 return getEnum(env
, "INFO_LEVEL");
4225 * Get the WARN_LEVEL enum field value of InfoLogLevel
4227 * @param env A pointer to the Java environment
4229 * @return A reference to the enum field value or a nullptr if
4230 * the enum field value could not be retrieved
4232 static jobject
WARN_LEVEL(JNIEnv
* env
) {
4233 return getEnum(env
, "WARN_LEVEL");
4237 * Get the ERROR_LEVEL enum field value of InfoLogLevel
4239 * @param env A pointer to the Java environment
4241 * @return A reference to the enum field value or a nullptr if
4242 * the enum field value could not be retrieved
4244 static jobject
ERROR_LEVEL(JNIEnv
* env
) {
4245 return getEnum(env
, "ERROR_LEVEL");
4249 * Get the FATAL_LEVEL enum field value of InfoLogLevel
4251 * @param env A pointer to the Java environment
4253 * @return A reference to the enum field value or a nullptr if
4254 * the enum field value could not be retrieved
4256 static jobject
FATAL_LEVEL(JNIEnv
* env
) {
4257 return getEnum(env
, "FATAL_LEVEL");
4261 * Get the HEADER_LEVEL enum field value of InfoLogLevel
4263 * @param env A pointer to the Java environment
4265 * @return A reference to the enum field value or a nullptr if
4266 * the enum field value could not be retrieved
4268 static jobject
HEADER_LEVEL(JNIEnv
* env
) {
4269 return getEnum(env
, "HEADER_LEVEL");
4274 * Get the Java Class org.rocksdb.InfoLogLevel
4276 * @param env A pointer to the Java environment
4278 * @return The Java Class or nullptr if one of the
4279 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
4280 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
4282 static jclass
getJClass(JNIEnv
* env
) {
4283 return JavaClass::getJClass(env
, "org/rocksdb/InfoLogLevel");
4287 * Get an enum field of org.rocksdb.InfoLogLevel
4289 * @param env A pointer to the Java environment
4290 * @param name The name of the enum field
4292 * @return A reference to the enum field value or a nullptr if
4293 * the enum field value could not be retrieved
4295 static jobject
getEnum(JNIEnv
* env
, const char name
[]) {
4296 jclass jclazz
= getJClass(env
);
4297 if(jclazz
== nullptr) {
4298 // exception occurred accessing class
4303 env
->GetStaticFieldID(jclazz
, name
, "Lorg/rocksdb/InfoLogLevel;");
4304 if(env
->ExceptionCheck()) {
4305 // exception occurred while getting field
4307 } else if(jfid
== nullptr) {
4311 jobject jinfo_log_level
= env
->GetStaticObjectField(jclazz
, jfid
);
4312 assert(jinfo_log_level
!= nullptr);
4313 return jinfo_log_level
;
4317 // The portal class for org.rocksdb.Logger
4319 : public RocksDBNativeClass
<
4320 std::shared_ptr
<ROCKSDB_NAMESPACE::LoggerJniCallback
>*, LoggerJni
> {
4323 * Get the Java Class org/rocksdb/Logger
4325 * @param env A pointer to the Java environment
4327 * @return The Java Class or nullptr if one of the
4328 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
4329 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
4331 static jclass
getJClass(JNIEnv
* env
) {
4332 return RocksDBNativeClass::getJClass(env
, "org/rocksdb/Logger");
4336 * Get the Java Method: Logger#log
4338 * @param env A pointer to the Java environment
4340 * @return The Java Method ID or nullptr if the class or method id could not
4343 static jmethodID
getLogMethodId(JNIEnv
* env
) {
4344 jclass jclazz
= getJClass(env
);
4345 if(jclazz
== nullptr) {
4346 // exception occurred accessing class
4350 static jmethodID mid
=
4351 env
->GetMethodID(jclazz
, "log",
4352 "(Lorg/rocksdb/InfoLogLevel;Ljava/lang/String;)V");
4353 assert(mid
!= nullptr);
4358 // The portal class for org.rocksdb.TransactionLogIterator.BatchResult
4359 class BatchResultJni
: public JavaClass
{
4362 * Get the Java Class org.rocksdb.TransactionLogIterator.BatchResult
4364 * @param env A pointer to the Java environment
4366 * @return The Java Class or nullptr if one of the
4367 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
4368 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
4370 static jclass
getJClass(JNIEnv
* env
) {
4371 return JavaClass::getJClass(env
,
4372 "org/rocksdb/TransactionLogIterator$BatchResult");
4376 * Create a new Java org.rocksdb.TransactionLogIterator.BatchResult object
4377 * with the same properties as the provided C++ ROCKSDB_NAMESPACE::BatchResult
4380 * @param env A pointer to the Java environment
4381 * @param batch_result The ROCKSDB_NAMESPACE::BatchResult object
4383 * @return A reference to a Java
4384 * org.rocksdb.TransactionLogIterator.BatchResult object,
4385 * or nullptr if an an exception occurs
4387 static jobject
construct(JNIEnv
* env
,
4388 ROCKSDB_NAMESPACE::BatchResult
& batch_result
) {
4389 jclass jclazz
= getJClass(env
);
4390 if(jclazz
== nullptr) {
4391 // exception occurred accessing class
4395 jmethodID mid
= env
->GetMethodID(
4396 jclazz
, "<init>", "(JJ)V");
4397 if(mid
== nullptr) {
4398 // exception thrown: NoSuchMethodException or OutOfMemoryError
4402 jobject jbatch_result
= env
->NewObject(jclazz
, mid
,
4403 batch_result
.sequence
, batch_result
.writeBatchPtr
.get());
4404 if(jbatch_result
== nullptr) {
4405 // exception thrown: InstantiationException or OutOfMemoryError
4409 batch_result
.writeBatchPtr
.release();
4410 return jbatch_result
;
4414 // The portal class for org.rocksdb.BottommostLevelCompaction
4415 class BottommostLevelCompactionJni
{
4417 // Returns the equivalent org.rocksdb.BottommostLevelCompaction for the
4418 // provided C++ ROCKSDB_NAMESPACE::BottommostLevelCompaction enum
4419 static jint
toJavaBottommostLevelCompaction(
4420 const ROCKSDB_NAMESPACE::BottommostLevelCompaction
&
4421 bottommost_level_compaction
) {
4422 switch(bottommost_level_compaction
) {
4423 case ROCKSDB_NAMESPACE::BottommostLevelCompaction::kSkip
:
4425 case ROCKSDB_NAMESPACE::BottommostLevelCompaction::
4426 kIfHaveCompactionFilter
:
4428 case ROCKSDB_NAMESPACE::BottommostLevelCompaction::kForce
:
4430 case ROCKSDB_NAMESPACE::BottommostLevelCompaction::kForceOptimized
:
4433 return 0x7F; // undefined
4437 // Returns the equivalent C++ ROCKSDB_NAMESPACE::BottommostLevelCompaction
4438 // enum for the provided Java org.rocksdb.BottommostLevelCompaction
4439 static ROCKSDB_NAMESPACE::BottommostLevelCompaction
4440 toCppBottommostLevelCompaction(jint bottommost_level_compaction
) {
4441 switch(bottommost_level_compaction
) {
4443 return ROCKSDB_NAMESPACE::BottommostLevelCompaction::kSkip
;
4445 return ROCKSDB_NAMESPACE::BottommostLevelCompaction::
4446 kIfHaveCompactionFilter
;
4448 return ROCKSDB_NAMESPACE::BottommostLevelCompaction::kForce
;
4450 return ROCKSDB_NAMESPACE::BottommostLevelCompaction::kForceOptimized
;
4452 // undefined/default
4453 return ROCKSDB_NAMESPACE::BottommostLevelCompaction::
4454 kIfHaveCompactionFilter
;
4459 // The portal class for org.rocksdb.CompactionStopStyle
4460 class CompactionStopStyleJni
{
4462 // Returns the equivalent org.rocksdb.CompactionStopStyle for the provided
4463 // C++ ROCKSDB_NAMESPACE::CompactionStopStyle enum
4464 static jbyte
toJavaCompactionStopStyle(
4465 const ROCKSDB_NAMESPACE::CompactionStopStyle
& compaction_stop_style
) {
4466 switch(compaction_stop_style
) {
4467 case ROCKSDB_NAMESPACE::CompactionStopStyle::
4468 kCompactionStopStyleSimilarSize
:
4470 case ROCKSDB_NAMESPACE::CompactionStopStyle::
4471 kCompactionStopStyleTotalSize
:
4474 return 0x7F; // undefined
4478 // Returns the equivalent C++ ROCKSDB_NAMESPACE::CompactionStopStyle enum for
4479 // the provided Java org.rocksdb.CompactionStopStyle
4480 static ROCKSDB_NAMESPACE::CompactionStopStyle
toCppCompactionStopStyle(
4481 jbyte jcompaction_stop_style
) {
4482 switch(jcompaction_stop_style
) {
4484 return ROCKSDB_NAMESPACE::CompactionStopStyle::
4485 kCompactionStopStyleSimilarSize
;
4487 return ROCKSDB_NAMESPACE::CompactionStopStyle::
4488 kCompactionStopStyleTotalSize
;
4490 // undefined/default
4491 return ROCKSDB_NAMESPACE::CompactionStopStyle::
4492 kCompactionStopStyleSimilarSize
;
4497 // The portal class for org.rocksdb.CompressionType
4498 class CompressionTypeJni
{
4500 // Returns the equivalent org.rocksdb.CompressionType for the provided
4501 // C++ ROCKSDB_NAMESPACE::CompressionType enum
4502 static jbyte
toJavaCompressionType(
4503 const ROCKSDB_NAMESPACE::CompressionType
& compression_type
) {
4504 switch(compression_type
) {
4505 case ROCKSDB_NAMESPACE::CompressionType::kNoCompression
:
4507 case ROCKSDB_NAMESPACE::CompressionType::kSnappyCompression
:
4509 case ROCKSDB_NAMESPACE::CompressionType::kZlibCompression
:
4511 case ROCKSDB_NAMESPACE::CompressionType::kBZip2Compression
:
4513 case ROCKSDB_NAMESPACE::CompressionType::kLZ4Compression
:
4515 case ROCKSDB_NAMESPACE::CompressionType::kLZ4HCCompression
:
4517 case ROCKSDB_NAMESPACE::CompressionType::kXpressCompression
:
4519 case ROCKSDB_NAMESPACE::CompressionType::kZSTD
:
4521 case ROCKSDB_NAMESPACE::CompressionType::kDisableCompressionOption
:
4527 // Returns the equivalent C++ ROCKSDB_NAMESPACE::CompressionType enum for the
4528 // provided Java org.rocksdb.CompressionType
4529 static ROCKSDB_NAMESPACE::CompressionType
toCppCompressionType(
4530 jbyte jcompression_type
) {
4531 switch(jcompression_type
) {
4533 return ROCKSDB_NAMESPACE::CompressionType::kNoCompression
;
4535 return ROCKSDB_NAMESPACE::CompressionType::kSnappyCompression
;
4537 return ROCKSDB_NAMESPACE::CompressionType::kZlibCompression
;
4539 return ROCKSDB_NAMESPACE::CompressionType::kBZip2Compression
;
4541 return ROCKSDB_NAMESPACE::CompressionType::kLZ4Compression
;
4543 return ROCKSDB_NAMESPACE::CompressionType::kLZ4HCCompression
;
4545 return ROCKSDB_NAMESPACE::CompressionType::kXpressCompression
;
4547 return ROCKSDB_NAMESPACE::CompressionType::kZSTD
;
4550 return ROCKSDB_NAMESPACE::CompressionType::kDisableCompressionOption
;
4555 // The portal class for org.rocksdb.CompactionPriority
4556 class CompactionPriorityJni
{
4558 // Returns the equivalent org.rocksdb.CompactionPriority for the provided
4559 // C++ ROCKSDB_NAMESPACE::CompactionPri enum
4560 static jbyte
toJavaCompactionPriority(
4561 const ROCKSDB_NAMESPACE::CompactionPri
& compaction_priority
) {
4562 switch(compaction_priority
) {
4563 case ROCKSDB_NAMESPACE::CompactionPri::kByCompensatedSize
:
4565 case ROCKSDB_NAMESPACE::CompactionPri::kOldestLargestSeqFirst
:
4567 case ROCKSDB_NAMESPACE::CompactionPri::kOldestSmallestSeqFirst
:
4569 case ROCKSDB_NAMESPACE::CompactionPri::kMinOverlappingRatio
:
4572 return 0x0; // undefined
4576 // Returns the equivalent C++ ROCKSDB_NAMESPACE::CompactionPri enum for the
4577 // provided Java org.rocksdb.CompactionPriority
4578 static ROCKSDB_NAMESPACE::CompactionPri
toCppCompactionPriority(
4579 jbyte jcompaction_priority
) {
4580 switch(jcompaction_priority
) {
4582 return ROCKSDB_NAMESPACE::CompactionPri::kByCompensatedSize
;
4584 return ROCKSDB_NAMESPACE::CompactionPri::kOldestLargestSeqFirst
;
4586 return ROCKSDB_NAMESPACE::CompactionPri::kOldestSmallestSeqFirst
;
4588 return ROCKSDB_NAMESPACE::CompactionPri::kMinOverlappingRatio
;
4590 // undefined/default
4591 return ROCKSDB_NAMESPACE::CompactionPri::kByCompensatedSize
;
4596 // The portal class for org.rocksdb.AccessHint
4597 class AccessHintJni
{
4599 // Returns the equivalent org.rocksdb.AccessHint for the provided
4600 // C++ ROCKSDB_NAMESPACE::DBOptions::AccessHint enum
4601 static jbyte
toJavaAccessHint(
4602 const ROCKSDB_NAMESPACE::DBOptions::AccessHint
& access_hint
) {
4603 switch(access_hint
) {
4604 case ROCKSDB_NAMESPACE::DBOptions::AccessHint::NONE
:
4606 case ROCKSDB_NAMESPACE::DBOptions::AccessHint::NORMAL
:
4608 case ROCKSDB_NAMESPACE::DBOptions::AccessHint::SEQUENTIAL
:
4610 case ROCKSDB_NAMESPACE::DBOptions::AccessHint::WILLNEED
:
4613 // undefined/default
4618 // Returns the equivalent C++ ROCKSDB_NAMESPACE::DBOptions::AccessHint enum
4619 // for the provided Java org.rocksdb.AccessHint
4620 static ROCKSDB_NAMESPACE::DBOptions::AccessHint
toCppAccessHint(
4621 jbyte jaccess_hint
) {
4622 switch(jaccess_hint
) {
4624 return ROCKSDB_NAMESPACE::DBOptions::AccessHint::NONE
;
4626 return ROCKSDB_NAMESPACE::DBOptions::AccessHint::NORMAL
;
4628 return ROCKSDB_NAMESPACE::DBOptions::AccessHint::SEQUENTIAL
;
4630 return ROCKSDB_NAMESPACE::DBOptions::AccessHint::WILLNEED
;
4632 // undefined/default
4633 return ROCKSDB_NAMESPACE::DBOptions::AccessHint::NORMAL
;
4638 // The portal class for org.rocksdb.WALRecoveryMode
4639 class WALRecoveryModeJni
{
4641 // Returns the equivalent org.rocksdb.WALRecoveryMode for the provided
4642 // C++ ROCKSDB_NAMESPACE::WALRecoveryMode enum
4643 static jbyte
toJavaWALRecoveryMode(
4644 const ROCKSDB_NAMESPACE::WALRecoveryMode
& wal_recovery_mode
) {
4645 switch(wal_recovery_mode
) {
4646 case ROCKSDB_NAMESPACE::WALRecoveryMode::kTolerateCorruptedTailRecords
:
4648 case ROCKSDB_NAMESPACE::WALRecoveryMode::kAbsoluteConsistency
:
4650 case ROCKSDB_NAMESPACE::WALRecoveryMode::kPointInTimeRecovery
:
4652 case ROCKSDB_NAMESPACE::WALRecoveryMode::kSkipAnyCorruptedRecords
:
4655 // undefined/default
4660 // Returns the equivalent C++ ROCKSDB_NAMESPACE::WALRecoveryMode enum for the
4661 // provided Java org.rocksdb.WALRecoveryMode
4662 static ROCKSDB_NAMESPACE::WALRecoveryMode
toCppWALRecoveryMode(
4663 jbyte jwal_recovery_mode
) {
4664 switch(jwal_recovery_mode
) {
4666 return ROCKSDB_NAMESPACE::WALRecoveryMode::
4667 kTolerateCorruptedTailRecords
;
4669 return ROCKSDB_NAMESPACE::WALRecoveryMode::kAbsoluteConsistency
;
4671 return ROCKSDB_NAMESPACE::WALRecoveryMode::kPointInTimeRecovery
;
4673 return ROCKSDB_NAMESPACE::WALRecoveryMode::kSkipAnyCorruptedRecords
;
4675 // undefined/default
4676 return ROCKSDB_NAMESPACE::WALRecoveryMode::kPointInTimeRecovery
;
4681 // The portal class for org.rocksdb.TickerType
4682 class TickerTypeJni
{
4684 // Returns the equivalent org.rocksdb.TickerType for the provided
4685 // C++ ROCKSDB_NAMESPACE::Tickers enum
4686 static jbyte
toJavaTickerType(const ROCKSDB_NAMESPACE::Tickers
& tickers
) {
4688 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_MISS
:
4690 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_HIT
:
4692 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_ADD
:
4694 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_ADD_FAILURES
:
4696 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_MISS
:
4698 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_HIT
:
4700 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_ADD
:
4702 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_BYTES_INSERT
:
4704 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_BYTES_EVICT
:
4706 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_MISS
:
4708 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_HIT
:
4710 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_ADD
:
4712 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_BYTES_INSERT
:
4714 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_BYTES_EVICT
:
4716 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_MISS
:
4718 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_HIT
:
4720 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_ADD
:
4722 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_BYTES_INSERT
:
4724 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_BYTES_READ
:
4726 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_BYTES_WRITE
:
4728 case ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_USEFUL
:
4730 case ROCKSDB_NAMESPACE::Tickers::PERSISTENT_CACHE_HIT
:
4732 case ROCKSDB_NAMESPACE::Tickers::PERSISTENT_CACHE_MISS
:
4734 case ROCKSDB_NAMESPACE::Tickers::SIM_BLOCK_CACHE_HIT
:
4736 case ROCKSDB_NAMESPACE::Tickers::SIM_BLOCK_CACHE_MISS
:
4738 case ROCKSDB_NAMESPACE::Tickers::MEMTABLE_HIT
:
4740 case ROCKSDB_NAMESPACE::Tickers::MEMTABLE_MISS
:
4742 case ROCKSDB_NAMESPACE::Tickers::GET_HIT_L0
:
4744 case ROCKSDB_NAMESPACE::Tickers::GET_HIT_L1
:
4746 case ROCKSDB_NAMESPACE::Tickers::GET_HIT_L2_AND_UP
:
4748 case ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_NEWER_ENTRY
:
4750 case ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_OBSOLETE
:
4752 case ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_RANGE_DEL
:
4754 case ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_USER
:
4756 case ROCKSDB_NAMESPACE::Tickers::COMPACTION_RANGE_DEL_DROP_OBSOLETE
:
4758 case ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_WRITTEN
:
4760 case ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_READ
:
4762 case ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_UPDATED
:
4764 case ROCKSDB_NAMESPACE::Tickers::BYTES_WRITTEN
:
4766 case ROCKSDB_NAMESPACE::Tickers::BYTES_READ
:
4768 case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_SEEK
:
4770 case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_NEXT
:
4772 case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_PREV
:
4774 case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_SEEK_FOUND
:
4776 case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_NEXT_FOUND
:
4778 case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_PREV_FOUND
:
4780 case ROCKSDB_NAMESPACE::Tickers::ITER_BYTES_READ
:
4782 case ROCKSDB_NAMESPACE::Tickers::NO_FILE_CLOSES
:
4784 case ROCKSDB_NAMESPACE::Tickers::NO_FILE_OPENS
:
4786 case ROCKSDB_NAMESPACE::Tickers::NO_FILE_ERRORS
:
4788 case ROCKSDB_NAMESPACE::Tickers::STALL_L0_SLOWDOWN_MICROS
:
4790 case ROCKSDB_NAMESPACE::Tickers::STALL_MEMTABLE_COMPACTION_MICROS
:
4792 case ROCKSDB_NAMESPACE::Tickers::STALL_L0_NUM_FILES_MICROS
:
4794 case ROCKSDB_NAMESPACE::Tickers::STALL_MICROS
:
4796 case ROCKSDB_NAMESPACE::Tickers::DB_MUTEX_WAIT_MICROS
:
4798 case ROCKSDB_NAMESPACE::Tickers::RATE_LIMIT_DELAY_MILLIS
:
4800 case ROCKSDB_NAMESPACE::Tickers::NO_ITERATORS
:
4802 case ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_CALLS
:
4804 case ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_KEYS_READ
:
4806 case ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_BYTES_READ
:
4808 case ROCKSDB_NAMESPACE::Tickers::NUMBER_FILTERED_DELETES
:
4810 case ROCKSDB_NAMESPACE::Tickers::NUMBER_MERGE_FAILURES
:
4812 case ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_PREFIX_CHECKED
:
4814 case ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_PREFIX_USEFUL
:
4816 case ROCKSDB_NAMESPACE::Tickers::NUMBER_OF_RESEEKS_IN_ITERATION
:
4818 case ROCKSDB_NAMESPACE::Tickers::GET_UPDATES_SINCE_CALLS
:
4820 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_MISS
:
4822 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_HIT
:
4824 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_ADD
:
4826 case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_ADD_FAILURES
:
4828 case ROCKSDB_NAMESPACE::Tickers::WAL_FILE_SYNCED
:
4830 case ROCKSDB_NAMESPACE::Tickers::WAL_FILE_BYTES
:
4832 case ROCKSDB_NAMESPACE::Tickers::WRITE_DONE_BY_SELF
:
4834 case ROCKSDB_NAMESPACE::Tickers::WRITE_DONE_BY_OTHER
:
4836 case ROCKSDB_NAMESPACE::Tickers::WRITE_TIMEDOUT
:
4838 case ROCKSDB_NAMESPACE::Tickers::WRITE_WITH_WAL
:
4840 case ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES
:
4842 case ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES
:
4844 case ROCKSDB_NAMESPACE::Tickers::FLUSH_WRITE_BYTES
:
4846 case ROCKSDB_NAMESPACE::Tickers::NUMBER_DIRECT_LOAD_TABLE_PROPERTIES
:
4848 case ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_ACQUIRES
:
4850 case ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_RELEASES
:
4852 case ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_CLEANUPS
:
4854 case ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_COMPRESSED
:
4856 case ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_DECOMPRESSED
:
4858 case ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_NOT_COMPRESSED
:
4860 case ROCKSDB_NAMESPACE::Tickers::MERGE_OPERATION_TOTAL_TIME
:
4862 case ROCKSDB_NAMESPACE::Tickers::FILTER_OPERATION_TOTAL_TIME
:
4864 case ROCKSDB_NAMESPACE::Tickers::ROW_CACHE_HIT
:
4866 case ROCKSDB_NAMESPACE::Tickers::ROW_CACHE_MISS
:
4868 case ROCKSDB_NAMESPACE::Tickers::READ_AMP_ESTIMATE_USEFUL_BYTES
:
4870 case ROCKSDB_NAMESPACE::Tickers::READ_AMP_TOTAL_READ_BYTES
:
4872 case ROCKSDB_NAMESPACE::Tickers::NUMBER_RATE_LIMITER_DRAINS
:
4874 case ROCKSDB_NAMESPACE::Tickers::NUMBER_ITER_SKIP
:
4876 case ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_KEYS_FOUND
:
4878 case ROCKSDB_NAMESPACE::Tickers::NO_ITERATOR_CREATED
:
4879 // -0x01 to fixate the new value that incorrectly changed TICKER_ENUM_MAX.
4881 case ROCKSDB_NAMESPACE::Tickers::NO_ITERATOR_DELETED
:
4883 case ROCKSDB_NAMESPACE::Tickers::COMPACTION_OPTIMIZED_DEL_DROP_OBSOLETE
:
4885 case ROCKSDB_NAMESPACE::Tickers::COMPACTION_CANCELLED
:
4887 case ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_FULL_POSITIVE
:
4889 case ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_FULL_TRUE_POSITIVE
:
4891 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_PUT
:
4893 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_WRITE
:
4895 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_GET
:
4897 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_MULTIGET
:
4899 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_SEEK
:
4901 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_NEXT
:
4903 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_PREV
:
4905 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_KEYS_WRITTEN
:
4907 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_KEYS_READ
:
4909 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BYTES_WRITTEN
:
4911 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BYTES_READ
:
4913 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_INLINED
:
4915 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_INLINED_TTL
:
4917 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_BLOB
:
4919 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_BLOB_TTL
:
4921 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_BYTES_WRITTEN
:
4923 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_BYTES_READ
:
4925 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_SYNCED
:
4927 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EXPIRED_COUNT
:
4929 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EXPIRED_SIZE
:
4931 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EVICTED_COUNT
:
4933 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EVICTED_SIZE
:
4935 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_FILES
:
4937 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_NEW_FILES
:
4939 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_FAILURES
:
4941 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_OVERWRITTEN
:
4943 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_EXPIRED
:
4945 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_RELOCATED
:
4947 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_OVERWRITTEN
:
4949 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_EXPIRED
:
4951 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_RELOCATED
:
4953 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_NUM_FILES_EVICTED
:
4955 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_NUM_KEYS_EVICTED
:
4957 case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_BYTES_EVICTED
:
4959 case ROCKSDB_NAMESPACE::Tickers::TXN_PREPARE_MUTEX_OVERHEAD
:
4961 case ROCKSDB_NAMESPACE::Tickers::TXN_OLD_COMMIT_MAP_MUTEX_OVERHEAD
:
4963 case ROCKSDB_NAMESPACE::Tickers::TXN_DUPLICATE_KEY_OVERHEAD
:
4965 case ROCKSDB_NAMESPACE::Tickers::TXN_SNAPSHOT_MUTEX_OVERHEAD
:
4967 case ROCKSDB_NAMESPACE::Tickers::TXN_GET_TRY_AGAIN
:
4969 case ROCKSDB_NAMESPACE::Tickers::FILES_MARKED_TRASH
:
4971 case ROCKSDB_NAMESPACE::Tickers::FILES_DELETED_IMMEDIATELY
:
4973 case ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_MARKED
:
4975 case ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_PERIODIC
:
4977 case ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_TTL
:
4979 case ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_MARKED
:
4981 case ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_PERIODIC
:
4983 case ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_TTL
:
4986 case ROCKSDB_NAMESPACE::Tickers::TICKER_ENUM_MAX
:
4987 // 0x5F for backwards compatibility on current minor version.
4990 // undefined/default
4995 // Returns the equivalent C++ ROCKSDB_NAMESPACE::Tickers enum for the
4996 // provided Java org.rocksdb.TickerType
4997 static ROCKSDB_NAMESPACE::Tickers
toCppTickers(jbyte jticker_type
) {
4998 switch(jticker_type
) {
5000 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_MISS
;
5002 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_HIT
;
5004 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_ADD
;
5006 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_ADD_FAILURES
;
5008 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_MISS
;
5010 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_HIT
;
5012 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_ADD
;
5014 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_BYTES_INSERT
;
5016 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_BYTES_EVICT
;
5018 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_MISS
;
5020 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_HIT
;
5022 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_ADD
;
5024 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_BYTES_INSERT
;
5026 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_BYTES_EVICT
;
5028 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_MISS
;
5030 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_HIT
;
5032 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_ADD
;
5034 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_BYTES_INSERT
;
5036 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_BYTES_READ
;
5038 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_BYTES_WRITE
;
5040 return ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_USEFUL
;
5042 return ROCKSDB_NAMESPACE::Tickers::PERSISTENT_CACHE_HIT
;
5044 return ROCKSDB_NAMESPACE::Tickers::PERSISTENT_CACHE_MISS
;
5046 return ROCKSDB_NAMESPACE::Tickers::SIM_BLOCK_CACHE_HIT
;
5048 return ROCKSDB_NAMESPACE::Tickers::SIM_BLOCK_CACHE_MISS
;
5050 return ROCKSDB_NAMESPACE::Tickers::MEMTABLE_HIT
;
5052 return ROCKSDB_NAMESPACE::Tickers::MEMTABLE_MISS
;
5054 return ROCKSDB_NAMESPACE::Tickers::GET_HIT_L0
;
5056 return ROCKSDB_NAMESPACE::Tickers::GET_HIT_L1
;
5058 return ROCKSDB_NAMESPACE::Tickers::GET_HIT_L2_AND_UP
;
5060 return ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_NEWER_ENTRY
;
5062 return ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_OBSOLETE
;
5064 return ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_RANGE_DEL
;
5066 return ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_USER
;
5068 return ROCKSDB_NAMESPACE::Tickers::COMPACTION_RANGE_DEL_DROP_OBSOLETE
;
5070 return ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_WRITTEN
;
5072 return ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_READ
;
5074 return ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_UPDATED
;
5076 return ROCKSDB_NAMESPACE::Tickers::BYTES_WRITTEN
;
5078 return ROCKSDB_NAMESPACE::Tickers::BYTES_READ
;
5080 return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_SEEK
;
5082 return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_NEXT
;
5084 return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_PREV
;
5086 return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_SEEK_FOUND
;
5088 return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_NEXT_FOUND
;
5090 return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_PREV_FOUND
;
5092 return ROCKSDB_NAMESPACE::Tickers::ITER_BYTES_READ
;
5094 return ROCKSDB_NAMESPACE::Tickers::NO_FILE_CLOSES
;
5096 return ROCKSDB_NAMESPACE::Tickers::NO_FILE_OPENS
;
5098 return ROCKSDB_NAMESPACE::Tickers::NO_FILE_ERRORS
;
5100 return ROCKSDB_NAMESPACE::Tickers::STALL_L0_SLOWDOWN_MICROS
;
5102 return ROCKSDB_NAMESPACE::Tickers::STALL_MEMTABLE_COMPACTION_MICROS
;
5104 return ROCKSDB_NAMESPACE::Tickers::STALL_L0_NUM_FILES_MICROS
;
5106 return ROCKSDB_NAMESPACE::Tickers::STALL_MICROS
;
5108 return ROCKSDB_NAMESPACE::Tickers::DB_MUTEX_WAIT_MICROS
;
5110 return ROCKSDB_NAMESPACE::Tickers::RATE_LIMIT_DELAY_MILLIS
;
5112 return ROCKSDB_NAMESPACE::Tickers::NO_ITERATORS
;
5114 return ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_CALLS
;
5116 return ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_KEYS_READ
;
5118 return ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_BYTES_READ
;
5120 return ROCKSDB_NAMESPACE::Tickers::NUMBER_FILTERED_DELETES
;
5122 return ROCKSDB_NAMESPACE::Tickers::NUMBER_MERGE_FAILURES
;
5124 return ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_PREFIX_CHECKED
;
5126 return ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_PREFIX_USEFUL
;
5128 return ROCKSDB_NAMESPACE::Tickers::NUMBER_OF_RESEEKS_IN_ITERATION
;
5130 return ROCKSDB_NAMESPACE::Tickers::GET_UPDATES_SINCE_CALLS
;
5132 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_MISS
;
5134 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_HIT
;
5136 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_ADD
;
5138 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_ADD_FAILURES
;
5140 return ROCKSDB_NAMESPACE::Tickers::WAL_FILE_SYNCED
;
5142 return ROCKSDB_NAMESPACE::Tickers::WAL_FILE_BYTES
;
5144 return ROCKSDB_NAMESPACE::Tickers::WRITE_DONE_BY_SELF
;
5146 return ROCKSDB_NAMESPACE::Tickers::WRITE_DONE_BY_OTHER
;
5148 return ROCKSDB_NAMESPACE::Tickers::WRITE_TIMEDOUT
;
5150 return ROCKSDB_NAMESPACE::Tickers::WRITE_WITH_WAL
;
5152 return ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES
;
5154 return ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES
;
5156 return ROCKSDB_NAMESPACE::Tickers::FLUSH_WRITE_BYTES
;
5158 return ROCKSDB_NAMESPACE::Tickers::NUMBER_DIRECT_LOAD_TABLE_PROPERTIES
;
5160 return ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_ACQUIRES
;
5162 return ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_RELEASES
;
5164 return ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_CLEANUPS
;
5166 return ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_COMPRESSED
;
5168 return ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_DECOMPRESSED
;
5170 return ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_NOT_COMPRESSED
;
5172 return ROCKSDB_NAMESPACE::Tickers::MERGE_OPERATION_TOTAL_TIME
;
5174 return ROCKSDB_NAMESPACE::Tickers::FILTER_OPERATION_TOTAL_TIME
;
5176 return ROCKSDB_NAMESPACE::Tickers::ROW_CACHE_HIT
;
5178 return ROCKSDB_NAMESPACE::Tickers::ROW_CACHE_MISS
;
5180 return ROCKSDB_NAMESPACE::Tickers::READ_AMP_ESTIMATE_USEFUL_BYTES
;
5182 return ROCKSDB_NAMESPACE::Tickers::READ_AMP_TOTAL_READ_BYTES
;
5184 return ROCKSDB_NAMESPACE::Tickers::NUMBER_RATE_LIMITER_DRAINS
;
5186 return ROCKSDB_NAMESPACE::Tickers::NUMBER_ITER_SKIP
;
5188 return ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_KEYS_FOUND
;
5190 // -0x01 to fixate the new value that incorrectly changed TICKER_ENUM_MAX.
5191 return ROCKSDB_NAMESPACE::Tickers::NO_ITERATOR_CREATED
;
5193 return ROCKSDB_NAMESPACE::Tickers::NO_ITERATOR_DELETED
;
5195 return ROCKSDB_NAMESPACE::Tickers::
5196 COMPACTION_OPTIMIZED_DEL_DROP_OBSOLETE
;
5198 return ROCKSDB_NAMESPACE::Tickers::COMPACTION_CANCELLED
;
5200 return ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_FULL_POSITIVE
;
5202 return ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_FULL_TRUE_POSITIVE
;
5204 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_PUT
;
5206 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_WRITE
;
5208 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_GET
;
5210 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_MULTIGET
;
5212 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_SEEK
;
5214 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_NEXT
;
5216 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_PREV
;
5218 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_KEYS_WRITTEN
;
5220 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_KEYS_READ
;
5222 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BYTES_WRITTEN
;
5224 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BYTES_READ
;
5226 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_INLINED
;
5228 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_INLINED_TTL
;
5230 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_BLOB
;
5232 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_BLOB_TTL
;
5234 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_BYTES_WRITTEN
;
5236 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_BYTES_READ
;
5238 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_SYNCED
;
5240 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EXPIRED_COUNT
;
5242 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EXPIRED_SIZE
;
5244 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EVICTED_COUNT
;
5246 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EVICTED_SIZE
;
5248 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_FILES
;
5250 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_NEW_FILES
;
5252 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_FAILURES
;
5254 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_OVERWRITTEN
;
5256 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_EXPIRED
;
5258 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_RELOCATED
;
5260 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_OVERWRITTEN
;
5262 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_EXPIRED
;
5264 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_RELOCATED
;
5266 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_NUM_FILES_EVICTED
;
5268 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_NUM_KEYS_EVICTED
;
5270 return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_BYTES_EVICTED
;
5272 return ROCKSDB_NAMESPACE::Tickers::TXN_PREPARE_MUTEX_OVERHEAD
;
5274 return ROCKSDB_NAMESPACE::Tickers::TXN_OLD_COMMIT_MAP_MUTEX_OVERHEAD
;
5276 return ROCKSDB_NAMESPACE::Tickers::TXN_DUPLICATE_KEY_OVERHEAD
;
5278 return ROCKSDB_NAMESPACE::Tickers::TXN_SNAPSHOT_MUTEX_OVERHEAD
;
5280 return ROCKSDB_NAMESPACE::Tickers::TXN_GET_TRY_AGAIN
;
5282 return ROCKSDB_NAMESPACE::Tickers::FILES_MARKED_TRASH
;
5284 return ROCKSDB_NAMESPACE::Tickers::FILES_DELETED_IMMEDIATELY
;
5286 return ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_MARKED
;
5288 return ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_PERIODIC
;
5290 return ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_TTL
;
5292 return ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_MARKED
;
5294 return ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_PERIODIC
;
5296 return ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_TTL
;
5298 // 0x5F for backwards compatibility on current minor version.
5299 return ROCKSDB_NAMESPACE::Tickers::TICKER_ENUM_MAX
;
5302 // undefined/default
5303 return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_MISS
;
5308 // The portal class for org.rocksdb.HistogramType
5309 class HistogramTypeJni
{
5311 // Returns the equivalent org.rocksdb.HistogramType for the provided
5312 // C++ ROCKSDB_NAMESPACE::Histograms enum
5313 static jbyte
toJavaHistogramsType(
5314 const ROCKSDB_NAMESPACE::Histograms
& histograms
) {
5315 switch(histograms
) {
5316 case ROCKSDB_NAMESPACE::Histograms::DB_GET
:
5318 case ROCKSDB_NAMESPACE::Histograms::DB_WRITE
:
5320 case ROCKSDB_NAMESPACE::Histograms::COMPACTION_TIME
:
5322 case ROCKSDB_NAMESPACE::Histograms::SUBCOMPACTION_SETUP_TIME
:
5324 case ROCKSDB_NAMESPACE::Histograms::TABLE_SYNC_MICROS
:
5326 case ROCKSDB_NAMESPACE::Histograms::COMPACTION_OUTFILE_SYNC_MICROS
:
5328 case ROCKSDB_NAMESPACE::Histograms::WAL_FILE_SYNC_MICROS
:
5330 case ROCKSDB_NAMESPACE::Histograms::MANIFEST_FILE_SYNC_MICROS
:
5332 case ROCKSDB_NAMESPACE::Histograms::TABLE_OPEN_IO_MICROS
:
5334 case ROCKSDB_NAMESPACE::Histograms::DB_MULTIGET
:
5336 case ROCKSDB_NAMESPACE::Histograms::READ_BLOCK_COMPACTION_MICROS
:
5338 case ROCKSDB_NAMESPACE::Histograms::READ_BLOCK_GET_MICROS
:
5340 case ROCKSDB_NAMESPACE::Histograms::WRITE_RAW_BLOCK_MICROS
:
5342 case ROCKSDB_NAMESPACE::Histograms::STALL_L0_SLOWDOWN_COUNT
:
5344 case ROCKSDB_NAMESPACE::Histograms::STALL_MEMTABLE_COMPACTION_COUNT
:
5346 case ROCKSDB_NAMESPACE::Histograms::STALL_L0_NUM_FILES_COUNT
:
5348 case ROCKSDB_NAMESPACE::Histograms::HARD_RATE_LIMIT_DELAY_COUNT
:
5350 case ROCKSDB_NAMESPACE::Histograms::SOFT_RATE_LIMIT_DELAY_COUNT
:
5352 case ROCKSDB_NAMESPACE::Histograms::NUM_FILES_IN_SINGLE_COMPACTION
:
5354 case ROCKSDB_NAMESPACE::Histograms::DB_SEEK
:
5356 case ROCKSDB_NAMESPACE::Histograms::WRITE_STALL
:
5358 case ROCKSDB_NAMESPACE::Histograms::SST_READ_MICROS
:
5360 case ROCKSDB_NAMESPACE::Histograms::NUM_SUBCOMPACTIONS_SCHEDULED
:
5362 case ROCKSDB_NAMESPACE::Histograms::BYTES_PER_READ
:
5364 case ROCKSDB_NAMESPACE::Histograms::BYTES_PER_WRITE
:
5366 case ROCKSDB_NAMESPACE::Histograms::BYTES_PER_MULTIGET
:
5368 case ROCKSDB_NAMESPACE::Histograms::BYTES_COMPRESSED
:
5370 case ROCKSDB_NAMESPACE::Histograms::BYTES_DECOMPRESSED
:
5372 case ROCKSDB_NAMESPACE::Histograms::COMPRESSION_TIMES_NANOS
:
5374 case ROCKSDB_NAMESPACE::Histograms::DECOMPRESSION_TIMES_NANOS
:
5376 case ROCKSDB_NAMESPACE::Histograms::READ_NUM_MERGE_OPERANDS
:
5378 // 0x20 to skip 0x1F so TICKER_ENUM_MAX remains unchanged for minor version compatibility.
5379 case ROCKSDB_NAMESPACE::Histograms::FLUSH_TIME
:
5381 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_KEY_SIZE
:
5383 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_VALUE_SIZE
:
5385 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_WRITE_MICROS
:
5387 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_GET_MICROS
:
5389 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_MULTIGET_MICROS
:
5391 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_SEEK_MICROS
:
5393 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_NEXT_MICROS
:
5395 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_PREV_MICROS
:
5397 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_WRITE_MICROS
:
5399 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_READ_MICROS
:
5401 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_SYNC_MICROS
:
5403 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_GC_MICROS
:
5405 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_COMPRESSION_MICROS
:
5407 case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_DECOMPRESSION_MICROS
:
5409 case ROCKSDB_NAMESPACE::Histograms::
5410 NUM_INDEX_AND_FILTER_BLOCKS_READ_PER_LEVEL
:
5412 case ROCKSDB_NAMESPACE::Histograms::NUM_DATA_BLOCKS_READ_PER_LEVEL
:
5414 case ROCKSDB_NAMESPACE::Histograms::NUM_SST_READ_PER_LEVEL
:
5416 case ROCKSDB_NAMESPACE::Histograms::HISTOGRAM_ENUM_MAX
:
5417 // 0x1F for backwards compatibility on current minor version.
5421 // undefined/default
5426 // Returns the equivalent C++ ROCKSDB_NAMESPACE::Histograms enum for the
5427 // provided Java org.rocksdb.HistogramsType
5428 static ROCKSDB_NAMESPACE::Histograms
toCppHistograms(jbyte jhistograms_type
) {
5429 switch(jhistograms_type
) {
5431 return ROCKSDB_NAMESPACE::Histograms::DB_GET
;
5433 return ROCKSDB_NAMESPACE::Histograms::DB_WRITE
;
5435 return ROCKSDB_NAMESPACE::Histograms::COMPACTION_TIME
;
5437 return ROCKSDB_NAMESPACE::Histograms::SUBCOMPACTION_SETUP_TIME
;
5439 return ROCKSDB_NAMESPACE::Histograms::TABLE_SYNC_MICROS
;
5441 return ROCKSDB_NAMESPACE::Histograms::COMPACTION_OUTFILE_SYNC_MICROS
;
5443 return ROCKSDB_NAMESPACE::Histograms::WAL_FILE_SYNC_MICROS
;
5445 return ROCKSDB_NAMESPACE::Histograms::MANIFEST_FILE_SYNC_MICROS
;
5447 return ROCKSDB_NAMESPACE::Histograms::TABLE_OPEN_IO_MICROS
;
5449 return ROCKSDB_NAMESPACE::Histograms::DB_MULTIGET
;
5451 return ROCKSDB_NAMESPACE::Histograms::READ_BLOCK_COMPACTION_MICROS
;
5453 return ROCKSDB_NAMESPACE::Histograms::READ_BLOCK_GET_MICROS
;
5455 return ROCKSDB_NAMESPACE::Histograms::WRITE_RAW_BLOCK_MICROS
;
5457 return ROCKSDB_NAMESPACE::Histograms::STALL_L0_SLOWDOWN_COUNT
;
5459 return ROCKSDB_NAMESPACE::Histograms::STALL_MEMTABLE_COMPACTION_COUNT
;
5461 return ROCKSDB_NAMESPACE::Histograms::STALL_L0_NUM_FILES_COUNT
;
5463 return ROCKSDB_NAMESPACE::Histograms::HARD_RATE_LIMIT_DELAY_COUNT
;
5465 return ROCKSDB_NAMESPACE::Histograms::SOFT_RATE_LIMIT_DELAY_COUNT
;
5467 return ROCKSDB_NAMESPACE::Histograms::NUM_FILES_IN_SINGLE_COMPACTION
;
5469 return ROCKSDB_NAMESPACE::Histograms::DB_SEEK
;
5471 return ROCKSDB_NAMESPACE::Histograms::WRITE_STALL
;
5473 return ROCKSDB_NAMESPACE::Histograms::SST_READ_MICROS
;
5475 return ROCKSDB_NAMESPACE::Histograms::NUM_SUBCOMPACTIONS_SCHEDULED
;
5477 return ROCKSDB_NAMESPACE::Histograms::BYTES_PER_READ
;
5479 return ROCKSDB_NAMESPACE::Histograms::BYTES_PER_WRITE
;
5481 return ROCKSDB_NAMESPACE::Histograms::BYTES_PER_MULTIGET
;
5483 return ROCKSDB_NAMESPACE::Histograms::BYTES_COMPRESSED
;
5485 return ROCKSDB_NAMESPACE::Histograms::BYTES_DECOMPRESSED
;
5487 return ROCKSDB_NAMESPACE::Histograms::COMPRESSION_TIMES_NANOS
;
5489 return ROCKSDB_NAMESPACE::Histograms::DECOMPRESSION_TIMES_NANOS
;
5491 return ROCKSDB_NAMESPACE::Histograms::READ_NUM_MERGE_OPERANDS
;
5492 // 0x20 to skip 0x1F so TICKER_ENUM_MAX remains unchanged for minor version compatibility.
5494 return ROCKSDB_NAMESPACE::Histograms::FLUSH_TIME
;
5496 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_KEY_SIZE
;
5498 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_VALUE_SIZE
;
5500 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_WRITE_MICROS
;
5502 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_GET_MICROS
;
5504 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_MULTIGET_MICROS
;
5506 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_SEEK_MICROS
;
5508 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_NEXT_MICROS
;
5510 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_PREV_MICROS
;
5512 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_WRITE_MICROS
;
5514 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_READ_MICROS
;
5516 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_SYNC_MICROS
;
5518 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_GC_MICROS
;
5520 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_COMPRESSION_MICROS
;
5522 return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_DECOMPRESSION_MICROS
;
5524 return ROCKSDB_NAMESPACE::Histograms::
5525 NUM_INDEX_AND_FILTER_BLOCKS_READ_PER_LEVEL
;
5527 return ROCKSDB_NAMESPACE::Histograms::NUM_DATA_BLOCKS_READ_PER_LEVEL
;
5529 return ROCKSDB_NAMESPACE::Histograms::NUM_SST_READ_PER_LEVEL
;
5531 // 0x1F for backwards compatibility on current minor version.
5532 return ROCKSDB_NAMESPACE::Histograms::HISTOGRAM_ENUM_MAX
;
5535 // undefined/default
5536 return ROCKSDB_NAMESPACE::Histograms::DB_GET
;
5541 // The portal class for org.rocksdb.StatsLevel
5542 class StatsLevelJni
{
5544 // Returns the equivalent org.rocksdb.StatsLevel for the provided
5545 // C++ ROCKSDB_NAMESPACE::StatsLevel enum
5546 static jbyte
toJavaStatsLevel(
5547 const ROCKSDB_NAMESPACE::StatsLevel
& stats_level
) {
5548 switch(stats_level
) {
5549 case ROCKSDB_NAMESPACE::StatsLevel::kExceptDetailedTimers
:
5551 case ROCKSDB_NAMESPACE::StatsLevel::kExceptTimeForMutex
:
5553 case ROCKSDB_NAMESPACE::StatsLevel::kAll
:
5557 // undefined/default
5562 // Returns the equivalent C++ ROCKSDB_NAMESPACE::StatsLevel enum for the
5563 // provided Java org.rocksdb.StatsLevel
5564 static ROCKSDB_NAMESPACE::StatsLevel
toCppStatsLevel(jbyte jstats_level
) {
5565 switch(jstats_level
) {
5567 return ROCKSDB_NAMESPACE::StatsLevel::kExceptDetailedTimers
;
5569 return ROCKSDB_NAMESPACE::StatsLevel::kExceptTimeForMutex
;
5571 return ROCKSDB_NAMESPACE::StatsLevel::kAll
;
5574 // undefined/default
5575 return ROCKSDB_NAMESPACE::StatsLevel::kExceptDetailedTimers
;
5580 // The portal class for org.rocksdb.RateLimiterMode
5581 class RateLimiterModeJni
{
5583 // Returns the equivalent org.rocksdb.RateLimiterMode for the provided
5584 // C++ ROCKSDB_NAMESPACE::RateLimiter::Mode enum
5585 static jbyte
toJavaRateLimiterMode(
5586 const ROCKSDB_NAMESPACE::RateLimiter::Mode
& rate_limiter_mode
) {
5587 switch(rate_limiter_mode
) {
5588 case ROCKSDB_NAMESPACE::RateLimiter::Mode::kReadsOnly
:
5590 case ROCKSDB_NAMESPACE::RateLimiter::Mode::kWritesOnly
:
5592 case ROCKSDB_NAMESPACE::RateLimiter::Mode::kAllIo
:
5596 // undefined/default
5601 // Returns the equivalent C++ ROCKSDB_NAMESPACE::RateLimiter::Mode enum for
5602 // the provided Java org.rocksdb.RateLimiterMode
5603 static ROCKSDB_NAMESPACE::RateLimiter::Mode
toCppRateLimiterMode(
5604 jbyte jrate_limiter_mode
) {
5605 switch(jrate_limiter_mode
) {
5607 return ROCKSDB_NAMESPACE::RateLimiter::Mode::kReadsOnly
;
5609 return ROCKSDB_NAMESPACE::RateLimiter::Mode::kWritesOnly
;
5611 return ROCKSDB_NAMESPACE::RateLimiter::Mode::kAllIo
;
5614 // undefined/default
5615 return ROCKSDB_NAMESPACE::RateLimiter::Mode::kWritesOnly
;
5620 // The portal class for org.rocksdb.MemoryUsageType
5621 class MemoryUsageTypeJni
{
5623 // Returns the equivalent org.rocksdb.MemoryUsageType for the provided
5624 // C++ ROCKSDB_NAMESPACE::MemoryUtil::UsageType enum
5625 static jbyte
toJavaMemoryUsageType(
5626 const ROCKSDB_NAMESPACE::MemoryUtil::UsageType
& usage_type
) {
5627 switch (usage_type
) {
5628 case ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kMemTableTotal
:
5630 case ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kMemTableUnFlushed
:
5632 case ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kTableReadersTotal
:
5634 case ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kCacheTotal
:
5637 // undefined: use kNumUsageTypes
5642 // Returns the equivalent C++ ROCKSDB_NAMESPACE::MemoryUtil::UsageType enum for
5643 // the provided Java org.rocksdb.MemoryUsageType
5644 static ROCKSDB_NAMESPACE::MemoryUtil::UsageType
toCppMemoryUsageType(
5646 switch (usage_type
) {
5648 return ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kMemTableTotal
;
5650 return ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kMemTableUnFlushed
;
5652 return ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kTableReadersTotal
;
5654 return ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kCacheTotal
;
5656 // undefined/default: use kNumUsageTypes
5657 return ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kNumUsageTypes
;
5662 // The portal class for org.rocksdb.Transaction
5663 class TransactionJni
: public JavaClass
{
5666 * Get the Java Class org.rocksdb.Transaction
5668 * @param env A pointer to the Java environment
5670 * @return The Java Class or nullptr if one of the
5671 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
5672 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
5674 static jclass
getJClass(JNIEnv
* env
) {
5675 return JavaClass::getJClass(env
,
5676 "org/rocksdb/Transaction");
5680 * Create a new Java org.rocksdb.Transaction.WaitingTransactions object
5682 * @param env A pointer to the Java environment
5683 * @param jtransaction A Java org.rocksdb.Transaction object
5684 * @param column_family_id The id of the column family
5685 * @param key The key
5686 * @param transaction_ids The transaction ids
5688 * @return A reference to a Java
5689 * org.rocksdb.Transaction.WaitingTransactions object,
5690 * or nullptr if an an exception occurs
5692 static jobject
newWaitingTransactions(JNIEnv
* env
, jobject jtransaction
,
5693 const uint32_t column_family_id
, const std::string
&key
,
5694 const std::vector
<TransactionID
> &transaction_ids
) {
5695 jclass jclazz
= getJClass(env
);
5696 if(jclazz
== nullptr) {
5697 // exception occurred accessing class
5701 jmethodID mid
= env
->GetMethodID(
5702 jclazz
, "newWaitingTransactions", "(JLjava/lang/String;[J)Lorg/rocksdb/Transaction$WaitingTransactions;");
5703 if(mid
== nullptr) {
5704 // exception thrown: NoSuchMethodException or OutOfMemoryError
5708 jstring jkey
= env
->NewStringUTF(key
.c_str());
5709 if(jkey
== nullptr) {
5710 // exception thrown: OutOfMemoryError
5714 const size_t len
= transaction_ids
.size();
5715 jlongArray jtransaction_ids
= env
->NewLongArray(static_cast<jsize
>(len
));
5716 if(jtransaction_ids
== nullptr) {
5717 // exception thrown: OutOfMemoryError
5718 env
->DeleteLocalRef(jkey
);
5723 jlong
* body
= env
->GetLongArrayElements(jtransaction_ids
, &is_copy
);
5724 if(body
== nullptr) {
5725 // exception thrown: OutOfMemoryError
5726 env
->DeleteLocalRef(jkey
);
5727 env
->DeleteLocalRef(jtransaction_ids
);
5730 for(size_t i
= 0; i
< len
; ++i
) {
5731 body
[i
] = static_cast<jlong
>(transaction_ids
[i
]);
5733 env
->ReleaseLongArrayElements(jtransaction_ids
, body
,
5734 is_copy
== JNI_TRUE
? 0 : JNI_ABORT
);
5736 jobject jwaiting_transactions
= env
->CallObjectMethod(jtransaction
,
5737 mid
, static_cast<jlong
>(column_family_id
), jkey
, jtransaction_ids
);
5738 if(env
->ExceptionCheck()) {
5739 // exception thrown: InstantiationException or OutOfMemoryError
5740 env
->DeleteLocalRef(jkey
);
5741 env
->DeleteLocalRef(jtransaction_ids
);
5745 return jwaiting_transactions
;
5749 // The portal class for org.rocksdb.TransactionDB
5750 class TransactionDBJni
: public JavaClass
{
5753 * Get the Java Class org.rocksdb.TransactionDB
5755 * @param env A pointer to the Java environment
5757 * @return The Java Class or nullptr if one of the
5758 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
5759 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
5761 static jclass
getJClass(JNIEnv
* env
) {
5762 return JavaClass::getJClass(env
,
5763 "org/rocksdb/TransactionDB");
5767 * Create a new Java org.rocksdb.TransactionDB.DeadlockInfo object
5769 * @param env A pointer to the Java environment
5770 * @param jtransaction A Java org.rocksdb.Transaction object
5771 * @param column_family_id The id of the column family
5772 * @param key The key
5773 * @param transaction_ids The transaction ids
5775 * @return A reference to a Java
5776 * org.rocksdb.Transaction.WaitingTransactions object,
5777 * or nullptr if an an exception occurs
5779 static jobject
newDeadlockInfo(
5780 JNIEnv
* env
, jobject jtransaction_db
,
5781 const ROCKSDB_NAMESPACE::TransactionID transaction_id
,
5782 const uint32_t column_family_id
, const std::string
& waiting_key
,
5783 const bool exclusive
) {
5784 jclass jclazz
= getJClass(env
);
5785 if(jclazz
== nullptr) {
5786 // exception occurred accessing class
5790 jmethodID mid
= env
->GetMethodID(
5791 jclazz
, "newDeadlockInfo", "(JJLjava/lang/String;Z)Lorg/rocksdb/TransactionDB$DeadlockInfo;");
5792 if(mid
== nullptr) {
5793 // exception thrown: NoSuchMethodException or OutOfMemoryError
5797 jstring jwaiting_key
= env
->NewStringUTF(waiting_key
.c_str());
5798 if(jwaiting_key
== nullptr) {
5799 // exception thrown: OutOfMemoryError
5803 // resolve the column family id to a ColumnFamilyHandle
5804 jobject jdeadlock_info
= env
->CallObjectMethod(jtransaction_db
,
5805 mid
, transaction_id
, static_cast<jlong
>(column_family_id
),
5806 jwaiting_key
, exclusive
);
5807 if(env
->ExceptionCheck()) {
5808 // exception thrown: InstantiationException or OutOfMemoryError
5809 env
->DeleteLocalRef(jwaiting_key
);
5813 return jdeadlock_info
;
5817 // The portal class for org.rocksdb.TxnDBWritePolicy
5818 class TxnDBWritePolicyJni
{
5820 // Returns the equivalent org.rocksdb.TxnDBWritePolicy for the provided
5821 // C++ ROCKSDB_NAMESPACE::TxnDBWritePolicy enum
5822 static jbyte
toJavaTxnDBWritePolicy(
5823 const ROCKSDB_NAMESPACE::TxnDBWritePolicy
& txndb_write_policy
) {
5824 switch (txndb_write_policy
) {
5825 case ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_COMMITTED
:
5827 case ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_PREPARED
:
5829 case ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_UNPREPARED
:
5832 return 0x7F; // undefined
5836 // Returns the equivalent C++ ROCKSDB_NAMESPACE::TxnDBWritePolicy enum for the
5837 // provided Java org.rocksdb.TxnDBWritePolicy
5838 static ROCKSDB_NAMESPACE::TxnDBWritePolicy
toCppTxnDBWritePolicy(
5839 jbyte jtxndb_write_policy
) {
5840 switch (jtxndb_write_policy
) {
5842 return ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_COMMITTED
;
5844 return ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_PREPARED
;
5846 return ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_UNPREPARED
;
5848 // undefined/default
5849 return ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_COMMITTED
;
5854 // The portal class for org.rocksdb.TransactionDB.KeyLockInfo
5855 class KeyLockInfoJni
: public JavaClass
{
5858 * Get the Java Class org.rocksdb.TransactionDB.KeyLockInfo
5860 * @param env A pointer to the Java environment
5862 * @return The Java Class or nullptr if one of the
5863 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
5864 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
5866 static jclass
getJClass(JNIEnv
* env
) {
5867 return JavaClass::getJClass(env
,
5868 "org/rocksdb/TransactionDB$KeyLockInfo");
5872 * Create a new Java org.rocksdb.TransactionDB.KeyLockInfo object
5873 * with the same properties as the provided C++ ROCKSDB_NAMESPACE::KeyLockInfo
5876 * @param env A pointer to the Java environment
5877 * @param key_lock_info The ROCKSDB_NAMESPACE::KeyLockInfo object
5879 * @return A reference to a Java
5880 * org.rocksdb.TransactionDB.KeyLockInfo object,
5881 * or nullptr if an an exception occurs
5883 static jobject
construct(
5884 JNIEnv
* env
, const ROCKSDB_NAMESPACE::KeyLockInfo
& key_lock_info
) {
5885 jclass jclazz
= getJClass(env
);
5886 if(jclazz
== nullptr) {
5887 // exception occurred accessing class
5891 jmethodID mid
= env
->GetMethodID(
5892 jclazz
, "<init>", "(Ljava/lang/String;[JZ)V");
5893 if (mid
== nullptr) {
5894 // exception thrown: NoSuchMethodException or OutOfMemoryError
5898 jstring jkey
= env
->NewStringUTF(key_lock_info
.key
.c_str());
5899 if (jkey
== nullptr) {
5900 // exception thrown: OutOfMemoryError
5904 const jsize jtransaction_ids_len
= static_cast<jsize
>(key_lock_info
.ids
.size());
5905 jlongArray jtransactions_ids
= env
->NewLongArray(jtransaction_ids_len
);
5906 if (jtransactions_ids
== nullptr) {
5907 // exception thrown: OutOfMemoryError
5908 env
->DeleteLocalRef(jkey
);
5912 const jobject jkey_lock_info
= env
->NewObject(jclazz
, mid
,
5913 jkey
, jtransactions_ids
, key_lock_info
.exclusive
);
5914 if(jkey_lock_info
== nullptr) {
5915 // exception thrown: InstantiationException or OutOfMemoryError
5916 env
->DeleteLocalRef(jtransactions_ids
);
5917 env
->DeleteLocalRef(jkey
);
5921 return jkey_lock_info
;
5925 // The portal class for org.rocksdb.TransactionDB.DeadlockInfo
5926 class DeadlockInfoJni
: public JavaClass
{
5929 * Get the Java Class org.rocksdb.TransactionDB.DeadlockInfo
5931 * @param env A pointer to the Java environment
5933 * @return The Java Class or nullptr if one of the
5934 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
5935 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
5937 static jclass
getJClass(JNIEnv
* env
) {
5938 return JavaClass::getJClass(env
,"org/rocksdb/TransactionDB$DeadlockInfo");
5942 // The portal class for org.rocksdb.TransactionDB.DeadlockPath
5943 class DeadlockPathJni
: public JavaClass
{
5946 * Get the Java Class org.rocksdb.TransactionDB.DeadlockPath
5948 * @param env A pointer to the Java environment
5950 * @return The Java Class or nullptr if one of the
5951 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
5952 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
5954 static jclass
getJClass(JNIEnv
* env
) {
5955 return JavaClass::getJClass(env
,
5956 "org/rocksdb/TransactionDB$DeadlockPath");
5960 * Create a new Java org.rocksdb.TransactionDB.DeadlockPath object
5962 * @param env A pointer to the Java environment
5964 * @return A reference to a Java
5965 * org.rocksdb.TransactionDB.DeadlockPath object,
5966 * or nullptr if an an exception occurs
5968 static jobject
construct(JNIEnv
* env
,
5969 const jobjectArray jdeadlock_infos
, const bool limit_exceeded
) {
5970 jclass jclazz
= getJClass(env
);
5971 if(jclazz
== nullptr) {
5972 // exception occurred accessing class
5976 jmethodID mid
= env
->GetMethodID(
5977 jclazz
, "<init>", "([LDeadlockInfo;Z)V");
5978 if (mid
== nullptr) {
5979 // exception thrown: NoSuchMethodException or OutOfMemoryError
5983 const jobject jdeadlock_path
= env
->NewObject(jclazz
, mid
,
5984 jdeadlock_infos
, limit_exceeded
);
5985 if(jdeadlock_path
== nullptr) {
5986 // exception thrown: InstantiationException or OutOfMemoryError
5990 return jdeadlock_path
;
5994 class AbstractTableFilterJni
5995 : public RocksDBNativeClass
<
5996 const ROCKSDB_NAMESPACE::TableFilterJniCallback
*,
5997 AbstractTableFilterJni
> {
6000 * Get the Java Method: TableFilter#filter(TableProperties)
6002 * @param env A pointer to the Java environment
6004 * @return The Java Method ID or nullptr if the class or method id could not
6007 static jmethodID
getFilterMethod(JNIEnv
* env
) {
6008 jclass jclazz
= getJClass(env
);
6009 if(jclazz
== nullptr) {
6010 // exception occurred accessing class
6014 static jmethodID mid
=
6015 env
->GetMethodID(jclazz
, "filter", "(Lorg/rocksdb/TableProperties;)Z");
6016 assert(mid
!= nullptr);
6021 static jclass
getJClass(JNIEnv
* env
) {
6022 return JavaClass::getJClass(env
, "org/rocksdb/TableFilter");
6026 class TablePropertiesJni
: public JavaClass
{
6029 * Create a new Java org.rocksdb.TableProperties object.
6031 * @param env A pointer to the Java environment
6032 * @param table_properties A Cpp table properties object
6034 * @return A reference to a Java org.rocksdb.TableProperties object, or
6035 * nullptr if an an exception occurs
6037 static jobject
fromCppTableProperties(
6038 JNIEnv
* env
, const ROCKSDB_NAMESPACE::TableProperties
& table_properties
) {
6039 jclass jclazz
= getJClass(env
);
6040 if (jclazz
== nullptr) {
6041 // exception occurred accessing class
6045 jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "(JJJJJJJJJJJJJJJJJJJ[BLjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;)V");
6046 if (mid
== nullptr) {
6047 // exception thrown: NoSuchMethodException or OutOfMemoryError
6051 jbyteArray jcolumn_family_name
= ROCKSDB_NAMESPACE::JniUtil::copyBytes(
6052 env
, table_properties
.column_family_name
);
6053 if (jcolumn_family_name
== nullptr) {
6054 // exception occurred creating java string
6058 jstring jfilter_policy_name
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
6059 env
, &table_properties
.filter_policy_name
, true);
6060 if (env
->ExceptionCheck()) {
6061 // exception occurred creating java string
6062 env
->DeleteLocalRef(jcolumn_family_name
);
6066 jstring jcomparator_name
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
6067 env
, &table_properties
.comparator_name
, true);
6068 if (env
->ExceptionCheck()) {
6069 // exception occurred creating java string
6070 env
->DeleteLocalRef(jcolumn_family_name
);
6071 env
->DeleteLocalRef(jfilter_policy_name
);
6075 jstring jmerge_operator_name
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
6076 env
, &table_properties
.merge_operator_name
, true);
6077 if (env
->ExceptionCheck()) {
6078 // exception occurred creating java string
6079 env
->DeleteLocalRef(jcolumn_family_name
);
6080 env
->DeleteLocalRef(jfilter_policy_name
);
6081 env
->DeleteLocalRef(jcomparator_name
);
6085 jstring jprefix_extractor_name
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
6086 env
, &table_properties
.prefix_extractor_name
, true);
6087 if (env
->ExceptionCheck()) {
6088 // exception occurred creating java string
6089 env
->DeleteLocalRef(jcolumn_family_name
);
6090 env
->DeleteLocalRef(jfilter_policy_name
);
6091 env
->DeleteLocalRef(jcomparator_name
);
6092 env
->DeleteLocalRef(jmerge_operator_name
);
6096 jstring jproperty_collectors_names
=
6097 ROCKSDB_NAMESPACE::JniUtil::toJavaString(
6098 env
, &table_properties
.property_collectors_names
, true);
6099 if (env
->ExceptionCheck()) {
6100 // exception occurred creating java string
6101 env
->DeleteLocalRef(jcolumn_family_name
);
6102 env
->DeleteLocalRef(jfilter_policy_name
);
6103 env
->DeleteLocalRef(jcomparator_name
);
6104 env
->DeleteLocalRef(jmerge_operator_name
);
6105 env
->DeleteLocalRef(jprefix_extractor_name
);
6109 jstring jcompression_name
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
6110 env
, &table_properties
.compression_name
, true);
6111 if (env
->ExceptionCheck()) {
6112 // exception occurred creating java string
6113 env
->DeleteLocalRef(jcolumn_family_name
);
6114 env
->DeleteLocalRef(jfilter_policy_name
);
6115 env
->DeleteLocalRef(jcomparator_name
);
6116 env
->DeleteLocalRef(jmerge_operator_name
);
6117 env
->DeleteLocalRef(jprefix_extractor_name
);
6118 env
->DeleteLocalRef(jproperty_collectors_names
);
6122 // Map<String, String>
6123 jobject juser_collected_properties
=
6124 ROCKSDB_NAMESPACE::HashMapJni::fromCppMap(
6125 env
, &table_properties
.user_collected_properties
);
6126 if (env
->ExceptionCheck()) {
6127 // exception occurred creating java map
6128 env
->DeleteLocalRef(jcolumn_family_name
);
6129 env
->DeleteLocalRef(jfilter_policy_name
);
6130 env
->DeleteLocalRef(jcomparator_name
);
6131 env
->DeleteLocalRef(jmerge_operator_name
);
6132 env
->DeleteLocalRef(jprefix_extractor_name
);
6133 env
->DeleteLocalRef(jproperty_collectors_names
);
6134 env
->DeleteLocalRef(jcompression_name
);
6138 // Map<String, String>
6139 jobject jreadable_properties
= ROCKSDB_NAMESPACE::HashMapJni::fromCppMap(
6140 env
, &table_properties
.readable_properties
);
6141 if (env
->ExceptionCheck()) {
6142 // exception occurred creating java map
6143 env
->DeleteLocalRef(jcolumn_family_name
);
6144 env
->DeleteLocalRef(jfilter_policy_name
);
6145 env
->DeleteLocalRef(jcomparator_name
);
6146 env
->DeleteLocalRef(jmerge_operator_name
);
6147 env
->DeleteLocalRef(jprefix_extractor_name
);
6148 env
->DeleteLocalRef(jproperty_collectors_names
);
6149 env
->DeleteLocalRef(jcompression_name
);
6150 env
->DeleteLocalRef(juser_collected_properties
);
6154 // Map<String, Long>
6155 jobject jproperties_offsets
= ROCKSDB_NAMESPACE::HashMapJni::fromCppMap(
6156 env
, &table_properties
.properties_offsets
);
6157 if (env
->ExceptionCheck()) {
6158 // exception occurred creating java map
6159 env
->DeleteLocalRef(jcolumn_family_name
);
6160 env
->DeleteLocalRef(jfilter_policy_name
);
6161 env
->DeleteLocalRef(jcomparator_name
);
6162 env
->DeleteLocalRef(jmerge_operator_name
);
6163 env
->DeleteLocalRef(jprefix_extractor_name
);
6164 env
->DeleteLocalRef(jproperty_collectors_names
);
6165 env
->DeleteLocalRef(jcompression_name
);
6166 env
->DeleteLocalRef(juser_collected_properties
);
6167 env
->DeleteLocalRef(jreadable_properties
);
6171 jobject jtable_properties
= env
->NewObject(jclazz
, mid
,
6172 static_cast<jlong
>(table_properties
.data_size
),
6173 static_cast<jlong
>(table_properties
.index_size
),
6174 static_cast<jlong
>(table_properties
.index_partitions
),
6175 static_cast<jlong
>(table_properties
.top_level_index_size
),
6176 static_cast<jlong
>(table_properties
.index_key_is_user_key
),
6177 static_cast<jlong
>(table_properties
.index_value_is_delta_encoded
),
6178 static_cast<jlong
>(table_properties
.filter_size
),
6179 static_cast<jlong
>(table_properties
.raw_key_size
),
6180 static_cast<jlong
>(table_properties
.raw_value_size
),
6181 static_cast<jlong
>(table_properties
.num_data_blocks
),
6182 static_cast<jlong
>(table_properties
.num_entries
),
6183 static_cast<jlong
>(table_properties
.num_deletions
),
6184 static_cast<jlong
>(table_properties
.num_merge_operands
),
6185 static_cast<jlong
>(table_properties
.num_range_deletions
),
6186 static_cast<jlong
>(table_properties
.format_version
),
6187 static_cast<jlong
>(table_properties
.fixed_key_len
),
6188 static_cast<jlong
>(table_properties
.column_family_id
),
6189 static_cast<jlong
>(table_properties
.creation_time
),
6190 static_cast<jlong
>(table_properties
.oldest_key_time
),
6191 jcolumn_family_name
,
6192 jfilter_policy_name
,
6194 jmerge_operator_name
,
6195 jprefix_extractor_name
,
6196 jproperty_collectors_names
,
6198 juser_collected_properties
,
6199 jreadable_properties
,
6203 if (env
->ExceptionCheck()) {
6207 return jtable_properties
;
6211 static jclass
getJClass(JNIEnv
* env
) {
6212 return JavaClass::getJClass(env
, "org/rocksdb/TableProperties");
6216 class ColumnFamilyDescriptorJni
: public JavaClass
{
6219 * Get the Java Class org.rocksdb.ColumnFamilyDescriptor
6221 * @param env A pointer to the Java environment
6223 * @return The Java Class or nullptr if one of the
6224 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
6225 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
6227 static jclass
getJClass(JNIEnv
* env
) {
6228 return JavaClass::getJClass(env
, "org/rocksdb/ColumnFamilyDescriptor");
6232 * Create a new Java org.rocksdb.ColumnFamilyDescriptor object with the same
6233 * properties as the provided C++ ROCKSDB_NAMESPACE::ColumnFamilyDescriptor
6236 * @param env A pointer to the Java environment
6237 * @param cfd A pointer to ROCKSDB_NAMESPACE::ColumnFamilyDescriptor object
6239 * @return A reference to a Java org.rocksdb.ColumnFamilyDescriptor object, or
6240 * nullptr if an an exception occurs
6242 static jobject
construct(JNIEnv
* env
, ColumnFamilyDescriptor
* cfd
) {
6243 jbyteArray jcf_name
= JniUtil::copyBytes(env
, cfd
->name
);
6244 jobject cfopts
= ColumnFamilyOptionsJni::construct(env
, &(cfd
->options
));
6246 jclass jclazz
= getJClass(env
);
6247 if (jclazz
== nullptr) {
6248 // exception occurred accessing class
6252 jmethodID mid
= env
->GetMethodID(jclazz
, "<init>",
6253 "([BLorg/rocksdb/ColumnFamilyOptions;)V");
6254 if (mid
== nullptr) {
6255 // exception thrown: NoSuchMethodException or OutOfMemoryError
6256 env
->DeleteLocalRef(jcf_name
);
6260 jobject jcfd
= env
->NewObject(jclazz
, mid
, jcf_name
, cfopts
);
6261 if (env
->ExceptionCheck()) {
6262 env
->DeleteLocalRef(jcf_name
);
6270 * Get the Java Method: ColumnFamilyDescriptor#columnFamilyName
6272 * @param env A pointer to the Java environment
6274 * @return The Java Method ID or nullptr if the class or method id could not
6277 static jmethodID
getColumnFamilyNameMethod(JNIEnv
* env
) {
6278 jclass jclazz
= getJClass(env
);
6279 if (jclazz
== nullptr) {
6280 // exception occurred accessing class
6284 static jmethodID mid
= env
->GetMethodID(jclazz
, "columnFamilyName", "()[B");
6285 assert(mid
!= nullptr);
6290 * Get the Java Method: ColumnFamilyDescriptor#columnFamilyOptions
6292 * @param env A pointer to the Java environment
6294 * @return The Java Method ID or nullptr if the class or method id could not
6297 static jmethodID
getColumnFamilyOptionsMethod(JNIEnv
* env
) {
6298 jclass jclazz
= getJClass(env
);
6299 if (jclazz
== nullptr) {
6300 // exception occurred accessing class
6304 static jmethodID mid
= env
->GetMethodID(
6305 jclazz
, "columnFamilyOptions", "()Lorg/rocksdb/ColumnFamilyOptions;");
6306 assert(mid
!= nullptr);
6311 // The portal class for org.rocksdb.IndexType
6312 class IndexTypeJni
{
6314 // Returns the equivalent org.rocksdb.IndexType for the provided
6315 // C++ ROCKSDB_NAMESPACE::IndexType enum
6316 static jbyte
toJavaIndexType(
6317 const ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType
& index_type
) {
6318 switch (index_type
) {
6319 case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::kBinarySearch
:
6321 case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::kHashSearch
:
6323 case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
6324 kTwoLevelIndexSearch
:
6326 case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
6327 kBinarySearchWithFirstKey
:
6330 return 0x7F; // undefined
6334 // Returns the equivalent C++ ROCKSDB_NAMESPACE::IndexType enum for the
6335 // provided Java org.rocksdb.IndexType
6336 static ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType
toCppIndexType(
6337 jbyte jindex_type
) {
6338 switch (jindex_type
) {
6340 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
6343 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
6346 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
6347 kTwoLevelIndexSearch
;
6349 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
6350 kBinarySearchWithFirstKey
;
6352 // undefined/default
6353 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
6359 // The portal class for org.rocksdb.DataBlockIndexType
6360 class DataBlockIndexTypeJni
{
6362 // Returns the equivalent org.rocksdb.DataBlockIndexType for the provided
6363 // C++ ROCKSDB_NAMESPACE::DataBlockIndexType enum
6364 static jbyte
toJavaDataBlockIndexType(
6365 const ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType
&
6367 switch (index_type
) {
6368 case ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType::
6369 kDataBlockBinarySearch
:
6371 case ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType::
6372 kDataBlockBinaryAndHash
:
6375 return 0x7F; // undefined
6379 // Returns the equivalent C++ ROCKSDB_NAMESPACE::DataBlockIndexType enum for
6380 // the provided Java org.rocksdb.DataBlockIndexType
6381 static ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType
6382 toCppDataBlockIndexType(jbyte jindex_type
) {
6383 switch (jindex_type
) {
6385 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType::
6386 kDataBlockBinarySearch
;
6388 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType::
6389 kDataBlockBinaryAndHash
;
6391 // undefined/default
6392 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType::
6393 kDataBlockBinarySearch
;
6398 // The portal class for org.rocksdb.ChecksumType
6399 class ChecksumTypeJni
{
6401 // Returns the equivalent org.rocksdb.ChecksumType for the provided
6402 // C++ ROCKSDB_NAMESPACE::ChecksumType enum
6403 static jbyte
toJavaChecksumType(
6404 const ROCKSDB_NAMESPACE::ChecksumType
& checksum_type
) {
6405 switch (checksum_type
) {
6406 case ROCKSDB_NAMESPACE::ChecksumType::kNoChecksum
:
6408 case ROCKSDB_NAMESPACE::ChecksumType::kCRC32c
:
6410 case ROCKSDB_NAMESPACE::ChecksumType::kxxHash
:
6412 case ROCKSDB_NAMESPACE::ChecksumType::kxxHash64
:
6415 return 0x7F; // undefined
6419 // Returns the equivalent C++ ROCKSDB_NAMESPACE::ChecksumType enum for the
6420 // provided Java org.rocksdb.ChecksumType
6421 static ROCKSDB_NAMESPACE::ChecksumType
toCppChecksumType(
6422 jbyte jchecksum_type
) {
6423 switch (jchecksum_type
) {
6425 return ROCKSDB_NAMESPACE::ChecksumType::kNoChecksum
;
6427 return ROCKSDB_NAMESPACE::ChecksumType::kCRC32c
;
6429 return ROCKSDB_NAMESPACE::ChecksumType::kxxHash
;
6431 return ROCKSDB_NAMESPACE::ChecksumType::kxxHash64
;
6433 // undefined/default
6434 return ROCKSDB_NAMESPACE::ChecksumType::kCRC32c
;
6439 // The portal class for org.rocksdb.IndexShorteningMode
6440 class IndexShorteningModeJni
{
6442 // Returns the equivalent org.rocksdb.IndexShorteningMode for the provided
6443 // C++ ROCKSDB_NAMESPACE::IndexShorteningMode enum
6444 static jbyte
toJavaIndexShorteningMode(
6445 const ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode
&
6446 index_shortening_mode
) {
6447 switch (index_shortening_mode
) {
6448 case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
6451 case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
6454 case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
6455 kShortenSeparatorsAndSuccessor
:
6458 return 0x7F; // undefined
6462 // Returns the equivalent C++ ROCKSDB_NAMESPACE::IndexShorteningMode enum for
6463 // the provided Java org.rocksdb.IndexShorteningMode
6464 static ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode
6465 toCppIndexShorteningMode(jbyte jindex_shortening_mode
) {
6466 switch (jindex_shortening_mode
) {
6468 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
6471 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
6474 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
6475 kShortenSeparatorsAndSuccessor
;
6477 // undefined/default
6478 return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
6484 // The portal class for org.rocksdb.Priority
6487 // Returns the equivalent org.rocksdb.Priority for the provided
6488 // C++ ROCKSDB_NAMESPACE::Env::Priority enum
6489 static jbyte
toJavaPriority(
6490 const ROCKSDB_NAMESPACE::Env::Priority
& priority
) {
6492 case ROCKSDB_NAMESPACE::Env::Priority::BOTTOM
:
6494 case ROCKSDB_NAMESPACE::Env::Priority::LOW
:
6496 case ROCKSDB_NAMESPACE::Env::Priority::HIGH
:
6498 case ROCKSDB_NAMESPACE::Env::Priority::TOTAL
:
6501 return 0x7F; // undefined
6505 // Returns the equivalent C++ ROCKSDB_NAMESPACE::env::Priority enum for the
6506 // provided Java org.rocksdb.Priority
6507 static ROCKSDB_NAMESPACE::Env::Priority
toCppPriority(jbyte jpriority
) {
6508 switch (jpriority
) {
6510 return ROCKSDB_NAMESPACE::Env::Priority::BOTTOM
;
6512 return ROCKSDB_NAMESPACE::Env::Priority::LOW
;
6514 return ROCKSDB_NAMESPACE::Env::Priority::HIGH
;
6516 return ROCKSDB_NAMESPACE::Env::Priority::TOTAL
;
6518 // undefined/default
6519 return ROCKSDB_NAMESPACE::Env::Priority::LOW
;
6524 // The portal class for org.rocksdb.ThreadType
6525 class ThreadTypeJni
{
6527 // Returns the equivalent org.rocksdb.ThreadType for the provided
6528 // C++ ROCKSDB_NAMESPACE::ThreadStatus::ThreadType enum
6529 static jbyte
toJavaThreadType(
6530 const ROCKSDB_NAMESPACE::ThreadStatus::ThreadType
& thread_type
) {
6531 switch (thread_type
) {
6532 case ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::HIGH_PRIORITY
:
6534 case ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::LOW_PRIORITY
:
6536 case ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::USER
:
6538 case ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::BOTTOM_PRIORITY
:
6541 return 0x7F; // undefined
6545 // Returns the equivalent C++ ROCKSDB_NAMESPACE::ThreadStatus::ThreadType enum
6546 // for the provided Java org.rocksdb.ThreadType
6547 static ROCKSDB_NAMESPACE::ThreadStatus::ThreadType
toCppThreadType(
6548 jbyte jthread_type
) {
6549 switch (jthread_type
) {
6551 return ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::HIGH_PRIORITY
;
6553 return ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::LOW_PRIORITY
;
6555 return ThreadStatus::ThreadType::USER
;
6557 return ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::BOTTOM_PRIORITY
;
6559 // undefined/default
6560 return ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::LOW_PRIORITY
;
6565 // The portal class for org.rocksdb.OperationType
6566 class OperationTypeJni
{
6568 // Returns the equivalent org.rocksdb.OperationType for the provided
6569 // C++ ROCKSDB_NAMESPACE::ThreadStatus::OperationType enum
6570 static jbyte
toJavaOperationType(
6571 const ROCKSDB_NAMESPACE::ThreadStatus::OperationType
& operation_type
) {
6572 switch (operation_type
) {
6573 case ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_UNKNOWN
:
6575 case ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_COMPACTION
:
6577 case ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_FLUSH
:
6580 return 0x7F; // undefined
6584 // Returns the equivalent C++ ROCKSDB_NAMESPACE::ThreadStatus::OperationType
6585 // enum for the provided Java org.rocksdb.OperationType
6586 static ROCKSDB_NAMESPACE::ThreadStatus::OperationType
toCppOperationType(
6587 jbyte joperation_type
) {
6588 switch (joperation_type
) {
6590 return ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_UNKNOWN
;
6592 return ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_COMPACTION
;
6594 return ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_FLUSH
;
6596 // undefined/default
6597 return ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_UNKNOWN
;
6602 // The portal class for org.rocksdb.OperationStage
6603 class OperationStageJni
{
6605 // Returns the equivalent org.rocksdb.OperationStage for the provided
6606 // C++ ROCKSDB_NAMESPACE::ThreadStatus::OperationStage enum
6607 static jbyte
toJavaOperationStage(
6608 const ROCKSDB_NAMESPACE::ThreadStatus::OperationStage
& operation_stage
) {
6609 switch (operation_stage
) {
6610 case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::STAGE_UNKNOWN
:
6612 case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::STAGE_FLUSH_RUN
:
6614 case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6615 STAGE_FLUSH_WRITE_L0
:
6617 case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6618 STAGE_COMPACTION_PREPARE
:
6620 case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6621 STAGE_COMPACTION_RUN
:
6623 case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6624 STAGE_COMPACTION_PROCESS_KV
:
6626 case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6627 STAGE_COMPACTION_INSTALL
:
6629 case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6630 STAGE_COMPACTION_SYNC_FILE
:
6632 case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6633 STAGE_PICK_MEMTABLES_TO_FLUSH
:
6635 case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6636 STAGE_MEMTABLE_ROLLBACK
:
6638 case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6639 STAGE_MEMTABLE_INSTALL_FLUSH_RESULTS
:
6642 return 0x7F; // undefined
6646 // Returns the equivalent C++ ROCKSDB_NAMESPACE::ThreadStatus::OperationStage
6647 // enum for the provided Java org.rocksdb.OperationStage
6648 static ROCKSDB_NAMESPACE::ThreadStatus::OperationStage
toCppOperationStage(
6649 jbyte joperation_stage
) {
6650 switch (joperation_stage
) {
6652 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::STAGE_UNKNOWN
;
6654 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::STAGE_FLUSH_RUN
;
6656 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6657 STAGE_FLUSH_WRITE_L0
;
6659 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6660 STAGE_COMPACTION_PREPARE
;
6662 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6663 STAGE_COMPACTION_RUN
;
6665 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6666 STAGE_COMPACTION_PROCESS_KV
;
6668 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6669 STAGE_COMPACTION_INSTALL
;
6671 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6672 STAGE_COMPACTION_SYNC_FILE
;
6674 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6675 STAGE_PICK_MEMTABLES_TO_FLUSH
;
6677 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6678 STAGE_MEMTABLE_ROLLBACK
;
6680 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
6681 STAGE_MEMTABLE_INSTALL_FLUSH_RESULTS
;
6683 // undefined/default
6684 return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::STAGE_UNKNOWN
;
6689 // The portal class for org.rocksdb.StateType
6690 class StateTypeJni
{
6692 // Returns the equivalent org.rocksdb.StateType for the provided
6693 // C++ ROCKSDB_NAMESPACE::ThreadStatus::StateType enum
6694 static jbyte
toJavaStateType(
6695 const ROCKSDB_NAMESPACE::ThreadStatus::StateType
& state_type
) {
6696 switch (state_type
) {
6697 case ROCKSDB_NAMESPACE::ThreadStatus::StateType::STATE_UNKNOWN
:
6699 case ROCKSDB_NAMESPACE::ThreadStatus::StateType::STATE_MUTEX_WAIT
:
6702 return 0x7F; // undefined
6706 // Returns the equivalent C++ ROCKSDB_NAMESPACE::ThreadStatus::StateType enum
6707 // for the provided Java org.rocksdb.StateType
6708 static ROCKSDB_NAMESPACE::ThreadStatus::StateType
toCppStateType(
6709 jbyte jstate_type
) {
6710 switch (jstate_type
) {
6712 return ROCKSDB_NAMESPACE::ThreadStatus::StateType::STATE_UNKNOWN
;
6714 return ROCKSDB_NAMESPACE::ThreadStatus::StateType::STATE_MUTEX_WAIT
;
6716 // undefined/default
6717 return ROCKSDB_NAMESPACE::ThreadStatus::StateType::STATE_UNKNOWN
;
6722 // The portal class for org.rocksdb.ThreadStatus
6723 class ThreadStatusJni
: public JavaClass
{
6726 * Get the Java Class org.rocksdb.ThreadStatus
6728 * @param env A pointer to the Java environment
6730 * @return The Java Class or nullptr if one of the
6731 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
6732 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
6734 static jclass
getJClass(JNIEnv
* env
) {
6735 return JavaClass::getJClass(env
,
6736 "org/rocksdb/ThreadStatus");
6740 * Create a new Java org.rocksdb.ThreadStatus object with the same
6741 * properties as the provided C++ ROCKSDB_NAMESPACE::ThreadStatus object
6743 * @param env A pointer to the Java environment
6744 * @param thread_status A pointer to ROCKSDB_NAMESPACE::ThreadStatus object
6746 * @return A reference to a Java org.rocksdb.ColumnFamilyOptions object, or
6747 * nullptr if an an exception occurs
6749 static jobject
construct(
6750 JNIEnv
* env
, const ROCKSDB_NAMESPACE::ThreadStatus
* thread_status
) {
6751 jclass jclazz
= getJClass(env
);
6752 if(jclazz
== nullptr) {
6753 // exception occurred accessing class
6757 jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "(JBLjava/lang/String;Ljava/lang/String;BJB[JB)V");
6758 if (mid
== nullptr) {
6759 // exception thrown: NoSuchMethodException or OutOfMemoryError
6764 JniUtil::toJavaString(env
, &(thread_status
->db_name
), true);
6765 if (env
->ExceptionCheck()) {
6766 // an error occurred
6771 JniUtil::toJavaString(env
, &(thread_status
->cf_name
), true);
6772 if (env
->ExceptionCheck()) {
6773 // an error occurred
6774 env
->DeleteLocalRef(jdb_name
);
6779 const jsize len
= static_cast<jsize
>(
6780 ROCKSDB_NAMESPACE::ThreadStatus::kNumOperationProperties
);
6781 jlongArray joperation_properties
=
6782 env
->NewLongArray(len
);
6783 if (joperation_properties
== nullptr) {
6784 // an exception occurred
6785 env
->DeleteLocalRef(jdb_name
);
6786 env
->DeleteLocalRef(jcf_name
);
6790 jlong
* body
= env
->GetLongArrayElements(joperation_properties
, &is_copy
);
6791 if (body
== nullptr) {
6792 // exception thrown: OutOfMemoryError
6793 env
->DeleteLocalRef(jdb_name
);
6794 env
->DeleteLocalRef(jcf_name
);
6795 env
->DeleteLocalRef(joperation_properties
);
6798 for (size_t i
= 0; i
< len
; ++i
) {
6799 body
[i
] = static_cast<jlong
>(thread_status
->op_properties
[i
]);
6801 env
->ReleaseLongArrayElements(joperation_properties
, body
,
6802 is_copy
== JNI_TRUE
? 0 : JNI_ABORT
);
6804 jobject jcfd
= env
->NewObject(jclazz
, mid
,
6805 static_cast<jlong
>(thread_status
->thread_id
),
6806 ThreadTypeJni::toJavaThreadType(thread_status
->thread_type
),
6809 OperationTypeJni::toJavaOperationType(thread_status
->operation_type
),
6810 static_cast<jlong
>(thread_status
->op_elapsed_micros
),
6811 OperationStageJni::toJavaOperationStage(thread_status
->operation_stage
),
6812 joperation_properties
,
6813 StateTypeJni::toJavaStateType(thread_status
->state_type
));
6814 if (env
->ExceptionCheck()) {
6815 // exception occurred
6816 env
->DeleteLocalRef(jdb_name
);
6817 env
->DeleteLocalRef(jcf_name
);
6818 env
->DeleteLocalRef(joperation_properties
);
6823 env
->DeleteLocalRef(jdb_name
);
6824 env
->DeleteLocalRef(jcf_name
);
6825 env
->DeleteLocalRef(joperation_properties
);
6831 // The portal class for org.rocksdb.CompactionStyle
6832 class CompactionStyleJni
{
6834 // Returns the equivalent org.rocksdb.CompactionStyle for the provided
6835 // C++ ROCKSDB_NAMESPACE::CompactionStyle enum
6836 static jbyte
toJavaCompactionStyle(
6837 const ROCKSDB_NAMESPACE::CompactionStyle
& compaction_style
) {
6838 switch (compaction_style
) {
6839 case ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleLevel
:
6841 case ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleUniversal
:
6843 case ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleFIFO
:
6845 case ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleNone
:
6848 return 0x7F; // undefined
6852 // Returns the equivalent C++ ROCKSDB_NAMESPACE::CompactionStyle enum for the
6853 // provided Java org.rocksdb.CompactionStyle
6854 static ROCKSDB_NAMESPACE::CompactionStyle
toCppCompactionStyle(
6855 jbyte jcompaction_style
) {
6856 switch (jcompaction_style
) {
6858 return ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleLevel
;
6860 return ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleUniversal
;
6862 return ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleFIFO
;
6864 return ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleNone
;
6866 // undefined/default
6867 return ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleLevel
;
6872 // The portal class for org.rocksdb.CompactionReason
6873 class CompactionReasonJni
{
6875 // Returns the equivalent org.rocksdb.CompactionReason for the provided
6876 // C++ ROCKSDB_NAMESPACE::CompactionReason enum
6877 static jbyte
toJavaCompactionReason(
6878 const ROCKSDB_NAMESPACE::CompactionReason
& compaction_reason
) {
6879 switch (compaction_reason
) {
6880 case ROCKSDB_NAMESPACE::CompactionReason::kUnknown
:
6882 case ROCKSDB_NAMESPACE::CompactionReason::kLevelL0FilesNum
:
6884 case ROCKSDB_NAMESPACE::CompactionReason::kLevelMaxLevelSize
:
6886 case ROCKSDB_NAMESPACE::CompactionReason::kUniversalSizeAmplification
:
6888 case ROCKSDB_NAMESPACE::CompactionReason::kUniversalSizeRatio
:
6890 case ROCKSDB_NAMESPACE::CompactionReason::kUniversalSortedRunNum
:
6892 case ROCKSDB_NAMESPACE::CompactionReason::kFIFOMaxSize
:
6894 case ROCKSDB_NAMESPACE::CompactionReason::kFIFOReduceNumFiles
:
6896 case ROCKSDB_NAMESPACE::CompactionReason::kFIFOTtl
:
6898 case ROCKSDB_NAMESPACE::CompactionReason::kManualCompaction
:
6900 case ROCKSDB_NAMESPACE::CompactionReason::kFilesMarkedForCompaction
:
6902 case ROCKSDB_NAMESPACE::CompactionReason::kBottommostFiles
:
6904 case ROCKSDB_NAMESPACE::CompactionReason::kTtl
:
6906 case ROCKSDB_NAMESPACE::CompactionReason::kFlush
:
6908 case ROCKSDB_NAMESPACE::CompactionReason::kExternalSstIngestion
:
6911 return 0x7F; // undefined
6915 // Returns the equivalent C++ ROCKSDB_NAMESPACE::CompactionReason enum for the
6916 // provided Java org.rocksdb.CompactionReason
6917 static ROCKSDB_NAMESPACE::CompactionReason
toCppCompactionReason(
6918 jbyte jcompaction_reason
) {
6919 switch (jcompaction_reason
) {
6921 return ROCKSDB_NAMESPACE::CompactionReason::kUnknown
;
6923 return ROCKSDB_NAMESPACE::CompactionReason::kLevelL0FilesNum
;
6925 return ROCKSDB_NAMESPACE::CompactionReason::kLevelMaxLevelSize
;
6927 return ROCKSDB_NAMESPACE::CompactionReason::kUniversalSizeAmplification
;
6929 return ROCKSDB_NAMESPACE::CompactionReason::kUniversalSizeRatio
;
6931 return ROCKSDB_NAMESPACE::CompactionReason::kUniversalSortedRunNum
;
6933 return ROCKSDB_NAMESPACE::CompactionReason::kFIFOMaxSize
;
6935 return ROCKSDB_NAMESPACE::CompactionReason::kFIFOReduceNumFiles
;
6937 return ROCKSDB_NAMESPACE::CompactionReason::kFIFOTtl
;
6939 return ROCKSDB_NAMESPACE::CompactionReason::kManualCompaction
;
6941 return ROCKSDB_NAMESPACE::CompactionReason::kFilesMarkedForCompaction
;
6943 return ROCKSDB_NAMESPACE::CompactionReason::kBottommostFiles
;
6945 return ROCKSDB_NAMESPACE::CompactionReason::kTtl
;
6947 return ROCKSDB_NAMESPACE::CompactionReason::kFlush
;
6949 return ROCKSDB_NAMESPACE::CompactionReason::kExternalSstIngestion
;
6951 // undefined/default
6952 return ROCKSDB_NAMESPACE::CompactionReason::kUnknown
;
6957 // The portal class for org.rocksdb.WalFileType
6958 class WalFileTypeJni
{
6960 // Returns the equivalent org.rocksdb.WalFileType for the provided
6961 // C++ ROCKSDB_NAMESPACE::WalFileType enum
6962 static jbyte
toJavaWalFileType(
6963 const ROCKSDB_NAMESPACE::WalFileType
& wal_file_type
) {
6964 switch (wal_file_type
) {
6965 case ROCKSDB_NAMESPACE::WalFileType::kArchivedLogFile
:
6967 case ROCKSDB_NAMESPACE::WalFileType::kAliveLogFile
:
6970 return 0x7F; // undefined
6974 // Returns the equivalent C++ ROCKSDB_NAMESPACE::WalFileType enum for the
6975 // provided Java org.rocksdb.WalFileType
6976 static ROCKSDB_NAMESPACE::WalFileType
toCppWalFileType(jbyte jwal_file_type
) {
6977 switch (jwal_file_type
) {
6979 return ROCKSDB_NAMESPACE::WalFileType::kArchivedLogFile
;
6981 return ROCKSDB_NAMESPACE::WalFileType::kAliveLogFile
;
6983 // undefined/default
6984 return ROCKSDB_NAMESPACE::WalFileType::kAliveLogFile
;
6989 class LogFileJni
: public JavaClass
{
6992 * Create a new Java org.rocksdb.LogFile object.
6994 * @param env A pointer to the Java environment
6995 * @param log_file A Cpp log file object
6997 * @return A reference to a Java org.rocksdb.LogFile object, or
6998 * nullptr if an an exception occurs
7000 static jobject
fromCppLogFile(JNIEnv
* env
,
7001 ROCKSDB_NAMESPACE::LogFile
* log_file
) {
7002 jclass jclazz
= getJClass(env
);
7003 if (jclazz
== nullptr) {
7004 // exception occurred accessing class
7008 jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "(Ljava/lang/String;JBJJ)V");
7009 if (mid
== nullptr) {
7010 // exception thrown: NoSuchMethodException or OutOfMemoryError
7014 std::string path_name
= log_file
->PathName();
7015 jstring jpath_name
=
7016 ROCKSDB_NAMESPACE::JniUtil::toJavaString(env
, &path_name
, true);
7017 if (env
->ExceptionCheck()) {
7018 // exception occurred creating java string
7022 jobject jlog_file
= env
->NewObject(
7023 jclazz
, mid
, jpath_name
, static_cast<jlong
>(log_file
->LogNumber()),
7024 ROCKSDB_NAMESPACE::WalFileTypeJni::toJavaWalFileType(log_file
->Type()),
7025 static_cast<jlong
>(log_file
->StartSequence()),
7026 static_cast<jlong
>(log_file
->SizeFileBytes()));
7028 if (env
->ExceptionCheck()) {
7029 env
->DeleteLocalRef(jpath_name
);
7034 env
->DeleteLocalRef(jpath_name
);
7039 static jclass
getJClass(JNIEnv
* env
) {
7040 return JavaClass::getJClass(env
, "org/rocksdb/LogFile");
7044 class LiveFileMetaDataJni
: public JavaClass
{
7047 * Create a new Java org.rocksdb.LiveFileMetaData object.
7049 * @param env A pointer to the Java environment
7050 * @param live_file_meta_data A Cpp live file meta data object
7052 * @return A reference to a Java org.rocksdb.LiveFileMetaData object, or
7053 * nullptr if an an exception occurs
7055 static jobject
fromCppLiveFileMetaData(
7056 JNIEnv
* env
, ROCKSDB_NAMESPACE::LiveFileMetaData
* live_file_meta_data
) {
7057 jclass jclazz
= getJClass(env
);
7058 if (jclazz
== nullptr) {
7059 // exception occurred accessing class
7063 jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "([BILjava/lang/String;Ljava/lang/String;JJJ[B[BJZJJ)V");
7064 if (mid
== nullptr) {
7065 // exception thrown: NoSuchMethodException or OutOfMemoryError
7069 jbyteArray jcolumn_family_name
= ROCKSDB_NAMESPACE::JniUtil::copyBytes(
7070 env
, live_file_meta_data
->column_family_name
);
7071 if (jcolumn_family_name
== nullptr) {
7072 // exception occurred creating java byte array
7076 jstring jfile_name
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
7077 env
, &live_file_meta_data
->name
, true);
7078 if (env
->ExceptionCheck()) {
7079 // exception occurred creating java string
7080 env
->DeleteLocalRef(jcolumn_family_name
);
7084 jstring jpath
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
7085 env
, &live_file_meta_data
->db_path
, true);
7086 if (env
->ExceptionCheck()) {
7087 // exception occurred creating java string
7088 env
->DeleteLocalRef(jcolumn_family_name
);
7089 env
->DeleteLocalRef(jfile_name
);
7093 jbyteArray jsmallest_key
= ROCKSDB_NAMESPACE::JniUtil::copyBytes(
7094 env
, live_file_meta_data
->smallestkey
);
7095 if (jsmallest_key
== nullptr) {
7096 // exception occurred creating java byte array
7097 env
->DeleteLocalRef(jcolumn_family_name
);
7098 env
->DeleteLocalRef(jfile_name
);
7099 env
->DeleteLocalRef(jpath
);
7103 jbyteArray jlargest_key
= ROCKSDB_NAMESPACE::JniUtil::copyBytes(
7104 env
, live_file_meta_data
->largestkey
);
7105 if (jlargest_key
== nullptr) {
7106 // exception occurred creating java byte array
7107 env
->DeleteLocalRef(jcolumn_family_name
);
7108 env
->DeleteLocalRef(jfile_name
);
7109 env
->DeleteLocalRef(jpath
);
7110 env
->DeleteLocalRef(jsmallest_key
);
7114 jobject jlive_file_meta_data
= env
->NewObject(jclazz
, mid
,
7115 jcolumn_family_name
,
7116 static_cast<jint
>(live_file_meta_data
->level
),
7119 static_cast<jlong
>(live_file_meta_data
->size
),
7120 static_cast<jlong
>(live_file_meta_data
->smallest_seqno
),
7121 static_cast<jlong
>(live_file_meta_data
->largest_seqno
),
7124 static_cast<jlong
>(live_file_meta_data
->num_reads_sampled
),
7125 static_cast<jboolean
>(live_file_meta_data
->being_compacted
),
7126 static_cast<jlong
>(live_file_meta_data
->num_entries
),
7127 static_cast<jlong
>(live_file_meta_data
->num_deletions
)
7130 if (env
->ExceptionCheck()) {
7131 env
->DeleteLocalRef(jcolumn_family_name
);
7132 env
->DeleteLocalRef(jfile_name
);
7133 env
->DeleteLocalRef(jpath
);
7134 env
->DeleteLocalRef(jsmallest_key
);
7135 env
->DeleteLocalRef(jlargest_key
);
7140 env
->DeleteLocalRef(jcolumn_family_name
);
7141 env
->DeleteLocalRef(jfile_name
);
7142 env
->DeleteLocalRef(jpath
);
7143 env
->DeleteLocalRef(jsmallest_key
);
7144 env
->DeleteLocalRef(jlargest_key
);
7146 return jlive_file_meta_data
;
7149 static jclass
getJClass(JNIEnv
* env
) {
7150 return JavaClass::getJClass(env
, "org/rocksdb/LiveFileMetaData");
7154 class SstFileMetaDataJni
: public JavaClass
{
7157 * Create a new Java org.rocksdb.SstFileMetaData object.
7159 * @param env A pointer to the Java environment
7160 * @param sst_file_meta_data A Cpp sst file meta data object
7162 * @return A reference to a Java org.rocksdb.SstFileMetaData object, or
7163 * nullptr if an an exception occurs
7165 static jobject
fromCppSstFileMetaData(
7167 const ROCKSDB_NAMESPACE::SstFileMetaData
* sst_file_meta_data
) {
7168 jclass jclazz
= getJClass(env
);
7169 if (jclazz
== nullptr) {
7170 // exception occurred accessing class
7174 jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "(Ljava/lang/String;Ljava/lang/String;JJJ[B[BJZJJ)V");
7175 if (mid
== nullptr) {
7176 // exception thrown: NoSuchMethodException or OutOfMemoryError
7180 jstring jfile_name
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
7181 env
, &sst_file_meta_data
->name
, true);
7182 if (jfile_name
== nullptr) {
7183 // exception occurred creating java byte array
7187 jstring jpath
= ROCKSDB_NAMESPACE::JniUtil::toJavaString(
7188 env
, &sst_file_meta_data
->db_path
, true);
7189 if (jpath
== nullptr) {
7190 // exception occurred creating java byte array
7191 env
->DeleteLocalRef(jfile_name
);
7195 jbyteArray jsmallest_key
= ROCKSDB_NAMESPACE::JniUtil::copyBytes(
7196 env
, sst_file_meta_data
->smallestkey
);
7197 if (jsmallest_key
== nullptr) {
7198 // exception occurred creating java byte array
7199 env
->DeleteLocalRef(jfile_name
);
7200 env
->DeleteLocalRef(jpath
);
7204 jbyteArray jlargest_key
= ROCKSDB_NAMESPACE::JniUtil::copyBytes(
7205 env
, sst_file_meta_data
->largestkey
);
7206 if (jlargest_key
== nullptr) {
7207 // exception occurred creating java byte array
7208 env
->DeleteLocalRef(jfile_name
);
7209 env
->DeleteLocalRef(jpath
);
7210 env
->DeleteLocalRef(jsmallest_key
);
7214 jobject jsst_file_meta_data
= env
->NewObject(jclazz
, mid
,
7217 static_cast<jlong
>(sst_file_meta_data
->size
),
7218 static_cast<jint
>(sst_file_meta_data
->smallest_seqno
),
7219 static_cast<jlong
>(sst_file_meta_data
->largest_seqno
),
7222 static_cast<jlong
>(sst_file_meta_data
->num_reads_sampled
),
7223 static_cast<jboolean
>(sst_file_meta_data
->being_compacted
),
7224 static_cast<jlong
>(sst_file_meta_data
->num_entries
),
7225 static_cast<jlong
>(sst_file_meta_data
->num_deletions
)
7228 if (env
->ExceptionCheck()) {
7229 env
->DeleteLocalRef(jfile_name
);
7230 env
->DeleteLocalRef(jpath
);
7231 env
->DeleteLocalRef(jsmallest_key
);
7232 env
->DeleteLocalRef(jlargest_key
);
7237 env
->DeleteLocalRef(jfile_name
);
7238 env
->DeleteLocalRef(jpath
);
7239 env
->DeleteLocalRef(jsmallest_key
);
7240 env
->DeleteLocalRef(jlargest_key
);
7242 return jsst_file_meta_data
;
7245 static jclass
getJClass(JNIEnv
* env
) {
7246 return JavaClass::getJClass(env
, "org/rocksdb/SstFileMetaData");
7250 class LevelMetaDataJni
: public JavaClass
{
7253 * Create a new Java org.rocksdb.LevelMetaData object.
7255 * @param env A pointer to the Java environment
7256 * @param level_meta_data A Cpp level meta data object
7258 * @return A reference to a Java org.rocksdb.LevelMetaData object, or
7259 * nullptr if an an exception occurs
7261 static jobject
fromCppLevelMetaData(
7262 JNIEnv
* env
, const ROCKSDB_NAMESPACE::LevelMetaData
* level_meta_data
) {
7263 jclass jclazz
= getJClass(env
);
7264 if (jclazz
== nullptr) {
7265 // exception occurred accessing class
7269 jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "(IJ[Lorg/rocksdb/SstFileMetaData;)V");
7270 if (mid
== nullptr) {
7271 // exception thrown: NoSuchMethodException or OutOfMemoryError
7276 static_cast<jsize
>(level_meta_data
->files
.size());
7277 jobjectArray jfiles
= env
->NewObjectArray(jlen
, SstFileMetaDataJni::getJClass(env
), nullptr);
7278 if (jfiles
== nullptr) {
7279 // exception thrown: OutOfMemoryError
7284 for (auto it
= level_meta_data
->files
.begin();
7285 it
!= level_meta_data
->files
.end(); ++it
) {
7286 jobject jfile
= SstFileMetaDataJni::fromCppSstFileMetaData(env
, &(*it
));
7287 if (jfile
== nullptr) {
7288 // exception occurred
7289 env
->DeleteLocalRef(jfiles
);
7292 env
->SetObjectArrayElement(jfiles
, i
++, jfile
);
7295 jobject jlevel_meta_data
= env
->NewObject(jclazz
, mid
,
7296 static_cast<jint
>(level_meta_data
->level
),
7297 static_cast<jlong
>(level_meta_data
->size
),
7301 if (env
->ExceptionCheck()) {
7302 env
->DeleteLocalRef(jfiles
);
7307 env
->DeleteLocalRef(jfiles
);
7309 return jlevel_meta_data
;
7312 static jclass
getJClass(JNIEnv
* env
) {
7313 return JavaClass::getJClass(env
, "org/rocksdb/LevelMetaData");
7317 class ColumnFamilyMetaDataJni
: public JavaClass
{
7320 * Create a new Java org.rocksdb.ColumnFamilyMetaData object.
7322 * @param env A pointer to the Java environment
7323 * @param column_famly_meta_data A Cpp live file meta data object
7325 * @return A reference to a Java org.rocksdb.ColumnFamilyMetaData object, or
7326 * nullptr if an an exception occurs
7328 static jobject
fromCppColumnFamilyMetaData(
7330 const ROCKSDB_NAMESPACE::ColumnFamilyMetaData
* column_famly_meta_data
) {
7331 jclass jclazz
= getJClass(env
);
7332 if (jclazz
== nullptr) {
7333 // exception occurred accessing class
7337 jmethodID mid
= env
->GetMethodID(jclazz
, "<init>", "(JJ[B[Lorg/rocksdb/LevelMetaData;)V");
7338 if (mid
== nullptr) {
7339 // exception thrown: NoSuchMethodException or OutOfMemoryError
7343 jbyteArray jname
= ROCKSDB_NAMESPACE::JniUtil::copyBytes(
7344 env
, column_famly_meta_data
->name
);
7345 if (jname
== nullptr) {
7346 // exception occurred creating java byte array
7351 static_cast<jsize
>(column_famly_meta_data
->levels
.size());
7352 jobjectArray jlevels
= env
->NewObjectArray(jlen
, LevelMetaDataJni::getJClass(env
), nullptr);
7353 if(jlevels
== nullptr) {
7354 // exception thrown: OutOfMemoryError
7355 env
->DeleteLocalRef(jname
);
7360 for (auto it
= column_famly_meta_data
->levels
.begin();
7361 it
!= column_famly_meta_data
->levels
.end(); ++it
) {
7362 jobject jlevel
= LevelMetaDataJni::fromCppLevelMetaData(env
, &(*it
));
7363 if (jlevel
== nullptr) {
7364 // exception occurred
7365 env
->DeleteLocalRef(jname
);
7366 env
->DeleteLocalRef(jlevels
);
7369 env
->SetObjectArrayElement(jlevels
, i
++, jlevel
);
7372 jobject jcolumn_family_meta_data
= env
->NewObject(jclazz
, mid
,
7373 static_cast<jlong
>(column_famly_meta_data
->size
),
7374 static_cast<jlong
>(column_famly_meta_data
->file_count
),
7379 if (env
->ExceptionCheck()) {
7380 env
->DeleteLocalRef(jname
);
7381 env
->DeleteLocalRef(jlevels
);
7386 env
->DeleteLocalRef(jname
);
7387 env
->DeleteLocalRef(jlevels
);
7389 return jcolumn_family_meta_data
;
7392 static jclass
getJClass(JNIEnv
* env
) {
7393 return JavaClass::getJClass(env
, "org/rocksdb/ColumnFamilyMetaData");
7397 // The portal class for org.rocksdb.AbstractTraceWriter
7398 class AbstractTraceWriterJni
7399 : public RocksDBNativeClass
<
7400 const ROCKSDB_NAMESPACE::TraceWriterJniCallback
*,
7401 AbstractTraceWriterJni
> {
7404 * Get the Java Class org.rocksdb.AbstractTraceWriter
7406 * @param env A pointer to the Java environment
7408 * @return The Java Class or nullptr if one of the
7409 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
7410 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
7412 static jclass
getJClass(JNIEnv
* env
) {
7413 return RocksDBNativeClass::getJClass(env
,
7414 "org/rocksdb/AbstractTraceWriter");
7418 * Get the Java Method: AbstractTraceWriter#write
7420 * @param env A pointer to the Java environment
7422 * @return The Java Method ID or nullptr if the class or method id could not
7425 static jmethodID
getWriteProxyMethodId(JNIEnv
* env
) {
7426 jclass jclazz
= getJClass(env
);
7427 if(jclazz
== nullptr) {
7428 // exception occurred accessing class
7432 static jmethodID mid
= env
->GetMethodID(
7433 jclazz
, "writeProxy", "(J)S");
7434 assert(mid
!= nullptr);
7439 * Get the Java Method: AbstractTraceWriter#closeWriter
7441 * @param env A pointer to the Java environment
7443 * @return The Java Method ID or nullptr if the class or method id could not
7446 static jmethodID
getCloseWriterProxyMethodId(JNIEnv
* env
) {
7447 jclass jclazz
= getJClass(env
);
7448 if(jclazz
== nullptr) {
7449 // exception occurred accessing class
7453 static jmethodID mid
= env
->GetMethodID(
7454 jclazz
, "closeWriterProxy", "()S");
7455 assert(mid
!= nullptr);
7460 * Get the Java Method: AbstractTraceWriter#getFileSize
7462 * @param env A pointer to the Java environment
7464 * @return The Java Method ID or nullptr if the class or method id could not
7467 static jmethodID
getGetFileSizeMethodId(JNIEnv
* env
) {
7468 jclass jclazz
= getJClass(env
);
7469 if(jclazz
== nullptr) {
7470 // exception occurred accessing class
7474 static jmethodID mid
= env
->GetMethodID(
7475 jclazz
, "getFileSize", "()J");
7476 assert(mid
!= nullptr);
7481 // The portal class for org.rocksdb.AbstractWalFilter
7482 class AbstractWalFilterJni
7483 : public RocksDBNativeClass
<const ROCKSDB_NAMESPACE::WalFilterJniCallback
*,
7484 AbstractWalFilterJni
> {
7487 * Get the Java Class org.rocksdb.AbstractWalFilter
7489 * @param env A pointer to the Java environment
7491 * @return The Java Class or nullptr if one of the
7492 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
7493 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
7495 static jclass
getJClass(JNIEnv
* env
) {
7496 return RocksDBNativeClass::getJClass(env
,
7497 "org/rocksdb/AbstractWalFilter");
7501 * Get the Java Method: AbstractWalFilter#columnFamilyLogNumberMap
7503 * @param env A pointer to the Java environment
7505 * @return The Java Method ID or nullptr if the class or method id could not
7508 static jmethodID
getColumnFamilyLogNumberMapMethodId(JNIEnv
* env
) {
7509 jclass jclazz
= getJClass(env
);
7510 if(jclazz
== nullptr) {
7511 // exception occurred accessing class
7515 static jmethodID mid
= env
->GetMethodID(
7516 jclazz
, "columnFamilyLogNumberMap",
7517 "(Ljava/util/Map;Ljava/util/Map;)V");
7518 assert(mid
!= nullptr);
7523 * Get the Java Method: AbstractTraceWriter#logRecordFoundProxy
7525 * @param env A pointer to the Java environment
7527 * @return The Java Method ID or nullptr if the class or method id could not
7530 static jmethodID
getLogRecordFoundProxyMethodId(JNIEnv
* env
) {
7531 jclass jclazz
= getJClass(env
);
7532 if(jclazz
== nullptr) {
7533 // exception occurred accessing class
7537 static jmethodID mid
= env
->GetMethodID(
7538 jclazz
, "logRecordFoundProxy", "(JLjava/lang/String;JJ)S");
7539 assert(mid
!= nullptr);
7544 * Get the Java Method: AbstractTraceWriter#name
7546 * @param env A pointer to the Java environment
7548 * @return The Java Method ID or nullptr if the class or method id could not
7551 static jmethodID
getNameMethodId(JNIEnv
* env
) {
7552 jclass jclazz
= getJClass(env
);
7553 if(jclazz
== nullptr) {
7554 // exception occurred accessing class
7558 static jmethodID mid
= env
->GetMethodID(
7559 jclazz
, "name", "()Ljava/lang/String;");
7560 assert(mid
!= nullptr);
7565 // The portal class for org.rocksdb.WalProcessingOption
7566 class WalProcessingOptionJni
{
7568 // Returns the equivalent org.rocksdb.WalProcessingOption for the provided
7569 // C++ ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption enum
7570 static jbyte
toJavaWalProcessingOption(
7571 const ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption
&
7572 wal_processing_option
) {
7573 switch (wal_processing_option
) {
7574 case ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
7575 kContinueProcessing
:
7577 case ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
7578 kIgnoreCurrentRecord
:
7580 case ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::kStopReplay
:
7582 case ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::kCorruptedRecord
:
7585 return 0x7F; // undefined
7589 // Returns the equivalent C++
7590 // ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption enum for the provided
7591 // Java org.rocksdb.WalProcessingOption
7592 static ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption
7593 toCppWalProcessingOption(jbyte jwal_processing_option
) {
7594 switch (jwal_processing_option
) {
7596 return ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
7597 kContinueProcessing
;
7599 return ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
7600 kIgnoreCurrentRecord
;
7602 return ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::kStopReplay
;
7604 return ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
7607 // undefined/default
7608 return ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
7614 // The portal class for org.rocksdb.ReusedSynchronisationType
7615 class ReusedSynchronisationTypeJni
{
7617 // Returns the equivalent org.rocksdb.ReusedSynchronisationType for the
7618 // provided C++ ROCKSDB_NAMESPACE::ReusedSynchronisationType enum
7619 static jbyte
toJavaReusedSynchronisationType(
7620 const ROCKSDB_NAMESPACE::ReusedSynchronisationType
&
7621 reused_synchronisation_type
) {
7622 switch(reused_synchronisation_type
) {
7623 case ROCKSDB_NAMESPACE::ReusedSynchronisationType::MUTEX
:
7625 case ROCKSDB_NAMESPACE::ReusedSynchronisationType::ADAPTIVE_MUTEX
:
7627 case ROCKSDB_NAMESPACE::ReusedSynchronisationType::THREAD_LOCAL
:
7630 return 0x7F; // undefined
7634 // Returns the equivalent C++ ROCKSDB_NAMESPACE::ReusedSynchronisationType
7635 // enum for the provided Java org.rocksdb.ReusedSynchronisationType
7636 static ROCKSDB_NAMESPACE::ReusedSynchronisationType
7637 toCppReusedSynchronisationType(jbyte reused_synchronisation_type
) {
7638 switch(reused_synchronisation_type
) {
7640 return ROCKSDB_NAMESPACE::ReusedSynchronisationType::MUTEX
;
7642 return ROCKSDB_NAMESPACE::ReusedSynchronisationType::ADAPTIVE_MUTEX
;
7644 return ROCKSDB_NAMESPACE::ReusedSynchronisationType::THREAD_LOCAL
;
7646 // undefined/default
7647 return ROCKSDB_NAMESPACE::ReusedSynchronisationType::ADAPTIVE_MUTEX
;
7651 // The portal class for org.rocksdb.SanityLevel
7652 class SanityLevelJni
{
7654 // Returns the equivalent org.rocksdb.SanityLevel for the provided
7655 // C++ ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel enum
7656 static jbyte
toJavaSanityLevel(
7657 const ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel
&sanity_level
) {
7658 switch (sanity_level
) {
7659 case ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel::kSanityLevelNone
:
7661 case ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel::
7662 kSanityLevelLooselyCompatible
:
7664 case ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel::
7665 kSanityLevelExactMatch
:
7668 return -0x01; // undefined
7672 // Returns the equivalent C++ ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel enum for
7673 // the provided Java org.rocksdb.SanityLevel
7674 static ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel
toCppSanityLevel(
7675 jbyte sanity_level
) {
7676 switch (sanity_level
) {
7678 return ROCKSDB_NAMESPACE::ConfigOptions::kSanityLevelNone
;
7680 return ROCKSDB_NAMESPACE::ConfigOptions::kSanityLevelLooselyCompatible
;
7682 // undefined/default
7683 return ROCKSDB_NAMESPACE::ConfigOptions::kSanityLevelExactMatch
;
7688 // The portal class for org.rocksdb.AbstractListener.EnabledEventCallback
7689 class EnabledEventCallbackJni
{
7691 // Returns the set of equivalent C++
7692 // rocksdb::EnabledEventCallbackJni::EnabledEventCallback enums for
7693 // the provided Java jenabled_event_callback_values
7694 static std::set
<EnabledEventCallback
> toCppEnabledEventCallbacks(
7695 jlong jenabled_event_callback_values
) {
7696 std::set
<EnabledEventCallback
> enabled_event_callbacks
;
7697 for (size_t i
= 0; i
< EnabledEventCallback::NUM_ENABLED_EVENT_CALLBACK
;
7699 if (((1ULL << i
) & jenabled_event_callback_values
) > 0) {
7700 enabled_event_callbacks
.emplace(static_cast<EnabledEventCallback
>(i
));
7703 return enabled_event_callbacks
;
7707 // The portal class for org.rocksdb.AbstractEventListener
7708 class AbstractEventListenerJni
7709 : public RocksDBNativeClass
<
7710 const ROCKSDB_NAMESPACE::EventListenerJniCallback
*,
7711 AbstractEventListenerJni
> {
7714 * Get the Java Class org.rocksdb.AbstractEventListener
7716 * @param env A pointer to the Java environment
7718 * @return The Java Class or nullptr if one of the
7719 * ClassFormatError, ClassCircularityError, NoClassDefFoundError,
7720 * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
7722 static jclass
getJClass(JNIEnv
* env
) {
7723 return RocksDBNativeClass::getJClass(env
,
7724 "org/rocksdb/AbstractEventListener");
7728 * Get the Java Method: AbstractEventListener#onFlushCompletedProxy
7730 * @param env A pointer to the Java environment
7732 * @return The Java Method ID
7734 static jmethodID
getOnFlushCompletedProxyMethodId(JNIEnv
* env
) {
7735 jclass jclazz
= getJClass(env
);
7736 assert(jclazz
!= nullptr);
7737 static jmethodID mid
= env
->GetMethodID(jclazz
, "onFlushCompletedProxy",
7738 "(JLorg/rocksdb/FlushJobInfo;)V");
7739 assert(mid
!= nullptr);
7744 * Get the Java Method: AbstractEventListener#onFlushBeginProxy
7746 * @param env A pointer to the Java environment
7748 * @return The Java Method ID
7750 static jmethodID
getOnFlushBeginProxyMethodId(JNIEnv
* env
) {
7751 jclass jclazz
= getJClass(env
);
7752 assert(jclazz
!= nullptr);
7753 static jmethodID mid
= env
->GetMethodID(jclazz
, "onFlushBeginProxy",
7754 "(JLorg/rocksdb/FlushJobInfo;)V");
7755 assert(mid
!= nullptr);
7760 * Get the Java Method: AbstractEventListener#onTableFileDeleted
7762 * @param env A pointer to the Java environment
7764 * @return The Java Method ID
7766 static jmethodID
getOnTableFileDeletedMethodId(JNIEnv
* env
) {
7767 jclass jclazz
= getJClass(env
);
7768 assert(jclazz
!= nullptr);
7769 static jmethodID mid
= env
->GetMethodID(
7770 jclazz
, "onTableFileDeleted", "(Lorg/rocksdb/TableFileDeletionInfo;)V");
7771 assert(mid
!= nullptr);
7776 * Get the Java Method: AbstractEventListener#onCompactionBeginProxy
7778 * @param env A pointer to the Java environment
7780 * @return The Java Method ID
7782 static jmethodID
getOnCompactionBeginProxyMethodId(JNIEnv
* env
) {
7783 jclass jclazz
= getJClass(env
);
7784 assert(jclazz
!= nullptr);
7785 static jmethodID mid
=
7786 env
->GetMethodID(jclazz
, "onCompactionBeginProxy",
7787 "(JLorg/rocksdb/CompactionJobInfo;)V");
7788 assert(mid
!= nullptr);
7793 * Get the Java Method: AbstractEventListener#onCompactionCompletedProxy
7795 * @param env A pointer to the Java environment
7797 * @return The Java Method ID
7799 static jmethodID
getOnCompactionCompletedProxyMethodId(JNIEnv
* env
) {
7800 jclass jclazz
= getJClass(env
);
7801 assert(jclazz
!= nullptr);
7802 static jmethodID mid
=
7803 env
->GetMethodID(jclazz
, "onCompactionCompletedProxy",
7804 "(JLorg/rocksdb/CompactionJobInfo;)V");
7805 assert(mid
!= nullptr);
7810 * Get the Java Method: AbstractEventListener#onTableFileCreated
7812 * @param env A pointer to the Java environment
7814 * @return The Java Method ID
7816 static jmethodID
getOnTableFileCreatedMethodId(JNIEnv
* env
) {
7817 jclass jclazz
= getJClass(env
);
7818 assert(jclazz
!= nullptr);
7819 static jmethodID mid
= env
->GetMethodID(
7820 jclazz
, "onTableFileCreated", "(Lorg/rocksdb/TableFileCreationInfo;)V");
7821 assert(mid
!= nullptr);
7826 * Get the Java Method: AbstractEventListener#onTableFileCreationStarted
7828 * @param env A pointer to the Java environment
7830 * @return The Java Method ID
7832 static jmethodID
getOnTableFileCreationStartedMethodId(JNIEnv
* env
) {
7833 jclass jclazz
= getJClass(env
);
7834 assert(jclazz
!= nullptr);
7835 static jmethodID mid
=
7836 env
->GetMethodID(jclazz
, "onTableFileCreationStarted",
7837 "(Lorg/rocksdb/TableFileCreationBriefInfo;)V");
7838 assert(mid
!= nullptr);
7843 * Get the Java Method: AbstractEventListener#onMemTableSealed
7845 * @param env A pointer to the Java environment
7847 * @return The Java Method ID
7849 static jmethodID
getOnMemTableSealedMethodId(JNIEnv
* env
) {
7850 jclass jclazz
= getJClass(env
);
7851 assert(jclazz
!= nullptr);
7852 static jmethodID mid
= env
->GetMethodID(jclazz
, "onMemTableSealed",
7853 "(Lorg/rocksdb/MemTableInfo;)V");
7854 assert(mid
!= nullptr);
7859 * Get the Java Method:
7860 * AbstractEventListener#onColumnFamilyHandleDeletionStarted
7862 * @param env A pointer to the Java environment
7864 * @return The Java Method ID
7866 static jmethodID
getOnColumnFamilyHandleDeletionStartedMethodId(JNIEnv
* env
) {
7867 jclass jclazz
= getJClass(env
);
7868 assert(jclazz
!= nullptr);
7869 static jmethodID mid
=
7870 env
->GetMethodID(jclazz
, "onColumnFamilyHandleDeletionStarted",
7871 "(Lorg/rocksdb/ColumnFamilyHandle;)V");
7872 assert(mid
!= nullptr);
7877 * Get the Java Method: AbstractEventListener#onExternalFileIngestedProxy
7879 * @param env A pointer to the Java environment
7881 * @return The Java Method ID
7883 static jmethodID
getOnExternalFileIngestedProxyMethodId(JNIEnv
* env
) {
7884 jclass jclazz
= getJClass(env
);
7885 assert(jclazz
!= nullptr);
7886 static jmethodID mid
=
7887 env
->GetMethodID(jclazz
, "onExternalFileIngestedProxy",
7888 "(JLorg/rocksdb/ExternalFileIngestionInfo;)V");
7889 assert(mid
!= nullptr);
7894 * Get the Java Method: AbstractEventListener#onBackgroundError
7896 * @param env A pointer to the Java environment
7898 * @return The Java Method ID
7900 static jmethodID
getOnBackgroundErrorProxyMethodId(JNIEnv
* env
) {
7901 jclass jclazz
= getJClass(env
);
7902 assert(jclazz
!= nullptr);
7903 static jmethodID mid
= env
->GetMethodID(jclazz
, "onBackgroundErrorProxy",
7904 "(BLorg/rocksdb/Status;)V");
7905 assert(mid
!= nullptr);
7910 * Get the Java Method: AbstractEventListener#onStallConditionsChanged
7912 * @param env A pointer to the Java environment
7914 * @return The Java Method ID
7916 static jmethodID
getOnStallConditionsChangedMethodId(JNIEnv
* env
) {
7917 jclass jclazz
= getJClass(env
);
7918 assert(jclazz
!= nullptr);
7919 static jmethodID mid
= env
->GetMethodID(jclazz
, "onStallConditionsChanged",
7920 "(Lorg/rocksdb/WriteStallInfo;)V");
7921 assert(mid
!= nullptr);
7926 * Get the Java Method: AbstractEventListener#onFileReadFinish
7928 * @param env A pointer to the Java environment
7930 * @return The Java Method ID
7932 static jmethodID
getOnFileReadFinishMethodId(JNIEnv
* env
) {
7933 jclass jclazz
= getJClass(env
);
7934 assert(jclazz
!= nullptr);
7935 static jmethodID mid
= env
->GetMethodID(
7936 jclazz
, "onFileReadFinish", "(Lorg/rocksdb/FileOperationInfo;)V");
7937 assert(mid
!= nullptr);
7942 * Get the Java Method: AbstractEventListener#onFileWriteFinish
7944 * @param env A pointer to the Java environment
7946 * @return The Java Method ID
7948 static jmethodID
getOnFileWriteFinishMethodId(JNIEnv
* env
) {
7949 jclass jclazz
= getJClass(env
);
7950 assert(jclazz
!= nullptr);
7951 static jmethodID mid
= env
->GetMethodID(
7952 jclazz
, "onFileWriteFinish", "(Lorg/rocksdb/FileOperationInfo;)V");
7953 assert(mid
!= nullptr);
7958 * Get the Java Method: AbstractEventListener#onFileFlushFinish
7960 * @param env A pointer to the Java environment
7962 * @return The Java Method ID
7964 static jmethodID
getOnFileFlushFinishMethodId(JNIEnv
* env
) {
7965 jclass jclazz
= getJClass(env
);
7966 assert(jclazz
!= nullptr);
7967 static jmethodID mid
= env
->GetMethodID(
7968 jclazz
, "onFileFlushFinish", "(Lorg/rocksdb/FileOperationInfo;)V");
7969 assert(mid
!= nullptr);
7974 * Get the Java Method: AbstractEventListener#onFileSyncFinish
7976 * @param env A pointer to the Java environment
7978 * @return The Java Method ID
7980 static jmethodID
getOnFileSyncFinishMethodId(JNIEnv
* env
) {
7981 jclass jclazz
= getJClass(env
);
7982 assert(jclazz
!= nullptr);
7983 static jmethodID mid
= env
->GetMethodID(
7984 jclazz
, "onFileSyncFinish", "(Lorg/rocksdb/FileOperationInfo;)V");
7985 assert(mid
!= nullptr);
7990 * Get the Java Method: AbstractEventListener#onFileRangeSyncFinish
7992 * @param env A pointer to the Java environment
7994 * @return The Java Method ID
7996 static jmethodID
getOnFileRangeSyncFinishMethodId(JNIEnv
* env
) {
7997 jclass jclazz
= getJClass(env
);
7998 assert(jclazz
!= nullptr);
7999 static jmethodID mid
= env
->GetMethodID(
8000 jclazz
, "onFileRangeSyncFinish", "(Lorg/rocksdb/FileOperationInfo;)V");
8001 assert(mid
!= nullptr);
8006 * Get the Java Method: AbstractEventListener#onFileTruncateFinish
8008 * @param env A pointer to the Java environment
8010 * @return The Java Method ID
8012 static jmethodID
getOnFileTruncateFinishMethodId(JNIEnv
* env
) {
8013 jclass jclazz
= getJClass(env
);
8014 assert(jclazz
!= nullptr);
8015 static jmethodID mid
= env
->GetMethodID(
8016 jclazz
, "onFileTruncateFinish", "(Lorg/rocksdb/FileOperationInfo;)V");
8017 assert(mid
!= nullptr);
8022 * Get the Java Method: AbstractEventListener#onFileCloseFinish
8024 * @param env A pointer to the Java environment
8026 * @return The Java Method ID
8028 static jmethodID
getOnFileCloseFinishMethodId(JNIEnv
* env
) {
8029 jclass jclazz
= getJClass(env
);
8030 assert(jclazz
!= nullptr);
8031 static jmethodID mid
= env
->GetMethodID(
8032 jclazz
, "onFileCloseFinish", "(Lorg/rocksdb/FileOperationInfo;)V");
8033 assert(mid
!= nullptr);
8038 * Get the Java Method: AbstractEventListener#shouldBeNotifiedOnFileIO
8040 * @param env A pointer to the Java environment
8042 * @return The Java Method ID
8044 static jmethodID
getShouldBeNotifiedOnFileIOMethodId(JNIEnv
* env
) {
8045 jclass jclazz
= getJClass(env
);
8046 assert(jclazz
!= nullptr);
8047 static jmethodID mid
=
8048 env
->GetMethodID(jclazz
, "shouldBeNotifiedOnFileIO", "()Z");
8049 assert(mid
!= nullptr);
8054 * Get the Java Method: AbstractEventListener#onErrorRecoveryBeginProxy
8056 * @param env A pointer to the Java environment
8058 * @return The Java Method ID
8060 static jmethodID
getOnErrorRecoveryBeginProxyMethodId(JNIEnv
* env
) {
8061 jclass jclazz
= getJClass(env
);
8062 assert(jclazz
!= nullptr);
8063 static jmethodID mid
= env
->GetMethodID(jclazz
, "onErrorRecoveryBeginProxy",
8064 "(BLorg/rocksdb/Status;)Z");
8065 assert(mid
!= nullptr);
8070 * Get the Java Method: AbstractEventListener#onErrorRecoveryCompleted
8072 * @param env A pointer to the Java environment
8074 * @return The Java Method ID
8076 static jmethodID
getOnErrorRecoveryCompletedMethodId(JNIEnv
* env
) {
8077 jclass jclazz
= getJClass(env
);
8078 assert(jclazz
!= nullptr);
8079 static jmethodID mid
= env
->GetMethodID(jclazz
, "onErrorRecoveryCompleted",
8080 "(Lorg/rocksdb/Status;)V");
8081 assert(mid
!= nullptr);
8086 class FlushJobInfoJni
: public JavaClass
{
8089 * Create a new Java org.rocksdb.FlushJobInfo object.
8091 * @param env A pointer to the Java environment
8092 * @param flush_job_info A Cpp flush job info object
8094 * @return A reference to a Java org.rocksdb.FlushJobInfo object, or
8095 * nullptr if an an exception occurs
8097 static jobject
fromCppFlushJobInfo(
8098 JNIEnv
* env
, const ROCKSDB_NAMESPACE::FlushJobInfo
* flush_job_info
) {
8099 jclass jclazz
= getJClass(env
);
8100 if (jclazz
== nullptr) {
8101 // exception occurred accessing class
8104 static jmethodID ctor
= getConstructorMethodId(env
, jclazz
);
8105 assert(ctor
!= nullptr);
8106 jstring jcf_name
= JniUtil::toJavaString(env
, &flush_job_info
->cf_name
);
8107 if (env
->ExceptionCheck()) {
8110 jstring jfile_path
= JniUtil::toJavaString(env
, &flush_job_info
->file_path
);
8111 if (env
->ExceptionCheck()) {
8112 env
->DeleteLocalRef(jfile_path
);
8115 jobject jtable_properties
= TablePropertiesJni::fromCppTableProperties(
8116 env
, flush_job_info
->table_properties
);
8117 if (jtable_properties
== nullptr) {
8118 env
->DeleteLocalRef(jcf_name
);
8119 env
->DeleteLocalRef(jfile_path
);
8122 return env
->NewObject(
8123 jclazz
, ctor
, static_cast<jlong
>(flush_job_info
->cf_id
), jcf_name
,
8124 jfile_path
, static_cast<jlong
>(flush_job_info
->thread_id
),
8125 static_cast<jint
>(flush_job_info
->job_id
),
8126 static_cast<jboolean
>(flush_job_info
->triggered_writes_slowdown
),
8127 static_cast<jboolean
>(flush_job_info
->triggered_writes_stop
),
8128 static_cast<jlong
>(flush_job_info
->smallest_seqno
),
8129 static_cast<jlong
>(flush_job_info
->largest_seqno
), jtable_properties
,
8130 static_cast<jbyte
>(flush_job_info
->flush_reason
));
8133 static jclass
getJClass(JNIEnv
* env
) {
8134 return JavaClass::getJClass(env
, "org/rocksdb/FlushJobInfo");
8137 static jmethodID
getConstructorMethodId(JNIEnv
* env
, jclass clazz
) {
8138 return env
->GetMethodID(clazz
, "<init>",
8139 "(JLjava/lang/String;Ljava/lang/String;JIZZJJLorg/"
8140 "rocksdb/TableProperties;B)V");
8144 class TableFileDeletionInfoJni
: public JavaClass
{
8147 * Create a new Java org.rocksdb.TableFileDeletionInfo object.
8149 * @param env A pointer to the Java environment
8150 * @param file_del_info A Cpp table file deletion info object
8152 * @return A reference to a Java org.rocksdb.TableFileDeletionInfo object, or
8153 * nullptr if an an exception occurs
8155 static jobject
fromCppTableFileDeletionInfo(
8157 const ROCKSDB_NAMESPACE::TableFileDeletionInfo
* file_del_info
) {
8158 jclass jclazz
= getJClass(env
);
8159 if (jclazz
== nullptr) {
8160 // exception occurred accessing class
8163 static jmethodID ctor
= getConstructorMethodId(env
, jclazz
);
8164 assert(ctor
!= nullptr);
8165 jstring jdb_name
= JniUtil::toJavaString(env
, &file_del_info
->db_name
);
8166 if (env
->ExceptionCheck()) {
8169 jobject jstatus
= StatusJni::construct(env
, file_del_info
->status
);
8170 if (jstatus
== nullptr) {
8171 env
->DeleteLocalRef(jdb_name
);
8174 return env
->NewObject(jclazz
, ctor
, jdb_name
,
8175 JniUtil::toJavaString(env
, &file_del_info
->file_path
),
8176 static_cast<jint
>(file_del_info
->job_id
), jstatus
);
8179 static jclass
getJClass(JNIEnv
* env
) {
8180 return JavaClass::getJClass(env
, "org/rocksdb/TableFileDeletionInfo");
8183 static jmethodID
getConstructorMethodId(JNIEnv
* env
, jclass clazz
) {
8184 return env
->GetMethodID(
8186 "(Ljava/lang/String;Ljava/lang/String;ILorg/rocksdb/Status;)V");
8190 class CompactionJobInfoJni
: public JavaClass
{
8192 static jobject
fromCppCompactionJobInfo(
8194 const ROCKSDB_NAMESPACE::CompactionJobInfo
* compaction_job_info
) {
8195 jclass jclazz
= getJClass(env
);
8196 assert(jclazz
!= nullptr);
8197 static jmethodID ctor
= getConstructorMethodId(env
, jclazz
);
8198 assert(ctor
!= nullptr);
8199 return env
->NewObject(jclazz
, ctor
,
8200 reinterpret_cast<jlong
>(compaction_job_info
));
8203 static jclass
getJClass(JNIEnv
* env
) {
8204 return JavaClass::getJClass(env
, "org/rocksdb/CompactionJobInfo");
8207 static jmethodID
getConstructorMethodId(JNIEnv
* env
, jclass clazz
) {
8208 return env
->GetMethodID(clazz
, "<init>", "(J)V");
8212 class TableFileCreationInfoJni
: public JavaClass
{
8214 static jobject
fromCppTableFileCreationInfo(
8215 JNIEnv
* env
, const ROCKSDB_NAMESPACE::TableFileCreationInfo
* info
) {
8216 jclass jclazz
= getJClass(env
);
8217 assert(jclazz
!= nullptr);
8218 static jmethodID ctor
= getConstructorMethodId(env
, jclazz
);
8219 assert(ctor
!= nullptr);
8220 jstring jdb_name
= JniUtil::toJavaString(env
, &info
->db_name
);
8221 if (env
->ExceptionCheck()) {
8224 jstring jcf_name
= JniUtil::toJavaString(env
, &info
->cf_name
);
8225 if (env
->ExceptionCheck()) {
8226 env
->DeleteLocalRef(jdb_name
);
8229 jstring jfile_path
= JniUtil::toJavaString(env
, &info
->file_path
);
8230 if (env
->ExceptionCheck()) {
8231 env
->DeleteLocalRef(jdb_name
);
8232 env
->DeleteLocalRef(jcf_name
);
8235 jobject jtable_properties
=
8236 TablePropertiesJni::fromCppTableProperties(env
, info
->table_properties
);
8237 if (jtable_properties
== nullptr) {
8238 env
->DeleteLocalRef(jdb_name
);
8239 env
->DeleteLocalRef(jcf_name
);
8242 jobject jstatus
= StatusJni::construct(env
, info
->status
);
8243 if (jstatus
== nullptr) {
8244 env
->DeleteLocalRef(jdb_name
);
8245 env
->DeleteLocalRef(jcf_name
);
8246 env
->DeleteLocalRef(jtable_properties
);
8249 return env
->NewObject(jclazz
, ctor
, static_cast<jlong
>(info
->file_size
),
8250 jtable_properties
, jstatus
, jdb_name
, jcf_name
,
8251 jfile_path
, static_cast<jint
>(info
->job_id
),
8252 static_cast<jbyte
>(info
->reason
));
8255 static jclass
getJClass(JNIEnv
* env
) {
8256 return JavaClass::getJClass(env
, "org/rocksdb/TableFileCreationInfo");
8259 static jmethodID
getConstructorMethodId(JNIEnv
* env
, jclass clazz
) {
8260 return env
->GetMethodID(
8262 "(JLorg/rocksdb/TableProperties;Lorg/rocksdb/Status;Ljava/lang/"
8263 "String;Ljava/lang/String;Ljava/lang/String;IB)V");
8267 class TableFileCreationBriefInfoJni
: public JavaClass
{
8269 static jobject
fromCppTableFileCreationBriefInfo(
8270 JNIEnv
* env
, const ROCKSDB_NAMESPACE::TableFileCreationBriefInfo
* info
) {
8271 jclass jclazz
= getJClass(env
);
8272 assert(jclazz
!= nullptr);
8273 static jmethodID ctor
= getConstructorMethodId(env
, jclazz
);
8274 assert(ctor
!= nullptr);
8275 jstring jdb_name
= JniUtil::toJavaString(env
, &info
->db_name
);
8276 if (env
->ExceptionCheck()) {
8279 jstring jcf_name
= JniUtil::toJavaString(env
, &info
->cf_name
);
8280 if (env
->ExceptionCheck()) {
8281 env
->DeleteLocalRef(jdb_name
);
8284 jstring jfile_path
= JniUtil::toJavaString(env
, &info
->file_path
);
8285 if (env
->ExceptionCheck()) {
8286 env
->DeleteLocalRef(jdb_name
);
8287 env
->DeleteLocalRef(jcf_name
);
8290 return env
->NewObject(jclazz
, ctor
, jdb_name
, jcf_name
, jfile_path
,
8291 static_cast<jint
>(info
->job_id
),
8292 static_cast<jbyte
>(info
->reason
));
8295 static jclass
getJClass(JNIEnv
* env
) {
8296 return JavaClass::getJClass(env
, "org/rocksdb/TableFileCreationBriefInfo");
8299 static jmethodID
getConstructorMethodId(JNIEnv
* env
, jclass clazz
) {
8300 return env
->GetMethodID(
8302 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IB)V");
8306 class MemTableInfoJni
: public JavaClass
{
8308 static jobject
fromCppMemTableInfo(
8309 JNIEnv
* env
, const ROCKSDB_NAMESPACE::MemTableInfo
* info
) {
8310 jclass jclazz
= getJClass(env
);
8311 assert(jclazz
!= nullptr);
8312 static jmethodID ctor
= getConstructorMethodId(env
, jclazz
);
8313 assert(ctor
!= nullptr);
8314 jstring jcf_name
= JniUtil::toJavaString(env
, &info
->cf_name
);
8315 if (env
->ExceptionCheck()) {
8318 return env
->NewObject(jclazz
, ctor
, jcf_name
,
8319 static_cast<jlong
>(info
->first_seqno
),
8320 static_cast<jlong
>(info
->earliest_seqno
),
8321 static_cast<jlong
>(info
->num_entries
),
8322 static_cast<jlong
>(info
->num_deletes
));
8325 static jclass
getJClass(JNIEnv
* env
) {
8326 return JavaClass::getJClass(env
, "org/rocksdb/MemTableInfo");
8329 static jmethodID
getConstructorMethodId(JNIEnv
* env
, jclass clazz
) {
8330 return env
->GetMethodID(clazz
, "<init>", "(Ljava/lang/String;JJJJ)V");
8334 class ExternalFileIngestionInfoJni
: public JavaClass
{
8336 static jobject
fromCppExternalFileIngestionInfo(
8337 JNIEnv
* env
, const ROCKSDB_NAMESPACE::ExternalFileIngestionInfo
* info
) {
8338 jclass jclazz
= getJClass(env
);
8339 assert(jclazz
!= nullptr);
8340 static jmethodID ctor
= getConstructorMethodId(env
, jclazz
);
8341 assert(ctor
!= nullptr);
8342 jstring jcf_name
= JniUtil::toJavaString(env
, &info
->cf_name
);
8343 if (env
->ExceptionCheck()) {
8346 jstring jexternal_file_path
=
8347 JniUtil::toJavaString(env
, &info
->external_file_path
);
8348 if (env
->ExceptionCheck()) {
8349 env
->DeleteLocalRef(jcf_name
);
8352 jstring jinternal_file_path
=
8353 JniUtil::toJavaString(env
, &info
->internal_file_path
);
8354 if (env
->ExceptionCheck()) {
8355 env
->DeleteLocalRef(jcf_name
);
8356 env
->DeleteLocalRef(jexternal_file_path
);
8359 jobject jtable_properties
=
8360 TablePropertiesJni::fromCppTableProperties(env
, info
->table_properties
);
8361 if (jtable_properties
== nullptr) {
8362 env
->DeleteLocalRef(jcf_name
);
8363 env
->DeleteLocalRef(jexternal_file_path
);
8364 env
->DeleteLocalRef(jinternal_file_path
);
8367 return env
->NewObject(
8368 jclazz
, ctor
, jcf_name
, jexternal_file_path
, jinternal_file_path
,
8369 static_cast<jlong
>(info
->global_seqno
), jtable_properties
);
8372 static jclass
getJClass(JNIEnv
* env
) {
8373 return JavaClass::getJClass(env
, "org/rocksdb/ExternalFileIngestionInfo");
8376 static jmethodID
getConstructorMethodId(JNIEnv
* env
, jclass clazz
) {
8377 return env
->GetMethodID(clazz
, "<init>",
8378 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/"
8379 "String;JLorg/rocksdb/TableProperties;)V");
8383 class WriteStallInfoJni
: public JavaClass
{
8385 static jobject
fromCppWriteStallInfo(
8386 JNIEnv
* env
, const ROCKSDB_NAMESPACE::WriteStallInfo
* info
) {
8387 jclass jclazz
= getJClass(env
);
8388 assert(jclazz
!= nullptr);
8389 static jmethodID ctor
= getConstructorMethodId(env
, jclazz
);
8390 assert(ctor
!= nullptr);
8391 jstring jcf_name
= JniUtil::toJavaString(env
, &info
->cf_name
);
8392 if (env
->ExceptionCheck()) {
8395 return env
->NewObject(jclazz
, ctor
, jcf_name
,
8396 static_cast<jbyte
>(info
->condition
.cur
),
8397 static_cast<jbyte
>(info
->condition
.prev
));
8400 static jclass
getJClass(JNIEnv
* env
) {
8401 return JavaClass::getJClass(env
, "org/rocksdb/WriteStallInfo");
8404 static jmethodID
getConstructorMethodId(JNIEnv
* env
, jclass clazz
) {
8405 return env
->GetMethodID(clazz
, "<init>", "(Ljava/lang/String;BB)V");
8409 class FileOperationInfoJni
: public JavaClass
{
8411 static jobject
fromCppFileOperationInfo(
8412 JNIEnv
* env
, const ROCKSDB_NAMESPACE::FileOperationInfo
* info
) {
8413 jclass jclazz
= getJClass(env
);
8414 assert(jclazz
!= nullptr);
8415 static jmethodID ctor
= getConstructorMethodId(env
, jclazz
);
8416 assert(ctor
!= nullptr);
8417 jstring jpath
= JniUtil::toJavaString(env
, &info
->path
);
8418 if (env
->ExceptionCheck()) {
8421 jobject jstatus
= StatusJni::construct(env
, info
->status
);
8422 if (jstatus
== nullptr) {
8423 env
->DeleteLocalRef(jpath
);
8426 return env
->NewObject(
8427 jclazz
, ctor
, jpath
, static_cast<jlong
>(info
->offset
),
8428 static_cast<jlong
>(info
->length
),
8429 static_cast<jlong
>(info
->start_ts
.time_since_epoch().count()),
8430 static_cast<jlong
>(info
->duration
.count()), jstatus
);
8433 static jclass
getJClass(JNIEnv
* env
) {
8434 return JavaClass::getJClass(env
, "org/rocksdb/FileOperationInfo");
8437 static jmethodID
getConstructorMethodId(JNIEnv
* env
, jclass clazz
) {
8438 return env
->GetMethodID(clazz
, "<init>",
8439 "(Ljava/lang/String;JJJJLorg/rocksdb/Status;)V");
8442 } // namespace ROCKSDB_NAMESPACE
8443 #endif // JAVA_ROCKSJNI_PORTAL_H_