1 // Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
2 // This source code is licensed under both the GPLv2 (found in the
3 // COPYING file in the root directory) and Apache 2.0 License
4 // (found in the LICENSE.Apache file in the root directory).
6 // This file implements the "bridge" between Java and C++ and enables
7 // calling c++ ROCKSDB_NAMESPACE::WriteBatchWithIndex methods from Java side.
9 #include "rocksdb/utilities/write_batch_with_index.h"
11 #include "include/org_rocksdb_WBWIRocksIterator.h"
12 #include "include/org_rocksdb_WriteBatchWithIndex.h"
13 #include "rocksdb/comparator.h"
14 #include "rocksjni/cplusplus_to_java_convert.h"
15 #include "rocksjni/portal.h"
18 * Class: org_rocksdb_WriteBatchWithIndex
19 * Method: newWriteBatchWithIndex
22 jlong
Java_org_rocksdb_WriteBatchWithIndex_newWriteBatchWithIndex__(
23 JNIEnv
* /*env*/, jclass
/*jcls*/) {
24 auto* wbwi
= new ROCKSDB_NAMESPACE::WriteBatchWithIndex();
25 return GET_CPLUSPLUS_POINTER(wbwi
);
29 * Class: org_rocksdb_WriteBatchWithIndex
30 * Method: newWriteBatchWithIndex
33 jlong
Java_org_rocksdb_WriteBatchWithIndex_newWriteBatchWithIndex__Z(
34 JNIEnv
* /*env*/, jclass
/*jcls*/, jboolean joverwrite_key
) {
35 auto* wbwi
= new ROCKSDB_NAMESPACE::WriteBatchWithIndex(
36 ROCKSDB_NAMESPACE::BytewiseComparator(), 0,
37 static_cast<bool>(joverwrite_key
));
38 return GET_CPLUSPLUS_POINTER(wbwi
);
42 * Class: org_rocksdb_WriteBatchWithIndex
43 * Method: newWriteBatchWithIndex
46 jlong
Java_org_rocksdb_WriteBatchWithIndex_newWriteBatchWithIndex__JBIZ(
47 JNIEnv
* /*env*/, jclass
/*jcls*/, jlong jfallback_index_comparator_handle
,
48 jbyte jcomparator_type
, jint jreserved_bytes
, jboolean joverwrite_key
) {
49 ROCKSDB_NAMESPACE::Comparator
* fallback_comparator
= nullptr;
50 switch (jcomparator_type
) {
54 reinterpret_cast<ROCKSDB_NAMESPACE::ComparatorJniCallback
*>(
55 jfallback_index_comparator_handle
);
58 // JAVA_NATIVE_COMPARATOR_WRAPPER
60 fallback_comparator
= reinterpret_cast<ROCKSDB_NAMESPACE::Comparator
*>(
61 jfallback_index_comparator_handle
);
64 auto* wbwi
= new ROCKSDB_NAMESPACE::WriteBatchWithIndex(
65 fallback_comparator
, static_cast<size_t>(jreserved_bytes
),
66 static_cast<bool>(joverwrite_key
));
67 return GET_CPLUSPLUS_POINTER(wbwi
);
71 * Class: org_rocksdb_WriteBatchWithIndex
75 jint
Java_org_rocksdb_WriteBatchWithIndex_count0(JNIEnv
* /*env*/,
79 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
80 assert(wbwi
!= nullptr);
82 return static_cast<jint
>(wbwi
->GetWriteBatch()->Count());
86 * Class: org_rocksdb_WriteBatchWithIndex
88 * Signature: (J[BI[BI)V
90 void Java_org_rocksdb_WriteBatchWithIndex_put__J_3BI_3BI(
91 JNIEnv
* env
, jobject jobj
, jlong jwbwi_handle
, jbyteArray jkey
,
92 jint jkey_len
, jbyteArray jentry_value
, jint jentry_value_len
) {
94 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
95 assert(wbwi
!= nullptr);
96 auto put
= [&wbwi
](ROCKSDB_NAMESPACE::Slice key
,
97 ROCKSDB_NAMESPACE::Slice value
) {
98 return wbwi
->Put(key
, value
);
100 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
101 ROCKSDB_NAMESPACE::JniUtil::kv_op(put
, env
, jobj
, jkey
, jkey_len
,
102 jentry_value
, jentry_value_len
);
103 if (status
!= nullptr && !status
->ok()) {
104 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, status
);
109 * Class: org_rocksdb_WriteBatchWithIndex
111 * Signature: (J[BI[BIJ)V
113 void Java_org_rocksdb_WriteBatchWithIndex_put__J_3BI_3BIJ(
114 JNIEnv
* env
, jobject jobj
, jlong jwbwi_handle
, jbyteArray jkey
,
115 jint jkey_len
, jbyteArray jentry_value
, jint jentry_value_len
,
118 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
119 assert(wbwi
!= nullptr);
121 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*>(jcf_handle
);
122 assert(cf_handle
!= nullptr);
123 auto put
= [&wbwi
, &cf_handle
](ROCKSDB_NAMESPACE::Slice key
,
124 ROCKSDB_NAMESPACE::Slice value
) {
125 return wbwi
->Put(cf_handle
, key
, value
);
127 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
128 ROCKSDB_NAMESPACE::JniUtil::kv_op(put
, env
, jobj
, jkey
, jkey_len
,
129 jentry_value
, jentry_value_len
);
130 if (status
!= nullptr && !status
->ok()) {
131 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, status
);
136 * Class: org_rocksdb_WriteBatchWithIndex
138 * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V
140 void Java_org_rocksdb_WriteBatchWithIndex_putDirect(
141 JNIEnv
* env
, jobject
/*jobj*/, jlong jwb_handle
, jobject jkey
,
142 jint jkey_offset
, jint jkey_len
, jobject jval
, jint jval_offset
,
143 jint jval_len
, jlong jcf_handle
) {
144 auto* wb
= reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch
*>(jwb_handle
);
145 assert(wb
!= nullptr);
147 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*>(jcf_handle
);
148 auto put
= [&wb
, &cf_handle
](ROCKSDB_NAMESPACE::Slice
& key
,
149 ROCKSDB_NAMESPACE::Slice
& value
) {
150 if (cf_handle
== nullptr) {
153 wb
->Put(cf_handle
, key
, value
);
156 ROCKSDB_NAMESPACE::JniUtil::kv_op_direct(
157 put
, env
, jkey
, jkey_offset
, jkey_len
, jval
, jval_offset
, jval_len
);
161 * Class: org_rocksdb_WriteBatchWithIndex
163 * Signature: (J[BI[BI)V
165 void Java_org_rocksdb_WriteBatchWithIndex_merge__J_3BI_3BI(
166 JNIEnv
* env
, jobject jobj
, jlong jwbwi_handle
, jbyteArray jkey
,
167 jint jkey_len
, jbyteArray jentry_value
, jint jentry_value_len
) {
169 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
170 assert(wbwi
!= nullptr);
171 auto merge
= [&wbwi
](ROCKSDB_NAMESPACE::Slice key
,
172 ROCKSDB_NAMESPACE::Slice value
) {
173 return wbwi
->Merge(key
, value
);
175 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
176 ROCKSDB_NAMESPACE::JniUtil::kv_op(merge
, env
, jobj
, jkey
, jkey_len
,
177 jentry_value
, jentry_value_len
);
178 if (status
!= nullptr && !status
->ok()) {
179 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, status
);
184 * Class: org_rocksdb_WriteBatchWithIndex
186 * Signature: (J[BI[BIJ)V
188 void Java_org_rocksdb_WriteBatchWithIndex_merge__J_3BI_3BIJ(
189 JNIEnv
* env
, jobject jobj
, jlong jwbwi_handle
, jbyteArray jkey
,
190 jint jkey_len
, jbyteArray jentry_value
, jint jentry_value_len
,
193 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
194 assert(wbwi
!= nullptr);
196 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*>(jcf_handle
);
197 assert(cf_handle
!= nullptr);
198 auto merge
= [&wbwi
, &cf_handle
](ROCKSDB_NAMESPACE::Slice key
,
199 ROCKSDB_NAMESPACE::Slice value
) {
200 return wbwi
->Merge(cf_handle
, key
, value
);
202 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
203 ROCKSDB_NAMESPACE::JniUtil::kv_op(merge
, env
, jobj
, jkey
, jkey_len
,
204 jentry_value
, jentry_value_len
);
205 if (status
!= nullptr && !status
->ok()) {
206 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, status
);
211 * Class: org_rocksdb_WriteBatchWithIndex
215 void Java_org_rocksdb_WriteBatchWithIndex_delete__J_3BI(JNIEnv
* env
,
221 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
222 assert(wbwi
!= nullptr);
223 auto remove
= [&wbwi
](ROCKSDB_NAMESPACE::Slice key
) {
224 return wbwi
->Delete(key
);
226 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
227 ROCKSDB_NAMESPACE::JniUtil::k_op(remove
, env
, jobj
, jkey
, jkey_len
);
228 if (status
!= nullptr && !status
->ok()) {
229 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, status
);
234 * Class: org_rocksdb_WriteBatchWithIndex
236 * Signature: (J[BIJ)V
238 void Java_org_rocksdb_WriteBatchWithIndex_delete__J_3BIJ(
239 JNIEnv
* env
, jobject jobj
, jlong jwbwi_handle
, jbyteArray jkey
,
240 jint jkey_len
, jlong jcf_handle
) {
242 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
243 assert(wbwi
!= nullptr);
245 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*>(jcf_handle
);
246 assert(cf_handle
!= nullptr);
247 auto remove
= [&wbwi
, &cf_handle
](ROCKSDB_NAMESPACE::Slice key
) {
248 return wbwi
->Delete(cf_handle
, key
);
250 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
251 ROCKSDB_NAMESPACE::JniUtil::k_op(remove
, env
, jobj
, jkey
, jkey_len
);
252 if (status
!= nullptr && !status
->ok()) {
253 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, status
);
258 * Class: org_rocksdb_WriteBatchWithIndex
259 * Method: singleDelete
262 void Java_org_rocksdb_WriteBatchWithIndex_singleDelete__J_3BI(
263 JNIEnv
* env
, jobject jobj
, jlong jwbwi_handle
, jbyteArray jkey
,
266 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
267 assert(wbwi
!= nullptr);
268 auto single_delete
= [&wbwi
](ROCKSDB_NAMESPACE::Slice key
) {
269 return wbwi
->SingleDelete(key
);
271 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
272 ROCKSDB_NAMESPACE::JniUtil::k_op(single_delete
, env
, jobj
, jkey
,
274 if (status
!= nullptr && !status
->ok()) {
275 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, status
);
280 * Class: org_rocksdb_WriteBatchWithIndex
281 * Method: singleDelete
282 * Signature: (J[BIJ)V
284 void Java_org_rocksdb_WriteBatchWithIndex_singleDelete__J_3BIJ(
285 JNIEnv
* env
, jobject jobj
, jlong jwbwi_handle
, jbyteArray jkey
,
286 jint jkey_len
, jlong jcf_handle
) {
288 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
289 assert(wbwi
!= nullptr);
291 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*>(jcf_handle
);
292 assert(cf_handle
!= nullptr);
293 auto single_delete
= [&wbwi
, &cf_handle
](ROCKSDB_NAMESPACE::Slice key
) {
294 return wbwi
->SingleDelete(cf_handle
, key
);
296 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
297 ROCKSDB_NAMESPACE::JniUtil::k_op(single_delete
, env
, jobj
, jkey
,
299 if (status
!= nullptr && !status
->ok()) {
300 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, status
);
305 * Class: org_rocksdb_WriteBatchWithIndex
306 * Method: deleteDirect
307 * Signature: (JLjava/nio/ByteBuffer;IIJ)V
309 void Java_org_rocksdb_WriteBatchWithIndex_deleteDirect(
310 JNIEnv
* env
, jobject
/*jobj*/, jlong jwb_handle
, jobject jkey
,
311 jint jkey_offset
, jint jkey_len
, jlong jcf_handle
) {
312 auto* wb
= reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch
*>(jwb_handle
);
313 assert(wb
!= nullptr);
315 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*>(jcf_handle
);
316 auto remove
= [&wb
, &cf_handle
](ROCKSDB_NAMESPACE::Slice
& key
) {
317 if (cf_handle
== nullptr) {
320 wb
->Delete(cf_handle
, key
);
323 ROCKSDB_NAMESPACE::JniUtil::k_op_direct(remove
, env
, jkey
, jkey_offset
,
328 * Class: org_rocksdb_WriteBatchWithIndex
329 * Method: deleteRange
330 * Signature: (J[BI[BI)V
332 void Java_org_rocksdb_WriteBatchWithIndex_deleteRange__J_3BI_3BI(
333 JNIEnv
* env
, jobject jobj
, jlong jwbwi_handle
, jbyteArray jbegin_key
,
334 jint jbegin_key_len
, jbyteArray jend_key
, jint jend_key_len
) {
336 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
337 assert(wbwi
!= nullptr);
338 auto deleteRange
= [&wbwi
](ROCKSDB_NAMESPACE::Slice beginKey
,
339 ROCKSDB_NAMESPACE::Slice endKey
) {
340 return wbwi
->DeleteRange(beginKey
, endKey
);
342 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
343 ROCKSDB_NAMESPACE::JniUtil::kv_op(deleteRange
, env
, jobj
, jbegin_key
,
344 jbegin_key_len
, jend_key
, jend_key_len
);
345 if (status
!= nullptr && !status
->ok()) {
346 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, status
);
351 * Class: org_rocksdb_WriteBatchWithIndex
352 * Method: deleteRange
353 * Signature: (J[BI[BIJ)V
355 void Java_org_rocksdb_WriteBatchWithIndex_deleteRange__J_3BI_3BIJ(
356 JNIEnv
* env
, jobject jobj
, jlong jwbwi_handle
, jbyteArray jbegin_key
,
357 jint jbegin_key_len
, jbyteArray jend_key
, jint jend_key_len
,
360 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
361 assert(wbwi
!= nullptr);
363 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*>(jcf_handle
);
364 assert(cf_handle
!= nullptr);
365 auto deleteRange
= [&wbwi
, &cf_handle
](ROCKSDB_NAMESPACE::Slice beginKey
,
366 ROCKSDB_NAMESPACE::Slice endKey
) {
367 return wbwi
->DeleteRange(cf_handle
, beginKey
, endKey
);
369 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
370 ROCKSDB_NAMESPACE::JniUtil::kv_op(deleteRange
, env
, jobj
, jbegin_key
,
371 jbegin_key_len
, jend_key
, jend_key_len
);
372 if (status
!= nullptr && !status
->ok()) {
373 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, status
);
378 * Class: org_rocksdb_WriteBatchWithIndex
382 void Java_org_rocksdb_WriteBatchWithIndex_putLogData(JNIEnv
* env
, jobject jobj
,
387 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
388 assert(wbwi
!= nullptr);
389 auto putLogData
= [&wbwi
](ROCKSDB_NAMESPACE::Slice blob
) {
390 return wbwi
->PutLogData(blob
);
392 std::unique_ptr
<ROCKSDB_NAMESPACE::Status
> status
=
393 ROCKSDB_NAMESPACE::JniUtil::k_op(putLogData
, env
, jobj
, jblob
, jblob_len
);
394 if (status
!= nullptr && !status
->ok()) {
395 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, status
);
400 * Class: org_rocksdb_WriteBatchWithIndex
404 void Java_org_rocksdb_WriteBatchWithIndex_clear0(JNIEnv
* /*env*/,
406 jlong jwbwi_handle
) {
408 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
409 assert(wbwi
!= nullptr);
415 * Class: org_rocksdb_WriteBatchWithIndex
416 * Method: setSavePoint0
419 void Java_org_rocksdb_WriteBatchWithIndex_setSavePoint0(JNIEnv
* /*env*/,
421 jlong jwbwi_handle
) {
423 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
424 assert(wbwi
!= nullptr);
426 wbwi
->SetSavePoint();
430 * Class: org_rocksdb_WriteBatchWithIndex
431 * Method: rollbackToSavePoint0
434 void Java_org_rocksdb_WriteBatchWithIndex_rollbackToSavePoint0(
435 JNIEnv
* env
, jobject
/*jobj*/, jlong jwbwi_handle
) {
437 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
438 assert(wbwi
!= nullptr);
440 auto s
= wbwi
->RollbackToSavePoint();
446 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, s
);
450 * Class: org_rocksdb_WriteBatchWithIndex
451 * Method: popSavePoint
454 void Java_org_rocksdb_WriteBatchWithIndex_popSavePoint(JNIEnv
* env
,
456 jlong jwbwi_handle
) {
458 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
459 assert(wbwi
!= nullptr);
461 auto s
= wbwi
->PopSavePoint();
467 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, s
);
471 * Class: org_rocksdb_WriteBatchWithIndex
472 * Method: setMaxBytes
475 void Java_org_rocksdb_WriteBatchWithIndex_setMaxBytes(JNIEnv
* /*env*/,
480 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
481 assert(wbwi
!= nullptr);
483 wbwi
->SetMaxBytes(static_cast<size_t>(jmax_bytes
));
487 * Class: org_rocksdb_WriteBatchWithIndex
488 * Method: getWriteBatch
489 * Signature: (J)Lorg/rocksdb/WriteBatch;
491 jobject
Java_org_rocksdb_WriteBatchWithIndex_getWriteBatch(JNIEnv
* env
,
493 jlong jwbwi_handle
) {
495 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
496 assert(wbwi
!= nullptr);
498 auto* wb
= wbwi
->GetWriteBatch();
500 // TODO(AR) is the `wb` object owned by us?
501 return ROCKSDB_NAMESPACE::WriteBatchJni::construct(env
, wb
);
505 * Class: org_rocksdb_WriteBatchWithIndex
509 jlong
Java_org_rocksdb_WriteBatchWithIndex_iterator0(JNIEnv
* /*env*/,
511 jlong jwbwi_handle
) {
513 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
514 auto* wbwi_iterator
= wbwi
->NewIterator();
515 return GET_CPLUSPLUS_POINTER(wbwi_iterator
);
519 * Class: org_rocksdb_WriteBatchWithIndex
523 jlong
Java_org_rocksdb_WriteBatchWithIndex_iterator1(JNIEnv
* /*env*/,
528 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
530 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*>(jcf_handle
);
531 auto* wbwi_iterator
= wbwi
->NewIterator(cf_handle
);
532 return GET_CPLUSPLUS_POINTER(wbwi_iterator
);
536 * Class: org_rocksdb_WriteBatchWithIndex
537 * Method: iteratorWithBase
540 jlong
Java_org_rocksdb_WriteBatchWithIndex_iteratorWithBase(
541 JNIEnv
*, jobject
, jlong jwbwi_handle
, jlong jcf_handle
,
542 jlong jbase_iterator_handle
, jlong jread_opts_handle
) {
544 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
546 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*>(jcf_handle
);
547 auto* base_iterator
=
548 reinterpret_cast<ROCKSDB_NAMESPACE::Iterator
*>(jbase_iterator_handle
);
549 ROCKSDB_NAMESPACE::ReadOptions
* read_opts
=
550 jread_opts_handle
== 0
552 : reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions
*>(
555 wbwi
->NewIteratorWithBase(cf_handle
, base_iterator
, read_opts
);
556 return GET_CPLUSPLUS_POINTER(iterator
);
560 * Class: org_rocksdb_WriteBatchWithIndex
561 * Method: getFromBatch
562 * Signature: (JJ[BI)[B
564 jbyteArray JNICALL
Java_org_rocksdb_WriteBatchWithIndex_getFromBatch__JJ_3BI(
565 JNIEnv
* env
, jobject
/*jobj*/, jlong jwbwi_handle
, jlong jdbopt_handle
,
566 jbyteArray jkey
, jint jkey_len
) {
568 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
569 auto* dbopt
= reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions
*>(jdbopt_handle
);
571 auto getter
= [&wbwi
, &dbopt
](const ROCKSDB_NAMESPACE::Slice
& key
,
572 std::string
* value
) {
573 return wbwi
->GetFromBatch(*dbopt
, key
, value
);
576 return ROCKSDB_NAMESPACE::JniUtil::v_op(getter
, env
, jkey
, jkey_len
);
580 * Class: org_rocksdb_WriteBatchWithIndex
581 * Method: getFromBatch
582 * Signature: (JJ[BIJ)[B
584 jbyteArray
Java_org_rocksdb_WriteBatchWithIndex_getFromBatch__JJ_3BIJ(
585 JNIEnv
* env
, jobject
/*jobj*/, jlong jwbwi_handle
, jlong jdbopt_handle
,
586 jbyteArray jkey
, jint jkey_len
, jlong jcf_handle
) {
588 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
589 auto* dbopt
= reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions
*>(jdbopt_handle
);
591 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*>(jcf_handle
);
593 auto getter
= [&wbwi
, &cf_handle
, &dbopt
](const ROCKSDB_NAMESPACE::Slice
& key
,
594 std::string
* value
) {
595 return wbwi
->GetFromBatch(cf_handle
, *dbopt
, key
, value
);
598 return ROCKSDB_NAMESPACE::JniUtil::v_op(getter
, env
, jkey
, jkey_len
);
602 * Class: org_rocksdb_WriteBatchWithIndex
603 * Method: getFromBatchAndDB
604 * Signature: (JJJ[BI)[B
606 jbyteArray
Java_org_rocksdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BI(
607 JNIEnv
* env
, jobject
/*jobj*/, jlong jwbwi_handle
, jlong jdb_handle
,
608 jlong jreadopt_handle
, jbyteArray jkey
, jint jkey_len
) {
610 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
611 auto* db
= reinterpret_cast<ROCKSDB_NAMESPACE::DB
*>(jdb_handle
);
613 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions
*>(jreadopt_handle
);
615 auto getter
= [&wbwi
, &db
, &readopt
](const ROCKSDB_NAMESPACE::Slice
& key
,
616 std::string
* value
) {
617 return wbwi
->GetFromBatchAndDB(db
, *readopt
, key
, value
);
620 return ROCKSDB_NAMESPACE::JniUtil::v_op(getter
, env
, jkey
, jkey_len
);
624 * Class: org_rocksdb_WriteBatchWithIndex
625 * Method: getFromBatchAndDB
626 * Signature: (JJJ[BIJ)[B
628 jbyteArray
Java_org_rocksdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BIJ(
629 JNIEnv
* env
, jobject
/*jobj*/, jlong jwbwi_handle
, jlong jdb_handle
,
630 jlong jreadopt_handle
, jbyteArray jkey
, jint jkey_len
, jlong jcf_handle
) {
632 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(jwbwi_handle
);
633 auto* db
= reinterpret_cast<ROCKSDB_NAMESPACE::DB
*>(jdb_handle
);
635 reinterpret_cast<ROCKSDB_NAMESPACE::ReadOptions
*>(jreadopt_handle
);
637 reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyHandle
*>(jcf_handle
);
639 auto getter
= [&wbwi
, &db
, &cf_handle
, &readopt
](
640 const ROCKSDB_NAMESPACE::Slice
& key
, std::string
* value
) {
641 return wbwi
->GetFromBatchAndDB(db
, *readopt
, cf_handle
, key
, value
);
644 return ROCKSDB_NAMESPACE::JniUtil::v_op(getter
, env
, jkey
, jkey_len
);
648 * Class: org_rocksdb_WriteBatchWithIndex
649 * Method: disposeInternal
652 void Java_org_rocksdb_WriteBatchWithIndex_disposeInternal(JNIEnv
* /*env*/,
656 reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatchWithIndex
*>(handle
);
657 assert(wbwi
!= nullptr);
661 /* WBWIRocksIterator below */
664 * Class: org_rocksdb_WBWIRocksIterator
665 * Method: disposeInternal
668 void Java_org_rocksdb_WBWIRocksIterator_disposeInternal(JNIEnv
* /*env*/,
671 auto* it
= reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
);
672 assert(it
!= nullptr);
677 * Class: org_rocksdb_WBWIRocksIterator
681 jboolean
Java_org_rocksdb_WBWIRocksIterator_isValid0(JNIEnv
* /*env*/,
684 return reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
)->Valid();
688 * Class: org_rocksdb_WBWIRocksIterator
689 * Method: seekToFirst0
692 void Java_org_rocksdb_WBWIRocksIterator_seekToFirst0(JNIEnv
* /*env*/,
695 reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
)->SeekToFirst();
699 * Class: org_rocksdb_WBWIRocksIterator
700 * Method: seekToLast0
703 void Java_org_rocksdb_WBWIRocksIterator_seekToLast0(JNIEnv
* /*env*/,
706 reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
)->SeekToLast();
710 * Class: org_rocksdb_WBWIRocksIterator
714 void Java_org_rocksdb_WBWIRocksIterator_next0(JNIEnv
* /*env*/, jobject
/*jobj*/,
716 reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
)->Next();
720 * Class: org_rocksdb_WBWIRocksIterator
724 void Java_org_rocksdb_WBWIRocksIterator_prev0(JNIEnv
* /*env*/, jobject
/*jobj*/,
726 reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
)->Prev();
730 * Class: org_rocksdb_WBWIRocksIterator
734 void Java_org_rocksdb_WBWIRocksIterator_seek0(JNIEnv
* env
, jobject
/*jobj*/,
735 jlong handle
, jbyteArray jtarget
,
737 auto* it
= reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
);
738 jbyte
* target
= new jbyte
[jtarget_len
];
739 env
->GetByteArrayRegion(jtarget
, 0, jtarget_len
, target
);
740 if (env
->ExceptionCheck()) {
741 // exception thrown: ArrayIndexOutOfBoundsException
746 ROCKSDB_NAMESPACE::Slice
target_slice(reinterpret_cast<char*>(target
),
749 it
->Seek(target_slice
);
755 * Class: org_rocksdb_WBWIRocksIterator
756 * Method: seekDirect0
757 * Signature: (JLjava/nio/ByteBuffer;II)V
759 void Java_org_rocksdb_WBWIRocksIterator_seekDirect0(
760 JNIEnv
* env
, jobject
/*jobj*/, jlong handle
, jobject jtarget
,
761 jint jtarget_off
, jint jtarget_len
) {
762 auto* it
= reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
);
763 auto seek
= [&it
](ROCKSDB_NAMESPACE::Slice
& target_slice
) {
764 it
->Seek(target_slice
);
766 ROCKSDB_NAMESPACE::JniUtil::k_op_direct(seek
, env
, jtarget
, jtarget_off
,
771 * This method supports fetching into indirect byte buffers;
772 * the Java wrapper extracts the byte[] and passes it here.
774 * Class: org_rocksdb_WBWIRocksIterator
775 * Method: seekByteArray0
776 * Signature: (J[BII)V
778 void Java_org_rocksdb_WBWIRocksIterator_seekByteArray0(
779 JNIEnv
* env
, jobject
/*jobj*/, jlong handle
, jbyteArray jtarget
,
780 jint jtarget_off
, jint jtarget_len
) {
781 const std::unique_ptr
<char[]> target(new char[jtarget_len
]);
782 if (target
== nullptr) {
783 jclass oom_class
= env
->FindClass("/lang/java/OutOfMemoryError");
784 env
->ThrowNew(oom_class
,
785 "Memory allocation failed in RocksDB JNI function");
788 env
->GetByteArrayRegion(jtarget
, jtarget_off
, jtarget_len
,
789 reinterpret_cast<jbyte
*>(target
.get()));
791 ROCKSDB_NAMESPACE::Slice
target_slice(target
.get(), jtarget_len
);
793 auto* it
= reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
);
794 it
->Seek(target_slice
);
798 * Class: org_rocksdb_WBWIRocksIterator
799 * Method: seekForPrev0
802 void Java_org_rocksdb_WBWIRocksIterator_seekForPrev0(JNIEnv
* env
,
807 auto* it
= reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
);
808 jbyte
* target
= new jbyte
[jtarget_len
];
809 env
->GetByteArrayRegion(jtarget
, 0, jtarget_len
, target
);
810 if (env
->ExceptionCheck()) {
811 // exception thrown: ArrayIndexOutOfBoundsException
816 ROCKSDB_NAMESPACE::Slice
target_slice(reinterpret_cast<char*>(target
),
819 it
->SeekForPrev(target_slice
);
825 * Class: org_rocksdb_WBWIRocksIterator
826 * Method: seekForPrevDirect0
827 * Signature: (JLjava/nio/ByteBuffer;II)V
829 void Java_org_rocksdb_WBWIRocksIterator_seekForPrevDirect0(
830 JNIEnv
* env
, jobject
/*jobj*/, jlong handle
, jobject jtarget
,
831 jint jtarget_off
, jint jtarget_len
) {
832 auto* it
= reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
);
833 auto seek_for_prev
= [&it
](ROCKSDB_NAMESPACE::Slice
& target_slice
) {
834 it
->SeekForPrev(target_slice
);
836 ROCKSDB_NAMESPACE::JniUtil::k_op_direct(seek_for_prev
, env
, jtarget
,
837 jtarget_off
, jtarget_len
);
841 * This method supports fetching into indirect byte buffers;
842 * the Java wrapper extracts the byte[] and passes it here.
844 * Class: org_rocksdb_WBWIRocksIterator
845 * Method: seekForPrevByteArray0
846 * Signature: (J[BII)V
848 void Java_org_rocksdb_WBWIRocksIterator_seekForPrevByteArray0(
849 JNIEnv
* env
, jobject
/*jobj*/, jlong handle
, jbyteArray jtarget
,
850 jint jtarget_off
, jint jtarget_len
) {
851 const std::unique_ptr
<char[]> target(new char[jtarget_len
]);
852 if (target
== nullptr) {
853 jclass oom_class
= env
->FindClass("/lang/java/OutOfMemoryError");
854 env
->ThrowNew(oom_class
,
855 "Memory allocation failed in RocksDB JNI function");
858 env
->GetByteArrayRegion(jtarget
, jtarget_off
, jtarget_len
,
859 reinterpret_cast<jbyte
*>(target
.get()));
861 ROCKSDB_NAMESPACE::Slice
target_slice(target
.get(), jtarget_len
);
863 auto* it
= reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
);
864 it
->SeekForPrev(target_slice
);
868 * Class: org_rocksdb_WBWIRocksIterator
872 void Java_org_rocksdb_WBWIRocksIterator_status0(JNIEnv
* env
, jobject
/*jobj*/,
874 auto* it
= reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
);
875 ROCKSDB_NAMESPACE::Status s
= it
->status();
881 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, s
);
885 * Class: org_rocksdb_WBWIRocksIterator
889 jlongArray
Java_org_rocksdb_WBWIRocksIterator_entry1(JNIEnv
* env
,
892 auto* it
= reinterpret_cast<ROCKSDB_NAMESPACE::WBWIIterator
*>(handle
);
893 const ROCKSDB_NAMESPACE::WriteEntry
& we
= it
->Entry();
897 // set the type of the write entry
898 results
[0] = ROCKSDB_NAMESPACE::WriteTypeJni::toJavaWriteType(we
.type
);
900 // NOTE: key_slice and value_slice will be freed by
901 // org.rocksdb.DirectSlice#close
903 auto* key_slice
= new ROCKSDB_NAMESPACE::Slice(we
.key
.data(), we
.key
.size());
904 results
[1] = GET_CPLUSPLUS_POINTER(key_slice
);
905 if (we
.type
== ROCKSDB_NAMESPACE::kDeleteRecord
||
906 we
.type
== ROCKSDB_NAMESPACE::kSingleDeleteRecord
||
907 we
.type
== ROCKSDB_NAMESPACE::kLogDataRecord
) {
908 // set native handle of value slice to null if no value available
912 new ROCKSDB_NAMESPACE::Slice(we
.value
.data(), we
.value
.size());
913 results
[2] = GET_CPLUSPLUS_POINTER(value_slice
);
916 jlongArray jresults
= env
->NewLongArray(3);
917 if (jresults
== nullptr) {
918 // exception thrown: OutOfMemoryError
919 if (results
[2] != 0) {
921 reinterpret_cast<ROCKSDB_NAMESPACE::Slice
*>(results
[2]);
928 env
->SetLongArrayRegion(jresults
, 0, 3, results
);
929 if (env
->ExceptionCheck()) {
930 // exception thrown: ArrayIndexOutOfBoundsException
931 env
->DeleteLocalRef(jresults
);
932 if (results
[2] != 0) {
934 reinterpret_cast<ROCKSDB_NAMESPACE::Slice
*>(results
[2]);
945 * Class: org_rocksdb_WBWIRocksIterator
949 void Java_org_rocksdb_WBWIRocksIterator_refresh0(JNIEnv
* env
) {
950 ROCKSDB_NAMESPACE::Status s
=
951 ROCKSDB_NAMESPACE::Status::NotSupported("Refresh() is not supported");
952 ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env
, s
);