andreacavalli/rocksdb
0
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
7b65666cf1
rocksdb/java/rocksjni/portal.h
Akanksha Mahajan 38d0a365e3 Add Stats for MultiGet (#7366) 
Summary:
Add following stats for MultiGet in Histogram to get more insight on MultiGet.
    1. Number of index and filter blocks read from file as part of MultiGet
    request per level.
    2. Number of data blocks read from file per level.
    3. Number of SST files loaded from file system per level.

Pull Request resolved: https://github.com/facebook/rocksdb/pull/7366

Reviewed By: anand1976

Differential Revision: D24127040

Pulled By: akankshamahajan15

fbshipit-source-id: e63a003056b833729b277edc0639c08fb432756b
2020-10-07 13:28:48 -07:00

7664 lines
252 KiB
C++
Raw Blame History

// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
// This source code is licensed under both the GPLv2 (found in the
// COPYING file in the root directory) and Apache 2.0 License
// (found in the LICENSE.Apache file in the root directory).
// This file is designed for caching those frequently used IDs and provide
// efficient portal (i.e, a set of static functions) to access java code
// from c++.
#ifndef JAVA_ROCKSJNI_PORTAL_H_
#define JAVA_ROCKSJNI_PORTAL_H_
#include <algorithm>
#include <cstring>
#include <functional>
#include <iostream>
#include <iterator>
#include <jni.h>
#include <limits>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
#include "rocksdb/convenience.h"
#include "rocksdb/db.h"
#include "rocksdb/filter_policy.h"
#include "rocksdb/rate_limiter.h"
#include "rocksdb/status.h"
#include "rocksdb/table.h"
#include "rocksdb/utilities/backupable_db.h"
#include "rocksdb/utilities/memory_util.h"
#include "rocksdb/utilities/transaction_db.h"
#include "rocksdb/utilities/write_batch_with_index.h"
#include "rocksjni/compaction_filter_factory_jnicallback.h"
#include "rocksjni/comparatorjnicallback.h"
#include "rocksjni/loggerjnicallback.h"
#include "rocksjni/table_filter_jnicallback.h"
#include "rocksjni/trace_writer_jnicallback.h"
#include "rocksjni/transaction_notifier_jnicallback.h"
#include "rocksjni/wal_filter_jnicallback.h"
#include "rocksjni/writebatchhandlerjnicallback.h"
// Remove macro on windows
#ifdef DELETE
#undef DELETE
#endif
namespace ROCKSDB_NAMESPACE {
class JavaClass {
public:
/**
* Gets and initializes a Java Class
*
* @param env A pointer to the Java environment
* @param jclazz_name The fully qualified JNI name of the Java Class
* e.g. "java/lang/String"
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env, const char* jclazz_name) {
jclass jclazz = env->FindClass(jclazz_name);
assert(jclazz != nullptr);
return jclazz;
}
};
// Native class template
template<class PTR, class DERIVED> class RocksDBNativeClass : public JavaClass {
};
// Native class template for sub-classes of RocksMutableObject
template<class PTR, class DERIVED> class NativeRocksMutableObject
: public RocksDBNativeClass<PTR, DERIVED> {
public:
/**
* Gets the Java Method ID for the
* RocksMutableObject#setNativeHandle(long, boolean) method
*
* @param env A pointer to the Java environment
* @return The Java Method ID or nullptr the RocksMutableObject class cannot
* be accessed, or if one of the NoSuchMethodError,
* ExceptionInInitializerError or OutOfMemoryError exceptions is thrown
*/
static jmethodID getSetNativeHandleMethod(JNIEnv* env) {
static jclass jclazz = DERIVED::getJClass(env);
if(jclazz == nullptr) {
return nullptr;
}
static jmethodID mid = env->GetMethodID(
jclazz, "setNativeHandle", "(JZ)V");
assert(mid != nullptr);
return mid;
}
/**
* Sets the C++ object pointer handle in the Java object
*
* @param env A pointer to the Java environment
* @param jobj The Java object on which to set the pointer handle
* @param ptr The C++ object pointer
* @param java_owns_handle JNI_TRUE if ownership of the C++ object is
* managed by the Java object
*
* @return true if a Java exception is pending, false otherwise
*/
static bool setHandle(JNIEnv* env, jobject jobj, PTR ptr,
jboolean java_owns_handle) {
assert(jobj != nullptr);
static jmethodID mid = getSetNativeHandleMethod(env);
if(mid == nullptr) {
return true; // signal exception
}
env->CallVoidMethod(jobj, mid, reinterpret_cast<jlong>(ptr), java_owns_handle);
if(env->ExceptionCheck()) {
return true; // signal exception
}
return false;
}
};
// Java Exception template
template<class DERIVED> class JavaException : public JavaClass {
public:
/**
* Create and throw a java exception with the provided message
*
* @param env A pointer to the Java environment
* @param msg The message for the exception
*
* @return true if an exception was thrown, false otherwise
*/
static bool ThrowNew(JNIEnv* env, const std::string& msg) {
jclass jclazz = DERIVED::getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
std::cerr << "JavaException::ThrowNew - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
const jint rs = env->ThrowNew(jclazz, msg.c_str());
if(rs != JNI_OK) {
// exception could not be thrown
std::cerr << "JavaException::ThrowNew - Fatal: could not throw exception!" << std::endl;
return env->ExceptionCheck();
}
return true;
}
};
// The portal class for java.lang.IllegalArgumentException
class IllegalArgumentExceptionJni :
public JavaException<IllegalArgumentExceptionJni> {
public:
/**
* Get the Java Class java.lang.IllegalArgumentException
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaException::getJClass(env, "java/lang/IllegalArgumentException");
}
/**
* Create and throw a Java IllegalArgumentException with the provided status
*
* If s.ok() == true, then this function will not throw any exception.
*
* @param env A pointer to the Java environment
* @param s The status for the exception
*
* @return true if an exception was thrown, false otherwise
*/
static bool ThrowNew(JNIEnv* env, const Status& s) {
assert(!s.ok());
if (s.ok()) {
return false;
}
// get the IllegalArgumentException class
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
std::cerr << "IllegalArgumentExceptionJni::ThrowNew/class - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
return JavaException::ThrowNew(env, s.ToString());
}
};
// The portal class for org.rocksdb.Status.Code
class CodeJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.Status.Code
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/Status$Code");
}
/**
* Get the Java Method: Status.Code#getValue
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getValueMethod(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "getValue", "()b");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.Status.SubCode
class SubCodeJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.Status.SubCode
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/Status$SubCode");
}
/**
* Get the Java Method: Status.SubCode#getValue
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getValueMethod(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "getValue", "()b");
assert(mid != nullptr);
return mid;
}
static ROCKSDB_NAMESPACE::Status::SubCode toCppSubCode(
const jbyte jsub_code) {
switch (jsub_code) {
case 0x0:
return ROCKSDB_NAMESPACE::Status::SubCode::kNone;
case 0x1:
return ROCKSDB_NAMESPACE::Status::SubCode::kMutexTimeout;
case 0x2:
return ROCKSDB_NAMESPACE::Status::SubCode::kLockTimeout;
case 0x3:
return ROCKSDB_NAMESPACE::Status::SubCode::kLockLimit;
case 0x4:
return ROCKSDB_NAMESPACE::Status::SubCode::kNoSpace;
case 0x5:
return ROCKSDB_NAMESPACE::Status::SubCode::kDeadlock;
case 0x6:
return ROCKSDB_NAMESPACE::Status::SubCode::kStaleFile;
case 0x7:
return ROCKSDB_NAMESPACE::Status::SubCode::kMemoryLimit;
case 0x7F:
default:
return ROCKSDB_NAMESPACE::Status::SubCode::kNone;
}
}
};
// The portal class for org.rocksdb.Status
class StatusJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::Status*, StatusJni> {
public:
/**
* Get the Java Class org.rocksdb.Status
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/Status");
}
/**
* Get the Java Method: Status#getCode
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getCodeMethod(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "getCode", "()Lorg/rocksdb/Status$Code;");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: Status#getSubCode
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getSubCodeMethod(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "getSubCode", "()Lorg/rocksdb/Status$SubCode;");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: Status#getState
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getStateMethod(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "getState", "()Ljava/lang/String;");
assert(mid != nullptr);
return mid;
}
/**
* Create a new Java org.rocksdb.Status object with the same properties as
* the provided C++ ROCKSDB_NAMESPACE::Status object
*
* @param env A pointer to the Java environment
* @param status The ROCKSDB_NAMESPACE::Status object
*
* @return A reference to a Java org.rocksdb.Status object, or nullptr
* if an an exception occurs
*/
static jobject construct(JNIEnv* env, const Status& status) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid =
env->GetMethodID(jclazz, "<init>", "(BBLjava/lang/String;)V");
if(mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
// convert the Status state for Java
jstring jstate = nullptr;
if (status.getState() != nullptr) {
const char* const state = status.getState();
jstate = env->NewStringUTF(state);
if(env->ExceptionCheck()) {
if(jstate != nullptr) {
env->DeleteLocalRef(jstate);
}
return nullptr;
}
}
jobject jstatus =
env->NewObject(jclazz, mid, toJavaStatusCode(status.code()),
toJavaStatusSubCode(status.subcode()), jstate);
if(env->ExceptionCheck()) {
// exception occurred
if(jstate != nullptr) {
env->DeleteLocalRef(jstate);
}
return nullptr;
}
if(jstate != nullptr) {
env->DeleteLocalRef(jstate);
}
return jstatus;
}
// Returns the equivalent org.rocksdb.Status.Code for the provided
// C++ ROCKSDB_NAMESPACE::Status::Code enum
static jbyte toJavaStatusCode(const ROCKSDB_NAMESPACE::Status::Code& code) {
switch (code) {
case ROCKSDB_NAMESPACE::Status::Code::kOk:
return 0x0;
case ROCKSDB_NAMESPACE::Status::Code::kNotFound:
return 0x1;
case ROCKSDB_NAMESPACE::Status::Code::kCorruption:
return 0x2;
case ROCKSDB_NAMESPACE::Status::Code::kNotSupported:
return 0x3;
case ROCKSDB_NAMESPACE::Status::Code::kInvalidArgument:
return 0x4;
case ROCKSDB_NAMESPACE::Status::Code::kIOError:
return 0x5;
case ROCKSDB_NAMESPACE::Status::Code::kMergeInProgress:
return 0x6;
case ROCKSDB_NAMESPACE::Status::Code::kIncomplete:
return 0x7;
case ROCKSDB_NAMESPACE::Status::Code::kShutdownInProgress:
return 0x8;
case ROCKSDB_NAMESPACE::Status::Code::kTimedOut:
return 0x9;
case ROCKSDB_NAMESPACE::Status::Code::kAborted:
return 0xA;
case ROCKSDB_NAMESPACE::Status::Code::kBusy:
return 0xB;
case ROCKSDB_NAMESPACE::Status::Code::kExpired:
return 0xC;
case ROCKSDB_NAMESPACE::Status::Code::kTryAgain:
return 0xD;
case ROCKSDB_NAMESPACE::Status::Code::kColumnFamilyDropped:
return 0xE;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent org.rocksdb.Status.SubCode for the provided
// C++ ROCKSDB_NAMESPACE::Status::SubCode enum
static jbyte toJavaStatusSubCode(
const ROCKSDB_NAMESPACE::Status::SubCode& subCode) {
switch (subCode) {
case ROCKSDB_NAMESPACE::Status::SubCode::kNone:
return 0x0;
case ROCKSDB_NAMESPACE::Status::SubCode::kMutexTimeout:
return 0x1;
case ROCKSDB_NAMESPACE::Status::SubCode::kLockTimeout:
return 0x2;
case ROCKSDB_NAMESPACE::Status::SubCode::kLockLimit:
return 0x3;
case ROCKSDB_NAMESPACE::Status::SubCode::kNoSpace:
return 0x4;
case ROCKSDB_NAMESPACE::Status::SubCode::kDeadlock:
return 0x5;
case ROCKSDB_NAMESPACE::Status::SubCode::kStaleFile:
return 0x6;
case ROCKSDB_NAMESPACE::Status::SubCode::kMemoryLimit:
return 0x7;
default:
return 0x7F; // undefined
}
}
static std::unique_ptr<ROCKSDB_NAMESPACE::Status> toCppStatus(
const jbyte jcode_value, const jbyte jsub_code_value) {
std::unique_ptr<ROCKSDB_NAMESPACE::Status> status;
switch (jcode_value) {
case 0x0:
//Ok
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::OK()));
break;
case 0x1:
//NotFound
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::NotFound(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value))));
break;
case 0x2:
//Corruption
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::Corruption(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value))));
break;
case 0x3:
//NotSupported
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(
ROCKSDB_NAMESPACE::Status::NotSupported(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(
jsub_code_value))));
break;
case 0x4:
//InvalidArgument
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(
ROCKSDB_NAMESPACE::Status::InvalidArgument(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(
jsub_code_value))));
break;
case 0x5:
//IOError
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::IOError(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value))));
break;
case 0x6:
//MergeInProgress
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(
ROCKSDB_NAMESPACE::Status::MergeInProgress(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(
jsub_code_value))));
break;
case 0x7:
//Incomplete
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::Incomplete(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value))));
break;
case 0x8:
//ShutdownInProgress
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(
ROCKSDB_NAMESPACE::Status::ShutdownInProgress(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(
jsub_code_value))));
break;
case 0x9:
//TimedOut
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::TimedOut(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value))));
break;
case 0xA:
//Aborted
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::Aborted(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value))));
break;
case 0xB:
//Busy
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::Busy(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value))));
break;
case 0xC:
//Expired
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::Expired(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value))));
break;
case 0xD:
//TryAgain
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Status::TryAgain(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(jsub_code_value))));
break;
case 0xE:
// ColumnFamilyDropped
status = std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(
ROCKSDB_NAMESPACE::Status::ColumnFamilyDropped(
ROCKSDB_NAMESPACE::SubCodeJni::toCppSubCode(
jsub_code_value))));
break;
case 0x7F:
default:
return nullptr;
}
return status;
}
// Returns the equivalent ROCKSDB_NAMESPACE::Status for the Java
// org.rocksdb.Status
static std::unique_ptr<ROCKSDB_NAMESPACE::Status> toCppStatus(
JNIEnv* env, const jobject jstatus) {
jmethodID mid_code = getCodeMethod(env);
if (mid_code == nullptr) {
// exception occurred
return nullptr;
}
jobject jcode = env->CallObjectMethod(jstatus, mid_code);
if (env->ExceptionCheck()) {
// exception occurred
return nullptr;
}
jmethodID mid_code_value = ROCKSDB_NAMESPACE::CodeJni::getValueMethod(env);
if (mid_code_value == nullptr) {
// exception occurred
return nullptr;
}
jbyte jcode_value = env->CallByteMethod(jcode, mid_code_value);
if (env->ExceptionCheck()) {
// exception occurred
if (jcode != nullptr) {
env->DeleteLocalRef(jcode);
}
return nullptr;
}
jmethodID mid_subCode = getSubCodeMethod(env);
if (mid_subCode == nullptr) {
// exception occurred
return nullptr;
}
jobject jsubCode = env->CallObjectMethod(jstatus, mid_subCode);
if (env->ExceptionCheck()) {
// exception occurred
if (jcode != nullptr) {
env->DeleteLocalRef(jcode);
}
return nullptr;
}
jbyte jsub_code_value = 0x0; // None
if (jsubCode != nullptr) {
jmethodID mid_subCode_value =
ROCKSDB_NAMESPACE::SubCodeJni::getValueMethod(env);
if (mid_subCode_value == nullptr) {
// exception occurred
return nullptr;
}
jsub_code_value = env->CallByteMethod(jsubCode, mid_subCode_value);
if (env->ExceptionCheck()) {
// exception occurred
if (jcode != nullptr) {
env->DeleteLocalRef(jcode);
}
return nullptr;
}
}
jmethodID mid_state = getStateMethod(env);
if (mid_state == nullptr) {
// exception occurred
return nullptr;
}
jobject jstate = env->CallObjectMethod(jstatus, mid_state);
if (env->ExceptionCheck()) {
// exception occurred
if (jsubCode != nullptr) {
env->DeleteLocalRef(jsubCode);
}
if (jcode != nullptr) {
env->DeleteLocalRef(jcode);
}
return nullptr;
}
std::unique_ptr<ROCKSDB_NAMESPACE::Status> status =
toCppStatus(jcode_value, jsub_code_value);
// delete all local refs
if (jstate != nullptr) {
env->DeleteLocalRef(jstate);
}
if (jsubCode != nullptr) {
env->DeleteLocalRef(jsubCode);
}
if (jcode != nullptr) {
env->DeleteLocalRef(jcode);
}
return status;
}
};
// The portal class for org.rocksdb.RocksDBException
class RocksDBExceptionJni :
public JavaException<RocksDBExceptionJni> {
public:
/**
* Get the Java Class org.rocksdb.RocksDBException
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaException::getJClass(env, "org/rocksdb/RocksDBException");
}
/**
* Create and throw a Java RocksDBException with the provided message
*
* @param env A pointer to the Java environment
* @param msg The message for the exception
*
* @return true if an exception was thrown, false otherwise
*/
static bool ThrowNew(JNIEnv* env, const std::string& msg) {
return JavaException::ThrowNew(env, msg);
}
/**
* Create and throw a Java RocksDBException with the provided status
*
* If s->ok() == true, then this function will not throw any exception.
*
* @param env A pointer to the Java environment
* @param s The status for the exception
*
* @return true if an exception was thrown, false otherwise
*/
static bool ThrowNew(JNIEnv* env, std::unique_ptr<Status>& s) {
return ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, *(s.get()));
}
/**
* Create and throw a Java RocksDBException with the provided status
*
* If s.ok() == true, then this function will not throw any exception.
*
* @param env A pointer to the Java environment
* @param s The status for the exception
*
* @return true if an exception was thrown, false otherwise
*/
static bool ThrowNew(JNIEnv* env, const Status& s) {
if (s.ok()) {
return false;
}
// get the RocksDBException class
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
std::cerr << "RocksDBExceptionJni::ThrowNew/class - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
// get the constructor of org.rocksdb.RocksDBException
jmethodID mid =
env->GetMethodID(jclazz, "<init>", "(Lorg/rocksdb/Status;)V");
if(mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
std::cerr << "RocksDBExceptionJni::ThrowNew/cstr - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
// get the Java status object
jobject jstatus = StatusJni::construct(env, s);
if(jstatus == nullptr) {
// exception occcurred
std::cerr << "RocksDBExceptionJni::ThrowNew/StatusJni - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
// construct the RocksDBException
jthrowable rocksdb_exception = reinterpret_cast<jthrowable>(env->NewObject(jclazz, mid, jstatus));
if(env->ExceptionCheck()) {
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
std::cerr << "RocksDBExceptionJni::ThrowNew/NewObject - Error: unexpected exception!" << std::endl;
return true;
}
// throw the RocksDBException
const jint rs = env->Throw(rocksdb_exception);
if(rs != JNI_OK) {
// exception could not be thrown
std::cerr << "RocksDBExceptionJni::ThrowNew - Fatal: could not throw exception!" << std::endl;
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
return env->ExceptionCheck();
}
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
return true;
}
/**
* Create and throw a Java RocksDBException with the provided message
* and status
*
* If s.ok() == true, then this function will not throw any exception.
*
* @param env A pointer to the Java environment
* @param msg The message for the exception
* @param s The status for the exception
*
* @return true if an exception was thrown, false otherwise
*/
static bool ThrowNew(JNIEnv* env, const std::string& msg, const Status& s) {
assert(!s.ok());
if (s.ok()) {
return false;
}
// get the RocksDBException class
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
std::cerr << "RocksDBExceptionJni::ThrowNew/class - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
// get the constructor of org.rocksdb.RocksDBException
jmethodID mid =
env->GetMethodID(jclazz, "<init>", "(Ljava/lang/String;Lorg/rocksdb/Status;)V");
if(mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
std::cerr << "RocksDBExceptionJni::ThrowNew/cstr - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
jstring jmsg = env->NewStringUTF(msg.c_str());
if(jmsg == nullptr) {
// exception thrown: OutOfMemoryError
std::cerr << "RocksDBExceptionJni::ThrowNew/msg - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
// get the Java status object
jobject jstatus = StatusJni::construct(env, s);
if(jstatus == nullptr) {
// exception occcurred
std::cerr << "RocksDBExceptionJni::ThrowNew/StatusJni - Error: unexpected exception!" << std::endl;
if(jmsg != nullptr) {
env->DeleteLocalRef(jmsg);
}
return env->ExceptionCheck();
}
// construct the RocksDBException
jthrowable rocksdb_exception = reinterpret_cast<jthrowable>(env->NewObject(jclazz, mid, jmsg, jstatus));
if(env->ExceptionCheck()) {
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(jmsg != nullptr) {
env->DeleteLocalRef(jmsg);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
std::cerr << "RocksDBExceptionJni::ThrowNew/NewObject - Error: unexpected exception!" << std::endl;
return true;
}
// throw the RocksDBException
const jint rs = env->Throw(rocksdb_exception);
if(rs != JNI_OK) {
// exception could not be thrown
std::cerr << "RocksDBExceptionJni::ThrowNew - Fatal: could not throw exception!" << std::endl;
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(jmsg != nullptr) {
env->DeleteLocalRef(jmsg);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
return env->ExceptionCheck();
}
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(jmsg != nullptr) {
env->DeleteLocalRef(jmsg);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
return true;
}
/**
* Get the Java Method: RocksDBException#getStatus
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getStatusMethod(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "getStatus", "()Lorg/rocksdb/Status;");
assert(mid != nullptr);
return mid;
}
static std::unique_ptr<ROCKSDB_NAMESPACE::Status> toCppStatus(
JNIEnv* env, jthrowable jrocksdb_exception) {
if(!env->IsInstanceOf(jrocksdb_exception, getJClass(env))) {
// not an instance of RocksDBException
return nullptr;
}
// get the java status object
jmethodID mid = getStatusMethod(env);
if(mid == nullptr) {
// exception occurred accessing class or method
return nullptr;
}
jobject jstatus = env->CallObjectMethod(jrocksdb_exception, mid);
if(env->ExceptionCheck()) {
// exception occurred
return nullptr;
}
if(jstatus == nullptr) {
return nullptr; // no status available
}
return ROCKSDB_NAMESPACE::StatusJni::toCppStatus(env, jstatus);
}
};
// The portal class for java.util.List
class ListJni : public JavaClass {
public:
/**
* Get the Java Class java.util.List
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getListClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/util/List");
}
/**
* Get the Java Class java.util.ArrayList
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getArrayListClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/util/ArrayList");
}
/**
* Get the Java Class java.util.Iterator
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getIteratorClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/util/Iterator");
}
/**
* Get the Java Method: List#iterator
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getIteratorMethod(JNIEnv* env) {
jclass jlist_clazz = getListClass(env);
if(jlist_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jlist_clazz, "iterator", "()Ljava/util/Iterator;");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: Iterator#hasNext
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getHasNextMethod(JNIEnv* env) {
jclass jiterator_clazz = getIteratorClass(env);
if(jiterator_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jiterator_clazz, "hasNext", "()Z");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: Iterator#next
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getNextMethod(JNIEnv* env) {
jclass jiterator_clazz = getIteratorClass(env);
if(jiterator_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jiterator_clazz, "next", "()Ljava/lang/Object;");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: ArrayList constructor
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getArrayListConstructorMethodId(JNIEnv* env) {
jclass jarray_list_clazz = getArrayListClass(env);
if(jarray_list_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jarray_list_clazz, "<init>", "(I)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: List#add
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getListAddMethodId(JNIEnv* env) {
jclass jlist_clazz = getListClass(env);
if(jlist_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jlist_clazz, "add", "(Ljava/lang/Object;)Z");
assert(mid != nullptr);
return mid;
}
};
// The portal class for java.lang.Byte
class ByteJni : public JavaClass {
public:
/**
* Get the Java Class java.lang.Byte
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/lang/Byte");
}
/**
* Get the Java Class byte[]
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getArrayJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "[B");
}
/**
* Creates a new 2-dimensional Java Byte Array byte[][]
*
* @param env A pointer to the Java environment
* @param len The size of the first dimension
*
* @return A reference to the Java byte[][] or nullptr if an exception occurs
*/
static jobjectArray new2dByteArray(JNIEnv* env, const jsize len) {
jclass clazz = getArrayJClass(env);
if(clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
return env->NewObjectArray(len, clazz, nullptr);
}
/**
* Get the Java Method: Byte#byteValue
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retrieved
*/
static jmethodID getByteValueMethod(JNIEnv* env) {
jclass clazz = getJClass(env);
if(clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(clazz, "byteValue", "()B");
assert(mid != nullptr);
return mid;
}
/**
* Calls the Java Method: Byte#valueOf, returning a constructed Byte jobject
*
* @param env A pointer to the Java environment
*
* @return A constructing Byte object or nullptr if the class or method id could not
* be retrieved, or an exception occurred
*/
static jobject valueOf(JNIEnv* env, jbyte jprimitive_byte) {
jclass clazz = getJClass(env);
if (clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetStaticMethodID(clazz, "valueOf", "(B)Ljava/lang/Byte;");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
const jobject jbyte_obj =
env->CallStaticObjectMethod(clazz, mid, jprimitive_byte);
if (env->ExceptionCheck()) {
// exception occurred
return nullptr;
}
return jbyte_obj;
}
};
// The portal class for java.nio.ByteBuffer
class ByteBufferJni : public JavaClass {
public:
/**
* Get the Java Class java.nio.ByteBuffer
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/nio/ByteBuffer");
}
/**
* Get the Java Method: ByteBuffer#allocate
*
* @param env A pointer to the Java environment
* @param jbytebuffer_clazz if you have a reference to a ByteBuffer class, or nullptr
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getAllocateMethodId(JNIEnv* env,
jclass jbytebuffer_clazz = nullptr) {
const jclass jclazz =
jbytebuffer_clazz == nullptr ? getJClass(env) : jbytebuffer_clazz;
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetStaticMethodID(
jclazz, "allocate", "(I)Ljava/nio/ByteBuffer;");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: ByteBuffer#array
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getArrayMethodId(JNIEnv* env,
jclass jbytebuffer_clazz = nullptr) {
const jclass jclazz =
jbytebuffer_clazz == nullptr ? getJClass(env) : jbytebuffer_clazz;
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "array", "()[B");
assert(mid != nullptr);
return mid;
}
static jobject construct(
JNIEnv* env, const bool direct, const size_t capacity,
jclass jbytebuffer_clazz = nullptr) {
return constructWith(env, direct, nullptr, capacity, jbytebuffer_clazz);
}
static jobject constructWith(JNIEnv* env, const bool direct, const char* buf,
const size_t capacity,
jclass jbytebuffer_clazz = nullptr) {
if (direct) {
bool allocated = false;
if (buf == nullptr) {
buf = new char[capacity];
allocated = true;
}
jobject jbuf = env->NewDirectByteBuffer(const_cast<char*>(buf), static_cast<jlong>(capacity));
if (jbuf == nullptr) {
// exception occurred
if (allocated) {
delete[] static_cast<const char*>(buf);
}
return nullptr;
}
return jbuf;
} else {
const jclass jclazz =
jbytebuffer_clazz == nullptr ? getJClass(env) : jbytebuffer_clazz;
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
const jmethodID jmid_allocate = getAllocateMethodId(env, jbytebuffer_clazz);
if (jmid_allocate == nullptr) {
// exception occurred accessing class, or NoSuchMethodException or OutOfMemoryError
return nullptr;
}
const jobject jbuf = env->CallStaticObjectMethod(
jclazz, jmid_allocate, static_cast<jint>(capacity));
if (env->ExceptionCheck()) {
// exception occurred
return nullptr;
}
// set buffer data?
if (buf != nullptr) {
jbyteArray jarray = array(env, jbuf, jbytebuffer_clazz);
if (jarray == nullptr) {
// exception occurred
env->DeleteLocalRef(jbuf);
return nullptr;
}
jboolean is_copy = JNI_FALSE;
jbyte* ja = reinterpret_cast<jbyte*>(
env->GetPrimitiveArrayCritical(jarray, &is_copy));
if (ja == nullptr) {
// exception occurred
env->DeleteLocalRef(jarray);
env->DeleteLocalRef(jbuf);
return nullptr;
}
memcpy(ja, const_cast<char*>(buf), capacity);
env->ReleasePrimitiveArrayCritical(jarray, ja, 0);
env->DeleteLocalRef(jarray);
}
return jbuf;
}
}
static jbyteArray array(JNIEnv* env, const jobject& jbyte_buffer,
jclass jbytebuffer_clazz = nullptr) {
const jmethodID mid = getArrayMethodId(env, jbytebuffer_clazz);
if (mid == nullptr) {
// exception occurred accessing class, or NoSuchMethodException or OutOfMemoryError
return nullptr;
}
const jobject jarray = env->CallObjectMethod(jbyte_buffer, mid);
if (env->ExceptionCheck()) {
// exception occurred
return nullptr;
}
return static_cast<jbyteArray>(jarray);
}
};
// The portal class for java.lang.Integer
class IntegerJni : public JavaClass {
public:
/**
* Get the Java Class java.lang.Integer
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/lang/Integer");
}
static jobject valueOf(JNIEnv* env, jint jprimitive_int) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid =
env->GetStaticMethodID(jclazz, "valueOf", "(I)Ljava/lang/Integer;");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
const jobject jinteger_obj =
env->CallStaticObjectMethod(jclazz, mid, jprimitive_int);
if (env->ExceptionCheck()) {
// exception occurred
return nullptr;
}
return jinteger_obj;
}
};
// The portal class for java.lang.Long
class LongJni : public JavaClass {
public:
/**
* Get the Java Class java.lang.Long
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/lang/Long");
}
static jobject valueOf(JNIEnv* env, jlong jprimitive_long) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid =
env->GetStaticMethodID(jclazz, "valueOf", "(J)Ljava/lang/Long;");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
const jobject jlong_obj =
env->CallStaticObjectMethod(jclazz, mid, jprimitive_long);
if (env->ExceptionCheck()) {
// exception occurred
return nullptr;
}
return jlong_obj;
}
};
// The portal class for java.lang.StringBuilder
class StringBuilderJni : public JavaClass {
public:
/**
* Get the Java Class java.lang.StringBuilder
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/lang/StringBuilder");
}
/**
* Get the Java Method: StringBuilder#append
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getListAddMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "append",
"(Ljava/lang/String;)Ljava/lang/StringBuilder;");
assert(mid != nullptr);
return mid;
}
/**
* Appends a C-style string to a StringBuilder
*
* @param env A pointer to the Java environment
* @param jstring_builder Reference to a java.lang.StringBuilder
* @param c_str A C-style string to append to the StringBuilder
*
* @return A reference to the updated StringBuilder, or a nullptr if
* an exception occurs
*/
static jobject append(JNIEnv* env, jobject jstring_builder,
const char* c_str) {
jmethodID mid = getListAddMethodId(env);
if(mid == nullptr) {
// exception occurred accessing class or method
return nullptr;
}
jstring new_value_str = env->NewStringUTF(c_str);
if(new_value_str == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
jobject jresult_string_builder =
env->CallObjectMethod(jstring_builder, mid, new_value_str);
if(env->ExceptionCheck()) {
// exception occurred
env->DeleteLocalRef(new_value_str);
return nullptr;
}
return jresult_string_builder;
}
};
// various utility functions for working with RocksDB and JNI
class JniUtil {
public:
/**
* Detect if jlong overflows size_t
*
* @param jvalue the jlong value
*
* @return
*/
inline static Status check_if_jlong_fits_size_t(const jlong& jvalue) {
Status s = Status::OK();
if (static_cast<uint64_t>(jvalue) > std::numeric_limits<size_t>::max()) {
s = Status::InvalidArgument(Slice("jlong overflows 32 bit value."));
}
return s;
}
/**
* Obtains a reference to the JNIEnv from
* the JVM
*
* If the current thread is not attached to the JavaVM
* then it will be attached so as to retrieve the JNIEnv
*
* If a thread is attached, it must later be manually
* released by calling JavaVM::DetachCurrentThread.
* This can be handled by always matching calls to this
* function with calls to {@link JniUtil::releaseJniEnv(JavaVM*, jboolean)}
*
* @param jvm (IN) A pointer to the JavaVM instance
* @param attached (OUT) A pointer to a boolean which
* will be set to JNI_TRUE if we had to attach the thread
*
* @return A pointer to the JNIEnv or nullptr if a fatal error
* occurs and the JNIEnv cannot be retrieved
*/
static JNIEnv* getJniEnv(JavaVM* jvm, jboolean* attached) {
assert(jvm != nullptr);
JNIEnv *env;
const jint env_rs = jvm->GetEnv(reinterpret_cast<void**>(&env),
JNI_VERSION_1_6);
if(env_rs == JNI_OK) {
// current thread is already attached, return the JNIEnv
*attached = JNI_FALSE;
return env;
} else if(env_rs == JNI_EDETACHED) {
// current thread is not attached, attempt to attach
const jint rs_attach = jvm->AttachCurrentThread(reinterpret_cast<void**>(&env), NULL);
if(rs_attach == JNI_OK) {
*attached = JNI_TRUE;
return env;
} else {
// error, could not attach the thread
std::cerr << "JniUtil::getJniEnv - Fatal: could not attach current thread to JVM!" << std::endl;
return nullptr;
}
} else if(env_rs == JNI_EVERSION) {
// error, JDK does not support JNI_VERSION_1_6+
std::cerr << "JniUtil::getJniEnv - Fatal: JDK does not support JNI_VERSION_1_6" << std::endl;
return nullptr;
} else {
std::cerr << "JniUtil::getJniEnv - Fatal: Unknown error: env_rs=" << env_rs << std::endl;
return nullptr;
}
}
/**
* Counterpart to {@link JniUtil::getJniEnv(JavaVM*, jboolean*)}
*
* Detachess the current thread from the JVM if it was previously
* attached
*
* @param jvm (IN) A pointer to the JavaVM instance
* @param attached (IN) JNI_TRUE if we previously had to attach the thread
* to the JavaVM to get the JNIEnv
*/
static void releaseJniEnv(JavaVM* jvm, jboolean& attached) {
assert(jvm != nullptr);
if(attached == JNI_TRUE) {
const jint rs_detach = jvm->DetachCurrentThread();
assert(rs_detach == JNI_OK);
if(rs_detach != JNI_OK) {
std::cerr << "JniUtil::getJniEnv - Warn: Unable to detach current thread from JVM!" << std::endl;
}
}
}
/**
* Copies a Java String[] to a C++ std::vector<std::string>
*
* @param env (IN) A pointer to the java environment
* @param jss (IN) The Java String array to copy
* @param has_exception (OUT) will be set to JNI_TRUE
* if an OutOfMemoryError or ArrayIndexOutOfBoundsException
* exception occurs
*
* @return A std::vector<std:string> containing copies of the Java strings
*/
static std::vector<std::string> copyStrings(JNIEnv* env,
jobjectArray jss, jboolean* has_exception) {
return ROCKSDB_NAMESPACE::JniUtil::copyStrings(
env, jss, env->GetArrayLength(jss), has_exception);
}
/**
* Copies a Java String[] to a C++ std::vector<std::string>
*
* @param env (IN) A pointer to the java environment
* @param jss (IN) The Java String array to copy
* @param jss_len (IN) The length of the Java String array to copy
* @param has_exception (OUT) will be set to JNI_TRUE
* if an OutOfMemoryError or ArrayIndexOutOfBoundsException
* exception occurs
*
* @return A std::vector<std:string> containing copies of the Java strings
*/
static std::vector<std::string> copyStrings(JNIEnv* env,
jobjectArray jss, const jsize jss_len, jboolean* has_exception) {
std::vector<std::string> strs;
strs.reserve(jss_len);
for (jsize i = 0; i < jss_len; i++) {
jobject js = env->GetObjectArrayElement(jss, i);
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
*has_exception = JNI_TRUE;
return strs;
}
jstring jstr = static_cast<jstring>(js);
const char* str = env->GetStringUTFChars(jstr, nullptr);
if(str == nullptr) {
// exception thrown: OutOfMemoryError
env->DeleteLocalRef(js);
*has_exception = JNI_TRUE;
return strs;
}
strs.push_back(std::string(str));
env->ReleaseStringUTFChars(jstr, str);
env->DeleteLocalRef(js);
}
*has_exception = JNI_FALSE;
return strs;
}
/**
* Copies a jstring to a C-style null-terminated byte string
* and releases the original jstring
*
* The jstring is copied as UTF-8
*
* If an exception occurs, then JNIEnv::ExceptionCheck()
* will have been called
*
* @param env (IN) A pointer to the java environment
* @param js (IN) The java string to copy
* @param has_exception (OUT) will be set to JNI_TRUE
* if an OutOfMemoryError exception occurs
*
* @return A pointer to the copied string, or a
* nullptr if has_exception == JNI_TRUE
*/
static std::unique_ptr<char[]> copyString(JNIEnv* env, jstring js,
jboolean* has_exception) {
const char *utf = env->GetStringUTFChars(js, nullptr);
if(utf == nullptr) {
// exception thrown: OutOfMemoryError
env->ExceptionCheck();
*has_exception = JNI_TRUE;
return nullptr;
} else if(env->ExceptionCheck()) {
// exception thrown
env->ReleaseStringUTFChars(js, utf);
*has_exception = JNI_TRUE;
return nullptr;
}
const jsize utf_len = env->GetStringUTFLength(js);
std::unique_ptr<char[]> str(new char[utf_len + 1]); // Note: + 1 is needed for the c_str null terminator
std::strcpy(str.get(), utf);
env->ReleaseStringUTFChars(js, utf);
*has_exception = JNI_FALSE;
return str;
}
/**
* Copies a jstring to a std::string
* and releases the original jstring
*
* If an exception occurs, then JNIEnv::ExceptionCheck()
* will have been called
*
* @param env (IN) A pointer to the java environment
* @param js (IN) The java string to copy
* @param has_exception (OUT) will be set to JNI_TRUE
* if an OutOfMemoryError exception occurs
*
* @return A std:string copy of the jstring, or an
* empty std::string if has_exception == JNI_TRUE
*/
static std::string copyStdString(JNIEnv* env, jstring js,
jboolean* has_exception) {
const char *utf = env->GetStringUTFChars(js, nullptr);
if(utf == nullptr) {
// exception thrown: OutOfMemoryError
env->ExceptionCheck();
*has_exception = JNI_TRUE;
return std::string();
} else if(env->ExceptionCheck()) {
// exception thrown
env->ReleaseStringUTFChars(js, utf);
*has_exception = JNI_TRUE;
return std::string();
}
std::string name(utf);
env->ReleaseStringUTFChars(js, utf);
*has_exception = JNI_FALSE;
return name;
}
/**
* Copies bytes from a std::string to a jByteArray
*
* @param env A pointer to the java environment
* @param bytes The bytes to copy
*
* @return the Java byte[], or nullptr if an exception occurs
*
* @throws RocksDBException thrown
* if memory size to copy exceeds general java specific array size limitation.
*/
static jbyteArray copyBytes(JNIEnv* env, std::string bytes) {
return createJavaByteArrayWithSizeCheck(env, bytes.c_str(), bytes.size());
}
/**
* Given a Java byte[][] which is an array of java.lang.Strings
* where each String is a byte[], the passed function `string_fn`
* will be called on each String, the result is the collected by
* calling the passed function `collector_fn`
*
* @param env (IN) A pointer to the java environment
* @param jbyte_strings (IN) A Java array of Strings expressed as bytes
* @param string_fn (IN) A transform function to call for each String
* @param collector_fn (IN) A collector which is called for the result
* of each `string_fn`
* @param has_exception (OUT) will be set to JNI_TRUE
* if an ArrayIndexOutOfBoundsException or OutOfMemoryError
* exception occurs
*/
template <typename T> static void byteStrings(JNIEnv* env,
jobjectArray jbyte_strings,
std::function<T(const char*, const size_t)> string_fn,
std::function<void(size_t, T)> collector_fn,
jboolean *has_exception) {
const jsize jlen = env->GetArrayLength(jbyte_strings);
for(jsize i = 0; i < jlen; i++) {
jobject jbyte_string_obj = env->GetObjectArrayElement(jbyte_strings, i);
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
*has_exception = JNI_TRUE; // signal error
return;
}
jbyteArray jbyte_string_ary =
reinterpret_cast<jbyteArray>(jbyte_string_obj);
T result = byteString(env, jbyte_string_ary, string_fn, has_exception);
env->DeleteLocalRef(jbyte_string_obj);
if(*has_exception == JNI_TRUE) {
// exception thrown: OutOfMemoryError
return;
}
collector_fn(i, result);
}
*has_exception = JNI_FALSE;
}
/**
* Given a Java String which is expressed as a Java Byte Array byte[],
* the passed function `string_fn` will be called on the String
* and the result returned
*
* @param env (IN) A pointer to the java environment
* @param jbyte_string_ary (IN) A Java String expressed in bytes
* @param string_fn (IN) A transform function to call on the String
* @param has_exception (OUT) will be set to JNI_TRUE
* if an OutOfMemoryError exception occurs
*/
template <typename T> static T byteString(JNIEnv* env,
jbyteArray jbyte_string_ary,
std::function<T(const char*, const size_t)> string_fn,
jboolean* has_exception) {
const jsize jbyte_string_len = env->GetArrayLength(jbyte_string_ary);
return byteString<T>(env, jbyte_string_ary, jbyte_string_len, string_fn,
has_exception);
}
/**
* Given a Java String which is expressed as a Java Byte Array byte[],
* the passed function `string_fn` will be called on the String
* and the result returned
*
* @param env (IN) A pointer to the java environment
* @param jbyte_string_ary (IN) A Java String expressed in bytes
* @param jbyte_string_len (IN) The length of the Java String
* expressed in bytes
* @param string_fn (IN) A transform function to call on the String
* @param has_exception (OUT) will be set to JNI_TRUE
* if an OutOfMemoryError exception occurs
*/
template <typename T> static T byteString(JNIEnv* env,
jbyteArray jbyte_string_ary, const jsize jbyte_string_len,
std::function<T(const char*, const size_t)> string_fn,
jboolean* has_exception) {
jbyte* jbyte_string =
env->GetByteArrayElements(jbyte_string_ary, nullptr);
if(jbyte_string == nullptr) {
// exception thrown: OutOfMemoryError
*has_exception = JNI_TRUE;
return nullptr; // signal error
}
T result =
string_fn(reinterpret_cast<char *>(jbyte_string), jbyte_string_len);
env->ReleaseByteArrayElements(jbyte_string_ary, jbyte_string, JNI_ABORT);
*has_exception = JNI_FALSE;
return result;
}
/**
* Converts a std::vector<string> to a Java byte[][] where each Java String
* is expressed as a Java Byte Array byte[].
*
* @param env A pointer to the java environment
* @param strings A vector of Strings
*
* @return A Java array of Strings expressed as bytes,
* or nullptr if an exception is thrown
*/
static jobjectArray stringsBytes(JNIEnv* env, std::vector<std::string> strings) {
jclass jcls_ba = ByteJni::getArrayJClass(env);
if(jcls_ba == nullptr) {
// exception occurred
return nullptr;
}
const jsize len = static_cast<jsize>(strings.size());
jobjectArray jbyte_strings = env->NewObjectArray(len, jcls_ba, nullptr);
if(jbyte_strings == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
for (jsize i = 0; i < len; i++) {
std::string *str = &strings[i];
const jsize str_len = static_cast<jsize>(str->size());
jbyteArray jbyte_string_ary = env->NewByteArray(str_len);
if(jbyte_string_ary == nullptr) {
// exception thrown: OutOfMemoryError
env->DeleteLocalRef(jbyte_strings);
return nullptr;
}
env->SetByteArrayRegion(
jbyte_string_ary, 0, str_len,
const_cast<jbyte*>(reinterpret_cast<const jbyte*>(str->c_str())));
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
env->DeleteLocalRef(jbyte_string_ary);
env->DeleteLocalRef(jbyte_strings);
return nullptr;
}
env->SetObjectArrayElement(jbyte_strings, i, jbyte_string_ary);
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
// or ArrayStoreException
env->DeleteLocalRef(jbyte_string_ary);
env->DeleteLocalRef(jbyte_strings);
return nullptr;
}
env->DeleteLocalRef(jbyte_string_ary);
}
return jbyte_strings;
}
/**
* Converts a std::vector<std::string> to a Java String[].
*
* @param env A pointer to the java environment
* @param strings A vector of Strings
*
* @return A Java array of Strings,
* or nullptr if an exception is thrown
*/
static jobjectArray toJavaStrings(JNIEnv* env,
const std::vector<std::string>* strings) {
jclass jcls_str = env->FindClass("java/lang/String");
if(jcls_str == nullptr) {
// exception occurred
return nullptr;
}
const jsize len = static_cast<jsize>(strings->size());
jobjectArray jstrings = env->NewObjectArray(len, jcls_str, nullptr);
if(jstrings == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
for (jsize i = 0; i < len; i++) {
const std::string *str = &((*strings)[i]);
jstring js = ROCKSDB_NAMESPACE::JniUtil::toJavaString(env, str);
if (js == nullptr) {
env->DeleteLocalRef(jstrings);
return nullptr;
}
env->SetObjectArrayElement(jstrings, i, js);
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
// or ArrayStoreException
env->DeleteLocalRef(js);
env->DeleteLocalRef(jstrings);
return nullptr;
}
}
return jstrings;
}
/**
* Creates a Java UTF String from a C++ std::string
*
* @param env A pointer to the java environment
* @param string the C++ std::string
* @param treat_empty_as_null true if empty strings should be treated as null
*
* @return the Java UTF string, or nullptr if the provided string
* is null (or empty and treat_empty_as_null is set), or if an
* exception occurs allocating the Java String.
*/
static jstring toJavaString(JNIEnv* env, const std::string* string,
const bool treat_empty_as_null = false) {
if (string == nullptr) {
return nullptr;
}
if (treat_empty_as_null && string->empty()) {
return nullptr;
}
return env->NewStringUTF(string->c_str());
}
/**
* Copies bytes to a new jByteArray with the check of java array size limitation.
*
* @param bytes pointer to memory to copy to a new jByteArray
* @param size number of bytes to copy
*
* @return the Java byte[], or nullptr if an exception occurs
*
* @throws RocksDBException thrown
* if memory size to copy exceeds general java array size limitation to avoid overflow.
*/
static jbyteArray createJavaByteArrayWithSizeCheck(JNIEnv* env, const char* bytes, const size_t size) {
// Limitation for java array size is vm specific
// In general it cannot exceed Integer.MAX_VALUE (2^31 - 1)
// Current HotSpot VM limitation for array size is Integer.MAX_VALUE - 5 (2^31 - 1 - 5)
// It means that the next call to env->NewByteArray can still end with
// OutOfMemoryError("Requested array size exceeds VM limit") coming from VM
static const size_t MAX_JARRAY_SIZE = (static_cast<size_t>(1)) << 31;
if(size > MAX_JARRAY_SIZE) {
ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(
env, "Requested array size exceeds VM limit");
return nullptr;
}
const jsize jlen = static_cast<jsize>(size);
jbyteArray jbytes = env->NewByteArray(jlen);
if(jbytes == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
env->SetByteArrayRegion(jbytes, 0, jlen,
const_cast<jbyte*>(reinterpret_cast<const jbyte*>(bytes)));
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
env->DeleteLocalRef(jbytes);
return nullptr;
}
return jbytes;
}
/**
* Copies bytes from a ROCKSDB_NAMESPACE::Slice to a jByteArray
*
* @param env A pointer to the java environment
* @param bytes The bytes to copy
*
* @return the Java byte[] or nullptr if an exception occurs
*
* @throws RocksDBException thrown
* if memory size to copy exceeds general java specific array size
* limitation.
*/
static jbyteArray copyBytes(JNIEnv* env, const Slice& bytes) {
return createJavaByteArrayWithSizeCheck(env, bytes.data(), bytes.size());
}
/*
* Helper for operations on a key and value
* for example WriteBatch->Put
*
* TODO(AR) could be used for RocksDB->Put etc.
*/
static std::unique_ptr<ROCKSDB_NAMESPACE::Status> kv_op(
std::function<ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Slice,
ROCKSDB_NAMESPACE::Slice)>
op,
JNIEnv* env, jobject /*jobj*/, jbyteArray jkey, jint jkey_len,
jbyteArray jvalue, jint jvalue_len) {
jbyte* key = env->GetByteArrayElements(jkey, nullptr);
if(env->ExceptionCheck()) {
// exception thrown: OutOfMemoryError
return nullptr;
}
jbyte* value = env->GetByteArrayElements(jvalue, nullptr);
if(env->ExceptionCheck()) {
// exception thrown: OutOfMemoryError
if(key != nullptr) {
env->ReleaseByteArrayElements(jkey, key, JNI_ABORT);
}
return nullptr;
}
ROCKSDB_NAMESPACE::Slice key_slice(reinterpret_cast<char*>(key),
jkey_len);
ROCKSDB_NAMESPACE::Slice value_slice(reinterpret_cast<char*>(value),
jvalue_len);
auto status = op(key_slice, value_slice);
if(value != nullptr) {
env->ReleaseByteArrayElements(jvalue, value, JNI_ABORT);
}
if(key != nullptr) {
env->ReleaseByteArrayElements(jkey, key, JNI_ABORT);
}
return std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(status));
}
/*
* Helper for operations on a key
* for example WriteBatch->Delete
*
* TODO(AR) could be used for RocksDB->Delete etc.
*/
static std::unique_ptr<ROCKSDB_NAMESPACE::Status> k_op(
std::function<ROCKSDB_NAMESPACE::Status(ROCKSDB_NAMESPACE::Slice)> op,
JNIEnv* env, jobject /*jobj*/, jbyteArray jkey, jint jkey_len) {
jbyte* key = env->GetByteArrayElements(jkey, nullptr);
if(env->ExceptionCheck()) {
// exception thrown: OutOfMemoryError
return nullptr;
}
ROCKSDB_NAMESPACE::Slice key_slice(reinterpret_cast<char*>(key),
jkey_len);
auto status = op(key_slice);
if(key != nullptr) {
env->ReleaseByteArrayElements(jkey, key, JNI_ABORT);
}
return std::unique_ptr<ROCKSDB_NAMESPACE::Status>(
new ROCKSDB_NAMESPACE::Status(status));
}
/*
* Helper for operations on a value
* for example WriteBatchWithIndex->GetFromBatch
*/
static jbyteArray v_op(std::function<ROCKSDB_NAMESPACE::Status(
ROCKSDB_NAMESPACE::Slice, std::string*)>
op,
JNIEnv* env, jbyteArray jkey, jint jkey_len) {
jbyte* key = env->GetByteArrayElements(jkey, nullptr);
if(env->ExceptionCheck()) {
// exception thrown: OutOfMemoryError
return nullptr;
}
ROCKSDB_NAMESPACE::Slice key_slice(reinterpret_cast<char*>(key),
jkey_len);
std::string value;
ROCKSDB_NAMESPACE::Status s = op(key_slice, &value);
if(key != nullptr) {
env->ReleaseByteArrayElements(jkey, key, JNI_ABORT);
}
if (s.IsNotFound()) {
return nullptr;
}
if (s.ok()) {
jbyteArray jret_value =
env->NewByteArray(static_cast<jsize>(value.size()));
if(jret_value == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
env->SetByteArrayRegion(jret_value, 0, static_cast<jsize>(value.size()),
const_cast<jbyte*>(reinterpret_cast<const jbyte*>(value.c_str())));
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
if(jret_value != nullptr) {
env->DeleteLocalRef(jret_value);
}
return nullptr;
}
return jret_value;
}
ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, s);
return nullptr;
}
/**
* Creates a vector<T*> of C++ pointers from
* a Java array of C++ pointer addresses.
*
* @param env (IN) A pointer to the java environment
* @param pointers (IN) A Java array of C++ pointer addresses
* @param has_exception (OUT) will be set to JNI_TRUE
* if an ArrayIndexOutOfBoundsException or OutOfMemoryError
* exception occurs.
*
* @return A vector of C++ pointers.
*/
template<typename T> static std::vector<T*> fromJPointers(
JNIEnv* env, jlongArray jptrs, jboolean *has_exception) {
const jsize jptrs_len = env->GetArrayLength(jptrs);
std::vector<T*> ptrs;
jlong* jptr = env->GetLongArrayElements(jptrs, nullptr);
if (jptr == nullptr) {
// exception thrown: OutOfMemoryError
*has_exception = JNI_TRUE;
return ptrs;
}
ptrs.reserve(jptrs_len);
for (jsize i = 0; i < jptrs_len; i++) {
ptrs.push_back(reinterpret_cast<T*>(jptr[i]));
}
env->ReleaseLongArrayElements(jptrs, jptr, JNI_ABORT);
return ptrs;
}
/**
* Creates a Java array of C++ pointer addresses
* from a vector of C++ pointers.
*
* @param env (IN) A pointer to the java environment
* @param pointers (IN) A vector of C++ pointers
* @param has_exception (OUT) will be set to JNI_TRUE
* if an ArrayIndexOutOfBoundsException or OutOfMemoryError
* exception occurs
*
* @return Java array of C++ pointer addresses.
*/
template<typename T> static jlongArray toJPointers(JNIEnv* env,
const std::vector<T*> &pointers,
jboolean *has_exception) {
const jsize len = static_cast<jsize>(pointers.size());
std::unique_ptr<jlong[]> results(new jlong[len]);
std::transform(pointers.begin(), pointers.end(), results.get(), [](T* pointer) -> jlong {
return reinterpret_cast<jlong>(pointer);
});
jlongArray jpointers = env->NewLongArray(len);
if (jpointers == nullptr) {
// exception thrown: OutOfMemoryError
*has_exception = JNI_TRUE;
return nullptr;
}
env->SetLongArrayRegion(jpointers, 0, len, results.get());
if (env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
*has_exception = JNI_TRUE;
env->DeleteLocalRef(jpointers);
return nullptr;
}
*has_exception = JNI_FALSE;
return jpointers;
}
/*
* Helper for operations on a key and value
* for example WriteBatch->Put
*
* TODO(AR) could be extended to cover returning ROCKSDB_NAMESPACE::Status
* from `op` and used for RocksDB->Put etc.
*/
static void kv_op_direct(std::function<void(ROCKSDB_NAMESPACE::Slice&,
ROCKSDB_NAMESPACE::Slice&)>
op,
JNIEnv* env, jobject jkey, jint jkey_off,
jint jkey_len, jobject jval, jint jval_off,
jint jval_len) {
char* key = reinterpret_cast<char*>(env->GetDirectBufferAddress(jkey));
if (key == nullptr ||
env->GetDirectBufferCapacity(jkey) < (jkey_off + jkey_len)) {
ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(
env, "Invalid key argument");
return;
}
char* value = reinterpret_cast<char*>(env->GetDirectBufferAddress(jval));
if (value == nullptr ||
env->GetDirectBufferCapacity(jval) < (jval_off + jval_len)) {
ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(
env, "Invalid value argument");
return;
}
key += jkey_off;
value += jval_off;
ROCKSDB_NAMESPACE::Slice key_slice(key, jkey_len);
ROCKSDB_NAMESPACE::Slice value_slice(value, jval_len);
op(key_slice, value_slice);
}
/*
* Helper for operations on a key and value
* for example WriteBatch->Delete
*
* TODO(AR) could be extended to cover returning ROCKSDB_NAMESPACE::Status
* from `op` and used for RocksDB->Delete etc.
*/
static void k_op_direct(std::function<void(ROCKSDB_NAMESPACE::Slice&)> op,
JNIEnv* env, jobject jkey, jint jkey_off,
jint jkey_len) {
char* key = reinterpret_cast<char*>(env->GetDirectBufferAddress(jkey));
if (key == nullptr ||
env->GetDirectBufferCapacity(jkey) < (jkey_off + jkey_len)) {
ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(
env, "Invalid key argument");
return;
}
key += jkey_off;
ROCKSDB_NAMESPACE::Slice key_slice(key, jkey_len);
return op(key_slice);
}
template <class T>
static jint copyToDirect(JNIEnv* env, T& source, jobject jtarget,
jint jtarget_off, jint jtarget_len) {
char* target =
reinterpret_cast<char*>(env->GetDirectBufferAddress(jtarget));
if (target == nullptr ||
env->GetDirectBufferCapacity(jtarget) < (jtarget_off + jtarget_len)) {
ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(
env, "Invalid target argument");
return 0;
}
target += jtarget_off;
const jint cvalue_len = static_cast<jint>(source.size());
const jint length = std::min(jtarget_len, cvalue_len);
memcpy(target, source.data(), length);
return cvalue_len;
}
};
class MapJni : public JavaClass {
public:
/**
* Get the Java Class java.util.Map
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/util/Map");
}
/**
* Get the Java Method: Map#put
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getMapPutMethodId(JNIEnv* env) {
jclass jlist_clazz = getJClass(env);
if(jlist_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jlist_clazz, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
assert(mid != nullptr);
return mid;
}
};
class HashMapJni : public JavaClass {
public:
/**
* Get the Java Class java.util.HashMap
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/util/HashMap");
}
/**
* Create a new Java java.util.HashMap object.
*
* @param env A pointer to the Java environment
*
* @return A reference to a Java java.util.HashMap object, or
* nullptr if an an exception occurs
*/
static jobject construct(JNIEnv* env, const uint32_t initial_capacity = 16) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(jclazz, "<init>", "(I)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jobject jhash_map = env->NewObject(jclazz, mid, static_cast<jint>(initial_capacity));
if (env->ExceptionCheck()) {
return nullptr;
}
return jhash_map;
}
/**
* A function which maps a std::pair<K,V> to a std::pair<JK, JV>
*
* @return Either a pointer to a std::pair<jobject, jobject>, or nullptr
* if an error occurs during the mapping
*/
template <typename K, typename V, typename JK, typename JV>
using FnMapKV = std::function<std::unique_ptr<std::pair<JK, JV>> (const std::pair<K, V>&)>;
// 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>
// static void putAll(JNIEnv* env, const jobject jhash_map, I iterator, const FnMapKV<const K,V,K1,V1> &fn_map_kv) {
/**
* Returns true if it succeeds, false if an error occurs
*/
template<class iterator_type, typename K, typename V>
static bool putAll(JNIEnv* env, const jobject jhash_map, iterator_type iterator, iterator_type end, const FnMapKV<K, V, jobject, jobject> &fn_map_kv) {
const jmethodID jmid_put =
ROCKSDB_NAMESPACE::MapJni::getMapPutMethodId(env);
if (jmid_put == nullptr) {
return false;
}
for (auto it = iterator; it != end; ++it) {
const std::unique_ptr<std::pair<jobject, jobject>> result = fn_map_kv(*it);
if (result == nullptr) {
// an error occurred during fn_map_kv
return false;
}
env->CallObjectMethod(jhash_map, jmid_put, result->first, result->second);
if (env->ExceptionCheck()) {
// exception occurred
env->DeleteLocalRef(result->second);
env->DeleteLocalRef(result->first);
return false;
}
// release local references
env->DeleteLocalRef(result->second);
env->DeleteLocalRef(result->first);
}
return true;
}
/**
* Creates a java.util.Map<String, String> from a std::map<std::string, std::string>
*
* @param env A pointer to the Java environment
* @param map the Cpp map
*
* @return a reference to the Java java.util.Map object, or nullptr if an exception occcurred
*/
static jobject fromCppMap(JNIEnv* env, const std::map<std::string, std::string>* map) {
if (map == nullptr) {
return nullptr;
}
jobject jhash_map = construct(env, static_cast<uint32_t>(map->size()));
if (jhash_map == nullptr) {
// exception occurred
return nullptr;
}
const ROCKSDB_NAMESPACE::HashMapJni::FnMapKV<
const std::string, const std::string, jobject, jobject>
fn_map_kv =
[env](const std::pair<const std::string, const std::string>& kv) {
jstring jkey = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &(kv.first), false);
if (env->ExceptionCheck()) {
// an error occurred
return std::unique_ptr<std::pair<jobject, jobject>>(nullptr);
}
jstring jvalue = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &(kv.second), true);
if (env->ExceptionCheck()) {
// an error occurred
env->DeleteLocalRef(jkey);
return std::unique_ptr<std::pair<jobject, jobject>>(nullptr);
}
return std::unique_ptr<std::pair<jobject, jobject>>(
new std::pair<jobject, jobject>(
static_cast<jobject>(jkey),
static_cast<jobject>(jvalue)));
};
if (!putAll(env, jhash_map, map->begin(), map->end(), fn_map_kv)) {
// exception occurred
return nullptr;
}
return jhash_map;
}
/**
* Creates a java.util.Map<String, Long> from a std::map<std::string, uint32_t>
*
* @param env A pointer to the Java environment
* @param map the Cpp map
*
* @return a reference to the Java java.util.Map object, or nullptr if an exception occcurred
*/
static jobject fromCppMap(JNIEnv* env, const std::map<std::string, uint32_t>* map) {
if (map == nullptr) {
return nullptr;
}
if (map == nullptr) {
return nullptr;
}
jobject jhash_map = construct(env, static_cast<uint32_t>(map->size()));
if (jhash_map == nullptr) {
// exception occurred
return nullptr;
}
const ROCKSDB_NAMESPACE::HashMapJni::FnMapKV<
const std::string, const uint32_t, jobject, jobject>
fn_map_kv =
[env](const std::pair<const std::string, const uint32_t>& kv) {
jstring jkey = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &(kv.first), false);
if (env->ExceptionCheck()) {
// an error occurred
return std::unique_ptr<std::pair<jobject, jobject>>(nullptr);
}
jobject jvalue = ROCKSDB_NAMESPACE::IntegerJni::valueOf(
env, static_cast<jint>(kv.second));
if (env->ExceptionCheck()) {
// an error occurred
env->DeleteLocalRef(jkey);
return std::unique_ptr<std::pair<jobject, jobject>>(nullptr);
}
return std::unique_ptr<std::pair<jobject, jobject>>(
new std::pair<jobject, jobject>(static_cast<jobject>(jkey),
jvalue));
};
if (!putAll(env, jhash_map, map->begin(), map->end(), fn_map_kv)) {
// exception occurred
return nullptr;
}
return jhash_map;
}
/**
* Creates a java.util.Map<String, Long> from a std::map<std::string, uint64_t>
*
* @param env A pointer to the Java environment
* @param map the Cpp map
*
* @return a reference to the Java java.util.Map object, or nullptr if an exception occcurred
*/
static jobject fromCppMap(JNIEnv* env, const std::map<std::string, uint64_t>* map) {
if (map == nullptr) {
return nullptr;
}
jobject jhash_map = construct(env, static_cast<uint32_t>(map->size()));
if (jhash_map == nullptr) {
// exception occurred
return nullptr;
}
const ROCKSDB_NAMESPACE::HashMapJni::FnMapKV<
const std::string, const uint64_t, jobject, jobject>
fn_map_kv =
[env](const std::pair<const std::string, const uint64_t>& kv) {
jstring jkey = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &(kv.first), false);
if (env->ExceptionCheck()) {
// an error occurred
return std::unique_ptr<std::pair<jobject, jobject>>(nullptr);
}
jobject jvalue = ROCKSDB_NAMESPACE::LongJni::valueOf(
env, static_cast<jlong>(kv.second));
if (env->ExceptionCheck()) {
// an error occurred
env->DeleteLocalRef(jkey);
return std::unique_ptr<std::pair<jobject, jobject>>(nullptr);
}
return std::unique_ptr<std::pair<jobject, jobject>>(
new std::pair<jobject, jobject>(static_cast<jobject>(jkey),
jvalue));
};
if (!putAll(env, jhash_map, map->begin(), map->end(), fn_map_kv)) {
// exception occurred
return nullptr;
}
return jhash_map;
}
/**
* Creates a java.util.Map<String, Long> from a std::map<uint32_t, uint64_t>
*
* @param env A pointer to the Java environment
* @param map the Cpp map
*
* @return a reference to the Java java.util.Map object, or nullptr if an exception occcurred
*/
static jobject fromCppMap(JNIEnv* env, const std::map<uint32_t, uint64_t>* map) {
if (map == nullptr) {
return nullptr;
}
jobject jhash_map = construct(env, static_cast<uint32_t>(map->size()));
if (jhash_map == nullptr) {
// exception occurred
return nullptr;
}
const ROCKSDB_NAMESPACE::HashMapJni::FnMapKV<const uint32_t, const uint64_t,
jobject, jobject>
fn_map_kv = [env](const std::pair<const uint32_t, const uint64_t>& kv) {
jobject jkey = ROCKSDB_NAMESPACE::IntegerJni::valueOf(
env, static_cast<jint>(kv.first));
if (env->ExceptionCheck()) {
// an error occurred
return std::unique_ptr<std::pair<jobject, jobject>>(nullptr);
}
jobject jvalue = ROCKSDB_NAMESPACE::LongJni::valueOf(
env, static_cast<jlong>(kv.second));
if (env->ExceptionCheck()) {
// an error occurred
env->DeleteLocalRef(jkey);
return std::unique_ptr<std::pair<jobject, jobject>>(nullptr);
}
return std::unique_ptr<std::pair<jobject, jobject>>(
new std::pair<jobject, jobject>(static_cast<jobject>(jkey),
jvalue));
};
if (!putAll(env, jhash_map, map->begin(), map->end(), fn_map_kv)) {
// exception occurred
return nullptr;
}
return jhash_map;
}
};
// The portal class for org.rocksdb.RocksDB
class RocksDBJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::DB*, RocksDBJni> {
public:
/**
* Get the Java Class org.rocksdb.RocksDB
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/RocksDB");
}
};
// The portal class for org.rocksdb.Options
class OptionsJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::Options*, OptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.Options
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/Options");
}
};
// The portal class for org.rocksdb.DBOptions
class DBOptionsJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::DBOptions*, DBOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.DBOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/DBOptions");
}
};
// The portal class for org.rocksdb.ColumnFamilyOptions
class ColumnFamilyOptionsJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::ColumnFamilyOptions*,
ColumnFamilyOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.ColumnFamilyOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/ColumnFamilyOptions");
}
/**
* Create a new Java org.rocksdb.ColumnFamilyOptions object with the same
* properties as the provided C++ ROCKSDB_NAMESPACE::ColumnFamilyOptions
* object
*
* @param env A pointer to the Java environment
* @param cfoptions A pointer to ROCKSDB_NAMESPACE::ColumnFamilyOptions object
*
* @return A reference to a Java org.rocksdb.ColumnFamilyOptions object, or
* nullptr if an an exception occurs
*/
static jobject construct(JNIEnv* env, const ColumnFamilyOptions* cfoptions) {
auto* cfo = new ROCKSDB_NAMESPACE::ColumnFamilyOptions(*cfoptions);
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(jclazz, "<init>", "(J)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jobject jcfd = env->NewObject(jclazz, mid, reinterpret_cast<jlong>(cfo));
if (env->ExceptionCheck()) {
return nullptr;
}
return jcfd;
}
};
// The portal class for org.rocksdb.WriteOptions
class WriteOptionsJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::WriteOptions*,
WriteOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.WriteOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/WriteOptions");
}
};
// The portal class for org.rocksdb.ReadOptions
class ReadOptionsJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::ReadOptions*,
ReadOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.ReadOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/ReadOptions");
}
};
// The portal class for org.rocksdb.WriteBatch
class WriteBatchJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::WriteBatch*, WriteBatchJni> {
public:
/**
* Get the Java Class org.rocksdb.WriteBatch
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/WriteBatch");
}
/**
* Create a new Java org.rocksdb.WriteBatch object
*
* @param env A pointer to the Java environment
* @param wb A pointer to ROCKSDB_NAMESPACE::WriteBatch object
*
* @return A reference to a Java org.rocksdb.WriteBatch object, or
* nullptr if an an exception occurs
*/
static jobject construct(JNIEnv* env, const WriteBatch* wb) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(jclazz, "<init>", "(J)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jobject jwb = env->NewObject(jclazz, mid, reinterpret_cast<jlong>(wb));
if (env->ExceptionCheck()) {
return nullptr;
}
return jwb;
}
};
// The portal class for org.rocksdb.WriteBatch.Handler
class WriteBatchHandlerJni
: public RocksDBNativeClass<
const ROCKSDB_NAMESPACE::WriteBatchHandlerJniCallback*,
WriteBatchHandlerJni> {
public:
/**
* Get the Java Class org.rocksdb.WriteBatch.Handler
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/WriteBatch$Handler");
}
/**
* Get the Java Method: WriteBatch.Handler#put
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getPutCfMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "put", "(I[B[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#put
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getPutMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "put", "([B[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#merge
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getMergeCfMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "merge", "(I[B[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#merge
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getMergeMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "merge", "([B[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#delete
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getDeleteCfMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "delete", "(I[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#delete
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getDeleteMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "delete", "([B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#singleDelete
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getSingleDeleteCfMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "singleDelete", "(I[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#singleDelete
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getSingleDeleteMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "singleDelete", "([B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#deleteRange
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getDeleteRangeCfMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "deleteRange", "(I[B[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#deleteRange
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getDeleteRangeMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "deleteRange", "([B[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#logData
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getLogDataMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "logData", "([B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#putBlobIndex
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getPutBlobIndexCfMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "putBlobIndex", "(I[B[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#markBeginPrepare
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getMarkBeginPrepareMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "markBeginPrepare", "()V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#markEndPrepare
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getMarkEndPrepareMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "markEndPrepare", "([B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#markNoop
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getMarkNoopMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "markNoop", "(Z)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#markRollback
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getMarkRollbackMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "markRollback", "([B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#markCommit
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getMarkCommitMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "markCommit", "([B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#shouldContinue
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getContinueMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "shouldContinue", "()Z");
assert(mid != nullptr);
return mid;
}
};
class WriteBatchSavePointJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.WriteBatch.SavePoint
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/WriteBatch$SavePoint");
}
/**
* Get the Java Method: HistogramData constructor
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getConstructorMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "<init>", "(JJJ)V");
assert(mid != nullptr);
return mid;
}
/**
* Create a new Java org.rocksdb.WriteBatch.SavePoint object
*
* @param env A pointer to the Java environment
* @param savePoint A pointer to ROCKSDB_NAMESPACE::WriteBatch::SavePoint
* object
*
* @return A reference to a Java org.rocksdb.WriteBatch.SavePoint object, or
* nullptr if an an exception occurs
*/
static jobject construct(JNIEnv* env, const SavePoint &save_point) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = getConstructorMethodId(env);
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jobject jsave_point = env->NewObject(jclazz, mid,
static_cast<jlong>(save_point.size),
static_cast<jlong>(save_point.count),
static_cast<jlong>(save_point.content_flags));
if (env->ExceptionCheck()) {
return nullptr;
}
return jsave_point;
}
};
// The portal class for org.rocksdb.WriteBatchWithIndex
class WriteBatchWithIndexJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::WriteBatchWithIndex*,
WriteBatchWithIndexJni> {
public:
/**
* Get the Java Class org.rocksdb.WriteBatchWithIndex
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/WriteBatchWithIndex");
}
};
// The portal class for org.rocksdb.HistogramData
class HistogramDataJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.HistogramData
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/HistogramData");
}
/**
* Get the Java Method: HistogramData constructor
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getConstructorMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "<init>", "(DDDDDDJJD)V");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.BackupableDBOptions
class BackupableDBOptionsJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::BackupableDBOptions*,
BackupableDBOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.BackupableDBOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/BackupableDBOptions");
}
};
// The portal class for org.rocksdb.BackupEngine
class BackupEngineJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::BackupEngine*,
BackupEngineJni> {
public:
/**
* Get the Java Class org.rocksdb.BackupableEngine
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/BackupEngine");
}
};
// The portal class for org.rocksdb.RocksIterator
class IteratorJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::Iterator*, IteratorJni> {
public:
/**
* Get the Java Class org.rocksdb.RocksIterator
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/RocksIterator");
}
};
// The portal class for org.rocksdb.Filter
class FilterJni
: public RocksDBNativeClass<
std::shared_ptr<ROCKSDB_NAMESPACE::FilterPolicy>*, FilterJni> {
public:
/**
* Get the Java Class org.rocksdb.Filter
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/Filter");
}
};
// The portal class for org.rocksdb.ColumnFamilyHandle
class ColumnFamilyHandleJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::ColumnFamilyHandle*,
ColumnFamilyHandleJni> {
public:
/**
* Get the Java Class org.rocksdb.ColumnFamilyHandle
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/ColumnFamilyHandle");
}
};
// The portal class for org.rocksdb.FlushOptions
class FlushOptionsJni
: public RocksDBNativeClass<ROCKSDB_NAMESPACE::FlushOptions*,
FlushOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.FlushOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/FlushOptions");
}
};
// The portal class for org.rocksdb.ComparatorOptions
class ComparatorOptionsJni
: public RocksDBNativeClass<
ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions*,
ComparatorOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.ComparatorOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/ComparatorOptions");
}
};
// The portal class for org.rocksdb.AbstractCompactionFilterFactory
class AbstractCompactionFilterFactoryJni
: public RocksDBNativeClass<
const ROCKSDB_NAMESPACE::CompactionFilterFactoryJniCallback*,
AbstractCompactionFilterFactoryJni> {
public:
/**
* Get the Java Class org.rocksdb.AbstractCompactionFilterFactory
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/AbstractCompactionFilterFactory");
}
/**
* Get the Java Method: AbstractCompactionFilterFactory#name
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getNameMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(
jclazz, "name", "()Ljava/lang/String;");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: AbstractCompactionFilterFactory#createCompactionFilter
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getCreateCompactionFilterMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz,
"createCompactionFilter",
"(ZZ)J");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.AbstractTransactionNotifier
class AbstractTransactionNotifierJni
: public RocksDBNativeClass<
const ROCKSDB_NAMESPACE::TransactionNotifierJniCallback*,
AbstractTransactionNotifierJni> {
public:
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/AbstractTransactionNotifier");
}
// Get the java method `snapshotCreated`
// of org.rocksdb.AbstractTransactionNotifier.
static jmethodID getSnapshotCreatedMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "snapshotCreated", "(J)V");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.AbstractComparatorJniBridge
class AbstractComparatorJniBridge : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.AbstractComparatorJniBridge
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env,
"org/rocksdb/AbstractComparatorJniBridge");
}
/**
* Get the Java Method: Comparator#compareInternal
*
* @param env A pointer to the Java environment
* @param jclazz the AbstractComparatorJniBridge class
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getCompareInternalMethodId(JNIEnv* env, jclass jclazz) {
static jmethodID mid =
env->GetStaticMethodID(jclazz, "compareInternal",
"(Lorg/rocksdb/AbstractComparator;Ljava/nio/ByteBuffer;ILjava/nio/ByteBuffer;I)I");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: Comparator#findShortestSeparatorInternal
*
* @param env A pointer to the Java environment
* @param jclazz the AbstractComparatorJniBridge class
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getFindShortestSeparatorInternalMethodId(JNIEnv* env, jclass jclazz) {
static jmethodID mid =
env->GetStaticMethodID(jclazz, "findShortestSeparatorInternal",
"(Lorg/rocksdb/AbstractComparator;Ljava/nio/ByteBuffer;ILjava/nio/ByteBuffer;I)I");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: Comparator#findShortSuccessorInternal
*
* @param env A pointer to the Java environment
* @param jclazz the AbstractComparatorJniBridge class
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getFindShortSuccessorInternalMethodId(JNIEnv* env, jclass jclazz) {
static jmethodID mid =
env->GetStaticMethodID(jclazz, "findShortSuccessorInternal",
"(Lorg/rocksdb/AbstractComparator;Ljava/nio/ByteBuffer;I)I");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.AbstractComparator
class AbstractComparatorJni
: public RocksDBNativeClass<const ROCKSDB_NAMESPACE::ComparatorJniCallback*,
AbstractComparatorJni> {
public:
/**
* Get the Java Class org.rocksdb.AbstractComparator
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/AbstractComparator");
}
/**
* Get the Java Method: Comparator#name
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getNameMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "name", "()Ljava/lang/String;");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.AbstractSlice
class AbstractSliceJni
: public NativeRocksMutableObject<const ROCKSDB_NAMESPACE::Slice*,
AbstractSliceJni> {
public:
/**
* Get the Java Class org.rocksdb.AbstractSlice
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/AbstractSlice");
}
};
// The portal class for org.rocksdb.Slice
class SliceJni
: public NativeRocksMutableObject<const ROCKSDB_NAMESPACE::Slice*,
AbstractSliceJni> {
public:
/**
* Get the Java Class org.rocksdb.Slice
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/Slice");
}
/**
* Constructs a Slice object
*
* @param env A pointer to the Java environment
*
* @return A reference to a Java Slice object, or a nullptr if an
* exception occurs
*/
static jobject construct0(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "<init>", "()V");
if(mid == nullptr) {
// exception occurred accessing method
return nullptr;
}
jobject jslice = env->NewObject(jclazz, mid);
if(env->ExceptionCheck()) {
return nullptr;
}
return jslice;
}
};
// The portal class for org.rocksdb.DirectSlice
class DirectSliceJni
: public NativeRocksMutableObject<const ROCKSDB_NAMESPACE::Slice*,
AbstractSliceJni> {
public:
/**
* Get the Java Class org.rocksdb.DirectSlice
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/DirectSlice");
}
/**
* Constructs a DirectSlice object
*
* @param env A pointer to the Java environment
*
* @return A reference to a Java DirectSlice object, or a nullptr if an
* exception occurs
*/
static jobject construct0(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "<init>", "()V");
if(mid == nullptr) {
// exception occurred accessing method
return nullptr;
}
jobject jdirect_slice = env->NewObject(jclazz, mid);
if(env->ExceptionCheck()) {
return nullptr;
}
return jdirect_slice;
}
};
// The portal class for org.rocksdb.BackupInfo
class BackupInfoJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.BackupInfo
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/BackupInfo");
}
/**
* Constructs a BackupInfo object
*
* @param env A pointer to the Java environment
* @param backup_id id of the backup
* @param timestamp timestamp of the backup
* @param size size of the backup
* @param number_files number of files related to the backup
* @param app_metadata application specific metadata
*
* @return A reference to a Java BackupInfo object, or a nullptr if an
* exception occurs
*/
static jobject construct0(JNIEnv* env, uint32_t backup_id, int64_t timestamp,
uint64_t size, uint32_t number_files,
const std::string& app_metadata) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "<init>", "(IJJILjava/lang/String;)V");
if(mid == nullptr) {
// exception occurred accessing method
return nullptr;
}
jstring japp_metadata = nullptr;
if (app_metadata != nullptr) {
japp_metadata = env->NewStringUTF(app_metadata.c_str());
if (japp_metadata == nullptr) {
// exception occurred creating java string
return nullptr;
}
}
jobject jbackup_info = env->NewObject(jclazz, mid, backup_id, timestamp,
size, number_files, japp_metadata);
if(env->ExceptionCheck()) {
env->DeleteLocalRef(japp_metadata);
return nullptr;
}
return jbackup_info;
}
};
class BackupInfoListJni {
public:
/**
* Converts a C++ std::vector<BackupInfo> object to
* a Java ArrayList<org.rocksdb.BackupInfo> object
*
* @param env A pointer to the Java environment
* @param backup_infos A vector of BackupInfo
*
* @return Either a reference to a Java ArrayList object, or a nullptr
* if an exception occurs
*/
static jobject getBackupInfo(JNIEnv* env,
std::vector<BackupInfo> backup_infos) {
jclass jarray_list_clazz =
ROCKSDB_NAMESPACE::ListJni::getArrayListClass(env);
if(jarray_list_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID cstr_mid =
ROCKSDB_NAMESPACE::ListJni::getArrayListConstructorMethodId(env);
if(cstr_mid == nullptr) {
// exception occurred accessing method
return nullptr;
}
jmethodID add_mid = ROCKSDB_NAMESPACE::ListJni::getListAddMethodId(env);
if(add_mid == nullptr) {
// exception occurred accessing method
return nullptr;
}
// create java list
jobject jbackup_info_handle_list =
env->NewObject(jarray_list_clazz, cstr_mid, backup_infos.size());
if(env->ExceptionCheck()) {
// exception occurred constructing object
return nullptr;
}
// insert in java list
auto end = backup_infos.end();
for (auto it = backup_infos.begin(); it != end; ++it) {
auto backup_info = *it;
jobject obj = ROCKSDB_NAMESPACE::BackupInfoJni::construct0(
env, backup_info.backup_id, backup_info.timestamp, backup_info.size,
backup_info.number_files, backup_info.app_metadata);
if(env->ExceptionCheck()) {
// exception occurred constructing object
if(obj != nullptr) {
env->DeleteLocalRef(obj);
}
if(jbackup_info_handle_list != nullptr) {
env->DeleteLocalRef(jbackup_info_handle_list);
}
return nullptr;
}
jboolean rs =
env->CallBooleanMethod(jbackup_info_handle_list, add_mid, obj);
if(env->ExceptionCheck() || rs == JNI_FALSE) {
// exception occurred calling method, or could not add
if(obj != nullptr) {
env->DeleteLocalRef(obj);
}
if(jbackup_info_handle_list != nullptr) {
env->DeleteLocalRef(jbackup_info_handle_list);
}
return nullptr;
}
}
return jbackup_info_handle_list;
}
};
// The portal class for org.rocksdb.WBWIRocksIterator
class WBWIRocksIteratorJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.WBWIRocksIterator
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/WBWIRocksIterator");
}
/**
* Get the Java Field: WBWIRocksIterator#entry
*
* @param env A pointer to the Java environment
*
* @return The Java Field ID or nullptr if the class or field id could not
* be retieved
*/
static jfieldID getWriteEntryField(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jfieldID fid =
env->GetFieldID(jclazz, "entry",
"Lorg/rocksdb/WBWIRocksIterator$WriteEntry;");
assert(fid != nullptr);
return fid;
}
/**
* Gets the value of the WBWIRocksIterator#entry
*
* @param env A pointer to the Java environment
* @param jwbwi_rocks_iterator A reference to a WBWIIterator
*
* @return A reference to a Java WBWIRocksIterator.WriteEntry object, or
* a nullptr if an exception occurs
*/
static jobject getWriteEntry(JNIEnv* env, jobject jwbwi_rocks_iterator) {
assert(jwbwi_rocks_iterator != nullptr);
jfieldID jwrite_entry_field = getWriteEntryField(env);
if(jwrite_entry_field == nullptr) {
// exception occurred accessing the field
return nullptr;
}
jobject jwe = env->GetObjectField(jwbwi_rocks_iterator, jwrite_entry_field);
assert(jwe != nullptr);
return jwe;
}
};
// The portal class for org.rocksdb.WBWIRocksIterator.WriteType
class WriteTypeJni : public JavaClass {
public:
/**
* Get the PUT enum field value of WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject PUT(JNIEnv* env) {
return getEnum(env, "PUT");
}
/**
* Get the MERGE enum field value of WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject MERGE(JNIEnv* env) {
return getEnum(env, "MERGE");
}
/**
* Get the DELETE enum field value of WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject DELETE(JNIEnv* env) {
return getEnum(env, "DELETE");
}
/**
* Get the LOG enum field value of WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject LOG(JNIEnv* env) {
return getEnum(env, "LOG");
}
// Returns the equivalent org.rocksdb.WBWIRocksIterator.WriteType for the
// provided C++ ROCKSDB_NAMESPACE::WriteType enum
static jbyte toJavaWriteType(const ROCKSDB_NAMESPACE::WriteType& writeType) {
switch (writeType) {
case ROCKSDB_NAMESPACE::WriteType::kPutRecord:
return 0x0;
case ROCKSDB_NAMESPACE::WriteType::kMergeRecord:
return 0x1;
case ROCKSDB_NAMESPACE::WriteType::kDeleteRecord:
return 0x2;
case ROCKSDB_NAMESPACE::WriteType::kSingleDeleteRecord:
return 0x3;
case ROCKSDB_NAMESPACE::WriteType::kDeleteRangeRecord:
return 0x4;
case ROCKSDB_NAMESPACE::WriteType::kLogDataRecord:
return 0x5;
case ROCKSDB_NAMESPACE::WriteType::kXIDRecord:
return 0x6;
default:
return 0x7F; // undefined
}
}
private:
/**
* Get the Java Class org.rocksdb.WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/WBWIRocksIterator$WriteType");
}
/**
* Get an enum field of org.rocksdb.WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
* @param name The name of the enum field
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject getEnum(JNIEnv* env, const char name[]) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jfieldID jfid =
env->GetStaticFieldID(jclazz, name,
"Lorg/rocksdb/WBWIRocksIterator$WriteType;");
if(env->ExceptionCheck()) {
// exception occurred while getting field
return nullptr;
} else if(jfid == nullptr) {
return nullptr;
}
jobject jwrite_type = env->GetStaticObjectField(jclazz, jfid);
assert(jwrite_type != nullptr);
return jwrite_type;
}
};
// The portal class for org.rocksdb.WBWIRocksIterator.WriteEntry
class WriteEntryJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.WBWIRocksIterator.WriteEntry
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/WBWIRocksIterator$WriteEntry");
}
};
// The portal class for org.rocksdb.InfoLogLevel
class InfoLogLevelJni : public JavaClass {
public:
/**
* Get the DEBUG_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject DEBUG_LEVEL(JNIEnv* env) {
return getEnum(env, "DEBUG_LEVEL");
}
/**
* Get the INFO_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject INFO_LEVEL(JNIEnv* env) {
return getEnum(env, "INFO_LEVEL");
}
/**
* Get the WARN_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject WARN_LEVEL(JNIEnv* env) {
return getEnum(env, "WARN_LEVEL");
}
/**
* Get the ERROR_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject ERROR_LEVEL(JNIEnv* env) {
return getEnum(env, "ERROR_LEVEL");
}
/**
* Get the FATAL_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject FATAL_LEVEL(JNIEnv* env) {
return getEnum(env, "FATAL_LEVEL");
}
/**
* Get the HEADER_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject HEADER_LEVEL(JNIEnv* env) {
return getEnum(env, "HEADER_LEVEL");
}
private:
/**
* Get the Java Class org.rocksdb.InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/InfoLogLevel");
}
/**
* Get an enum field of org.rocksdb.InfoLogLevel
*
* @param env A pointer to the Java environment
* @param name The name of the enum field
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject getEnum(JNIEnv* env, const char name[]) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jfieldID jfid =
env->GetStaticFieldID(jclazz, name, "Lorg/rocksdb/InfoLogLevel;");
if(env->ExceptionCheck()) {
// exception occurred while getting field
return nullptr;
} else if(jfid == nullptr) {
return nullptr;
}
jobject jinfo_log_level = env->GetStaticObjectField(jclazz, jfid);
assert(jinfo_log_level != nullptr);
return jinfo_log_level;
}
};
// The portal class for org.rocksdb.Logger
class LoggerJni
: public RocksDBNativeClass<
std::shared_ptr<ROCKSDB_NAMESPACE::LoggerJniCallback>*, LoggerJni> {
public:
/**
* Get the Java Class org/rocksdb/Logger
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/Logger");
}
/**
* Get the Java Method: Logger#log
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getLogMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "log",
"(Lorg/rocksdb/InfoLogLevel;Ljava/lang/String;)V");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.TransactionLogIterator.BatchResult
class BatchResultJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.TransactionLogIterator.BatchResult
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env,
"org/rocksdb/TransactionLogIterator$BatchResult");
}
/**
* Create a new Java org.rocksdb.TransactionLogIterator.BatchResult object
* with the same properties as the provided C++ ROCKSDB_NAMESPACE::BatchResult
* object
*
* @param env A pointer to the Java environment
* @param batch_result The ROCKSDB_NAMESPACE::BatchResult object
*
* @return A reference to a Java
* org.rocksdb.TransactionLogIterator.BatchResult object,
* or nullptr if an an exception occurs
*/
static jobject construct(JNIEnv* env,
ROCKSDB_NAMESPACE::BatchResult& batch_result) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(
jclazz, "<init>", "(JJ)V");
if(mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jobject jbatch_result = env->NewObject(jclazz, mid,
batch_result.sequence, batch_result.writeBatchPtr.get());
if(jbatch_result == nullptr) {
// exception thrown: InstantiationException or OutOfMemoryError
return nullptr;
}
batch_result.writeBatchPtr.release();
return jbatch_result;
}
};
// The portal class for org.rocksdb.BottommostLevelCompaction
class BottommostLevelCompactionJni {
public:
// Returns the equivalent org.rocksdb.BottommostLevelCompaction for the
// provided C++ ROCKSDB_NAMESPACE::BottommostLevelCompaction enum
static jint toJavaBottommostLevelCompaction(
const ROCKSDB_NAMESPACE::BottommostLevelCompaction&
bottommost_level_compaction) {
switch(bottommost_level_compaction) {
case ROCKSDB_NAMESPACE::BottommostLevelCompaction::kSkip:
return 0x0;
case ROCKSDB_NAMESPACE::BottommostLevelCompaction::
kIfHaveCompactionFilter:
return 0x1;
case ROCKSDB_NAMESPACE::BottommostLevelCompaction::kForce:
return 0x2;
case ROCKSDB_NAMESPACE::BottommostLevelCompaction::kForceOptimized:
return 0x3;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::BottommostLevelCompaction
// enum for the provided Java org.rocksdb.BottommostLevelCompaction
static ROCKSDB_NAMESPACE::BottommostLevelCompaction
toCppBottommostLevelCompaction(jint bottommost_level_compaction) {
switch(bottommost_level_compaction) {
case 0x0:
return ROCKSDB_NAMESPACE::BottommostLevelCompaction::kSkip;
case 0x1:
return ROCKSDB_NAMESPACE::BottommostLevelCompaction::
kIfHaveCompactionFilter;
case 0x2:
return ROCKSDB_NAMESPACE::BottommostLevelCompaction::kForce;
case 0x3:
return ROCKSDB_NAMESPACE::BottommostLevelCompaction::kForceOptimized;
default:
// undefined/default
return ROCKSDB_NAMESPACE::BottommostLevelCompaction::
kIfHaveCompactionFilter;
}
}
};
// The portal class for org.rocksdb.CompactionStopStyle
class CompactionStopStyleJni {
public:
// Returns the equivalent org.rocksdb.CompactionStopStyle for the provided
// C++ ROCKSDB_NAMESPACE::CompactionStopStyle enum
static jbyte toJavaCompactionStopStyle(
const ROCKSDB_NAMESPACE::CompactionStopStyle& compaction_stop_style) {
switch(compaction_stop_style) {
case ROCKSDB_NAMESPACE::CompactionStopStyle::
kCompactionStopStyleSimilarSize:
return 0x0;
case ROCKSDB_NAMESPACE::CompactionStopStyle::
kCompactionStopStyleTotalSize:
return 0x1;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::CompactionStopStyle enum for
// the provided Java org.rocksdb.CompactionStopStyle
static ROCKSDB_NAMESPACE::CompactionStopStyle toCppCompactionStopStyle(
jbyte jcompaction_stop_style) {
switch(jcompaction_stop_style) {
case 0x0:
return ROCKSDB_NAMESPACE::CompactionStopStyle::
kCompactionStopStyleSimilarSize;
case 0x1:
return ROCKSDB_NAMESPACE::CompactionStopStyle::
kCompactionStopStyleTotalSize;
default:
// undefined/default
return ROCKSDB_NAMESPACE::CompactionStopStyle::
kCompactionStopStyleSimilarSize;
}
}
};
// The portal class for org.rocksdb.CompressionType
class CompressionTypeJni {
public:
// Returns the equivalent org.rocksdb.CompressionType for the provided
// C++ ROCKSDB_NAMESPACE::CompressionType enum
static jbyte toJavaCompressionType(
const ROCKSDB_NAMESPACE::CompressionType& compression_type) {
switch(compression_type) {
case ROCKSDB_NAMESPACE::CompressionType::kNoCompression:
return 0x0;
case ROCKSDB_NAMESPACE::CompressionType::kSnappyCompression:
return 0x1;
case ROCKSDB_NAMESPACE::CompressionType::kZlibCompression:
return 0x2;
case ROCKSDB_NAMESPACE::CompressionType::kBZip2Compression:
return 0x3;
case ROCKSDB_NAMESPACE::CompressionType::kLZ4Compression:
return 0x4;
case ROCKSDB_NAMESPACE::CompressionType::kLZ4HCCompression:
return 0x5;
case ROCKSDB_NAMESPACE::CompressionType::kXpressCompression:
return 0x6;
case ROCKSDB_NAMESPACE::CompressionType::kZSTD:
return 0x7;
case ROCKSDB_NAMESPACE::CompressionType::kDisableCompressionOption:
default:
return 0x7F;
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::CompressionType enum for the
// provided Java org.rocksdb.CompressionType
static ROCKSDB_NAMESPACE::CompressionType toCppCompressionType(
jbyte jcompression_type) {
switch(jcompression_type) {
case 0x0:
return ROCKSDB_NAMESPACE::CompressionType::kNoCompression;
case 0x1:
return ROCKSDB_NAMESPACE::CompressionType::kSnappyCompression;
case 0x2:
return ROCKSDB_NAMESPACE::CompressionType::kZlibCompression;
case 0x3:
return ROCKSDB_NAMESPACE::CompressionType::kBZip2Compression;
case 0x4:
return ROCKSDB_NAMESPACE::CompressionType::kLZ4Compression;
case 0x5:
return ROCKSDB_NAMESPACE::CompressionType::kLZ4HCCompression;
case 0x6:
return ROCKSDB_NAMESPACE::CompressionType::kXpressCompression;
case 0x7:
return ROCKSDB_NAMESPACE::CompressionType::kZSTD;
case 0x7F:
default:
return ROCKSDB_NAMESPACE::CompressionType::kDisableCompressionOption;
}
}
};
// The portal class for org.rocksdb.CompactionPriority
class CompactionPriorityJni {
public:
// Returns the equivalent org.rocksdb.CompactionPriority for the provided
// C++ ROCKSDB_NAMESPACE::CompactionPri enum
static jbyte toJavaCompactionPriority(
const ROCKSDB_NAMESPACE::CompactionPri& compaction_priority) {
switch(compaction_priority) {
case ROCKSDB_NAMESPACE::CompactionPri::kByCompensatedSize:
return 0x0;
case ROCKSDB_NAMESPACE::CompactionPri::kOldestLargestSeqFirst:
return 0x1;
case ROCKSDB_NAMESPACE::CompactionPri::kOldestSmallestSeqFirst:
return 0x2;
case ROCKSDB_NAMESPACE::CompactionPri::kMinOverlappingRatio:
return 0x3;
default:
return 0x0; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::CompactionPri enum for the
// provided Java org.rocksdb.CompactionPriority
static ROCKSDB_NAMESPACE::CompactionPri toCppCompactionPriority(
jbyte jcompaction_priority) {
switch(jcompaction_priority) {
case 0x0:
return ROCKSDB_NAMESPACE::CompactionPri::kByCompensatedSize;
case 0x1:
return ROCKSDB_NAMESPACE::CompactionPri::kOldestLargestSeqFirst;
case 0x2:
return ROCKSDB_NAMESPACE::CompactionPri::kOldestSmallestSeqFirst;
case 0x3:
return ROCKSDB_NAMESPACE::CompactionPri::kMinOverlappingRatio;
default:
// undefined/default
return ROCKSDB_NAMESPACE::CompactionPri::kByCompensatedSize;
}
}
};
// The portal class for org.rocksdb.AccessHint
class AccessHintJni {
public:
// Returns the equivalent org.rocksdb.AccessHint for the provided
// C++ ROCKSDB_NAMESPACE::DBOptions::AccessHint enum
static jbyte toJavaAccessHint(
const ROCKSDB_NAMESPACE::DBOptions::AccessHint& access_hint) {
switch(access_hint) {
case ROCKSDB_NAMESPACE::DBOptions::AccessHint::NONE:
return 0x0;
case ROCKSDB_NAMESPACE::DBOptions::AccessHint::NORMAL:
return 0x1;
case ROCKSDB_NAMESPACE::DBOptions::AccessHint::SEQUENTIAL:
return 0x2;
case ROCKSDB_NAMESPACE::DBOptions::AccessHint::WILLNEED:
return 0x3;
default:
// undefined/default
return 0x1;
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::DBOptions::AccessHint enum
// for the provided Java org.rocksdb.AccessHint
static ROCKSDB_NAMESPACE::DBOptions::AccessHint toCppAccessHint(
jbyte jaccess_hint) {
switch(jaccess_hint) {
case 0x0:
return ROCKSDB_NAMESPACE::DBOptions::AccessHint::NONE;
case 0x1:
return ROCKSDB_NAMESPACE::DBOptions::AccessHint::NORMAL;
case 0x2:
return ROCKSDB_NAMESPACE::DBOptions::AccessHint::SEQUENTIAL;
case 0x3:
return ROCKSDB_NAMESPACE::DBOptions::AccessHint::WILLNEED;
default:
// undefined/default
return ROCKSDB_NAMESPACE::DBOptions::AccessHint::NORMAL;
}
}
};
// The portal class for org.rocksdb.WALRecoveryMode
class WALRecoveryModeJni {
public:
// Returns the equivalent org.rocksdb.WALRecoveryMode for the provided
// C++ ROCKSDB_NAMESPACE::WALRecoveryMode enum
static jbyte toJavaWALRecoveryMode(
const ROCKSDB_NAMESPACE::WALRecoveryMode& wal_recovery_mode) {
switch(wal_recovery_mode) {
case ROCKSDB_NAMESPACE::WALRecoveryMode::kTolerateCorruptedTailRecords:
return 0x0;
case ROCKSDB_NAMESPACE::WALRecoveryMode::kAbsoluteConsistency:
return 0x1;
case ROCKSDB_NAMESPACE::WALRecoveryMode::kPointInTimeRecovery:
return 0x2;
case ROCKSDB_NAMESPACE::WALRecoveryMode::kSkipAnyCorruptedRecords:
return 0x3;
default:
// undefined/default
return 0x2;
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::WALRecoveryMode enum for the
// provided Java org.rocksdb.WALRecoveryMode
static ROCKSDB_NAMESPACE::WALRecoveryMode toCppWALRecoveryMode(
jbyte jwal_recovery_mode) {
switch(jwal_recovery_mode) {
case 0x0:
return ROCKSDB_NAMESPACE::WALRecoveryMode::
kTolerateCorruptedTailRecords;
case 0x1:
return ROCKSDB_NAMESPACE::WALRecoveryMode::kAbsoluteConsistency;
case 0x2:
return ROCKSDB_NAMESPACE::WALRecoveryMode::kPointInTimeRecovery;
case 0x3:
return ROCKSDB_NAMESPACE::WALRecoveryMode::kSkipAnyCorruptedRecords;
default:
// undefined/default
return ROCKSDB_NAMESPACE::WALRecoveryMode::kPointInTimeRecovery;
}
}
};
// The portal class for org.rocksdb.TickerType
class TickerTypeJni {
public:
// Returns the equivalent org.rocksdb.TickerType for the provided
// C++ ROCKSDB_NAMESPACE::Tickers enum
static jbyte toJavaTickerType(const ROCKSDB_NAMESPACE::Tickers& tickers) {
switch(tickers) {
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_MISS:
return 0x0;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_HIT:
return 0x1;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_ADD:
return 0x2;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_ADD_FAILURES:
return 0x3;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_MISS:
return 0x4;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_HIT:
return 0x5;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_ADD:
return 0x6;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_BYTES_INSERT:
return 0x7;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_BYTES_EVICT:
return 0x8;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_MISS:
return 0x9;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_HIT:
return 0xA;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_ADD:
return 0xB;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_BYTES_INSERT:
return 0xC;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_BYTES_EVICT:
return 0xD;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_MISS:
return 0xE;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_HIT:
return 0xF;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_ADD:
return 0x10;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_BYTES_INSERT:
return 0x11;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_BYTES_READ:
return 0x12;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_BYTES_WRITE:
return 0x13;
case ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_USEFUL:
return 0x14;
case ROCKSDB_NAMESPACE::Tickers::PERSISTENT_CACHE_HIT:
return 0x15;
case ROCKSDB_NAMESPACE::Tickers::PERSISTENT_CACHE_MISS:
return 0x16;
case ROCKSDB_NAMESPACE::Tickers::SIM_BLOCK_CACHE_HIT:
return 0x17;
case ROCKSDB_NAMESPACE::Tickers::SIM_BLOCK_CACHE_MISS:
return 0x18;
case ROCKSDB_NAMESPACE::Tickers::MEMTABLE_HIT:
return 0x19;
case ROCKSDB_NAMESPACE::Tickers::MEMTABLE_MISS:
return 0x1A;
case ROCKSDB_NAMESPACE::Tickers::GET_HIT_L0:
return 0x1B;
case ROCKSDB_NAMESPACE::Tickers::GET_HIT_L1:
return 0x1C;
case ROCKSDB_NAMESPACE::Tickers::GET_HIT_L2_AND_UP:
return 0x1D;
case ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_NEWER_ENTRY:
return 0x1E;
case ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_OBSOLETE:
return 0x1F;
case ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_RANGE_DEL:
return 0x20;
case ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_USER:
return 0x21;
case ROCKSDB_NAMESPACE::Tickers::COMPACTION_RANGE_DEL_DROP_OBSOLETE:
return 0x22;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_WRITTEN:
return 0x23;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_READ:
return 0x24;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_UPDATED:
return 0x25;
case ROCKSDB_NAMESPACE::Tickers::BYTES_WRITTEN:
return 0x26;
case ROCKSDB_NAMESPACE::Tickers::BYTES_READ:
return 0x27;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_SEEK:
return 0x28;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_NEXT:
return 0x29;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_PREV:
return 0x2A;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_SEEK_FOUND:
return 0x2B;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_NEXT_FOUND:
return 0x2C;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_PREV_FOUND:
return 0x2D;
case ROCKSDB_NAMESPACE::Tickers::ITER_BYTES_READ:
return 0x2E;
case ROCKSDB_NAMESPACE::Tickers::NO_FILE_CLOSES:
return 0x2F;
case ROCKSDB_NAMESPACE::Tickers::NO_FILE_OPENS:
return 0x30;
case ROCKSDB_NAMESPACE::Tickers::NO_FILE_ERRORS:
return 0x31;
case ROCKSDB_NAMESPACE::Tickers::STALL_L0_SLOWDOWN_MICROS:
return 0x32;
case ROCKSDB_NAMESPACE::Tickers::STALL_MEMTABLE_COMPACTION_MICROS:
return 0x33;
case ROCKSDB_NAMESPACE::Tickers::STALL_L0_NUM_FILES_MICROS:
return 0x34;
case ROCKSDB_NAMESPACE::Tickers::STALL_MICROS:
return 0x35;
case ROCKSDB_NAMESPACE::Tickers::DB_MUTEX_WAIT_MICROS:
return 0x36;
case ROCKSDB_NAMESPACE::Tickers::RATE_LIMIT_DELAY_MILLIS:
return 0x37;
case ROCKSDB_NAMESPACE::Tickers::NO_ITERATORS:
return 0x38;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_CALLS:
return 0x39;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_KEYS_READ:
return 0x3A;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_BYTES_READ:
return 0x3B;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_FILTERED_DELETES:
return 0x3C;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_MERGE_FAILURES:
return 0x3D;
case ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_PREFIX_CHECKED:
return 0x3E;
case ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_PREFIX_USEFUL:
return 0x3F;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_OF_RESEEKS_IN_ITERATION:
return 0x40;
case ROCKSDB_NAMESPACE::Tickers::GET_UPDATES_SINCE_CALLS:
return 0x41;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_MISS:
return 0x42;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_HIT:
return 0x43;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_ADD:
return 0x44;
case ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_ADD_FAILURES:
return 0x45;
case ROCKSDB_NAMESPACE::Tickers::WAL_FILE_SYNCED:
return 0x46;
case ROCKSDB_NAMESPACE::Tickers::WAL_FILE_BYTES:
return 0x47;
case ROCKSDB_NAMESPACE::Tickers::WRITE_DONE_BY_SELF:
return 0x48;
case ROCKSDB_NAMESPACE::Tickers::WRITE_DONE_BY_OTHER:
return 0x49;
case ROCKSDB_NAMESPACE::Tickers::WRITE_TIMEDOUT:
return 0x4A;
case ROCKSDB_NAMESPACE::Tickers::WRITE_WITH_WAL:
return 0x4B;
case ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES:
return 0x4C;
case ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES:
return 0x4D;
case ROCKSDB_NAMESPACE::Tickers::FLUSH_WRITE_BYTES:
return 0x4E;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_DIRECT_LOAD_TABLE_PROPERTIES:
return 0x4F;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_ACQUIRES:
return 0x50;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_RELEASES:
return 0x51;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_CLEANUPS:
return 0x52;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_COMPRESSED:
return 0x53;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_DECOMPRESSED:
return 0x54;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_NOT_COMPRESSED:
return 0x55;
case ROCKSDB_NAMESPACE::Tickers::MERGE_OPERATION_TOTAL_TIME:
return 0x56;
case ROCKSDB_NAMESPACE::Tickers::FILTER_OPERATION_TOTAL_TIME:
return 0x57;
case ROCKSDB_NAMESPACE::Tickers::ROW_CACHE_HIT:
return 0x58;
case ROCKSDB_NAMESPACE::Tickers::ROW_CACHE_MISS:
return 0x59;
case ROCKSDB_NAMESPACE::Tickers::READ_AMP_ESTIMATE_USEFUL_BYTES:
return 0x5A;
case ROCKSDB_NAMESPACE::Tickers::READ_AMP_TOTAL_READ_BYTES:
return 0x5B;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_RATE_LIMITER_DRAINS:
return 0x5C;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_ITER_SKIP:
return 0x5D;
case ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_KEYS_FOUND:
return 0x5E;
case ROCKSDB_NAMESPACE::Tickers::NO_ITERATOR_CREATED:
// -0x01 to fixate the new value that incorrectly changed TICKER_ENUM_MAX.
return -0x01;
case ROCKSDB_NAMESPACE::Tickers::NO_ITERATOR_DELETED:
return 0x60;
case ROCKSDB_NAMESPACE::Tickers::COMPACTION_OPTIMIZED_DEL_DROP_OBSOLETE:
return 0x61;
case ROCKSDB_NAMESPACE::Tickers::COMPACTION_CANCELLED:
return 0x62;
case ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_FULL_POSITIVE:
return 0x63;
case ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_FULL_TRUE_POSITIVE:
return 0x64;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_PUT:
return 0x65;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_WRITE:
return 0x66;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_GET:
return 0x67;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_MULTIGET:
return 0x68;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_SEEK:
return 0x69;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_NEXT:
return 0x6A;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_PREV:
return 0x6B;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_KEYS_WRITTEN:
return 0x6C;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_KEYS_READ:
return 0x6D;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BYTES_WRITTEN:
return 0x6E;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BYTES_READ:
return 0x6F;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_INLINED:
return 0x70;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_INLINED_TTL:
return 0x71;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_BLOB:
return 0x72;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_BLOB_TTL:
return 0x73;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_BYTES_WRITTEN:
return 0x74;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_BYTES_READ:
return 0x75;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_SYNCED:
return 0x76;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EXPIRED_COUNT:
return 0x77;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EXPIRED_SIZE:
return 0x78;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EVICTED_COUNT:
return 0x79;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EVICTED_SIZE:
return 0x7A;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_FILES:
return 0x7B;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_NEW_FILES:
return 0x7C;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_FAILURES:
return 0x7D;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_OVERWRITTEN:
return 0x7E;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_EXPIRED:
return 0x7F;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_RELOCATED:
return -0x02;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_OVERWRITTEN:
return -0x03;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_EXPIRED:
return -0x04;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_RELOCATED:
return -0x05;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_NUM_FILES_EVICTED:
return -0x06;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_NUM_KEYS_EVICTED:
return -0x07;
case ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_BYTES_EVICTED:
return -0x08;
case ROCKSDB_NAMESPACE::Tickers::TXN_PREPARE_MUTEX_OVERHEAD:
return -0x09;
case ROCKSDB_NAMESPACE::Tickers::TXN_OLD_COMMIT_MAP_MUTEX_OVERHEAD:
return -0x0A;
case ROCKSDB_NAMESPACE::Tickers::TXN_DUPLICATE_KEY_OVERHEAD:
return -0x0B;
case ROCKSDB_NAMESPACE::Tickers::TXN_SNAPSHOT_MUTEX_OVERHEAD:
return -0x0C;
case ROCKSDB_NAMESPACE::Tickers::TXN_GET_TRY_AGAIN:
return -0x0D;
case ROCKSDB_NAMESPACE::Tickers::FILES_MARKED_TRASH:
return -0x0E;
case ROCKSDB_NAMESPACE::Tickers::FILES_DELETED_IMMEDIATELY:
return -0X0F;
case ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_MARKED:
return -0x10;
case ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_PERIODIC:
return -0x11;
case ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_TTL:
return -0x12;
case ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_MARKED:
return -0x13;
case ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_PERIODIC:
return -0x14;
case ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_TTL:
return -0x15;
case ROCKSDB_NAMESPACE::Tickers::TICKER_ENUM_MAX:
// 0x5F for backwards compatibility on current minor version.
return 0x5F;
default:
// undefined/default
return 0x0;
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::Tickers enum for the
// provided Java org.rocksdb.TickerType
static ROCKSDB_NAMESPACE::Tickers toCppTickers(jbyte jticker_type) {
switch(jticker_type) {
case 0x0:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_MISS;
case 0x1:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_HIT;
case 0x2:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_ADD;
case 0x3:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_ADD_FAILURES;
case 0x4:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_MISS;
case 0x5:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_HIT;
case 0x6:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_ADD;
case 0x7:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_BYTES_INSERT;
case 0x8:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_INDEX_BYTES_EVICT;
case 0x9:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_MISS;
case 0xA:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_HIT;
case 0xB:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_ADD;
case 0xC:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_BYTES_INSERT;
case 0xD:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_FILTER_BYTES_EVICT;
case 0xE:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_MISS;
case 0xF:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_HIT;
case 0x10:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_ADD;
case 0x11:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_DATA_BYTES_INSERT;
case 0x12:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_BYTES_READ;
case 0x13:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_BYTES_WRITE;
case 0x14:
return ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_USEFUL;
case 0x15:
return ROCKSDB_NAMESPACE::Tickers::PERSISTENT_CACHE_HIT;
case 0x16:
return ROCKSDB_NAMESPACE::Tickers::PERSISTENT_CACHE_MISS;
case 0x17:
return ROCKSDB_NAMESPACE::Tickers::SIM_BLOCK_CACHE_HIT;
case 0x18:
return ROCKSDB_NAMESPACE::Tickers::SIM_BLOCK_CACHE_MISS;
case 0x19:
return ROCKSDB_NAMESPACE::Tickers::MEMTABLE_HIT;
case 0x1A:
return ROCKSDB_NAMESPACE::Tickers::MEMTABLE_MISS;
case 0x1B:
return ROCKSDB_NAMESPACE::Tickers::GET_HIT_L0;
case 0x1C:
return ROCKSDB_NAMESPACE::Tickers::GET_HIT_L1;
case 0x1D:
return ROCKSDB_NAMESPACE::Tickers::GET_HIT_L2_AND_UP;
case 0x1E:
return ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_NEWER_ENTRY;
case 0x1F:
return ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_OBSOLETE;
case 0x20:
return ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_RANGE_DEL;
case 0x21:
return ROCKSDB_NAMESPACE::Tickers::COMPACTION_KEY_DROP_USER;
case 0x22:
return ROCKSDB_NAMESPACE::Tickers::COMPACTION_RANGE_DEL_DROP_OBSOLETE;
case 0x23:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_WRITTEN;
case 0x24:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_READ;
case 0x25:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_KEYS_UPDATED;
case 0x26:
return ROCKSDB_NAMESPACE::Tickers::BYTES_WRITTEN;
case 0x27:
return ROCKSDB_NAMESPACE::Tickers::BYTES_READ;
case 0x28:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_SEEK;
case 0x29:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_NEXT;
case 0x2A:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_PREV;
case 0x2B:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_SEEK_FOUND;
case 0x2C:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_NEXT_FOUND;
case 0x2D:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_DB_PREV_FOUND;
case 0x2E:
return ROCKSDB_NAMESPACE::Tickers::ITER_BYTES_READ;
case 0x2F:
return ROCKSDB_NAMESPACE::Tickers::NO_FILE_CLOSES;
case 0x30:
return ROCKSDB_NAMESPACE::Tickers::NO_FILE_OPENS;
case 0x31:
return ROCKSDB_NAMESPACE::Tickers::NO_FILE_ERRORS;
case 0x32:
return ROCKSDB_NAMESPACE::Tickers::STALL_L0_SLOWDOWN_MICROS;
case 0x33:
return ROCKSDB_NAMESPACE::Tickers::STALL_MEMTABLE_COMPACTION_MICROS;
case 0x34:
return ROCKSDB_NAMESPACE::Tickers::STALL_L0_NUM_FILES_MICROS;
case 0x35:
return ROCKSDB_NAMESPACE::Tickers::STALL_MICROS;
case 0x36:
return ROCKSDB_NAMESPACE::Tickers::DB_MUTEX_WAIT_MICROS;
case 0x37:
return ROCKSDB_NAMESPACE::Tickers::RATE_LIMIT_DELAY_MILLIS;
case 0x38:
return ROCKSDB_NAMESPACE::Tickers::NO_ITERATORS;
case 0x39:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_CALLS;
case 0x3A:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_KEYS_READ;
case 0x3B:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_BYTES_READ;
case 0x3C:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_FILTERED_DELETES;
case 0x3D:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_MERGE_FAILURES;
case 0x3E:
return ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_PREFIX_CHECKED;
case 0x3F:
return ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_PREFIX_USEFUL;
case 0x40:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_OF_RESEEKS_IN_ITERATION;
case 0x41:
return ROCKSDB_NAMESPACE::Tickers::GET_UPDATES_SINCE_CALLS;
case 0x42:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_MISS;
case 0x43:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_HIT;
case 0x44:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_ADD;
case 0x45:
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_COMPRESSED_ADD_FAILURES;
case 0x46:
return ROCKSDB_NAMESPACE::Tickers::WAL_FILE_SYNCED;
case 0x47:
return ROCKSDB_NAMESPACE::Tickers::WAL_FILE_BYTES;
case 0x48:
return ROCKSDB_NAMESPACE::Tickers::WRITE_DONE_BY_SELF;
case 0x49:
return ROCKSDB_NAMESPACE::Tickers::WRITE_DONE_BY_OTHER;
case 0x4A:
return ROCKSDB_NAMESPACE::Tickers::WRITE_TIMEDOUT;
case 0x4B:
return ROCKSDB_NAMESPACE::Tickers::WRITE_WITH_WAL;
case 0x4C:
return ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES;
case 0x4D:
return ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES;
case 0x4E:
return ROCKSDB_NAMESPACE::Tickers::FLUSH_WRITE_BYTES;
case 0x4F:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_DIRECT_LOAD_TABLE_PROPERTIES;
case 0x50:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_ACQUIRES;
case 0x51:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_RELEASES;
case 0x52:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_SUPERVERSION_CLEANUPS;
case 0x53:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_COMPRESSED;
case 0x54:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_DECOMPRESSED;
case 0x55:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_BLOCK_NOT_COMPRESSED;
case 0x56:
return ROCKSDB_NAMESPACE::Tickers::MERGE_OPERATION_TOTAL_TIME;
case 0x57:
return ROCKSDB_NAMESPACE::Tickers::FILTER_OPERATION_TOTAL_TIME;
case 0x58:
return ROCKSDB_NAMESPACE::Tickers::ROW_CACHE_HIT;
case 0x59:
return ROCKSDB_NAMESPACE::Tickers::ROW_CACHE_MISS;
case 0x5A:
return ROCKSDB_NAMESPACE::Tickers::READ_AMP_ESTIMATE_USEFUL_BYTES;
case 0x5B:
return ROCKSDB_NAMESPACE::Tickers::READ_AMP_TOTAL_READ_BYTES;
case 0x5C:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_RATE_LIMITER_DRAINS;
case 0x5D:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_ITER_SKIP;
case 0x5E:
return ROCKSDB_NAMESPACE::Tickers::NUMBER_MULTIGET_KEYS_FOUND;
case -0x01:
// -0x01 to fixate the new value that incorrectly changed TICKER_ENUM_MAX.
return ROCKSDB_NAMESPACE::Tickers::NO_ITERATOR_CREATED;
case 0x60:
return ROCKSDB_NAMESPACE::Tickers::NO_ITERATOR_DELETED;
case 0x61:
return ROCKSDB_NAMESPACE::Tickers::
COMPACTION_OPTIMIZED_DEL_DROP_OBSOLETE;
case 0x62:
return ROCKSDB_NAMESPACE::Tickers::COMPACTION_CANCELLED;
case 0x63:
return ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_FULL_POSITIVE;
case 0x64:
return ROCKSDB_NAMESPACE::Tickers::BLOOM_FILTER_FULL_TRUE_POSITIVE;
case 0x65:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_PUT;
case 0x66:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_WRITE;
case 0x67:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_GET;
case 0x68:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_MULTIGET;
case 0x69:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_SEEK;
case 0x6A:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_NEXT;
case 0x6B:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_PREV;
case 0x6C:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_KEYS_WRITTEN;
case 0x6D:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_NUM_KEYS_READ;
case 0x6E:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BYTES_WRITTEN;
case 0x6F:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BYTES_READ;
case 0x70:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_INLINED;
case 0x71:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_INLINED_TTL;
case 0x72:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_BLOB;
case 0x73:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_WRITE_BLOB_TTL;
case 0x74:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_BYTES_WRITTEN;
case 0x75:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_BYTES_READ;
case 0x76:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_FILE_SYNCED;
case 0x77:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EXPIRED_COUNT;
case 0x78:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EXPIRED_SIZE;
case 0x79:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EVICTED_COUNT;
case 0x7A:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_BLOB_INDEX_EVICTED_SIZE;
case 0x7B:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_FILES;
case 0x7C:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_NEW_FILES;
case 0x7D:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_FAILURES;
case 0x7E:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_OVERWRITTEN;
case 0x7F:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_EXPIRED;
case -0x02:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_NUM_KEYS_RELOCATED;
case -0x03:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_OVERWRITTEN;
case -0x04:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_EXPIRED;
case -0x05:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_GC_BYTES_RELOCATED;
case -0x06:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_NUM_FILES_EVICTED;
case -0x07:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_NUM_KEYS_EVICTED;
case -0x08:
return ROCKSDB_NAMESPACE::Tickers::BLOB_DB_FIFO_BYTES_EVICTED;
case -0x09:
return ROCKSDB_NAMESPACE::Tickers::TXN_PREPARE_MUTEX_OVERHEAD;
case -0x0A:
return ROCKSDB_NAMESPACE::Tickers::TXN_OLD_COMMIT_MAP_MUTEX_OVERHEAD;
case -0x0B:
return ROCKSDB_NAMESPACE::Tickers::TXN_DUPLICATE_KEY_OVERHEAD;
case -0x0C:
return ROCKSDB_NAMESPACE::Tickers::TXN_SNAPSHOT_MUTEX_OVERHEAD;
case -0x0D:
return ROCKSDB_NAMESPACE::Tickers::TXN_GET_TRY_AGAIN;
case -0x0E:
return ROCKSDB_NAMESPACE::Tickers::FILES_MARKED_TRASH;
case -0x0F:
return ROCKSDB_NAMESPACE::Tickers::FILES_DELETED_IMMEDIATELY;
case -0x10:
return ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_MARKED;
case -0x11:
return ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_PERIODIC;
case -0x12:
return ROCKSDB_NAMESPACE::Tickers::COMPACT_READ_BYTES_TTL;
case -0x13:
return ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_MARKED;
case -0x14:
return ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_PERIODIC;
case -0x15:
return ROCKSDB_NAMESPACE::Tickers::COMPACT_WRITE_BYTES_TTL;
case 0x5F:
// 0x5F for backwards compatibility on current minor version.
return ROCKSDB_NAMESPACE::Tickers::TICKER_ENUM_MAX;
default:
// undefined/default
return ROCKSDB_NAMESPACE::Tickers::BLOCK_CACHE_MISS;
}
}
};
// The portal class for org.rocksdb.HistogramType
class HistogramTypeJni {
public:
// Returns the equivalent org.rocksdb.HistogramType for the provided
// C++ ROCKSDB_NAMESPACE::Histograms enum
static jbyte toJavaHistogramsType(
const ROCKSDB_NAMESPACE::Histograms& histograms) {
switch(histograms) {
case ROCKSDB_NAMESPACE::Histograms::DB_GET:
return 0x0;
case ROCKSDB_NAMESPACE::Histograms::DB_WRITE:
return 0x1;
case ROCKSDB_NAMESPACE::Histograms::COMPACTION_TIME:
return 0x2;
case ROCKSDB_NAMESPACE::Histograms::SUBCOMPACTION_SETUP_TIME:
return 0x3;
case ROCKSDB_NAMESPACE::Histograms::TABLE_SYNC_MICROS:
return 0x4;
case ROCKSDB_NAMESPACE::Histograms::COMPACTION_OUTFILE_SYNC_MICROS:
return 0x5;
case ROCKSDB_NAMESPACE::Histograms::WAL_FILE_SYNC_MICROS:
return 0x6;
case ROCKSDB_NAMESPACE::Histograms::MANIFEST_FILE_SYNC_MICROS:
return 0x7;
case ROCKSDB_NAMESPACE::Histograms::TABLE_OPEN_IO_MICROS:
return 0x8;
case ROCKSDB_NAMESPACE::Histograms::DB_MULTIGET:
return 0x9;
case ROCKSDB_NAMESPACE::Histograms::READ_BLOCK_COMPACTION_MICROS:
return 0xA;
case ROCKSDB_NAMESPACE::Histograms::READ_BLOCK_GET_MICROS:
return 0xB;
case ROCKSDB_NAMESPACE::Histograms::WRITE_RAW_BLOCK_MICROS:
return 0xC;
case ROCKSDB_NAMESPACE::Histograms::STALL_L0_SLOWDOWN_COUNT:
return 0xD;
case ROCKSDB_NAMESPACE::Histograms::STALL_MEMTABLE_COMPACTION_COUNT:
return 0xE;
case ROCKSDB_NAMESPACE::Histograms::STALL_L0_NUM_FILES_COUNT:
return 0xF;
case ROCKSDB_NAMESPACE::Histograms::HARD_RATE_LIMIT_DELAY_COUNT:
return 0x10;
case ROCKSDB_NAMESPACE::Histograms::SOFT_RATE_LIMIT_DELAY_COUNT:
return 0x11;
case ROCKSDB_NAMESPACE::Histograms::NUM_FILES_IN_SINGLE_COMPACTION:
return 0x12;
case ROCKSDB_NAMESPACE::Histograms::DB_SEEK:
return 0x13;
case ROCKSDB_NAMESPACE::Histograms::WRITE_STALL:
return 0x14;
case ROCKSDB_NAMESPACE::Histograms::SST_READ_MICROS:
return 0x15;
case ROCKSDB_NAMESPACE::Histograms::NUM_SUBCOMPACTIONS_SCHEDULED:
return 0x16;
case ROCKSDB_NAMESPACE::Histograms::BYTES_PER_READ:
return 0x17;
case ROCKSDB_NAMESPACE::Histograms::BYTES_PER_WRITE:
return 0x18;
case ROCKSDB_NAMESPACE::Histograms::BYTES_PER_MULTIGET:
return 0x19;
case ROCKSDB_NAMESPACE::Histograms::BYTES_COMPRESSED:
return 0x1A;
case ROCKSDB_NAMESPACE::Histograms::BYTES_DECOMPRESSED:
return 0x1B;
case ROCKSDB_NAMESPACE::Histograms::COMPRESSION_TIMES_NANOS:
return 0x1C;
case ROCKSDB_NAMESPACE::Histograms::DECOMPRESSION_TIMES_NANOS:
return 0x1D;
case ROCKSDB_NAMESPACE::Histograms::READ_NUM_MERGE_OPERANDS:
return 0x1E;
// 0x20 to skip 0x1F so TICKER_ENUM_MAX remains unchanged for minor version compatibility.
case ROCKSDB_NAMESPACE::Histograms::FLUSH_TIME:
return 0x20;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_KEY_SIZE:
return 0x21;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_VALUE_SIZE:
return 0x22;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_WRITE_MICROS:
return 0x23;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_GET_MICROS:
return 0x24;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_MULTIGET_MICROS:
return 0x25;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_SEEK_MICROS:
return 0x26;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_NEXT_MICROS:
return 0x27;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_PREV_MICROS:
return 0x28;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_WRITE_MICROS:
return 0x29;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_READ_MICROS:
return 0x2A;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_SYNC_MICROS:
return 0x2B;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_GC_MICROS:
return 0x2C;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_COMPRESSION_MICROS:
return 0x2D;
case ROCKSDB_NAMESPACE::Histograms::BLOB_DB_DECOMPRESSION_MICROS:
return 0x2E;
case ROCKSDB_NAMESPACE::Histograms::
NUM_INDEX_AND_FILTER_BLOCKS_READ_PER_LEVEL:
return 0x2F;
case ROCKSDB_NAMESPACE::Histograms::NUM_DATA_BLOCKS_READ_PER_LEVEL:
return 0x30;
case ROCKSDB_NAMESPACE::Histograms::NUM_SST_READ_PER_LEVEL:
return 0x31;
case ROCKSDB_NAMESPACE::Histograms::HISTOGRAM_ENUM_MAX:
// 0x1F for backwards compatibility on current minor version.
return 0x1F;
default:
// undefined/default
return 0x0;
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::Histograms enum for the
// provided Java org.rocksdb.HistogramsType
static ROCKSDB_NAMESPACE::Histograms toCppHistograms(jbyte jhistograms_type) {
switch(jhistograms_type) {
case 0x0:
return ROCKSDB_NAMESPACE::Histograms::DB_GET;
case 0x1:
return ROCKSDB_NAMESPACE::Histograms::DB_WRITE;
case 0x2:
return ROCKSDB_NAMESPACE::Histograms::COMPACTION_TIME;
case 0x3:
return ROCKSDB_NAMESPACE::Histograms::SUBCOMPACTION_SETUP_TIME;
case 0x4:
return ROCKSDB_NAMESPACE::Histograms::TABLE_SYNC_MICROS;
case 0x5:
return ROCKSDB_NAMESPACE::Histograms::COMPACTION_OUTFILE_SYNC_MICROS;
case 0x6:
return ROCKSDB_NAMESPACE::Histograms::WAL_FILE_SYNC_MICROS;
case 0x7:
return ROCKSDB_NAMESPACE::Histograms::MANIFEST_FILE_SYNC_MICROS;
case 0x8:
return ROCKSDB_NAMESPACE::Histograms::TABLE_OPEN_IO_MICROS;
case 0x9:
return ROCKSDB_NAMESPACE::Histograms::DB_MULTIGET;
case 0xA:
return ROCKSDB_NAMESPACE::Histograms::READ_BLOCK_COMPACTION_MICROS;
case 0xB:
return ROCKSDB_NAMESPACE::Histograms::READ_BLOCK_GET_MICROS;
case 0xC:
return ROCKSDB_NAMESPACE::Histograms::WRITE_RAW_BLOCK_MICROS;
case 0xD:
return ROCKSDB_NAMESPACE::Histograms::STALL_L0_SLOWDOWN_COUNT;
case 0xE:
return ROCKSDB_NAMESPACE::Histograms::STALL_MEMTABLE_COMPACTION_COUNT;
case 0xF:
return ROCKSDB_NAMESPACE::Histograms::STALL_L0_NUM_FILES_COUNT;
case 0x10:
return ROCKSDB_NAMESPACE::Histograms::HARD_RATE_LIMIT_DELAY_COUNT;
case 0x11:
return ROCKSDB_NAMESPACE::Histograms::SOFT_RATE_LIMIT_DELAY_COUNT;
case 0x12:
return ROCKSDB_NAMESPACE::Histograms::NUM_FILES_IN_SINGLE_COMPACTION;
case 0x13:
return ROCKSDB_NAMESPACE::Histograms::DB_SEEK;
case 0x14:
return ROCKSDB_NAMESPACE::Histograms::WRITE_STALL;
case 0x15:
return ROCKSDB_NAMESPACE::Histograms::SST_READ_MICROS;
case 0x16:
return ROCKSDB_NAMESPACE::Histograms::NUM_SUBCOMPACTIONS_SCHEDULED;
case 0x17:
return ROCKSDB_NAMESPACE::Histograms::BYTES_PER_READ;
case 0x18:
return ROCKSDB_NAMESPACE::Histograms::BYTES_PER_WRITE;
case 0x19:
return ROCKSDB_NAMESPACE::Histograms::BYTES_PER_MULTIGET;
case 0x1A:
return ROCKSDB_NAMESPACE::Histograms::BYTES_COMPRESSED;
case 0x1B:
return ROCKSDB_NAMESPACE::Histograms::BYTES_DECOMPRESSED;
case 0x1C:
return ROCKSDB_NAMESPACE::Histograms::COMPRESSION_TIMES_NANOS;
case 0x1D:
return ROCKSDB_NAMESPACE::Histograms::DECOMPRESSION_TIMES_NANOS;
case 0x1E:
return ROCKSDB_NAMESPACE::Histograms::READ_NUM_MERGE_OPERANDS;
// 0x20 to skip 0x1F so TICKER_ENUM_MAX remains unchanged for minor version compatibility.
case 0x20:
return ROCKSDB_NAMESPACE::Histograms::FLUSH_TIME;
case 0x21:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_KEY_SIZE;
case 0x22:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_VALUE_SIZE;
case 0x23:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_WRITE_MICROS;
case 0x24:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_GET_MICROS;
case 0x25:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_MULTIGET_MICROS;
case 0x26:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_SEEK_MICROS;
case 0x27:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_NEXT_MICROS;
case 0x28:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_PREV_MICROS;
case 0x29:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_WRITE_MICROS;
case 0x2A:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_READ_MICROS;
case 0x2B:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_BLOB_FILE_SYNC_MICROS;
case 0x2C:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_GC_MICROS;
case 0x2D:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_COMPRESSION_MICROS;
case 0x2E:
return ROCKSDB_NAMESPACE::Histograms::BLOB_DB_DECOMPRESSION_MICROS;
case 0x2F:
return ROCKSDB_NAMESPACE::Histograms::
NUM_INDEX_AND_FILTER_BLOCKS_READ_PER_LEVEL;
case 0x30:
return ROCKSDB_NAMESPACE::Histograms::NUM_DATA_BLOCKS_READ_PER_LEVEL;
case 0x31:
return ROCKSDB_NAMESPACE::Histograms::NUM_SST_READ_PER_LEVEL;
case 0x1F:
// 0x1F for backwards compatibility on current minor version.
return ROCKSDB_NAMESPACE::Histograms::HISTOGRAM_ENUM_MAX;
default:
// undefined/default
return ROCKSDB_NAMESPACE::Histograms::DB_GET;
}
}
};
// The portal class for org.rocksdb.StatsLevel
class StatsLevelJni {
public:
// Returns the equivalent org.rocksdb.StatsLevel for the provided
// C++ ROCKSDB_NAMESPACE::StatsLevel enum
static jbyte toJavaStatsLevel(
const ROCKSDB_NAMESPACE::StatsLevel& stats_level) {
switch(stats_level) {
case ROCKSDB_NAMESPACE::StatsLevel::kExceptDetailedTimers:
return 0x0;
case ROCKSDB_NAMESPACE::StatsLevel::kExceptTimeForMutex:
return 0x1;
case ROCKSDB_NAMESPACE::StatsLevel::kAll:
return 0x2;
default:
// undefined/default
return 0x0;
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::StatsLevel enum for the
// provided Java org.rocksdb.StatsLevel
static ROCKSDB_NAMESPACE::StatsLevel toCppStatsLevel(jbyte jstats_level) {
switch(jstats_level) {
case 0x0:
return ROCKSDB_NAMESPACE::StatsLevel::kExceptDetailedTimers;
case 0x1:
return ROCKSDB_NAMESPACE::StatsLevel::kExceptTimeForMutex;
case 0x2:
return ROCKSDB_NAMESPACE::StatsLevel::kAll;
default:
// undefined/default
return ROCKSDB_NAMESPACE::StatsLevel::kExceptDetailedTimers;
}
}
};
// The portal class for org.rocksdb.RateLimiterMode
class RateLimiterModeJni {
public:
// Returns the equivalent org.rocksdb.RateLimiterMode for the provided
// C++ ROCKSDB_NAMESPACE::RateLimiter::Mode enum
static jbyte toJavaRateLimiterMode(
const ROCKSDB_NAMESPACE::RateLimiter::Mode& rate_limiter_mode) {
switch(rate_limiter_mode) {
case ROCKSDB_NAMESPACE::RateLimiter::Mode::kReadsOnly:
return 0x0;
case ROCKSDB_NAMESPACE::RateLimiter::Mode::kWritesOnly:
return 0x1;
case ROCKSDB_NAMESPACE::RateLimiter::Mode::kAllIo:
return 0x2;
default:
// undefined/default
return 0x1;
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::RateLimiter::Mode enum for
// the provided Java org.rocksdb.RateLimiterMode
static ROCKSDB_NAMESPACE::RateLimiter::Mode toCppRateLimiterMode(
jbyte jrate_limiter_mode) {
switch(jrate_limiter_mode) {
case 0x0:
return ROCKSDB_NAMESPACE::RateLimiter::Mode::kReadsOnly;
case 0x1:
return ROCKSDB_NAMESPACE::RateLimiter::Mode::kWritesOnly;
case 0x2:
return ROCKSDB_NAMESPACE::RateLimiter::Mode::kAllIo;
default:
// undefined/default
return ROCKSDB_NAMESPACE::RateLimiter::Mode::kWritesOnly;
}
}
};
// The portal class for org.rocksdb.MemoryUsageType
class MemoryUsageTypeJni {
public:
// Returns the equivalent org.rocksdb.MemoryUsageType for the provided
// C++ ROCKSDB_NAMESPACE::MemoryUtil::UsageType enum
static jbyte toJavaMemoryUsageType(
const ROCKSDB_NAMESPACE::MemoryUtil::UsageType& usage_type) {
switch (usage_type) {
case ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kMemTableTotal:
return 0x0;
case ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kMemTableUnFlushed:
return 0x1;
case ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kTableReadersTotal:
return 0x2;
case ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kCacheTotal:
return 0x3;
default:
// undefined: use kNumUsageTypes
return 0x4;
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::MemoryUtil::UsageType enum for
// the provided Java org.rocksdb.MemoryUsageType
static ROCKSDB_NAMESPACE::MemoryUtil::UsageType toCppMemoryUsageType(
jbyte usage_type) {
switch (usage_type) {
case 0x0:
return ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kMemTableTotal;
case 0x1:
return ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kMemTableUnFlushed;
case 0x2:
return ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kTableReadersTotal;
case 0x3:
return ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kCacheTotal;
default:
// undefined/default: use kNumUsageTypes
return ROCKSDB_NAMESPACE::MemoryUtil::UsageType::kNumUsageTypes;
}
}
};
// The portal class for org.rocksdb.Transaction
class TransactionJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.Transaction
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env,
"org/rocksdb/Transaction");
}
/**
* Create a new Java org.rocksdb.Transaction.WaitingTransactions object
*
* @param env A pointer to the Java environment
* @param jtransaction A Java org.rocksdb.Transaction object
* @param column_family_id The id of the column family
* @param key The key
* @param transaction_ids The transaction ids
*
* @return A reference to a Java
* org.rocksdb.Transaction.WaitingTransactions object,
* or nullptr if an an exception occurs
*/
static jobject newWaitingTransactions(JNIEnv* env, jobject jtransaction,
const uint32_t column_family_id, const std::string &key,
const std::vector<TransactionID> &transaction_ids) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(
jclazz, "newWaitingTransactions", "(JLjava/lang/String;[J)Lorg/rocksdb/Transaction$WaitingTransactions;");
if(mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jstring jkey = env->NewStringUTF(key.c_str());
if(jkey == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
const size_t len = transaction_ids.size();
jlongArray jtransaction_ids = env->NewLongArray(static_cast<jsize>(len));
if(jtransaction_ids == nullptr) {
// exception thrown: OutOfMemoryError
env->DeleteLocalRef(jkey);
return nullptr;
}
jlong *body = env->GetLongArrayElements(jtransaction_ids, nullptr);
if(body == nullptr) {
// exception thrown: OutOfMemoryError
env->DeleteLocalRef(jkey);
env->DeleteLocalRef(jtransaction_ids);
return nullptr;
}
for(size_t i = 0; i < len; ++i) {
body[i] = static_cast<jlong>(transaction_ids[i]);
}
env->ReleaseLongArrayElements(jtransaction_ids, body, 0);
jobject jwaiting_transactions = env->CallObjectMethod(jtransaction,
mid, static_cast<jlong>(column_family_id), jkey, jtransaction_ids);
if(env->ExceptionCheck()) {
// exception thrown: InstantiationException or OutOfMemoryError
env->DeleteLocalRef(jkey);
env->DeleteLocalRef(jtransaction_ids);
return nullptr;
}
return jwaiting_transactions;
}
};
// The portal class for org.rocksdb.TransactionDB
class TransactionDBJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.TransactionDB
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env,
"org/rocksdb/TransactionDB");
}
/**
* Create a new Java org.rocksdb.TransactionDB.DeadlockInfo object
*
* @param env A pointer to the Java environment
* @param jtransaction A Java org.rocksdb.Transaction object
* @param column_family_id The id of the column family
* @param key The key
* @param transaction_ids The transaction ids
*
* @return A reference to a Java
* org.rocksdb.Transaction.WaitingTransactions object,
* or nullptr if an an exception occurs
*/
static jobject newDeadlockInfo(
JNIEnv* env, jobject jtransaction_db,
const ROCKSDB_NAMESPACE::TransactionID transaction_id,
const uint32_t column_family_id, const std::string& waiting_key,
const bool exclusive) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(
jclazz, "newDeadlockInfo", "(JJLjava/lang/String;Z)Lorg/rocksdb/TransactionDB$DeadlockInfo;");
if(mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jstring jwaiting_key = env->NewStringUTF(waiting_key.c_str());
if(jwaiting_key == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
// resolve the column family id to a ColumnFamilyHandle
jobject jdeadlock_info = env->CallObjectMethod(jtransaction_db,
mid, transaction_id, static_cast<jlong>(column_family_id),
jwaiting_key, exclusive);
if(env->ExceptionCheck()) {
// exception thrown: InstantiationException or OutOfMemoryError
env->DeleteLocalRef(jwaiting_key);
return nullptr;
}
return jdeadlock_info;
}
};
// The portal class for org.rocksdb.TxnDBWritePolicy
class TxnDBWritePolicyJni {
public:
// Returns the equivalent org.rocksdb.TxnDBWritePolicy for the provided
// C++ ROCKSDB_NAMESPACE::TxnDBWritePolicy enum
static jbyte toJavaTxnDBWritePolicy(
const ROCKSDB_NAMESPACE::TxnDBWritePolicy& txndb_write_policy) {
switch (txndb_write_policy) {
case ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_COMMITTED:
return 0x0;
case ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_PREPARED:
return 0x1;
case ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_UNPREPARED:
return 0x2;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::TxnDBWritePolicy enum for the
// provided Java org.rocksdb.TxnDBWritePolicy
static ROCKSDB_NAMESPACE::TxnDBWritePolicy toCppTxnDBWritePolicy(
jbyte jtxndb_write_policy) {
switch (jtxndb_write_policy) {
case 0x0:
return ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_COMMITTED;
case 0x1:
return ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_PREPARED;
case 0x2:
return ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_UNPREPARED;
default:
// undefined/default
return ROCKSDB_NAMESPACE::TxnDBWritePolicy::WRITE_COMMITTED;
}
}
};
// The portal class for org.rocksdb.TransactionDB.KeyLockInfo
class KeyLockInfoJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.TransactionDB.KeyLockInfo
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env,
"org/rocksdb/TransactionDB$KeyLockInfo");
}
/**
* Create a new Java org.rocksdb.TransactionDB.KeyLockInfo object
* with the same properties as the provided C++ ROCKSDB_NAMESPACE::KeyLockInfo
* object
*
* @param env A pointer to the Java environment
* @param key_lock_info The ROCKSDB_NAMESPACE::KeyLockInfo object
*
* @return A reference to a Java
* org.rocksdb.TransactionDB.KeyLockInfo object,
* or nullptr if an an exception occurs
*/
static jobject construct(
JNIEnv* env, const ROCKSDB_NAMESPACE::KeyLockInfo& key_lock_info) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(
jclazz, "<init>", "(Ljava/lang/String;[JZ)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jstring jkey = env->NewStringUTF(key_lock_info.key.c_str());
if (jkey == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
const jsize jtransaction_ids_len = static_cast<jsize>(key_lock_info.ids.size());
jlongArray jtransactions_ids = env->NewLongArray(jtransaction_ids_len);
if (jtransactions_ids == nullptr) {
// exception thrown: OutOfMemoryError
env->DeleteLocalRef(jkey);
return nullptr;
}
const jobject jkey_lock_info = env->NewObject(jclazz, mid,
jkey, jtransactions_ids, key_lock_info.exclusive);
if(jkey_lock_info == nullptr) {
// exception thrown: InstantiationException or OutOfMemoryError
env->DeleteLocalRef(jtransactions_ids);
env->DeleteLocalRef(jkey);
return nullptr;
}
return jkey_lock_info;
}
};
// The portal class for org.rocksdb.TransactionDB.DeadlockInfo
class DeadlockInfoJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.TransactionDB.DeadlockInfo
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env,"org/rocksdb/TransactionDB$DeadlockInfo");
}
};
// The portal class for org.rocksdb.TransactionDB.DeadlockPath
class DeadlockPathJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.TransactionDB.DeadlockPath
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env,
"org/rocksdb/TransactionDB$DeadlockPath");
}
/**
* Create a new Java org.rocksdb.TransactionDB.DeadlockPath object
*
* @param env A pointer to the Java environment
*
* @return A reference to a Java
* org.rocksdb.TransactionDB.DeadlockPath object,
* or nullptr if an an exception occurs
*/
static jobject construct(JNIEnv* env,
const jobjectArray jdeadlock_infos, const bool limit_exceeded) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(
jclazz, "<init>", "([LDeadlockInfo;Z)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
const jobject jdeadlock_path = env->NewObject(jclazz, mid,
jdeadlock_infos, limit_exceeded);
if(jdeadlock_path == nullptr) {
// exception thrown: InstantiationException or OutOfMemoryError
return nullptr;
}
return jdeadlock_path;
}
};
class AbstractTableFilterJni
: public RocksDBNativeClass<
const ROCKSDB_NAMESPACE::TableFilterJniCallback*,
AbstractTableFilterJni> {
public:
/**
* Get the Java Method: TableFilter#filter(TableProperties)
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getFilterMethod(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "filter", "(Lorg/rocksdb/TableProperties;)Z");
assert(mid != nullptr);
return mid;
}
private:
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/TableFilter");
}
};
class TablePropertiesJni : public JavaClass {
public:
/**
* Create a new Java org.rocksdb.TableProperties object.
*
* @param env A pointer to the Java environment
* @param table_properties A Cpp table properties object
*
* @return A reference to a Java org.rocksdb.TableProperties object, or
* nullptr if an an exception occurs
*/
static jobject fromCppTableProperties(
JNIEnv* env, const ROCKSDB_NAMESPACE::TableProperties& table_properties) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
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");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jbyteArray jcolumn_family_name = ROCKSDB_NAMESPACE::JniUtil::copyBytes(
env, table_properties.column_family_name);
if (jcolumn_family_name == nullptr) {
// exception occurred creating java string
return nullptr;
}
jstring jfilter_policy_name = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &table_properties.filter_policy_name, true);
if (env->ExceptionCheck()) {
// exception occurred creating java string
env->DeleteLocalRef(jcolumn_family_name);
return nullptr;
}
jstring jcomparator_name = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &table_properties.comparator_name, true);
if (env->ExceptionCheck()) {
// exception occurred creating java string
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfilter_policy_name);
return nullptr;
}
jstring jmerge_operator_name = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &table_properties.merge_operator_name, true);
if (env->ExceptionCheck()) {
// exception occurred creating java string
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfilter_policy_name);
env->DeleteLocalRef(jcomparator_name);
return nullptr;
}
jstring jprefix_extractor_name = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &table_properties.prefix_extractor_name, true);
if (env->ExceptionCheck()) {
// exception occurred creating java string
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfilter_policy_name);
env->DeleteLocalRef(jcomparator_name);
env->DeleteLocalRef(jmerge_operator_name);
return nullptr;
}
jstring jproperty_collectors_names =
ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &table_properties.property_collectors_names, true);
if (env->ExceptionCheck()) {
// exception occurred creating java string
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfilter_policy_name);
env->DeleteLocalRef(jcomparator_name);
env->DeleteLocalRef(jmerge_operator_name);
env->DeleteLocalRef(jprefix_extractor_name);
return nullptr;
}
jstring jcompression_name = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &table_properties.compression_name, true);
if (env->ExceptionCheck()) {
// exception occurred creating java string
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfilter_policy_name);
env->DeleteLocalRef(jcomparator_name);
env->DeleteLocalRef(jmerge_operator_name);
env->DeleteLocalRef(jprefix_extractor_name);
env->DeleteLocalRef(jproperty_collectors_names);
return nullptr;
}
// Map<String, String>
jobject juser_collected_properties =
ROCKSDB_NAMESPACE::HashMapJni::fromCppMap(
env, &table_properties.user_collected_properties);
if (env->ExceptionCheck()) {
// exception occurred creating java map
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfilter_policy_name);
env->DeleteLocalRef(jcomparator_name);
env->DeleteLocalRef(jmerge_operator_name);
env->DeleteLocalRef(jprefix_extractor_name);
env->DeleteLocalRef(jproperty_collectors_names);
env->DeleteLocalRef(jcompression_name);
return nullptr;
}
// Map<String, String>
jobject jreadable_properties = ROCKSDB_NAMESPACE::HashMapJni::fromCppMap(
env, &table_properties.readable_properties);
if (env->ExceptionCheck()) {
// exception occurred creating java map
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfilter_policy_name);
env->DeleteLocalRef(jcomparator_name);
env->DeleteLocalRef(jmerge_operator_name);
env->DeleteLocalRef(jprefix_extractor_name);
env->DeleteLocalRef(jproperty_collectors_names);
env->DeleteLocalRef(jcompression_name);
env->DeleteLocalRef(juser_collected_properties);
return nullptr;
}
// Map<String, Long>
jobject jproperties_offsets = ROCKSDB_NAMESPACE::HashMapJni::fromCppMap(
env, &table_properties.properties_offsets);
if (env->ExceptionCheck()) {
// exception occurred creating java map
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfilter_policy_name);
env->DeleteLocalRef(jcomparator_name);
env->DeleteLocalRef(jmerge_operator_name);
env->DeleteLocalRef(jprefix_extractor_name);
env->DeleteLocalRef(jproperty_collectors_names);
env->DeleteLocalRef(jcompression_name);
env->DeleteLocalRef(juser_collected_properties);
env->DeleteLocalRef(jreadable_properties);
return nullptr;
}
jobject jtable_properties = env->NewObject(jclazz, mid,
static_cast<jlong>(table_properties.data_size),
static_cast<jlong>(table_properties.index_size),
static_cast<jlong>(table_properties.index_partitions),
static_cast<jlong>(table_properties.top_level_index_size),
static_cast<jlong>(table_properties.index_key_is_user_key),
static_cast<jlong>(table_properties.index_value_is_delta_encoded),
static_cast<jlong>(table_properties.filter_size),
static_cast<jlong>(table_properties.raw_key_size),
static_cast<jlong>(table_properties.raw_value_size),
static_cast<jlong>(table_properties.num_data_blocks),
static_cast<jlong>(table_properties.num_entries),
static_cast<jlong>(table_properties.num_deletions),
static_cast<jlong>(table_properties.num_merge_operands),
static_cast<jlong>(table_properties.num_range_deletions),
static_cast<jlong>(table_properties.format_version),
static_cast<jlong>(table_properties.fixed_key_len),
static_cast<jlong>(table_properties.column_family_id),
static_cast<jlong>(table_properties.creation_time),
static_cast<jlong>(table_properties.oldest_key_time),
jcolumn_family_name,
jfilter_policy_name,
jcomparator_name,
jmerge_operator_name,
jprefix_extractor_name,
jproperty_collectors_names,
jcompression_name,
juser_collected_properties,
jreadable_properties,
jproperties_offsets
);
if (env->ExceptionCheck()) {
return nullptr;
}
return jtable_properties;
}
private:
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/TableProperties");
}
};
class ColumnFamilyDescriptorJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.ColumnFamilyDescriptor
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/ColumnFamilyDescriptor");
}
/**
* Create a new Java org.rocksdb.ColumnFamilyDescriptor object with the same
* properties as the provided C++ ROCKSDB_NAMESPACE::ColumnFamilyDescriptor
* object
*
* @param env A pointer to the Java environment
* @param cfd A pointer to ROCKSDB_NAMESPACE::ColumnFamilyDescriptor object
*
* @return A reference to a Java org.rocksdb.ColumnFamilyDescriptor object, or
* nullptr if an an exception occurs
*/
static jobject construct(JNIEnv* env, ColumnFamilyDescriptor* cfd) {
jbyteArray jcf_name = JniUtil::copyBytes(env, cfd->name);
jobject cfopts = ColumnFamilyOptionsJni::construct(env, &(cfd->options));
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(jclazz, "<init>",
"([BLorg/rocksdb/ColumnFamilyOptions;)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
env->DeleteLocalRef(jcf_name);
return nullptr;
}
jobject jcfd = env->NewObject(jclazz, mid, jcf_name, cfopts);
if (env->ExceptionCheck()) {
env->DeleteLocalRef(jcf_name);
return nullptr;
}
return jcfd;
}
/**
* Get the Java Method: ColumnFamilyDescriptor#columnFamilyName
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getColumnFamilyNameMethod(JNIEnv* env) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "columnFamilyName", "()[B");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: ColumnFamilyDescriptor#columnFamilyOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getColumnFamilyOptionsMethod(JNIEnv* env) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(
jclazz, "columnFamilyOptions", "()Lorg/rocksdb/ColumnFamilyOptions;");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.IndexType
class IndexTypeJni {
public:
// Returns the equivalent org.rocksdb.IndexType for the provided
// C++ ROCKSDB_NAMESPACE::IndexType enum
static jbyte toJavaIndexType(
const ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType& index_type) {
switch (index_type) {
case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::kBinarySearch:
return 0x0;
case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::kHashSearch:
return 0x1;
case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
kTwoLevelIndexSearch:
return 0x2;
case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
kBinarySearchWithFirstKey:
return 0x3;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::IndexType enum for the
// provided Java org.rocksdb.IndexType
static ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType toCppIndexType(
jbyte jindex_type) {
switch (jindex_type) {
case 0x0:
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
kBinarySearch;
case 0x1:
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
kHashSearch;
case 0x2:
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
kTwoLevelIndexSearch;
case 0x3:
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
kBinarySearchWithFirstKey;
default:
// undefined/default
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexType::
kBinarySearch;
}
}
};
// The portal class for org.rocksdb.DataBlockIndexType
class DataBlockIndexTypeJni {
public:
// Returns the equivalent org.rocksdb.DataBlockIndexType for the provided
// C++ ROCKSDB_NAMESPACE::DataBlockIndexType enum
static jbyte toJavaDataBlockIndexType(
const ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType&
index_type) {
switch (index_type) {
case ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType::
kDataBlockBinarySearch:
return 0x0;
case ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType::
kDataBlockBinaryAndHash:
return 0x1;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::DataBlockIndexType enum for
// the provided Java org.rocksdb.DataBlockIndexType
static ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType
toCppDataBlockIndexType(jbyte jindex_type) {
switch (jindex_type) {
case 0x0:
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType::
kDataBlockBinarySearch;
case 0x1:
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType::
kDataBlockBinaryAndHash;
default:
// undefined/default
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::DataBlockIndexType::
kDataBlockBinarySearch;
}
}
};
// The portal class for org.rocksdb.ChecksumType
class ChecksumTypeJni {
public:
// Returns the equivalent org.rocksdb.ChecksumType for the provided
// C++ ROCKSDB_NAMESPACE::ChecksumType enum
static jbyte toJavaChecksumType(
const ROCKSDB_NAMESPACE::ChecksumType& checksum_type) {
switch (checksum_type) {
case ROCKSDB_NAMESPACE::ChecksumType::kNoChecksum:
return 0x0;
case ROCKSDB_NAMESPACE::ChecksumType::kCRC32c:
return 0x1;
case ROCKSDB_NAMESPACE::ChecksumType::kxxHash:
return 0x2;
case ROCKSDB_NAMESPACE::ChecksumType::kxxHash64:
return 0x3;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::ChecksumType enum for the
// provided Java org.rocksdb.ChecksumType
static ROCKSDB_NAMESPACE::ChecksumType toCppChecksumType(
jbyte jchecksum_type) {
switch (jchecksum_type) {
case 0x0:
return ROCKSDB_NAMESPACE::ChecksumType::kNoChecksum;
case 0x1:
return ROCKSDB_NAMESPACE::ChecksumType::kCRC32c;
case 0x2:
return ROCKSDB_NAMESPACE::ChecksumType::kxxHash;
case 0x3:
return ROCKSDB_NAMESPACE::ChecksumType::kxxHash64;
default:
// undefined/default
return ROCKSDB_NAMESPACE::ChecksumType::kCRC32c;
}
}
};
// The portal class for org.rocksdb.IndexShorteningMode
class IndexShorteningModeJni {
public:
// Returns the equivalent org.rocksdb.IndexShorteningMode for the provided
// C++ ROCKSDB_NAMESPACE::IndexShorteningMode enum
static jbyte toJavaIndexShorteningMode(
const ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode&
index_shortening_mode) {
switch (index_shortening_mode) {
case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
kNoShortening:
return 0x0;
case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
kShortenSeparators:
return 0x1;
case ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
kShortenSeparatorsAndSuccessor:
return 0x2;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::IndexShorteningMode enum for
// the provided Java org.rocksdb.IndexShorteningMode
static ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode
toCppIndexShorteningMode(jbyte jindex_shortening_mode) {
switch (jindex_shortening_mode) {
case 0x0:
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
kNoShortening;
case 0x1:
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
kShortenSeparators;
case 0x2:
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
kShortenSeparatorsAndSuccessor;
default:
// undefined/default
return ROCKSDB_NAMESPACE::BlockBasedTableOptions::IndexShorteningMode::
kShortenSeparators;
}
}
};
// The portal class for org.rocksdb.Priority
class PriorityJni {
public:
// Returns the equivalent org.rocksdb.Priority for the provided
// C++ ROCKSDB_NAMESPACE::Env::Priority enum
static jbyte toJavaPriority(
const ROCKSDB_NAMESPACE::Env::Priority& priority) {
switch (priority) {
case ROCKSDB_NAMESPACE::Env::Priority::BOTTOM:
return 0x0;
case ROCKSDB_NAMESPACE::Env::Priority::LOW:
return 0x1;
case ROCKSDB_NAMESPACE::Env::Priority::HIGH:
return 0x2;
case ROCKSDB_NAMESPACE::Env::Priority::TOTAL:
return 0x3;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::env::Priority enum for the
// provided Java org.rocksdb.Priority
static ROCKSDB_NAMESPACE::Env::Priority toCppPriority(jbyte jpriority) {
switch (jpriority) {
case 0x0:
return ROCKSDB_NAMESPACE::Env::Priority::BOTTOM;
case 0x1:
return ROCKSDB_NAMESPACE::Env::Priority::LOW;
case 0x2:
return ROCKSDB_NAMESPACE::Env::Priority::HIGH;
case 0x3:
return ROCKSDB_NAMESPACE::Env::Priority::TOTAL;
default:
// undefined/default
return ROCKSDB_NAMESPACE::Env::Priority::LOW;
}
}
};
// The portal class for org.rocksdb.ThreadType
class ThreadTypeJni {
public:
// Returns the equivalent org.rocksdb.ThreadType for the provided
// C++ ROCKSDB_NAMESPACE::ThreadStatus::ThreadType enum
static jbyte toJavaThreadType(
const ROCKSDB_NAMESPACE::ThreadStatus::ThreadType& thread_type) {
switch (thread_type) {
case ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::HIGH_PRIORITY:
return 0x0;
case ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::LOW_PRIORITY:
return 0x1;
case ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::USER:
return 0x2;
case ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::BOTTOM_PRIORITY:
return 0x3;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::ThreadStatus::ThreadType enum
// for the provided Java org.rocksdb.ThreadType
static ROCKSDB_NAMESPACE::ThreadStatus::ThreadType toCppThreadType(
jbyte jthread_type) {
switch (jthread_type) {
case 0x0:
return ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::HIGH_PRIORITY;
case 0x1:
return ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::LOW_PRIORITY;
case 0x2:
return ThreadStatus::ThreadType::USER;
case 0x3:
return ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::BOTTOM_PRIORITY;
default:
// undefined/default
return ROCKSDB_NAMESPACE::ThreadStatus::ThreadType::LOW_PRIORITY;
}
}
};
// The portal class for org.rocksdb.OperationType
class OperationTypeJni {
public:
// Returns the equivalent org.rocksdb.OperationType for the provided
// C++ ROCKSDB_NAMESPACE::ThreadStatus::OperationType enum
static jbyte toJavaOperationType(
const ROCKSDB_NAMESPACE::ThreadStatus::OperationType& operation_type) {
switch (operation_type) {
case ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_UNKNOWN:
return 0x0;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_COMPACTION:
return 0x1;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_FLUSH:
return 0x2;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::ThreadStatus::OperationType
// enum for the provided Java org.rocksdb.OperationType
static ROCKSDB_NAMESPACE::ThreadStatus::OperationType toCppOperationType(
jbyte joperation_type) {
switch (joperation_type) {
case 0x0:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_UNKNOWN;
case 0x1:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_COMPACTION;
case 0x2:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_FLUSH;
default:
// undefined/default
return ROCKSDB_NAMESPACE::ThreadStatus::OperationType::OP_UNKNOWN;
}
}
};
// The portal class for org.rocksdb.OperationStage
class OperationStageJni {
public:
// Returns the equivalent org.rocksdb.OperationStage for the provided
// C++ ROCKSDB_NAMESPACE::ThreadStatus::OperationStage enum
static jbyte toJavaOperationStage(
const ROCKSDB_NAMESPACE::ThreadStatus::OperationStage& operation_stage) {
switch (operation_stage) {
case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::STAGE_UNKNOWN:
return 0x0;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::STAGE_FLUSH_RUN:
return 0x1;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_FLUSH_WRITE_L0:
return 0x2;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_COMPACTION_PREPARE:
return 0x3;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_COMPACTION_RUN:
return 0x4;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_COMPACTION_PROCESS_KV:
return 0x5;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_COMPACTION_INSTALL:
return 0x6;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_COMPACTION_SYNC_FILE:
return 0x7;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_PICK_MEMTABLES_TO_FLUSH:
return 0x8;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_MEMTABLE_ROLLBACK:
return 0x9;
case ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_MEMTABLE_INSTALL_FLUSH_RESULTS:
return 0xA;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::ThreadStatus::OperationStage
// enum for the provided Java org.rocksdb.OperationStage
static ROCKSDB_NAMESPACE::ThreadStatus::OperationStage toCppOperationStage(
jbyte joperation_stage) {
switch (joperation_stage) {
case 0x0:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::STAGE_UNKNOWN;
case 0x1:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::STAGE_FLUSH_RUN;
case 0x2:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_FLUSH_WRITE_L0;
case 0x3:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_COMPACTION_PREPARE;
case 0x4:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_COMPACTION_RUN;
case 0x5:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_COMPACTION_PROCESS_KV;
case 0x6:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_COMPACTION_INSTALL;
case 0x7:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_COMPACTION_SYNC_FILE;
case 0x8:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_PICK_MEMTABLES_TO_FLUSH;
case 0x9:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_MEMTABLE_ROLLBACK;
case 0xA:
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::
STAGE_MEMTABLE_INSTALL_FLUSH_RESULTS;
default:
// undefined/default
return ROCKSDB_NAMESPACE::ThreadStatus::OperationStage::STAGE_UNKNOWN;
}
}
};
// The portal class for org.rocksdb.StateType
class StateTypeJni {
public:
// Returns the equivalent org.rocksdb.StateType for the provided
// C++ ROCKSDB_NAMESPACE::ThreadStatus::StateType enum
static jbyte toJavaStateType(
const ROCKSDB_NAMESPACE::ThreadStatus::StateType& state_type) {
switch (state_type) {
case ROCKSDB_NAMESPACE::ThreadStatus::StateType::STATE_UNKNOWN:
return 0x0;
case ROCKSDB_NAMESPACE::ThreadStatus::StateType::STATE_MUTEX_WAIT:
return 0x1;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::ThreadStatus::StateType enum
// for the provided Java org.rocksdb.StateType
static ROCKSDB_NAMESPACE::ThreadStatus::StateType toCppStateType(
jbyte jstate_type) {
switch (jstate_type) {
case 0x0:
return ROCKSDB_NAMESPACE::ThreadStatus::StateType::STATE_UNKNOWN;
case 0x1:
return ROCKSDB_NAMESPACE::ThreadStatus::StateType::STATE_MUTEX_WAIT;
default:
// undefined/default
return ROCKSDB_NAMESPACE::ThreadStatus::StateType::STATE_UNKNOWN;
}
}
};
// The portal class for org.rocksdb.ThreadStatus
class ThreadStatusJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.ThreadStatus
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env,
"org/rocksdb/ThreadStatus");
}
/**
* Create a new Java org.rocksdb.ThreadStatus object with the same
* properties as the provided C++ ROCKSDB_NAMESPACE::ThreadStatus object
*
* @param env A pointer to the Java environment
* @param thread_status A pointer to ROCKSDB_NAMESPACE::ThreadStatus object
*
* @return A reference to a Java org.rocksdb.ColumnFamilyOptions object, or
* nullptr if an an exception occurs
*/
static jobject construct(
JNIEnv* env, const ROCKSDB_NAMESPACE::ThreadStatus* thread_status) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(jclazz, "<init>", "(JBLjava/lang/String;Ljava/lang/String;BJB[JB)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jstring jdb_name =
JniUtil::toJavaString(env, &(thread_status->db_name), true);
if (env->ExceptionCheck()) {
// an error occurred
return nullptr;
}
jstring jcf_name =
JniUtil::toJavaString(env, &(thread_status->cf_name), true);
if (env->ExceptionCheck()) {
// an error occurred
env->DeleteLocalRef(jdb_name);
return nullptr;
}
// long[]
const jsize len = static_cast<jsize>(
ROCKSDB_NAMESPACE::ThreadStatus::kNumOperationProperties);
jlongArray joperation_properties =
env->NewLongArray(len);
if (joperation_properties == nullptr) {
// an exception occurred
env->DeleteLocalRef(jdb_name);
env->DeleteLocalRef(jcf_name);
return nullptr;
}
jlong *body = env->GetLongArrayElements(joperation_properties, nullptr);
if (body == nullptr) {
// exception thrown: OutOfMemoryError
env->DeleteLocalRef(jdb_name);
env->DeleteLocalRef(jcf_name);
env->DeleteLocalRef(joperation_properties);
return nullptr;
}
for (size_t i = 0; i < len; ++i) {
body[i] = static_cast<jlong>(thread_status->op_properties[i]);
}
env->ReleaseLongArrayElements(joperation_properties, body, 0);
jobject jcfd = env->NewObject(jclazz, mid,
static_cast<jlong>(thread_status->thread_id),
ThreadTypeJni::toJavaThreadType(thread_status->thread_type),
jdb_name,
jcf_name,
OperationTypeJni::toJavaOperationType(thread_status->operation_type),
static_cast<jlong>(thread_status->op_elapsed_micros),
OperationStageJni::toJavaOperationStage(thread_status->operation_stage),
joperation_properties,
StateTypeJni::toJavaStateType(thread_status->state_type));
if (env->ExceptionCheck()) {
// exception occurred
env->DeleteLocalRef(jdb_name);
env->DeleteLocalRef(jcf_name);
env->DeleteLocalRef(joperation_properties);
return nullptr;
}
// cleanup
env->DeleteLocalRef(jdb_name);
env->DeleteLocalRef(jcf_name);
env->DeleteLocalRef(joperation_properties);
return jcfd;
}
};
// The portal class for org.rocksdb.CompactionStyle
class CompactionStyleJni {
public:
// Returns the equivalent org.rocksdb.CompactionStyle for the provided
// C++ ROCKSDB_NAMESPACE::CompactionStyle enum
static jbyte toJavaCompactionStyle(
const ROCKSDB_NAMESPACE::CompactionStyle& compaction_style) {
switch (compaction_style) {
case ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleLevel:
return 0x0;
case ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleUniversal:
return 0x1;
case ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleFIFO:
return 0x2;
case ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleNone:
return 0x3;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::CompactionStyle enum for the
// provided Java org.rocksdb.CompactionStyle
static ROCKSDB_NAMESPACE::CompactionStyle toCppCompactionStyle(
jbyte jcompaction_style) {
switch (jcompaction_style) {
case 0x0:
return ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleLevel;
case 0x1:
return ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleUniversal;
case 0x2:
return ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleFIFO;
case 0x3:
return ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleNone;
default:
// undefined/default
return ROCKSDB_NAMESPACE::CompactionStyle::kCompactionStyleLevel;
}
}
};
// The portal class for org.rocksdb.CompactionReason
class CompactionReasonJni {
public:
// Returns the equivalent org.rocksdb.CompactionReason for the provided
// C++ ROCKSDB_NAMESPACE::CompactionReason enum
static jbyte toJavaCompactionReason(
const ROCKSDB_NAMESPACE::CompactionReason& compaction_reason) {
switch (compaction_reason) {
case ROCKSDB_NAMESPACE::CompactionReason::kUnknown:
return 0x0;
case ROCKSDB_NAMESPACE::CompactionReason::kLevelL0FilesNum:
return 0x1;
case ROCKSDB_NAMESPACE::CompactionReason::kLevelMaxLevelSize:
return 0x2;
case ROCKSDB_NAMESPACE::CompactionReason::kUniversalSizeAmplification:
return 0x3;
case ROCKSDB_NAMESPACE::CompactionReason::kUniversalSizeRatio:
return 0x4;
case ROCKSDB_NAMESPACE::CompactionReason::kUniversalSortedRunNum:
return 0x5;
case ROCKSDB_NAMESPACE::CompactionReason::kFIFOMaxSize:
return 0x6;
case ROCKSDB_NAMESPACE::CompactionReason::kFIFOReduceNumFiles:
return 0x7;
case ROCKSDB_NAMESPACE::CompactionReason::kFIFOTtl:
return 0x8;
case ROCKSDB_NAMESPACE::CompactionReason::kManualCompaction:
return 0x9;
case ROCKSDB_NAMESPACE::CompactionReason::kFilesMarkedForCompaction:
return 0x10;
case ROCKSDB_NAMESPACE::CompactionReason::kBottommostFiles:
return 0x0A;
case ROCKSDB_NAMESPACE::CompactionReason::kTtl:
return 0x0B;
case ROCKSDB_NAMESPACE::CompactionReason::kFlush:
return 0x0C;
case ROCKSDB_NAMESPACE::CompactionReason::kExternalSstIngestion:
return 0x0D;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::CompactionReason enum for the
// provided Java org.rocksdb.CompactionReason
static ROCKSDB_NAMESPACE::CompactionReason toCppCompactionReason(
jbyte jcompaction_reason) {
switch (jcompaction_reason) {
case 0x0:
return ROCKSDB_NAMESPACE::CompactionReason::kUnknown;
case 0x1:
return ROCKSDB_NAMESPACE::CompactionReason::kLevelL0FilesNum;
case 0x2:
return ROCKSDB_NAMESPACE::CompactionReason::kLevelMaxLevelSize;
case 0x3:
return ROCKSDB_NAMESPACE::CompactionReason::kUniversalSizeAmplification;
case 0x4:
return ROCKSDB_NAMESPACE::CompactionReason::kUniversalSizeRatio;
case 0x5:
return ROCKSDB_NAMESPACE::CompactionReason::kUniversalSortedRunNum;
case 0x6:
return ROCKSDB_NAMESPACE::CompactionReason::kFIFOMaxSize;
case 0x7:
return ROCKSDB_NAMESPACE::CompactionReason::kFIFOReduceNumFiles;
case 0x8:
return ROCKSDB_NAMESPACE::CompactionReason::kFIFOTtl;
case 0x9:
return ROCKSDB_NAMESPACE::CompactionReason::kManualCompaction;
case 0x10:
return ROCKSDB_NAMESPACE::CompactionReason::kFilesMarkedForCompaction;
case 0x0A:
return ROCKSDB_NAMESPACE::CompactionReason::kBottommostFiles;
case 0x0B:
return ROCKSDB_NAMESPACE::CompactionReason::kTtl;
case 0x0C:
return ROCKSDB_NAMESPACE::CompactionReason::kFlush;
case 0x0D:
return ROCKSDB_NAMESPACE::CompactionReason::kExternalSstIngestion;
default:
// undefined/default
return ROCKSDB_NAMESPACE::CompactionReason::kUnknown;
}
}
};
// The portal class for org.rocksdb.WalFileType
class WalFileTypeJni {
public:
// Returns the equivalent org.rocksdb.WalFileType for the provided
// C++ ROCKSDB_NAMESPACE::WalFileType enum
static jbyte toJavaWalFileType(
const ROCKSDB_NAMESPACE::WalFileType& wal_file_type) {
switch (wal_file_type) {
case ROCKSDB_NAMESPACE::WalFileType::kArchivedLogFile:
return 0x0;
case ROCKSDB_NAMESPACE::WalFileType::kAliveLogFile:
return 0x1;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::WalFileType enum for the
// provided Java org.rocksdb.WalFileType
static ROCKSDB_NAMESPACE::WalFileType toCppWalFileType(jbyte jwal_file_type) {
switch (jwal_file_type) {
case 0x0:
return ROCKSDB_NAMESPACE::WalFileType::kArchivedLogFile;
case 0x1:
return ROCKSDB_NAMESPACE::WalFileType::kAliveLogFile;
default:
// undefined/default
return ROCKSDB_NAMESPACE::WalFileType::kAliveLogFile;
}
}
};
class LogFileJni : public JavaClass {
public:
/**
* Create a new Java org.rocksdb.LogFile object.
*
* @param env A pointer to the Java environment
* @param log_file A Cpp log file object
*
* @return A reference to a Java org.rocksdb.LogFile object, or
* nullptr if an an exception occurs
*/
static jobject fromCppLogFile(JNIEnv* env,
ROCKSDB_NAMESPACE::LogFile* log_file) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(jclazz, "<init>", "(Ljava/lang/String;JBJJ)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
std::string path_name = log_file->PathName();
jstring jpath_name =
ROCKSDB_NAMESPACE::JniUtil::toJavaString(env, &path_name, true);
if (env->ExceptionCheck()) {
// exception occurred creating java string
return nullptr;
}
jobject jlog_file = env->NewObject(
jclazz, mid, jpath_name, static_cast<jlong>(log_file->LogNumber()),
ROCKSDB_NAMESPACE::WalFileTypeJni::toJavaWalFileType(log_file->Type()),
static_cast<jlong>(log_file->StartSequence()),
static_cast<jlong>(log_file->SizeFileBytes()));
if (env->ExceptionCheck()) {
env->DeleteLocalRef(jpath_name);
return nullptr;
}
// cleanup
env->DeleteLocalRef(jpath_name);
return jlog_file;
}
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/LogFile");
}
};
class LiveFileMetaDataJni : public JavaClass {
public:
/**
* Create a new Java org.rocksdb.LiveFileMetaData object.
*
* @param env A pointer to the Java environment
* @param live_file_meta_data A Cpp live file meta data object
*
* @return A reference to a Java org.rocksdb.LiveFileMetaData object, or
* nullptr if an an exception occurs
*/
static jobject fromCppLiveFileMetaData(
JNIEnv* env, ROCKSDB_NAMESPACE::LiveFileMetaData* live_file_meta_data) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(jclazz, "<init>", "([BILjava/lang/String;Ljava/lang/String;JJJ[B[BJZJJ)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jbyteArray jcolumn_family_name = ROCKSDB_NAMESPACE::JniUtil::copyBytes(
env, live_file_meta_data->column_family_name);
if (jcolumn_family_name == nullptr) {
// exception occurred creating java byte array
return nullptr;
}
jstring jfile_name = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &live_file_meta_data->name, true);
if (env->ExceptionCheck()) {
// exception occurred creating java string
env->DeleteLocalRef(jcolumn_family_name);
return nullptr;
}
jstring jpath = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &live_file_meta_data->db_path, true);
if (env->ExceptionCheck()) {
// exception occurred creating java string
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfile_name);
return nullptr;
}
jbyteArray jsmallest_key = ROCKSDB_NAMESPACE::JniUtil::copyBytes(
env, live_file_meta_data->smallestkey);
if (jsmallest_key == nullptr) {
// exception occurred creating java byte array
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfile_name);
env->DeleteLocalRef(jpath);
return nullptr;
}
jbyteArray jlargest_key = ROCKSDB_NAMESPACE::JniUtil::copyBytes(
env, live_file_meta_data->largestkey);
if (jlargest_key == nullptr) {
// exception occurred creating java byte array
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfile_name);
env->DeleteLocalRef(jpath);
env->DeleteLocalRef(jsmallest_key);
return nullptr;
}
jobject jlive_file_meta_data = env->NewObject(jclazz, mid,
jcolumn_family_name,
static_cast<jint>(live_file_meta_data->level),
jfile_name,
jpath,
static_cast<jlong>(live_file_meta_data->size),
static_cast<jlong>(live_file_meta_data->smallest_seqno),
static_cast<jlong>(live_file_meta_data->largest_seqno),
jsmallest_key,
jlargest_key,
static_cast<jlong>(live_file_meta_data->num_reads_sampled),
static_cast<jboolean>(live_file_meta_data->being_compacted),
static_cast<jlong>(live_file_meta_data->num_entries),
static_cast<jlong>(live_file_meta_data->num_deletions)
);
if (env->ExceptionCheck()) {
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfile_name);
env->DeleteLocalRef(jpath);
env->DeleteLocalRef(jsmallest_key);
env->DeleteLocalRef(jlargest_key);
return nullptr;
}
// cleanup
env->DeleteLocalRef(jcolumn_family_name);
env->DeleteLocalRef(jfile_name);
env->DeleteLocalRef(jpath);
env->DeleteLocalRef(jsmallest_key);
env->DeleteLocalRef(jlargest_key);
return jlive_file_meta_data;
}
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/LiveFileMetaData");
}
};
class SstFileMetaDataJni : public JavaClass {
public:
/**
* Create a new Java org.rocksdb.SstFileMetaData object.
*
* @param env A pointer to the Java environment
* @param sst_file_meta_data A Cpp sst file meta data object
*
* @return A reference to a Java org.rocksdb.SstFileMetaData object, or
* nullptr if an an exception occurs
*/
static jobject fromCppSstFileMetaData(
JNIEnv* env,
const ROCKSDB_NAMESPACE::SstFileMetaData* sst_file_meta_data) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(jclazz, "<init>", "(Ljava/lang/String;Ljava/lang/String;JJJ[B[BJZJJ)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jstring jfile_name = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &sst_file_meta_data->name, true);
if (jfile_name == nullptr) {
// exception occurred creating java byte array
return nullptr;
}
jstring jpath = ROCKSDB_NAMESPACE::JniUtil::toJavaString(
env, &sst_file_meta_data->db_path, true);
if (jpath == nullptr) {
// exception occurred creating java byte array
env->DeleteLocalRef(jfile_name);
return nullptr;
}
jbyteArray jsmallest_key = ROCKSDB_NAMESPACE::JniUtil::copyBytes(
env, sst_file_meta_data->smallestkey);
if (jsmallest_key == nullptr) {
// exception occurred creating java byte array
env->DeleteLocalRef(jfile_name);
env->DeleteLocalRef(jpath);
return nullptr;
}
jbyteArray jlargest_key = ROCKSDB_NAMESPACE::JniUtil::copyBytes(
env, sst_file_meta_data->largestkey);
if (jlargest_key == nullptr) {
// exception occurred creating java byte array
env->DeleteLocalRef(jfile_name);
env->DeleteLocalRef(jpath);
env->DeleteLocalRef(jsmallest_key);
return nullptr;
}
jobject jsst_file_meta_data = env->NewObject(jclazz, mid,
jfile_name,
jpath,
static_cast<jlong>(sst_file_meta_data->size),
static_cast<jint>(sst_file_meta_data->smallest_seqno),
static_cast<jlong>(sst_file_meta_data->largest_seqno),
jsmallest_key,
jlargest_key,
static_cast<jlong>(sst_file_meta_data->num_reads_sampled),
static_cast<jboolean>(sst_file_meta_data->being_compacted),
static_cast<jlong>(sst_file_meta_data->num_entries),
static_cast<jlong>(sst_file_meta_data->num_deletions)
);
if (env->ExceptionCheck()) {
env->DeleteLocalRef(jfile_name);
env->DeleteLocalRef(jpath);
env->DeleteLocalRef(jsmallest_key);
env->DeleteLocalRef(jlargest_key);
return nullptr;
}
// cleanup
env->DeleteLocalRef(jfile_name);
env->DeleteLocalRef(jpath);
env->DeleteLocalRef(jsmallest_key);
env->DeleteLocalRef(jlargest_key);
return jsst_file_meta_data;
}
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/SstFileMetaData");
}
};
class LevelMetaDataJni : public JavaClass {
public:
/**
* Create a new Java org.rocksdb.LevelMetaData object.
*
* @param env A pointer to the Java environment
* @param level_meta_data A Cpp level meta data object
*
* @return A reference to a Java org.rocksdb.LevelMetaData object, or
* nullptr if an an exception occurs
*/
static jobject fromCppLevelMetaData(
JNIEnv* env, const ROCKSDB_NAMESPACE::LevelMetaData* level_meta_data) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(jclazz, "<init>", "(IJ[Lorg/rocksdb/SstFileMetaData;)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
const jsize jlen =
static_cast<jsize>(level_meta_data->files.size());
jobjectArray jfiles = env->NewObjectArray(jlen, SstFileMetaDataJni::getJClass(env), nullptr);
if (jfiles == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
jsize i = 0;
for (auto it = level_meta_data->files.begin();
it != level_meta_data->files.end(); ++it) {
jobject jfile = SstFileMetaDataJni::fromCppSstFileMetaData(env, &(*it));
if (jfile == nullptr) {
// exception occurred
env->DeleteLocalRef(jfiles);
return nullptr;
}
env->SetObjectArrayElement(jfiles, i++, jfile);
}
jobject jlevel_meta_data = env->NewObject(jclazz, mid,
static_cast<jint>(level_meta_data->level),
static_cast<jlong>(level_meta_data->size),
jfiles
);
if (env->ExceptionCheck()) {
env->DeleteLocalRef(jfiles);
return nullptr;
}
// cleanup
env->DeleteLocalRef(jfiles);
return jlevel_meta_data;
}
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/LevelMetaData");
}
};
class ColumnFamilyMetaDataJni : public JavaClass {
public:
/**
* Create a new Java org.rocksdb.ColumnFamilyMetaData object.
*
* @param env A pointer to the Java environment
* @param column_famly_meta_data A Cpp live file meta data object
*
* @return A reference to a Java org.rocksdb.ColumnFamilyMetaData object, or
* nullptr if an an exception occurs
*/
static jobject fromCppColumnFamilyMetaData(
JNIEnv* env,
const ROCKSDB_NAMESPACE::ColumnFamilyMetaData* column_famly_meta_data) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(jclazz, "<init>", "(JJ[B[Lorg/rocksdb/LevelMetaData;)V");
if (mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jbyteArray jname = ROCKSDB_NAMESPACE::JniUtil::copyBytes(
env, column_famly_meta_data->name);
if (jname == nullptr) {
// exception occurred creating java byte array
return nullptr;
}
const jsize jlen =
static_cast<jsize>(column_famly_meta_data->levels.size());
jobjectArray jlevels = env->NewObjectArray(jlen, LevelMetaDataJni::getJClass(env), nullptr);
if(jlevels == nullptr) {
// exception thrown: OutOfMemoryError
env->DeleteLocalRef(jname);
return nullptr;
}
jsize i = 0;
for (auto it = column_famly_meta_data->levels.begin();
it != column_famly_meta_data->levels.end(); ++it) {
jobject jlevel = LevelMetaDataJni::fromCppLevelMetaData(env, &(*it));
if (jlevel == nullptr) {
// exception occurred
env->DeleteLocalRef(jname);
env->DeleteLocalRef(jlevels);
return nullptr;
}
env->SetObjectArrayElement(jlevels, i++, jlevel);
}
jobject jcolumn_family_meta_data = env->NewObject(jclazz, mid,
static_cast<jlong>(column_famly_meta_data->size),
static_cast<jlong>(column_famly_meta_data->file_count),
jname,
jlevels
);
if (env->ExceptionCheck()) {
env->DeleteLocalRef(jname);
env->DeleteLocalRef(jlevels);
return nullptr;
}
// cleanup
env->DeleteLocalRef(jname);
env->DeleteLocalRef(jlevels);
return jcolumn_family_meta_data;
}
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/ColumnFamilyMetaData");
}
};
// The portal class for org.rocksdb.AbstractTraceWriter
class AbstractTraceWriterJni
: public RocksDBNativeClass<
const ROCKSDB_NAMESPACE::TraceWriterJniCallback*,
AbstractTraceWriterJni> {
public:
/**
* Get the Java Class org.rocksdb.AbstractTraceWriter
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/AbstractTraceWriter");
}
/**
* Get the Java Method: AbstractTraceWriter#write
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getWriteProxyMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(
jclazz, "writeProxy", "(J)S");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: AbstractTraceWriter#closeWriter
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getCloseWriterProxyMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(
jclazz, "closeWriterProxy", "()S");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: AbstractTraceWriter#getFileSize
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getGetFileSizeMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(
jclazz, "getFileSize", "()J");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.AbstractWalFilter
class AbstractWalFilterJni
: public RocksDBNativeClass<const ROCKSDB_NAMESPACE::WalFilterJniCallback*,
AbstractWalFilterJni> {
public:
/**
* Get the Java Class org.rocksdb.AbstractWalFilter
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/AbstractWalFilter");
}
/**
* Get the Java Method: AbstractWalFilter#columnFamilyLogNumberMap
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getColumnFamilyLogNumberMapMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(
jclazz, "columnFamilyLogNumberMap",
"(Ljava/util/Map;Ljava/util/Map;)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: AbstractTraceWriter#logRecordFoundProxy
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getLogRecordFoundProxyMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(
jclazz, "logRecordFoundProxy", "(JLjava/lang/String;JJ)S");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: AbstractTraceWriter#name
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getNameMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(
jclazz, "name", "()Ljava/lang/String;");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.WalProcessingOption
class WalProcessingOptionJni {
public:
// Returns the equivalent org.rocksdb.WalProcessingOption for the provided
// C++ ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption enum
static jbyte toJavaWalProcessingOption(
const ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption&
wal_processing_option) {
switch (wal_processing_option) {
case ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
kContinueProcessing:
return 0x0;
case ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
kIgnoreCurrentRecord:
return 0x1;
case ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::kStopReplay:
return 0x2;
case ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::kCorruptedRecord:
return 0x3;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++
// ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption enum for the provided
// Java org.rocksdb.WalProcessingOption
static ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption
toCppWalProcessingOption(jbyte jwal_processing_option) {
switch (jwal_processing_option) {
case 0x0:
return ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
kContinueProcessing;
case 0x1:
return ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
kIgnoreCurrentRecord;
case 0x2:
return ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::kStopReplay;
case 0x3:
return ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
kCorruptedRecord;
default:
// undefined/default
return ROCKSDB_NAMESPACE::WalFilter::WalProcessingOption::
kCorruptedRecord;
}
}
};
// The portal class for org.rocksdb.ReusedSynchronisationType
class ReusedSynchronisationTypeJni {
public:
// Returns the equivalent org.rocksdb.ReusedSynchronisationType for the
// provided C++ ROCKSDB_NAMESPACE::ReusedSynchronisationType enum
static jbyte toJavaReusedSynchronisationType(
const ROCKSDB_NAMESPACE::ReusedSynchronisationType&
reused_synchronisation_type) {
switch(reused_synchronisation_type) {
case ROCKSDB_NAMESPACE::ReusedSynchronisationType::MUTEX:
return 0x0;
case ROCKSDB_NAMESPACE::ReusedSynchronisationType::ADAPTIVE_MUTEX:
return 0x1;
case ROCKSDB_NAMESPACE::ReusedSynchronisationType::THREAD_LOCAL:
return 0x2;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::ReusedSynchronisationType
// enum for the provided Java org.rocksdb.ReusedSynchronisationType
static ROCKSDB_NAMESPACE::ReusedSynchronisationType
toCppReusedSynchronisationType(jbyte reused_synchronisation_type) {
switch(reused_synchronisation_type) {
case 0x0:
return ROCKSDB_NAMESPACE::ReusedSynchronisationType::MUTEX;
case 0x1:
return ROCKSDB_NAMESPACE::ReusedSynchronisationType::ADAPTIVE_MUTEX;
case 0x2:
return ROCKSDB_NAMESPACE::ReusedSynchronisationType::THREAD_LOCAL;
default:
// undefined/default
return ROCKSDB_NAMESPACE::ReusedSynchronisationType::ADAPTIVE_MUTEX;
}
}
};
// The portal class for org.rocksdb.SanityLevel
class SanityLevelJni {
public:
// Returns the equivalent org.rocksdb.SanityLevel for the provided
// C++ ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel enum
static jbyte toJavaSanityLevel(
const ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel &sanity_level) {
switch (sanity_level) {
case ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel::kSanityLevelNone:
return 0x0;
case ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel::
kSanityLevelLooselyCompatible:
return 0x1;
case ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel::
kSanityLevelExactMatch:
return -0x01;
default:
return -0x01; // undefined
}
}
// Returns the equivalent C++ ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel enum for
// the provided Java org.rocksdb.SanityLevel
static ROCKSDB_NAMESPACE::ConfigOptions::SanityLevel toCppSanityLevel(
jbyte sanity_level) {
switch (sanity_level) {
case 0x0:
return ROCKSDB_NAMESPACE::ConfigOptions::kSanityLevelNone;
case 0x1:
return ROCKSDB_NAMESPACE::ConfigOptions::kSanityLevelLooselyCompatible;
default:
// undefined/default
return ROCKSDB_NAMESPACE::ConfigOptions::kSanityLevelExactMatch;
}
}
};
} // namespace ROCKSDB_NAMESPACE
#endif // JAVA_ROCKSJNI_PORTAL_H_
Reference in New Issue View Git Blame Copy Permalink