From 05f2425452bffccd60333d415d337aa8261b73a5 Mon Sep 17 00:00:00 2001 From: Andrew Kryczka Date: Tue, 25 Jul 2023 19:16:22 -0700 Subject: [PATCH 01/61] Update for 8.5.fb branch cut --- HISTORY.md | 12 ++++++++++++ .../behavior_changes/fifo_ttl_periodic_compaction.md | 1 - .../behavior_changes/fs_prefetch_compaction_read.md | 1 - .../avoid_memcpy_directio.md | 1 - unreleased_history/performance_improvements/hcc_perf | 1 - .../public_api_changes/rename_migration_caches.md | 1 - unreleased_history/release.sh | 2 +- 7 files changed, 13 insertions(+), 6 deletions(-) delete mode 100644 unreleased_history/behavior_changes/fifo_ttl_periodic_compaction.md delete mode 100644 unreleased_history/behavior_changes/fs_prefetch_compaction_read.md delete mode 100644 unreleased_history/performance_improvements/avoid_memcpy_directio.md delete mode 100644 unreleased_history/performance_improvements/hcc_perf delete mode 100644 unreleased_history/public_api_changes/rename_migration_caches.md diff --git a/HISTORY.md b/HISTORY.md index f4dce5cd8..262e3dd9c 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -1,6 +1,18 @@ # Rocksdb Change Log > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt` +## 8.5.0 (07/21/2023) +### Public API Changes +* Removed recently added APIs `GeneralCache` and `MakeSharedGeneralCache()` as our plan changed to stop exposing a general-purpose cache interface. The old forms of these APIs, `Cache` and `NewLRUCache()`, are still available, although general-purpose caching support will be dropped eventually. + +### Behavior Changes +* Option `periodic_compaction_seconds` no longer supports FIFO compaction: setting it has no effect on FIFO compactions. FIFO compaction users should only set option `ttl` instead. +* Move prefetching responsibility to page cache for compaction read for non directIO use case + +### Performance Improvements +* In case of direct_io, if buffer passed by callee is already aligned, RandomAccessFileRead::Read will avoid realloacting a new buffer, reducing memcpy and use already passed aligned buffer. +* Small efficiency improvement to HyperClockCache by reducing chance of compiler-generated heap allocations + ## 8.4.0 (06/26/2023) ### New Features * Add FSReadRequest::fs_scratch which is a data buffer allocated and provided by underlying FileSystem to RocksDB during reads, when FS wants to provide its own buffer with data instead of using RocksDB provided FSReadRequest::scratch. This can help in cpu optimization by avoiding copy from file system's buffer to RocksDB buffer. More details on how to use/enable it in file_system.h. Right now its supported only for MultiReads(async + sync) with non direct io. diff --git a/unreleased_history/behavior_changes/fifo_ttl_periodic_compaction.md b/unreleased_history/behavior_changes/fifo_ttl_periodic_compaction.md deleted file mode 100644 index 6297ccc91..000000000 --- a/unreleased_history/behavior_changes/fifo_ttl_periodic_compaction.md +++ /dev/null @@ -1 +0,0 @@ -Option `periodic_compaction_seconds` no longer supports FIFO compaction: setting it has no effect on FIFO compactions. FIFO compaction users should only set option `ttl` instead. \ No newline at end of file diff --git a/unreleased_history/behavior_changes/fs_prefetch_compaction_read.md b/unreleased_history/behavior_changes/fs_prefetch_compaction_read.md deleted file mode 100644 index 0552a57e0..000000000 --- a/unreleased_history/behavior_changes/fs_prefetch_compaction_read.md +++ /dev/null @@ -1 +0,0 @@ -Move prefetching responsibility to page cache for compaction read for non directIO use case diff --git a/unreleased_history/performance_improvements/avoid_memcpy_directio.md b/unreleased_history/performance_improvements/avoid_memcpy_directio.md deleted file mode 100644 index d5ac0b911..000000000 --- a/unreleased_history/performance_improvements/avoid_memcpy_directio.md +++ /dev/null @@ -1 +0,0 @@ -In case of direct_io, if buffer passed by callee is already aligned, RandomAccessFileRead::Read will avoid realloacting a new buffer, reducing memcpy and use already passed aligned buffer. diff --git a/unreleased_history/performance_improvements/hcc_perf b/unreleased_history/performance_improvements/hcc_perf deleted file mode 100644 index c129393dc..000000000 --- a/unreleased_history/performance_improvements/hcc_perf +++ /dev/null @@ -1 +0,0 @@ -Small efficiency improvement to HyperClockCache by reducing chance of compiler-generated heap allocations diff --git a/unreleased_history/public_api_changes/rename_migration_caches.md b/unreleased_history/public_api_changes/rename_migration_caches.md deleted file mode 100644 index 3db59947d..000000000 --- a/unreleased_history/public_api_changes/rename_migration_caches.md +++ /dev/null @@ -1 +0,0 @@ -Removed recently added APIs `GeneralCache` and `MakeSharedGeneralCache()` as our plan changed to stop exposing a general-purpose cache interface. The old forms of these APIs, `Cache` and `NewLRUCache()`, are still available, although general-purpose caching support will be dropped eventually. diff --git a/unreleased_history/release.sh b/unreleased_history/release.sh index 91bfed3ea..5ddbe3bfe 100755 --- a/unreleased_history/release.sh +++ b/unreleased_history/release.sh @@ -31,7 +31,7 @@ awk '/#define ROCKSDB_MAJOR/ { major = $3 } /#define ROCKSDB_MINOR/ { minor = $3 } /#define ROCKSDB_PATCH/ { patch = $3 } END { printf "## " major "." minor "." patch }' < include/rocksdb/version.h >> HISTORY.new -echo " (`date +%x`)" >> HISTORY.new +echo " (`git log -n1 --date=format:"%m/%d/%Y" --format="%ad"`)" >> HISTORY.new function process_file () { # use awk to correct extra or missing newlines, missing '* ' on first line From 69ddf2e0f6c6238156116a612ad24ebd21c37907 Mon Sep 17 00:00:00 2001 From: akankshamahajan Date: Thu, 27 Jul 2023 12:02:03 -0700 Subject: [PATCH 02/61] Fix use_after_free bug when underlying FS enables kFSBuffer (#11645) Summary: Fix use_after_free bug in async_io MultiReads when underlying FS enabled kFSBuffer. kFSBuffer is when underlying FS pass their own buffer instead of using RocksDB scratch in FSReadRequest Since it's an experimental feature, added a hack for now to fix the bug. Planning to make public API change to remove const from the callback as it doesn't make sense to use const. Pull Request resolved: https://github.com/facebook/rocksdb/pull/11645 Test Plan: tested locally Reviewed By: ltamasi Differential Revision: D47819907 Pulled By: akankshamahajan15 fbshipit-source-id: 1faf5ef795bf27e2b3a60960374d91274931df8d --- HISTORY.md | 8 ++++++-- util/async_file_reader.cc | 5 +++++ 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/HISTORY.md b/HISTORY.md index 262e3dd9c..67e1bea3d 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -1,6 +1,10 @@ # Rocksdb Change Log > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt` +## Unreleased +### Bug Fixes +* Fix use_after_free bug in async_io MultiReads when underlying FS enabled kFSBuffer. kFSBuffer is when underlying FS pass their own buffer instead of using RocksDB scratch in FSReadRequest. Right now it's an experimental feature. + ## 8.5.0 (07/21/2023) ### Public API Changes * Removed recently added APIs `GeneralCache` and `MakeSharedGeneralCache()` as our plan changed to stop exposing a general-purpose cache interface. The old forms of these APIs, `Cache` and `NewLRUCache()`, are still available, although general-purpose caching support will be dropped eventually. @@ -18,7 +22,7 @@ * Add FSReadRequest::fs_scratch which is a data buffer allocated and provided by underlying FileSystem to RocksDB during reads, when FS wants to provide its own buffer with data instead of using RocksDB provided FSReadRequest::scratch. This can help in cpu optimization by avoiding copy from file system's buffer to RocksDB buffer. More details on how to use/enable it in file_system.h. Right now its supported only for MultiReads(async + sync) with non direct io. * Start logging non-zero user-defined timestamp sizes in WAL to signal user key format in subsequent records and use it during recovery. This change will break recovery from WAL files written by early versions that contain user-defined timestamps. The workaround is to ensure there are no WAL files to recover (i.e. by flushing before close) before upgrade. * Added new property "rocksdb.obsolete-sst-files-size-property" that reports the size of SST files that have become obsolete but have not yet been deleted or scheduled for deletion -* Start to record the value of the flag `AdvancedColumnFamilyOptions.persist_user_defined_timestamps` in the Manifest and table properties for a SST file when it is created. And use the recorded flag when creating a table reader for the SST file. This flag is only explicitly record if it's false. +* Start to record the value of the flag `AdvancedColumnFamilyOptions.persist_user_defined_timestamps` in the Manifest and table properties for a SST file when it is created. And use the recorded flag when creating a table reader for the SST file. This flag is only explicitly record if it's false. * Add a new option OptimisticTransactionDBOptions::shared_lock_buckets that enables sharing mutexes for validating transactions between DB instances, for better balancing memory efficiency and validation contention across DB instances. Different column families and DBs also now use different hash seeds in this validation, so that the same set of key names will not contend across DBs or column families. * Add a new ticker `rocksdb.files.marked.trash.deleted` to track the number of trash files deleted by background thread from the trash queue. * Add an API NewTieredVolatileCache() in include/rocksdb/cache.h to allocate an instance of a block cache with a primary block cache tier and a compressed secondary cache tier. A cache of this type distributes memory reservations against the block cache, such as WriteBufferManager, table reader memory etc., proportionally across both the primary and compressed secondary cache. @@ -42,7 +46,7 @@ For Leveled Compaction users, `CompactRange()` with `bottommost_level_compaction ### Bug Fixes * Reduced cases of illegally using Env::Default() during static destruction by never destroying the internal PosixEnv itself (except for builds checking for memory leaks). (#11538) * Fix extra prefetching during seek in async_io when BlockBasedTableOptions.num_file_reads_for_auto_readahead is 1 leading to extra reads than required. -* Fix a bug where compactions that are qualified to be run as 2 subcompactions were only run as one subcompaction. +* Fix a bug where compactions that are qualified to be run as 2 subcompactions were only run as one subcompaction. * Fix a use-after-move bug in block.cc. ## 8.3.0 (05/19/2023) diff --git a/util/async_file_reader.cc b/util/async_file_reader.cc index 080c1ae96..9ce13b99f 100644 --- a/util/async_file_reader.cc +++ b/util/async_file_reader.cc @@ -26,6 +26,11 @@ bool AsyncFileReader::MultiReadAsyncImpl(ReadAwaiter* awaiter) { FSReadRequest* read_req = static_cast(cb_arg); read_req->status = req.status; read_req->result = req.result; + if (req.fs_scratch != nullptr) { + // TODO akanksha: Revisit to remove the const in the callback. + FSReadRequest& req_tmp = const_cast(req); + read_req->fs_scratch = std::move(req_tmp.fs_scratch); + } }, &awaiter->read_reqs_[i], &awaiter->io_handle_[i], &awaiter->del_fn_[i], /*aligned_buf=*/nullptr); From 393d2ddf386c49c6b84284a4bb6067b7c0427943 Mon Sep 17 00:00:00 2001 From: Andrew Kryczka Date: Thu, 27 Jul 2023 22:16:19 -0700 Subject: [PATCH 03/61] include last bug fix into 8.5.0 --- HISTORY.md | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/HISTORY.md b/HISTORY.md index 67e1bea3d..71b91d926 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -1,10 +1,6 @@ # Rocksdb Change Log > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt` -## Unreleased -### Bug Fixes -* Fix use_after_free bug in async_io MultiReads when underlying FS enabled kFSBuffer. kFSBuffer is when underlying FS pass their own buffer instead of using RocksDB scratch in FSReadRequest. Right now it's an experimental feature. - ## 8.5.0 (07/21/2023) ### Public API Changes * Removed recently added APIs `GeneralCache` and `MakeSharedGeneralCache()` as our plan changed to stop exposing a general-purpose cache interface. The old forms of these APIs, `Cache` and `NewLRUCache()`, are still available, although general-purpose caching support will be dropped eventually. @@ -17,6 +13,9 @@ * In case of direct_io, if buffer passed by callee is already aligned, RandomAccessFileRead::Read will avoid realloacting a new buffer, reducing memcpy and use already passed aligned buffer. * Small efficiency improvement to HyperClockCache by reducing chance of compiler-generated heap allocations +### Bug Fixes +* Fix use_after_free bug in async_io MultiReads when underlying FS enabled kFSBuffer. kFSBuffer is when underlying FS pass their own buffer instead of using RocksDB scratch in FSReadRequest. Right now it's an experimental feature. + ## 8.4.0 (06/26/2023) ### New Features * Add FSReadRequest::fs_scratch which is a data buffer allocated and provided by underlying FileSystem to RocksDB during reads, when FS wants to provide its own buffer with data instead of using RocksDB provided FSReadRequest::scratch. This can help in cpu optimization by avoiding copy from file system's buffer to RocksDB buffer. More details on how to use/enable it in file_system.h. Right now its supported only for MultiReads(async + sync) with non direct io. From 6fd663a22f199656e3cec051c44d60672e87650e Mon Sep 17 00:00:00 2001 From: Changyu Bi Date: Fri, 4 Aug 2023 14:29:50 -0700 Subject: [PATCH 04/61] Avoid shifting component too large error in FileTtlBooster (#11673) Summary: When `num_levels` > 65, we may be shifting more than 63 bits in FileTtlBooster. This can give errors like: `runtime error: shift exponent 98 is too large for 64-bit type 'uint64_t' (aka 'unsigned long')`. This PR makes a quick fix for this issue by taking a min in the shifting component. This issue should be rare since it requires a user using a large `num_levels`. I'll follow up with a more complex fix if needed. Pull Request resolved: https://github.com/facebook/rocksdb/pull/11673 Test Plan: * Add a unit test that produce the above error before this PR. Need to compile it with ubsan: `COMPILE_WITH_UBSAN=1 OPT="-fsanitize-blacklist=.circleci/ubsan_suppression_list.txt" ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 compaction_picker_test` Reviewed By: hx235 Differential Revision: D48074386 Pulled By: cbi42 fbshipit-source-id: 25e59df7e93f20e0793cffb941de70ac815d9392 --- db/compaction/compaction_picker_test.cc | 9 +++++++++ db/compaction/file_pri.h | 4 +++- .../shifting_componeng_too_large_file_ttl_booster.md | 1 + 3 files changed, 13 insertions(+), 1 deletion(-) create mode 100644 unreleased_history/bug_fixes/shifting_componeng_too_large_file_ttl_booster.md diff --git a/db/compaction/compaction_picker_test.cc b/db/compaction/compaction_picker_test.cc index fd14322b2..6aec03840 100644 --- a/db/compaction/compaction_picker_test.cc +++ b/db/compaction/compaction_picker_test.cc @@ -1968,6 +1968,15 @@ TEST_F(CompactionPickerTest, OverlappingUserKeys11) { ASSERT_EQ(7U, compaction->input(1, 0)->fd.GetNumber()); } +TEST_F(CompactionPickerTest, FileTtlBoosterLargeNumLevels) { + const uint64_t kCurrentTime = 1000000; + FileTtlBooster booster(kCurrentTime, /*ttl=*/2048, + /*num_non_empty_levels=*/100, /*level=*/1); + FileMetaData meta; + meta.oldest_ancester_time = kCurrentTime - 1023; + ASSERT_EQ(1, booster.GetBoostScore(&meta)); +} + TEST_F(CompactionPickerTest, FileTtlBooster) { // Set TTL to 2048 // TTL boosting for all levels starts at 1024, diff --git a/db/compaction/file_pri.h b/db/compaction/file_pri.h index 82dddcf93..e60d73e88 100644 --- a/db/compaction/file_pri.h +++ b/db/compaction/file_pri.h @@ -53,8 +53,10 @@ class FileTtlBooster { enabled_ = true; uint64_t all_boost_start_age = ttl / 2; uint64_t all_boost_age_range = (ttl / 32) * 31 - all_boost_start_age; + // TODO(cbi): more reasonable algorithm that gives different values + // when num_non_empty_levels - level - 1 > 63. uint64_t boost_age_range = - all_boost_age_range >> (num_non_empty_levels - level - 1); + all_boost_age_range >> std::min(63, num_non_empty_levels - level - 1); boost_age_start_ = all_boost_start_age + boost_age_range; const uint64_t kBoostRatio = 16; // prevent 0 value to avoid divide 0 error. diff --git a/unreleased_history/bug_fixes/shifting_componeng_too_large_file_ttl_booster.md b/unreleased_history/bug_fixes/shifting_componeng_too_large_file_ttl_booster.md new file mode 100644 index 000000000..f76830232 --- /dev/null +++ b/unreleased_history/bug_fixes/shifting_componeng_too_large_file_ttl_booster.md @@ -0,0 +1 @@ +Fix a bug in FileTTLBooster that can cause users with a large number of levels (more than 65) to see errors like "runtime error: shift exponent .. is too large.." (#11673). \ No newline at end of file From 89a3958bccdc9af519af8eda9270f4b51d1257b6 Mon Sep 17 00:00:00 2001 From: Andrew Kryczka Date: Sun, 6 Aug 2023 17:47:41 -0700 Subject: [PATCH 05/61] include last bug fix into 8.5.0 --- HISTORY.md | 1 + .../bug_fixes/shifting_componeng_too_large_file_ttl_booster.md | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) delete mode 100644 unreleased_history/bug_fixes/shifting_componeng_too_large_file_ttl_booster.md diff --git a/HISTORY.md b/HISTORY.md index 71b91d926..2a348a218 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -15,6 +15,7 @@ ### Bug Fixes * Fix use_after_free bug in async_io MultiReads when underlying FS enabled kFSBuffer. kFSBuffer is when underlying FS pass their own buffer instead of using RocksDB scratch in FSReadRequest. Right now it's an experimental feature. +* Fix a bug in FileTTLBooster that can cause users with a large number of levels (more than 65) to see errors like "runtime error: shift exponent .. is too large.." (#11673). ## 8.4.0 (06/26/2023) ### New Features diff --git a/unreleased_history/bug_fixes/shifting_componeng_too_large_file_ttl_booster.md b/unreleased_history/bug_fixes/shifting_componeng_too_large_file_ttl_booster.md deleted file mode 100644 index f76830232..000000000 --- a/unreleased_history/bug_fixes/shifting_componeng_too_large_file_ttl_booster.md +++ /dev/null @@ -1 +0,0 @@ -Fix a bug in FileTTLBooster that can cause users with a large number of levels (more than 65) to see errors like "runtime error: shift exponent .. is too large.." (#11673). \ No newline at end of file From 3885d765240c7740c2d4e9140df6ac142d2d8e91 Mon Sep 17 00:00:00 2001 From: Changyu Bi <102700264+cbi42@users.noreply.github.com> Date: Thu, 31 Aug 2023 14:50:26 -0700 Subject: [PATCH 06/61] 8.5.1 bug fix (#11783) * Check iterator status. * change log and version --- HISTORY.md | 4 ++++ include/rocksdb/version.h | 2 +- table/compaction_merging_iterator.cc | 1 + table/merging_iterator.cc | 8 ++++++++ 4 files changed, 14 insertions(+), 1 deletion(-) diff --git a/HISTORY.md b/HISTORY.md index 2a348a218..76e82989c 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -1,6 +1,10 @@ # Rocksdb Change Log > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt` +## 8.5.1 (08/31/2023) +### Bug fixes +* Fix a bug where if there is an error reading from offset 0 of a file from L1+ and that the file is not the first file in the sorted run, data can be lost in compaction and read/scan can return incorrect results. + ## 8.5.0 (07/21/2023) ### Public API Changes * Removed recently added APIs `GeneralCache` and `MakeSharedGeneralCache()` as our plan changed to stop exposing a general-purpose cache interface. The old forms of these APIs, `Cache` and `NewLRUCache()`, are still available, although general-purpose caching support will be dropped eventually. diff --git a/include/rocksdb/version.h b/include/rocksdb/version.h index 1b934a79f..bda9b75cc 100644 --- a/include/rocksdb/version.h +++ b/include/rocksdb/version.h @@ -13,7 +13,7 @@ // minor or major version number planned for release. #define ROCKSDB_MAJOR 8 #define ROCKSDB_MINOR 5 -#define ROCKSDB_PATCH 0 +#define ROCKSDB_PATCH 1 // Do not use these. We made the mistake of declaring macros starting with // double underscore. Now we have to live with our choice. We'll deprecate these diff --git a/table/compaction_merging_iterator.cc b/table/compaction_merging_iterator.cc index 8a5c45240..98581b16d 100644 --- a/table/compaction_merging_iterator.cc +++ b/table/compaction_merging_iterator.cc @@ -329,6 +329,7 @@ void CompactionMergingIterator::FindNextVisibleKey() { assert(current->iter.status().ok()); minHeap_.replace_top(current); } else { + considerStatus(current->iter.status()); minHeap_.pop(); } if (range_tombstone_iters_[current->level]) { diff --git a/table/merging_iterator.cc b/table/merging_iterator.cc index 0fa3fcd3e..ae92aa198 100644 --- a/table/merging_iterator.cc +++ b/table/merging_iterator.cc @@ -931,6 +931,7 @@ bool MergingIterator::SkipNextDeleted() { InsertRangeTombstoneToMinHeap(current->level, true /* start_key */, true /* replace_top */); } else { + // TruncatedRangeDelIterator does not have status minHeap_.pop(); } return true /* current key deleted */; @@ -988,6 +989,9 @@ bool MergingIterator::SkipNextDeleted() { if (current->iter.Valid()) { assert(current->iter.status().ok()); minHeap_.push(current); + } else { + // TODO(cbi): check status and early return if non-ok. + considerStatus(current->iter.status()); } // Invariants (rti) and (phi) if (range_tombstone_iters_[current->level] && @@ -1027,6 +1031,7 @@ bool MergingIterator::SkipNextDeleted() { if (current->iter.Valid()) { minHeap_.replace_top(current); } else { + considerStatus(current->iter.status()); minHeap_.pop(); } return true /* current key deleted */; @@ -1199,6 +1204,8 @@ bool MergingIterator::SkipPrevDeleted() { if (current->iter.Valid()) { assert(current->iter.status().ok()); maxHeap_->push(current); + } else { + considerStatus(current->iter.status()); } if (range_tombstone_iters_[current->level] && @@ -1241,6 +1248,7 @@ bool MergingIterator::SkipPrevDeleted() { if (current->iter.Valid()) { maxHeap_->replace_top(current); } else { + considerStatus(current->iter.status()); maxHeap_->pop(); } return true /* current key deleted */; From 5e063b9588025e18d4d2c767d9204b0212f16506 Mon Sep 17 00:00:00 2001 From: Changyu Bi <102700264+cbi42@users.noreply.github.com> Date: Fri, 1 Sep 2023 11:12:39 -0700 Subject: [PATCH 07/61] 8.5.2 Fix a bug where iterator can return incorrect data for DeleteRange() users (#11785) This should only affect iterator when - user uses DeleteRange(), - An iterator from level L has a non-ok status (such non-ok status may not be caught before the bug fix in https://github.com/facebook/rocksdb/pull/11783), and - A range tombstone covers a key from level > L and triggers a reseek sets the status_ to OK in SeekImpl()/SeekPrevImpl() e.g. https://github.com/facebook/rocksdb/blob/bd6a8340c3a2db764620e90b3ac5be173fc68a0c/table/merging_iterator.cc#L801 --- HISTORY.md | 4 ++++ include/rocksdb/version.h | 2 +- table/merging_iterator.cc | 4 ++-- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/HISTORY.md b/HISTORY.md index 76e82989c..68c4a8314 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -1,6 +1,10 @@ # Rocksdb Change Log > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt` +## 8.5.2 (08/31/2023) +### Bug fixes +* Fix a bug where iterator may return incorrect result for DeleteRange() users if there was an error reading from a file. + ## 8.5.1 (08/31/2023) ### Bug fixes * Fix a bug where if there is an error reading from offset 0 of a file from L1+ and that the file is not the first file in the sorted run, data can be lost in compaction and read/scan can return incorrect results. diff --git a/include/rocksdb/version.h b/include/rocksdb/version.h index bda9b75cc..601ef0e6b 100644 --- a/include/rocksdb/version.h +++ b/include/rocksdb/version.h @@ -13,7 +13,7 @@ // minor or major version number planned for release. #define ROCKSDB_MAJOR 8 #define ROCKSDB_MINOR 5 -#define ROCKSDB_PATCH 1 +#define ROCKSDB_PATCH 2 // Do not use these. We made the mistake of declaring macros starting with // double underscore. Now we have to live with our choice. We'll deprecate these diff --git a/table/merging_iterator.cc b/table/merging_iterator.cc index ae92aa198..505cd76d3 100644 --- a/table/merging_iterator.cc +++ b/table/merging_iterator.cc @@ -308,6 +308,7 @@ class MergingIterator : public InternalIterator { // holds after this call, and minHeap_.top().iter points to the // first key >= target among children_ that is not covered by any range // tombstone. + status_ = Status::OK(); SeekImpl(target); FindNextVisibleKey(); @@ -321,6 +322,7 @@ class MergingIterator : public InternalIterator { void SeekForPrev(const Slice& target) override { assert(range_tombstone_iters_.empty() || range_tombstone_iters_.size() == children_.size()); + status_ = Status::OK(); SeekForPrevImpl(target); FindPrevVisibleKey(); @@ -798,7 +800,6 @@ void MergingIterator::SeekImpl(const Slice& target, size_t starting_level, active_.erase(active_.lower_bound(starting_level), active_.end()); } - status_ = Status::OK(); IterKey current_search_key; current_search_key.SetInternalKey(target, false /* copy */); // Seek target might change to some range tombstone end key, so @@ -1083,7 +1084,6 @@ void MergingIterator::SeekForPrevImpl(const Slice& target, active_.erase(active_.lower_bound(starting_level), active_.end()); } - status_ = Status::OK(); IterKey current_search_key; current_search_key.SetInternalKey(target, false /* copy */); // Seek target might change to some range tombstone end key, so From fad0f3d34e823f10190367ee53a76b0c1cca75ef Mon Sep 17 00:00:00 2001 From: Andrew Kryczka Date: Mon, 28 Aug 2023 13:36:25 -0700 Subject: [PATCH 08/61] Fix `GenericRateLimiter` hanging bug (#11763) Summary: Fixes https://github.com/facebook/rocksdb/issues/11742 Even after performing duty (1) ("Waiting for the next refill time"), it is possible the remaining threads are all in `Wait()`. Waking up at least one thread is enough to ensure progress continues, even if no new requests arrive. The repro unit test (https://github.com/facebook/rocksdb/commit/bb54245e6) is not included as it depends on an unlanded PR (https://github.com/facebook/rocksdb/issues/11753) Pull Request resolved: https://github.com/facebook/rocksdb/pull/11763 Reviewed By: jaykorean Differential Revision: D48710130 Pulled By: ajkr fbshipit-source-id: 9d166bd577ea3a96ccd81dde85871fec5e85a4eb --- .../fixed_generic_rate_limiter_hang.md | 1 + util/rate_limiter.cc | 20 +++++++++---------- 2 files changed, 11 insertions(+), 10 deletions(-) create mode 100644 unreleased_history/bug_fixes/fixed_generic_rate_limiter_hang.md diff --git a/unreleased_history/bug_fixes/fixed_generic_rate_limiter_hang.md b/unreleased_history/bug_fixes/fixed_generic_rate_limiter_hang.md new file mode 100644 index 000000000..8f789e186 --- /dev/null +++ b/unreleased_history/bug_fixes/fixed_generic_rate_limiter_hang.md @@ -0,0 +1 @@ +Fixed a race condition in `GenericRateLimiter` that could cause it to stop granting requests diff --git a/util/rate_limiter.cc b/util/rate_limiter.cc index be54138d9..ddb9bdbf0 100644 --- a/util/rate_limiter.cc +++ b/util/rate_limiter.cc @@ -179,16 +179,16 @@ void GenericRateLimiter::Request(int64_t bytes, const Env::IOPriority pri, // Whichever thread reaches here first performs duty (2) as described // above. RefillBytesAndGrantRequestsLocked(); - if (r.request_bytes == 0) { - // If there is any remaining requests, make sure there exists at least - // one candidate is awake for future duties by signaling a front request - // of a queue. - for (int i = Env::IO_TOTAL - 1; i >= Env::IO_LOW; --i) { - std::deque queue = queue_[i]; - if (!queue.empty()) { - queue.front()->cv.Signal(); - break; - } + } + if (r.request_bytes == 0) { + // If there is any remaining requests, make sure there exists at least + // one candidate is awake for future duties by signaling a front request + // of a queue. + for (int i = Env::IO_TOTAL - 1; i >= Env::IO_LOW; --i) { + auto& queue = queue_[i]; + if (!queue.empty()) { + queue.front()->cv.Signal(); + break; } } } From f32521662acf3352397d438b732144c7813bbbec Mon Sep 17 00:00:00 2001 From: Andrew Kryczka Date: Fri, 1 Sep 2023 13:58:39 -0700 Subject: [PATCH 09/61] update HISTORY.md and version.h for 8.5.3 --- HISTORY.md | 4 ++++ include/rocksdb/version.h | 2 +- .../bug_fixes/fixed_generic_rate_limiter_hang.md | 1 - 3 files changed, 5 insertions(+), 2 deletions(-) delete mode 100644 unreleased_history/bug_fixes/fixed_generic_rate_limiter_hang.md diff --git a/HISTORY.md b/HISTORY.md index 68c4a8314..36a925ff5 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -1,6 +1,10 @@ # Rocksdb Change Log > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt` +## 8.5.3 (09/01/2023) +### Bug Fixes +* Fixed a race condition in `GenericRateLimiter` that could cause it to stop granting requests + ## 8.5.2 (08/31/2023) ### Bug fixes * Fix a bug where iterator may return incorrect result for DeleteRange() users if there was an error reading from a file. diff --git a/include/rocksdb/version.h b/include/rocksdb/version.h index 601ef0e6b..a19f41fd2 100644 --- a/include/rocksdb/version.h +++ b/include/rocksdb/version.h @@ -13,7 +13,7 @@ // minor or major version number planned for release. #define ROCKSDB_MAJOR 8 #define ROCKSDB_MINOR 5 -#define ROCKSDB_PATCH 2 +#define ROCKSDB_PATCH 3 // Do not use these. We made the mistake of declaring macros starting with // double underscore. Now we have to live with our choice. We'll deprecate these diff --git a/unreleased_history/bug_fixes/fixed_generic_rate_limiter_hang.md b/unreleased_history/bug_fixes/fixed_generic_rate_limiter_hang.md deleted file mode 100644 index 8f789e186..000000000 --- a/unreleased_history/bug_fixes/fixed_generic_rate_limiter_hang.md +++ /dev/null @@ -1 +0,0 @@ -Fixed a race condition in `GenericRateLimiter` that could cause it to stop granting requests From c486bb9e42cca1c867a108586c31697ef37b1d30 Mon Sep 17 00:00:00 2001 From: azagrebin Date: Wed, 6 Feb 2019 15:38:57 +0100 Subject: [PATCH 10/61] [FLINK-10471] Add Apache Flink specific compaction filter to evict expired state which has time-to-live --- CMakeLists.txt | 2 + Makefile | 3 + TARGETS | 5 + Vagrantfile | 2 +- java/CMakeLists.txt | 3 + java/Makefile | 1 + java/crossbuild/Vagrantfile | 2 +- java/rocksjni/flink_compactionfilterjni.cc | 239 ++++++++++++ .../org/rocksdb/FlinkCompactionFilter.java | 177 +++++++++ .../src/test/java/org/rocksdb/FilterTest.java | 2 +- .../rocksdb/FlinkCompactionFilterTest.java | 356 ++++++++++++++++++ src.mk | 3 + utilities/flink/flink_compaction_filter.cc | 206 ++++++++++ utilities/flink/flink_compaction_filter.h | 191 ++++++++++ .../flink/flink_compaction_filter_test.cc | 226 +++++++++++ 15 files changed, 1415 insertions(+), 3 deletions(-) create mode 100644 java/rocksjni/flink_compactionfilterjni.cc create mode 100644 java/src/main/java/org/rocksdb/FlinkCompactionFilter.java create mode 100644 java/src/test/java/org/rocksdb/FlinkCompactionFilterTest.java create mode 100644 utilities/flink/flink_compaction_filter.cc create mode 100644 utilities/flink/flink_compaction_filter.h create mode 100644 utilities/flink/flink_compaction_filter_test.cc diff --git a/CMakeLists.txt b/CMakeLists.txt index 4e30f6631..b07c3db94 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -891,6 +891,7 @@ set(SOURCES utilities/fault_injection_env.cc utilities/fault_injection_fs.cc utilities/fault_injection_secondary_cache.cc + utilities/flink/flink_compaction_filter.cc utilities/leveldb_options/leveldb_options.cc utilities/memory/memory_util.cc utilities/merge_operators.cc @@ -1434,6 +1435,7 @@ if(WITH_TESTS) utilities/cassandra/cassandra_serialize_test.cc utilities/checkpoint/checkpoint_test.cc utilities/env_timed_test.cc + utilities/flink/flink_compaction_filter_test.cc utilities/memory/memory_test.cc utilities/merge_operators/string_append/stringappend_test.cc utilities/object_registry_test.cc diff --git a/Makefile b/Makefile index a1ea379d7..0c111485c 100644 --- a/Makefile +++ b/Makefile @@ -1414,6 +1414,9 @@ histogram_test: $(OBJ_DIR)/monitoring/histogram_test.o $(TEST_LIBRARY) $(LIBRARY thread_local_test: $(OBJ_DIR)/util/thread_local_test.o $(TEST_LIBRARY) $(LIBRARY) $(AM_LINK) +flink_compaction_filter_test: $(OBJ_DIR)/utilities/flink/flink_compaction_filter_test.o $(TEST_LIBRARY) $(LIBRARY) + $(AM_LINK) + work_queue_test: $(OBJ_DIR)/util/work_queue_test.o $(TEST_LIBRARY) $(LIBRARY) $(AM_LINK) diff --git a/TARGETS b/TARGETS index 5125fcf54..d334291f3 100644 --- a/TARGETS +++ b/TARGETS @@ -291,6 +291,7 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[ "utilities/fault_injection_env.cc", "utilities/fault_injection_fs.cc", "utilities/fault_injection_secondary_cache.cc", + "utilities/flink/flink_compaction_filter.cc", "utilities/leveldb_options/leveldb_options.cc", "utilities/memory/memory_util.cc", "utilities/merge_operators.cc", @@ -5077,6 +5078,10 @@ cpp_unittest_wrapper(name="filename_test", deps=[":rocksdb_test_lib"], extra_compiler_flags=[]) +cpp_unittest_wrapper(name="flink_compaction_filter_test", + srcs=["utilities/flink/flink_compaction_filter_test.cc"], + deps=[":rocksdb_test_lib"], + extra_compiler_flags=[]) cpp_unittest_wrapper(name="flush_job_test", srcs=["db/flush_job_test.cc"], diff --git a/Vagrantfile b/Vagrantfile index 07f2e99fd..3dcedaf76 100644 --- a/Vagrantfile +++ b/Vagrantfile @@ -2,7 +2,7 @@ Vagrant.configure("2") do |config| config.vm.provider "virtualbox" do |v| - v.memory = 4096 + v.memory = 6096 v.cpus = 2 end diff --git a/java/CMakeLists.txt b/java/CMakeLists.txt index ff1f05a32..8ddb3da40 100644 --- a/java/CMakeLists.txt +++ b/java/CMakeLists.txt @@ -33,6 +33,7 @@ set(JNI_NATIVE_SOURCES rocksjni/env_options.cc rocksjni/event_listener.cc rocksjni/event_listener_jnicallback.cc + rocksjni/flink_compactionfilterjni.cc rocksjni/filter.cc rocksjni/ingest_external_file_options.cc rocksjni/iterator.cc @@ -152,6 +153,7 @@ set(JAVA_MAIN_CLASSES src/main/java/org/rocksdb/ExternalFileIngestionInfo.java src/main/java/org/rocksdb/Filter.java src/main/java/org/rocksdb/FileOperationInfo.java + src/main/java/org/rocksdb/FlinkCompactionFilter.java src/main/java/org/rocksdb/FlushJobInfo.java src/main/java/org/rocksdb/FlushReason.java src/main/java/org/rocksdb/FlushOptions.java @@ -452,6 +454,7 @@ if(${CMAKE_VERSION} VERSION_LESS "3.11.4") org.rocksdb.Env org.rocksdb.EnvOptions org.rocksdb.Filter + org.rocksdb.FlinkCompactionFilter org.rocksdb.FlushOptions org.rocksdb.HashLinkedListMemTableConfig org.rocksdb.HashSkipListMemTableConfig diff --git a/java/Makefile b/java/Makefile index 7d2695af8..69359733f 100644 --- a/java/Makefile +++ b/java/Makefile @@ -32,6 +32,7 @@ NATIVE_JAVA_CLASSES = \ org.rocksdb.DirectSlice\ org.rocksdb.Env\ org.rocksdb.EnvOptions\ + org.rocksdb.FlinkCompactionFilter\ org.rocksdb.FlushOptions\ org.rocksdb.Filter\ org.rocksdb.IngestExternalFileOptions\ diff --git a/java/crossbuild/Vagrantfile b/java/crossbuild/Vagrantfile index 0ee50de2c..a3035e683 100644 --- a/java/crossbuild/Vagrantfile +++ b/java/crossbuild/Vagrantfile @@ -33,7 +33,7 @@ Vagrant.configure(VAGRANTFILE_API_VERSION) do |config| end config.vm.provider "virtualbox" do |v| - v.memory = 2048 + v.memory = 6048 v.cpus = 4 v.customize ["modifyvm", :id, "--nictype1", "virtio" ] end diff --git a/java/rocksjni/flink_compactionfilterjni.cc b/java/rocksjni/flink_compactionfilterjni.cc new file mode 100644 index 000000000..9f0954b43 --- /dev/null +++ b/java/rocksjni/flink_compactionfilterjni.cc @@ -0,0 +1,239 @@ +#include // 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). + +#include +#include + +#include "include/org_rocksdb_FlinkCompactionFilter.h" +#include "loggerjnicallback.h" +#include "portal.h" +#include "rocksjni/jnicallback.h" +#include "utilities/flink/flink_compaction_filter.h" + +using namespace ROCKSDB_NAMESPACE::flink; + +class JniCallbackBase : public ROCKSDB_NAMESPACE::JniCallback { + public: + JniCallbackBase(JNIEnv* env, jobject jcallback_obj) + : JniCallback(env, jcallback_obj) {} + + protected: + inline void CheckAndRethrowException(JNIEnv* env) const { + if (env->ExceptionCheck()) { + env->ExceptionDescribe(); + env->Throw(env->ExceptionOccurred()); + } + } +}; + +// This list element filter operates on list state for which byte length of +// elements is unknown (variable), the list element serializer has to be used in +// this case to compute the offset of the next element. The filter wraps java +// object implenented in Flink. The java object holds element serializer and +// performs filtering. +class JavaListElementFilter + : public ROCKSDB_NAMESPACE::flink::FlinkCompactionFilter::ListElementFilter, + JniCallbackBase { + public: + JavaListElementFilter(JNIEnv* env, jobject jlist_filter) + : JniCallbackBase(env, jlist_filter) { + jclass jclazz = ROCKSDB_NAMESPACE::JavaClass::getJClass( + env, "org/rocksdb/FlinkCompactionFilter$ListElementFilter"); + if (jclazz == nullptr) { + // exception occurred accessing class + return; + } + m_jnext_unexpired_offset_methodid = + env->GetMethodID(jclazz, "nextUnexpiredOffset", "([BJJ)I"); + assert(m_jnext_unexpired_offset_methodid != nullptr); + } + + std::size_t NextUnexpiredOffset(const ROCKSDB_NAMESPACE::Slice& list, + int64_t ttl, + int64_t current_timestamp) const override { + jboolean attached_thread = JNI_FALSE; + JNIEnv* env = getJniEnv(&attached_thread); + jbyteArray jlist = ROCKSDB_NAMESPACE::JniUtil::copyBytes(env, list); + CheckAndRethrowException(env); + if (jlist == nullptr) { + return static_cast(-1); + } + auto jl_ttl = static_cast(ttl); + auto jl_current_timestamp = static_cast(current_timestamp); + jint next_offset = + env->CallIntMethod(m_jcallback_obj, m_jnext_unexpired_offset_methodid, + jlist, jl_ttl, jl_current_timestamp); + CheckAndRethrowException(env); + env->DeleteLocalRef(jlist); + releaseJniEnv(attached_thread); + return static_cast(next_offset); + }; + + private: + jmethodID m_jnext_unexpired_offset_methodid; +}; + +class JavaListElemenFilterFactory + : public ROCKSDB_NAMESPACE::flink::FlinkCompactionFilter:: + ListElementFilterFactory, + JniCallbackBase { + public: + JavaListElemenFilterFactory(JNIEnv* env, jobject jlist_filter_factory) + : JniCallbackBase(env, jlist_filter_factory) { + jclass jclazz = ROCKSDB_NAMESPACE::JavaClass::getJClass( + env, "org/rocksdb/FlinkCompactionFilter$ListElementFilterFactory"); + if (jclazz == nullptr) { + // exception occurred accessing class + return; + } + m_jcreate_filter_methodid = env->GetMethodID( + jclazz, "createListElementFilter", + "()Lorg/rocksdb/FlinkCompactionFilter$ListElementFilter;"); + assert(m_jcreate_filter_methodid != nullptr); + } + + FlinkCompactionFilter::ListElementFilter* CreateListElementFilter( + std::shared_ptr /*logger*/) const override { + jboolean attached_thread = JNI_FALSE; + JNIEnv* env = getJniEnv(&attached_thread); + auto jlist_filter = + env->CallObjectMethod(m_jcallback_obj, m_jcreate_filter_methodid); + auto list_filter = new JavaListElementFilter(env, jlist_filter); + CheckAndRethrowException(env); + releaseJniEnv(attached_thread); + return list_filter; + }; + + private: + jmethodID m_jcreate_filter_methodid; +}; + +class JavaTimeProvider + : public ROCKSDB_NAMESPACE::flink::FlinkCompactionFilter::TimeProvider, + JniCallbackBase { + public: + JavaTimeProvider(JNIEnv* env, jobject jtime_provider) + : JniCallbackBase(env, jtime_provider) { + jclass jclazz = ROCKSDB_NAMESPACE::JavaClass::getJClass( + env, "org/rocksdb/FlinkCompactionFilter$TimeProvider"); + if (jclazz == nullptr) { + // exception occurred accessing class + return; + } + m_jcurrent_timestamp_methodid = + env->GetMethodID(jclazz, "currentTimestamp", "()J"); + assert(m_jcurrent_timestamp_methodid != nullptr); + } + + int64_t CurrentTimestamp() const override { + jboolean attached_thread = JNI_FALSE; + JNIEnv* env = getJniEnv(&attached_thread); + auto jtimestamp = + env->CallLongMethod(m_jcallback_obj, m_jcurrent_timestamp_methodid); + CheckAndRethrowException(env); + releaseJniEnv(attached_thread); + return static_cast(jtimestamp); + }; + + private: + jmethodID m_jcurrent_timestamp_methodid; +}; + +static FlinkCompactionFilter::ListElementFilterFactory* +createListElementFilterFactory(JNIEnv* env, jint ji_list_elem_len, + jobject jlist_filter_factory) { + FlinkCompactionFilter::ListElementFilterFactory* list_filter_factory = + nullptr; + if (ji_list_elem_len > 0) { + auto fixed_size = static_cast(ji_list_elem_len); + list_filter_factory = + new FlinkCompactionFilter::FixedListElementFilterFactory( + fixed_size, static_cast(0)); + } else if (jlist_filter_factory != nullptr) { + list_filter_factory = + new JavaListElemenFilterFactory(env, jlist_filter_factory); + } + return list_filter_factory; +} + +/*x + * Class: org_rocksdb_FlinkCompactionFilter + * Method: createNewFlinkCompactionFilterConfigHolder + * Signature: ()J + */ +jlong Java_org_rocksdb_FlinkCompactionFilter_createNewFlinkCompactionFilterConfigHolder( + JNIEnv* /* env */, jclass /* jcls */) { + using namespace ROCKSDB_NAMESPACE::flink; + return reinterpret_cast( + new std::shared_ptr( + new FlinkCompactionFilter::ConfigHolder())); +} + +/* + * Class: org_rocksdb_FlinkCompactionFilter + * Method: disposeFlinkCompactionFilterConfigHolder + * Signature: (J)V + */ +void Java_org_rocksdb_FlinkCompactionFilter_disposeFlinkCompactionFilterConfigHolder( + JNIEnv* /* env */, jclass /* jcls */, jlong handle) { + using namespace ROCKSDB_NAMESPACE::flink; + auto* config_holder = + reinterpret_cast*>( + handle); + delete config_holder; +} + +/* + * Class: org_rocksdb_FlinkCompactionFilter + * Method: createNewFlinkCompactionFilter0 + * Signature: (JJJ)J + */ +jlong Java_org_rocksdb_FlinkCompactionFilter_createNewFlinkCompactionFilter0( + JNIEnv* env, jclass /* jcls */, jlong config_holder_handle, + jobject jtime_provider, jlong logger_handle) { + using namespace ROCKSDB_NAMESPACE::flink; + auto config_holder = + *(reinterpret_cast*>( + config_holder_handle)); + auto time_provider = new JavaTimeProvider(env, jtime_provider); + auto logger = + logger_handle == 0 + ? nullptr + : *(reinterpret_cast< + std::shared_ptr*>( + logger_handle)); + return reinterpret_cast(new FlinkCompactionFilter( + config_holder, + std::unique_ptr(time_provider), + logger)); +} + +/* + * Class: org_rocksdb_FlinkCompactionFilter + * Method: configureFlinkCompactionFilter + * Signature: (JIIJJILorg/rocksdb/FlinkCompactionFilter$ListElementFilter;)Z + */ +jboolean Java_org_rocksdb_FlinkCompactionFilter_configureFlinkCompactionFilter( + JNIEnv* env, jclass /* jcls */, jlong handle, jint ji_state_type, + jint ji_timestamp_offset, jlong jl_ttl_milli, + jlong jquery_time_after_num_entries, jint ji_list_elem_len, + jobject jlist_filter_factory) { + auto state_type = + static_cast(ji_state_type); + auto timestamp_offset = static_cast(ji_timestamp_offset); + auto ttl = static_cast(jl_ttl_milli); + auto query_time_after_num_entries = + static_cast(jquery_time_after_num_entries); + auto config_holder = + *(reinterpret_cast*>( + handle)); + auto list_filter_factory = createListElementFilterFactory( + env, ji_list_elem_len, jlist_filter_factory); + auto config = new FlinkCompactionFilter::Config{ + state_type, timestamp_offset, ttl, query_time_after_num_entries, + std::unique_ptr( + list_filter_factory)}; + return static_cast(config_holder->Configure(config)); +} \ No newline at end of file diff --git a/java/src/main/java/org/rocksdb/FlinkCompactionFilter.java b/java/src/main/java/org/rocksdb/FlinkCompactionFilter.java new file mode 100644 index 000000000..ee575d5ba --- /dev/null +++ b/java/src/main/java/org/rocksdb/FlinkCompactionFilter.java @@ -0,0 +1,177 @@ +// Copyright (c) 2017-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). + +package org.rocksdb; + +/** + * Just a Java wrapper around FlinkCompactionFilter implemented in C++. + * + * Note: this compaction filter is a special implementation, designed for usage only in Apache Flink + * project. + */ +public class FlinkCompactionFilter extends AbstractCompactionFilter { + public enum StateType { + // WARNING!!! Do not change the order of enum entries as it is important for jni translation + Disabled, + Value, + List + } + + public FlinkCompactionFilter(ConfigHolder configHolder, TimeProvider timeProvider) { + this(configHolder, timeProvider, null); + } + + public FlinkCompactionFilter( + ConfigHolder configHolder, TimeProvider timeProvider, Logger logger) { + super(createNewFlinkCompactionFilter0( + configHolder.nativeHandle_, timeProvider, logger == null ? 0 : logger.nativeHandle_)); + } + + private native static long createNewFlinkCompactionFilter0( + long configHolderHandle, TimeProvider timeProvider, long loggerHandle); + private native static long createNewFlinkCompactionFilterConfigHolder(); + private native static void disposeFlinkCompactionFilterConfigHolder(long configHolderHandle); + private native static boolean configureFlinkCompactionFilter(long configHolderHandle, + int stateType, int timestampOffset, long ttl, long queryTimeAfterNumEntries, + int fixedElementLength, ListElementFilterFactory listElementFilterFactory); + + public interface ListElementFilter { + /** + * Gets offset of the first unexpired element in the list. + * + *

Native code wraps this java object and calls it for list state + * for which element byte length is unknown and Flink custom type serializer has to be used + * to compute offset of the next element in serialized form. + * + * @param list serialised list of elements with timestamp + * @param ttl time-to-live of the list elements + * @param currentTimestamp current timestamp to check expiration against + * @return offset of the first unexpired element in the list + */ + @SuppressWarnings("unused") + int nextUnexpiredOffset(byte[] list, long ttl, long currentTimestamp); + } + + public interface ListElementFilterFactory { + @SuppressWarnings("unused") ListElementFilter createListElementFilter(); + } + + public static class Config { + final StateType stateType; + final int timestampOffset; + final long ttl; + /** + * Number of state entries to process by compaction filter before updating current timestamp. + */ + final long queryTimeAfterNumEntries; + final int fixedElementLength; + final ListElementFilterFactory listElementFilterFactory; + + private Config(StateType stateType, int timestampOffset, long ttl, + long queryTimeAfterNumEntries, int fixedElementLength, + ListElementFilterFactory listElementFilterFactory) { + this.stateType = stateType; + this.timestampOffset = timestampOffset; + this.ttl = ttl; + this.queryTimeAfterNumEntries = queryTimeAfterNumEntries; + this.fixedElementLength = fixedElementLength; + this.listElementFilterFactory = listElementFilterFactory; + } + + @SuppressWarnings("WeakerAccess") + public static Config createNotList( + StateType stateType, int timestampOffset, long ttl, long queryTimeAfterNumEntries) { + return new Config(stateType, timestampOffset, ttl, queryTimeAfterNumEntries, -1, null); + } + + @SuppressWarnings("unused") + public static Config createForValue(long ttl, long queryTimeAfterNumEntries) { + return createNotList(StateType.Value, 0, ttl, queryTimeAfterNumEntries); + } + + @SuppressWarnings("unused") + public static Config createForMap(long ttl, long queryTimeAfterNumEntries) { + return createNotList(StateType.Value, 1, ttl, queryTimeAfterNumEntries); + } + + @SuppressWarnings("WeakerAccess") + public static Config createForFixedElementList( + long ttl, long queryTimeAfterNumEntries, int fixedElementLength) { + return new Config(StateType.List, 0, ttl, queryTimeAfterNumEntries, fixedElementLength, null); + } + + @SuppressWarnings("WeakerAccess") + public static Config createForList(long ttl, long queryTimeAfterNumEntries, + ListElementFilterFactory listElementFilterFactory) { + return new Config( + StateType.List, 0, ttl, queryTimeAfterNumEntries, -1, listElementFilterFactory); + } + } + + private static class ConfigHolder extends RocksObject { + ConfigHolder() { + super(createNewFlinkCompactionFilterConfigHolder()); + } + + @Override + protected void disposeInternal(long handle) { + disposeFlinkCompactionFilterConfigHolder(handle); + } + } + + /** Provides current timestamp to check expiration, it must be thread safe. */ + public interface TimeProvider { + long currentTimestamp(); + } + + public static class FlinkCompactionFilterFactory + extends AbstractCompactionFilterFactory { + private final ConfigHolder configHolder; + private final TimeProvider timeProvider; + private final Logger logger; + + @SuppressWarnings("unused") + public FlinkCompactionFilterFactory(TimeProvider timeProvider) { + this(timeProvider, null); + } + + @SuppressWarnings("WeakerAccess") + public FlinkCompactionFilterFactory(TimeProvider timeProvider, Logger logger) { + this.configHolder = new ConfigHolder(); + this.timeProvider = timeProvider; + this.logger = logger; + } + + @Override + public void close() { + super.close(); + configHolder.close(); + if (logger != null) { + logger.close(); + } + } + + @Override + public FlinkCompactionFilter createCompactionFilter(Context context) { + return new FlinkCompactionFilter(configHolder, timeProvider, logger); + } + + @Override + public String name() { + return "FlinkCompactionFilterFactory"; + } + + @SuppressWarnings("WeakerAccess") + public void configure(Config config) { + boolean already_configured = + !configureFlinkCompactionFilter(configHolder.nativeHandle_, config.stateType.ordinal(), + config.timestampOffset, config.ttl, config.queryTimeAfterNumEntries, + config.fixedElementLength, config.listElementFilterFactory); + if (already_configured) { + throw new IllegalStateException("Compaction filter is already configured"); + } + } + } +} diff --git a/java/src/test/java/org/rocksdb/FilterTest.java b/java/src/test/java/org/rocksdb/FilterTest.java index dc5c19fbc..e308ffefb 100644 --- a/java/src/test/java/org/rocksdb/FilterTest.java +++ b/java/src/test/java/org/rocksdb/FilterTest.java @@ -16,7 +16,7 @@ public class FilterTest { @Test public void filter() { - // new Bloom filter + // new Bloom filterFactory final BlockBasedTableConfig blockConfig = new BlockBasedTableConfig(); try(final Options options = new Options()) { diff --git a/java/src/test/java/org/rocksdb/FlinkCompactionFilterTest.java b/java/src/test/java/org/rocksdb/FlinkCompactionFilterTest.java new file mode 100644 index 000000000..40320e9d5 --- /dev/null +++ b/java/src/test/java/org/rocksdb/FlinkCompactionFilterTest.java @@ -0,0 +1,356 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.rocksdb; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Random; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; +import org.rocksdb.FlinkCompactionFilter.StateType; +import org.rocksdb.FlinkCompactionFilter.TimeProvider; + +public class FlinkCompactionFilterTest { + private static final int LONG_LENGTH = 8; + private static final int INT_LENGTH = 4; + private static final String MERGE_OPERATOR_NAME = "stringappendtest"; + private static final byte DELIMITER = ','; + private static final long TTL = 100; + private static final long QUERY_TIME_AFTER_NUM_ENTRIES = 100; + private static final int TEST_TIMESTAMP_OFFSET = 2; + private static final Random rnd = new Random(); + + private TestTimeProvider timeProvider; + private List stateContexts; + private List cfDescs; + private List cfHandles; + + @Rule public TemporaryFolder dbFolder = new TemporaryFolder(); + + @Before + public void init() { + timeProvider = new TestTimeProvider(); + timeProvider.time = rnd.nextLong(); + stateContexts = + Arrays.asList(new StateContext(StateType.Value, timeProvider, TEST_TIMESTAMP_OFFSET), + new FixedElementListStateContext(timeProvider), + new NonFixedElementListStateContext(timeProvider)); + cfDescs = new ArrayList<>(); + cfHandles = new ArrayList<>(); + cfDescs.add(new ColumnFamilyDescriptor(RocksDB.DEFAULT_COLUMN_FAMILY)); + for (StateContext stateContext : stateContexts) { + cfDescs.add(stateContext.getCfDesc()); + } + } + + @After + public void cleanup() { + for (StateContext stateContext : stateContexts) { + stateContext.cfDesc.getOptions().close(); + stateContext.filterFactory.close(); + } + } + + @Test + public void checkStateTypeEnumOrder() { + // if the order changes it also needs to be adjusted + // in utilities/flink/flink_compaction_filter.h + // and in utilities/flink/flink_compaction_filter_test.cc + assertThat(StateType.Disabled.ordinal()).isEqualTo(0); + assertThat(StateType.Value.ordinal()).isEqualTo(1); + assertThat(StateType.List.ordinal()).isEqualTo(2); + } + + @Test + public void testCompactionFilter() throws RocksDBException { + try (DBOptions options = createDbOptions(); RocksDB rocksDb = setupDb(options)) { + try { + for (StateContext stateContext : stateContexts) { + stateContext.updateValueWithTimestamp(rocksDb); + stateContext.checkUnexpired(rocksDb); + rocksDb.compactRange(stateContext.columnFamilyHandle); + stateContext.checkUnexpired(rocksDb); + } + + timeProvider.time += TTL + TTL / 2; // expire state + + for (StateContext stateContext : stateContexts) { + stateContext.checkUnexpired(rocksDb); + rocksDb.compactRange(stateContext.columnFamilyHandle); + stateContext.checkExpired(rocksDb); + rocksDb.compactRange(stateContext.columnFamilyHandle); + } + } finally { + for (ColumnFamilyHandle cfHandle : cfHandles) { + cfHandle.close(); + } + } + } + } + + private static DBOptions createDbOptions() { + return new DBOptions().setCreateIfMissing(true).setCreateMissingColumnFamilies(true); + } + + private RocksDB setupDb(DBOptions options) throws RocksDBException { + RocksDB db = RocksDB.open(options, dbFolder.getRoot().getAbsolutePath(), cfDescs, cfHandles); + for (int i = 0; i < stateContexts.size(); i++) { + stateContexts.get(i).columnFamilyHandle = cfHandles.get(i + 1); + } + return db; + } + + private static class StateContext { + private final String cf; + final String key; + final ColumnFamilyDescriptor cfDesc; + final String userValue; + final long currentTime; + final FlinkCompactionFilter.FlinkCompactionFilterFactory filterFactory; + + ColumnFamilyHandle columnFamilyHandle; + + private StateContext(StateType type, TimeProvider timeProvider, int timestampOffset) { + this.currentTime = timeProvider.currentTimestamp(); + userValue = type.name() + "StateValue"; + cf = getClass().getSimpleName() + "StateCf"; + key = type.name() + "StateKey"; + filterFactory = + new FlinkCompactionFilter.FlinkCompactionFilterFactory(timeProvider, createLogger()); + filterFactory.configure(createConfig(type, timestampOffset)); + cfDesc = new ColumnFamilyDescriptor(getASCII(cf), getOptionsWithFilter(filterFactory)); + } + + private Logger createLogger() { + try (DBOptions opts = new DBOptions().setInfoLogLevel(InfoLogLevel.DEBUG_LEVEL)) { + return new Logger(opts) { + @Override + protected void log(InfoLogLevel infoLogLevel, String logMsg) { + System.out.println(infoLogLevel + ": " + logMsg); + } + }; + } + } + + FlinkCompactionFilter.Config createConfig(StateType type, int timestampOffset) { + return FlinkCompactionFilter.Config.createNotList( + type, timestampOffset, TTL, QUERY_TIME_AFTER_NUM_ENTRIES); + } + + private static ColumnFamilyOptions getOptionsWithFilter( + FlinkCompactionFilter.FlinkCompactionFilterFactory filterFactory) { + return new ColumnFamilyOptions() + .setCompactionFilterFactory(filterFactory) + .setMergeOperatorName(MERGE_OPERATOR_NAME); + } + + public String getKey() { + return key; + } + + ColumnFamilyDescriptor getCfDesc() { + return cfDesc; + } + + byte[] getValueWithTimestamp(RocksDB db) throws RocksDBException { + return db.get(columnFamilyHandle, getASCII(key)); + } + + void updateValueWithTimestamp(RocksDB db) throws RocksDBException { + db.put(columnFamilyHandle, getASCII(key), valueWithTimestamp()); + } + + byte[] valueWithTimestamp() { + return valueWithTimestamp(TEST_TIMESTAMP_OFFSET); + } + + byte[] valueWithTimestamp(@SuppressWarnings("SameParameterValue") int offset) { + return valueWithTimestamp(offset, currentTime); + } + + byte[] valueWithTimestamp(int offset, long timestamp) { + ByteBuffer buffer = getByteBuffer(offset); + buffer.put(new byte[offset]); + appendValueWithTimestamp(buffer, userValue, timestamp); + return buffer.array(); + } + + void appendValueWithTimestamp(ByteBuffer buffer, String value, long timestamp) { + buffer.putLong(timestamp); + buffer.putInt(value.length()); + buffer.put(getASCII(value)); + } + + ByteBuffer getByteBuffer(int offset) { + int length = offset + LONG_LENGTH + INT_LENGTH + userValue.length(); + return ByteBuffer.allocate(length); + } + + byte[] unexpiredValue() { + return valueWithTimestamp(); + } + + byte[] expiredValue() { + return null; + } + + void checkUnexpired(RocksDB db) throws RocksDBException { + assertThat(getValueWithTimestamp(db)).isEqualTo(unexpiredValue()); + } + + void checkExpired(RocksDB db) throws RocksDBException { + assertThat(getValueWithTimestamp(db)).isEqualTo(expiredValue()); + } + } + + private static class FixedElementListStateContext extends StateContext { + private FixedElementListStateContext(TimeProvider timeProvider) { + super(StateType.List, timeProvider, 0); + } + + @Override + FlinkCompactionFilter.Config createConfig(StateType type, int timestampOffset) { + // return FlinkCompactionFilter.Config.createForList(TTL, QUERY_TIME_AFTER_NUM_ENTRIES, + // ELEM_FILTER_FACTORY); + return FlinkCompactionFilter.Config.createForFixedElementList( + TTL, QUERY_TIME_AFTER_NUM_ENTRIES, 13 + userValue.getBytes().length); + } + + @Override + void updateValueWithTimestamp(RocksDB db) throws RocksDBException { + db.merge(columnFamilyHandle, getASCII(key), listExpired(3)); + db.merge(columnFamilyHandle, getASCII(key), mixedList(2, 3)); + db.merge(columnFamilyHandle, getASCII(key), listUnexpired(4)); + } + + @Override + byte[] unexpiredValue() { + return mixedList(5, 7); + } + + byte[] mergeBytes(byte[]... bytes) { + int length = 0; + for (byte[] a : bytes) { + length += a.length; + } + ByteBuffer buffer = ByteBuffer.allocate(length); + for (byte[] a : bytes) { + buffer.put(a); + } + return buffer.array(); + } + + @Override + byte[] expiredValue() { + return listUnexpired(7); + } + + private byte[] mixedList(int numberOfExpiredElements, int numberOfUnexpiredElements) { + assert numberOfExpiredElements > 0; + assert numberOfUnexpiredElements > 0; + return mergeBytes(listExpired(numberOfExpiredElements), new byte[] {DELIMITER}, + listUnexpired(numberOfUnexpiredElements)); + } + + private byte[] listExpired(int numberOfElements) { + return list(numberOfElements, currentTime); + } + + private byte[] listUnexpired(int numberOfElements) { + return list(numberOfElements, currentTime + TTL); + } + + private byte[] list(int numberOfElements, long timestamp) { + ByteBuffer buffer = getByteBufferForList(numberOfElements); + for (int i = 0; i < numberOfElements; i++) { + appendValueWithTimestamp(buffer, userValue, timestamp); + if (i < numberOfElements - 1) { + buffer.put(DELIMITER); + } + } + return buffer.array(); + } + + private ByteBuffer getByteBufferForList(int numberOfElements) { + int length = ((LONG_LENGTH + INT_LENGTH + userValue.length() + 1) * numberOfElements) - 1; + return ByteBuffer.allocate(length); + } + } + + private static class NonFixedElementListStateContext extends FixedElementListStateContext { + private static FlinkCompactionFilter.ListElementFilterFactory ELEM_FILTER_FACTORY = + new ListElementFilterFactory(); + + private NonFixedElementListStateContext(TimeProvider timeProvider) { + super(timeProvider); + } + + @Override + FlinkCompactionFilter.Config createConfig(StateType type, int timestampOffset) { + // return FlinkCompactionFilter.Config.createForList(TTL, QUERY_TIME_AFTER_NUM_ENTRIES, + // ELEM_FILTER_FACTORY); + return FlinkCompactionFilter.Config.createForList( + TTL, QUERY_TIME_AFTER_NUM_ENTRIES, ELEM_FILTER_FACTORY); + } + + private static class ListElementFilterFactory + implements FlinkCompactionFilter.ListElementFilterFactory { + @Override + public FlinkCompactionFilter.ListElementFilter createListElementFilter() { + return new FlinkCompactionFilter.ListElementFilter() { + @Override + public int nextUnexpiredOffset(byte[] list, long ttl, long currentTimestamp) { + int currentOffset = 0; + while (currentOffset < list.length) { + ByteBuffer bf = ByteBuffer.wrap(list, currentOffset, list.length - currentOffset); + long timestamp = bf.getLong(); + if (timestamp + ttl > currentTimestamp) { + break; + } + int elemLen = bf.getInt(8); + currentOffset += 13 + elemLen; + } + return currentOffset; + } + }; + } + } + } + + private static byte[] getASCII(String str) { + return str.getBytes(StandardCharsets.US_ASCII); + } + + private static class TestTimeProvider implements TimeProvider { + private long time; + + @Override + public long currentTimestamp() { + return time; + } + } +} \ No newline at end of file diff --git a/src.mk b/src.mk index 7d2663b99..629fca047 100644 --- a/src.mk +++ b/src.mk @@ -277,6 +277,7 @@ LIB_SOURCES = \ utilities/fault_injection_env.cc \ utilities/fault_injection_fs.cc \ utilities/fault_injection_secondary_cache.cc \ + utilities/flink/flink_compaction_filter.cc \ utilities/leveldb_options/leveldb_options.cc \ utilities/memory/memory_util.cc \ utilities/merge_operators.cc \ @@ -606,6 +607,7 @@ TEST_MAIN_SOURCES = \ utilities/cassandra/cassandra_serialize_test.cc \ utilities/checkpoint/checkpoint_test.cc \ utilities/env_timed_test.cc \ + utilities/flink/flink_compaction_filter_test.cc \ utilities/memory/memory_test.cc \ utilities/merge_operators/string_append/stringappend_test.cc \ utilities/object_registry_test.cc \ @@ -660,6 +662,7 @@ JNI_NATIVE_SOURCES = \ java/rocksjni/env_options.cc \ java/rocksjni/event_listener.cc \ java/rocksjni/event_listener_jnicallback.cc \ + java/rocksjni/flink_compactionfilterjni.cc \ java/rocksjni/ingest_external_file_options.cc \ java/rocksjni/filter.cc \ java/rocksjni/iterator.cc \ diff --git a/utilities/flink/flink_compaction_filter.cc b/utilities/flink/flink_compaction_filter.cc new file mode 100644 index 000000000..4cbdd7e7d --- /dev/null +++ b/utilities/flink/flink_compaction_filter.cc @@ -0,0 +1,206 @@ +// 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). + +#include "utilities/flink/flink_compaction_filter.h" + +#include +#include + +namespace ROCKSDB_NAMESPACE { +namespace flink { + +int64_t DeserializeTimestamp(const char* src, std::size_t offset) { + uint64_t result = 0; + for (unsigned long i = 0; i < sizeof(uint64_t); i++) { + result |= static_cast(static_cast(src[offset + i])) + << ((sizeof(int64_t) - 1 - i) * BITS_PER_BYTE); + } + return static_cast(result); +} + +CompactionFilter::Decision Decide(const char* ts_bytes, const int64_t ttl, + const std::size_t timestamp_offset, + const int64_t current_timestamp, + const std::shared_ptr& logger) { + int64_t timestamp = DeserializeTimestamp(ts_bytes, timestamp_offset); + const int64_t ttlWithoutOverflow = + timestamp > 0 ? std::min(JAVA_MAX_LONG - timestamp, ttl) : ttl; + Debug(logger.get(), + "Last access timestamp: %" PRId64 " ms, ttlWithoutOverflow: %" PRId64 + " ms, Current timestamp: %" PRId64 " ms", + timestamp, ttlWithoutOverflow, current_timestamp); + return timestamp + ttlWithoutOverflow <= current_timestamp + ? CompactionFilter::Decision::kRemove + : CompactionFilter::Decision::kKeep; +} + +FlinkCompactionFilter::ConfigHolder::ConfigHolder() + : config_(const_cast(&DISABLED_CONFIG)){}; + +FlinkCompactionFilter::ConfigHolder::~ConfigHolder() { + Config* config = config_.load(); + if (config != &DISABLED_CONFIG) { + delete config; + } +} + +// at the moment Flink configures filters (can be already created) only once +// when user creates state otherwise it can lead to ListElementFilter leak in +// Config or race between its delete in Configure() and usage in FilterV2() the +// method returns true if it was configured before +bool FlinkCompactionFilter::ConfigHolder::Configure(Config* config) { + bool not_configured = GetConfig() == &DISABLED_CONFIG; + if (not_configured) { + assert(config->query_time_after_num_entries_ >= 0); + config_ = config; + } + return not_configured; +} + +FlinkCompactionFilter::Config* +FlinkCompactionFilter::ConfigHolder::GetConfig() { + return config_.load(); +} + +std::size_t FlinkCompactionFilter::FixedListElementFilter::NextUnexpiredOffset( + const Slice& list, int64_t ttl, int64_t current_timestamp) const { + std::size_t offset = 0; + while (offset < list.size()) { + Decision decision = Decide(list.data(), ttl, offset + timestamp_offset_, + current_timestamp, logger_); + if (decision != Decision::kKeep) { + std::size_t new_offset = offset + fixed_size_; + if (new_offset >= JAVA_MAX_SIZE || new_offset < offset) { + return JAVA_MAX_SIZE; + } + offset = new_offset; + } else { + break; + } + } + return offset; +} + +const char* FlinkCompactionFilter::Name() const { + return "FlinkCompactionFilter"; +} + +FlinkCompactionFilter::FlinkCompactionFilter( + std::shared_ptr config_holder, + std::unique_ptr time_provider) + : FlinkCompactionFilter(std::move(config_holder), std::move(time_provider), + nullptr){}; + +FlinkCompactionFilter::FlinkCompactionFilter( + std::shared_ptr config_holder, + std::unique_ptr time_provider, std::shared_ptr logger) + : config_holder_(std::move(config_holder)), + time_provider_(std::move(time_provider)), + logger_(std::move(logger)), + config_cached_(const_cast(&DISABLED_CONFIG)){}; + +inline void FlinkCompactionFilter::InitConfigIfNotYet() const { + const_cast(this)->config_cached_ = + config_cached_ == &DISABLED_CONFIG ? config_holder_->GetConfig() + : config_cached_; +} + +CompactionFilter::Decision FlinkCompactionFilter::FilterV2( + int /*level*/, const Slice& key, ValueType value_type, + const Slice& existing_value, std::string* new_value, + std::string* /*skip_until*/) const { + InitConfigIfNotYet(); + CreateListElementFilterIfNull(); + UpdateCurrentTimestampIfStale(); + + const char* data = existing_value.data(); + + Debug(logger_.get(), + "Call FlinkCompactionFilter::FilterV2 - Key: %s, Data: %s, Value type: " + "%d, " + "State type: %d, TTL: %" PRId64 " ms, timestamp_offset: %zu", + key.ToString().c_str(), existing_value.ToString(true).c_str(), + value_type, config_cached_->state_type_, config_cached_->ttl_, + config_cached_->timestamp_offset_); + + // too short value to have timestamp at all + const bool tooShortValue = + existing_value.size() < + config_cached_->timestamp_offset_ + TIMESTAMP_BYTE_SIZE; + + const StateType state_type = config_cached_->state_type_; + const bool value_or_merge = + value_type == ValueType::kValue || value_type == ValueType::kMergeOperand; + const bool value_state = + state_type == StateType::Value && value_type == ValueType::kValue; + const bool list_entry = state_type == StateType::List && value_or_merge; + const bool toDecide = value_state || list_entry; + const bool list_filter = list_entry && list_element_filter_; + + Decision decision = Decision::kKeep; + if (!tooShortValue && toDecide) { + decision = list_filter ? ListDecide(existing_value, new_value) + : Decide(data, config_cached_->ttl_, + config_cached_->timestamp_offset_, + current_timestamp_, logger_); + } + Debug(logger_.get(), "Decision: %d", static_cast(decision)); + return decision; +} + +CompactionFilter::Decision FlinkCompactionFilter::ListDecide( + const Slice& existing_value, std::string* new_value) const { + std::size_t offset = 0; + if (offset < existing_value.size()) { + Decision decision = Decide(existing_value.data(), config_cached_->ttl_, + offset + config_cached_->timestamp_offset_, + current_timestamp_, logger_); + if (decision != Decision::kKeep) { + offset = + ListNextUnexpiredOffset(existing_value, offset, config_cached_->ttl_); + if (offset >= JAVA_MAX_SIZE) { + return Decision::kKeep; + } + } + } + if (offset >= existing_value.size()) { + return Decision::kRemove; + } else if (offset > 0) { + SetUnexpiredListValue(existing_value, offset, new_value); + return Decision::kChangeValue; + } + return Decision::kKeep; +} + +std::size_t FlinkCompactionFilter::ListNextUnexpiredOffset( + const Slice& existing_value, size_t offset, int64_t ttl) const { + std::size_t new_offset = list_element_filter_->NextUnexpiredOffset( + existing_value, ttl, current_timestamp_); + if (new_offset >= JAVA_MAX_SIZE || new_offset < offset) { + Error(logger_.get(), "Wrong next offset in list filter: %zu -> %zu", offset, + new_offset); + new_offset = JAVA_MAX_SIZE; + } else { + Debug(logger_.get(), "Next unexpired offset: %zu -> %zu", offset, + new_offset); + } + return new_offset; +} + +void FlinkCompactionFilter::SetUnexpiredListValue( + const Slice& existing_value, std::size_t offset, + std::string* new_value) const { + new_value->clear(); + auto new_value_char = existing_value.data() + offset; + auto new_value_size = existing_value.size() - offset; + new_value->assign(new_value_char, new_value_size); + Logger* logger = logger_.get(); + if (logger && logger->GetInfoLogLevel() <= InfoLogLevel::DEBUG_LEVEL) { + Slice new_value_slice = Slice(new_value_char, new_value_size); + Debug(logger, "New list value: %s", new_value_slice.ToString(true).c_str()); + } +} +} // namespace flink +} // namespace ROCKSDB_NAMESPACE diff --git a/utilities/flink/flink_compaction_filter.h b/utilities/flink/flink_compaction_filter.h new file mode 100644 index 000000000..3b3b651ea --- /dev/null +++ b/utilities/flink/flink_compaction_filter.h @@ -0,0 +1,191 @@ +// 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). + +#pragma once +#include + +#include +#include +#include +#include +#include + +#include "rocksdb/compaction_filter.h" +#include "rocksdb/slice.h" + +namespace ROCKSDB_NAMESPACE { +namespace flink { + +static const std::size_t BITS_PER_BYTE = static_cast(8); +static const std::size_t TIMESTAMP_BYTE_SIZE = static_cast(8); +static const int64_t JAVA_MIN_LONG = static_cast(0x8000000000000000); +static const int64_t JAVA_MAX_LONG = static_cast(0x7fffffffffffffff); +static const std::size_t JAVA_MAX_SIZE = static_cast(0x7fffffff); + +/** + * Compaction filter for removing expired Flink state entries with ttl. + * + * Note: this compaction filter is a special implementation, designed for usage + * only in Apache Flink project. + */ +class FlinkCompactionFilter : public CompactionFilter { + public: + enum StateType { + // WARNING!!! Do not change the order of enum entries as it is important for + // jni translation + Disabled, + Value, + List + }; + + // Provides current timestamp to check expiration, it must thread safe. + class TimeProvider { + public: + virtual ~TimeProvider() = default; + virtual int64_t CurrentTimestamp() const = 0; + }; + + // accepts serialized list state and checks elements for expiration starting + // from the head stops upon discovery of unexpired element and returns its + // offset or returns offset greater or equal to list byte length. + class ListElementFilter { + public: + virtual ~ListElementFilter() = default; + virtual std::size_t NextUnexpiredOffset( + const Slice& list, int64_t ttl, int64_t current_timestamp) const = 0; + }; + + // this filter can operate directly on list state bytes + // because the byte length of list element and last acess timestamp position + // are known. + class FixedListElementFilter : public ListElementFilter { + public: + explicit FixedListElementFilter(std::size_t fixed_size, + std::size_t timestamp_offset, + std::shared_ptr logger) + : fixed_size_(fixed_size), + timestamp_offset_(timestamp_offset), + logger_(std::move(logger)) {} + std::size_t NextUnexpiredOffset(const Slice& list, int64_t ttl, + int64_t current_timestamp) const override; + + private: + std::size_t fixed_size_; + std::size_t timestamp_offset_; + std::shared_ptr logger_; + }; + + // Factory is needed to create one filter per filter/thread + // and avoid concurrent access to the filter state + class ListElementFilterFactory { + public: + virtual ~ListElementFilterFactory() = default; + virtual ListElementFilter* CreateListElementFilter( + std::shared_ptr logger) const = 0; + }; + + class FixedListElementFilterFactory : public ListElementFilterFactory { + public: + explicit FixedListElementFilterFactory(std::size_t fixed_size, + std::size_t timestamp_offset) + : fixed_size_(fixed_size), timestamp_offset_(timestamp_offset) {} + FixedListElementFilter* CreateListElementFilter( + std::shared_ptr logger) const override { + return new FixedListElementFilter(fixed_size_, timestamp_offset_, logger); + }; + + private: + std::size_t fixed_size_; + std::size_t timestamp_offset_; + }; + + struct Config { + StateType state_type_; + std::size_t timestamp_offset_; + int64_t ttl_; + // Number of state entries to process by compaction filter before updating + // current timestamp. + int64_t query_time_after_num_entries_; + std::unique_ptr list_element_filter_factory_; + }; + + // Allows to configure at once all FlinkCompactionFilters created by the + // factory. The ConfigHolder holds the shared Config. + class ConfigHolder { + public: + explicit ConfigHolder(); + ~ConfigHolder(); + bool Configure(Config* config); + Config* GetConfig(); + + private: + std::atomic config_; + }; + + explicit FlinkCompactionFilter(std::shared_ptr config_holder, + std::unique_ptr time_provider); + + explicit FlinkCompactionFilter(std::shared_ptr config_holder, + std::unique_ptr time_provider, + std::shared_ptr logger); + + const char* Name() const override; + Decision FilterV2(int level, const Slice& key, ValueType value_type, + const Slice& existing_value, std::string* new_value, + std::string* skip_until) const override; + + bool IgnoreSnapshots() const override { return true; } + + private: + inline void InitConfigIfNotYet() const; + + Decision ListDecide(const Slice& existing_value, + std::string* new_value) const; + + inline std::size_t ListNextUnexpiredOffset(const Slice& existing_value, + std::size_t offset, + int64_t ttl) const; + + inline void SetUnexpiredListValue(const Slice& existing_value, + std::size_t offset, + std::string* new_value) const; + + inline void CreateListElementFilterIfNull() const { + if (!list_element_filter_ && config_cached_->list_element_filter_factory_) { + const_cast(this)->list_element_filter_ = + std::unique_ptr( + config_cached_->list_element_filter_factory_ + ->CreateListElementFilter(logger_)); + } + } + + inline void UpdateCurrentTimestampIfStale() const { + bool is_stale = + record_counter_ >= config_cached_->query_time_after_num_entries_; + if (is_stale) { + const_cast(this)->record_counter_ = 0; + const_cast(this)->current_timestamp_ = + time_provider_->CurrentTimestamp(); + } + const_cast(this)->record_counter_ = + record_counter_ + 1; + } + + std::shared_ptr config_holder_; + std::unique_ptr time_provider_; + std::shared_ptr logger_; + Config* config_cached_; + std::unique_ptr list_element_filter_; + int64_t current_timestamp_ = std::numeric_limits::max(); + int64_t record_counter_ = std::numeric_limits::max(); +}; + +static const FlinkCompactionFilter::Config DISABLED_CONFIG = + FlinkCompactionFilter::Config{FlinkCompactionFilter::StateType::Disabled, 0, + std::numeric_limits::max(), + std::numeric_limits::max(), nullptr}; + +} // namespace flink +} // namespace ROCKSDB_NAMESPACE diff --git a/utilities/flink/flink_compaction_filter_test.cc b/utilities/flink/flink_compaction_filter_test.cc new file mode 100644 index 000000000..26613ae68 --- /dev/null +++ b/utilities/flink/flink_compaction_filter_test.cc @@ -0,0 +1,226 @@ +// Copyright (c) 2017-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). + +#include "utilities/flink/flink_compaction_filter.h" + +#include + +#include "test_util/testharness.h" + +namespace ROCKSDB_NAMESPACE { +namespace flink { + +#define DISABLED FlinkCompactionFilter::StateType::Disabled +#define VALUE FlinkCompactionFilter::StateType::Value +#define LIST FlinkCompactionFilter::StateType::List + +#define KVALUE CompactionFilter::ValueType::kValue +#define KMERGE CompactionFilter::ValueType::kMergeOperand +#define KBLOB CompactionFilter::ValueType::kBlobIndex + +#define KKEEP CompactionFilter::Decision::kKeep +#define KREMOVE CompactionFilter::Decision::kRemove +#define KCHANGE CompactionFilter::Decision::kChangeValue + +#define EXPIRE (time += ttl + 20) + +#define EXPECT_ARR_EQ(arr1, arr2, num) \ + EXPECT_TRUE(0 == memcmp(arr1, arr2, num)); + +static const std::size_t TEST_TIMESTAMP_OFFSET = static_cast(2); + +static const std::size_t LIST_ELEM_FIXED_LEN = static_cast(8 + 4); + +static const int64_t QUERY_TIME_AFTER_NUM_ENTRIES = static_cast(10); + +class ConsoleLogger : public Logger { + public: + using Logger::Logv; + ConsoleLogger() : Logger(InfoLogLevel::DEBUG_LEVEL) {} + + void Logv(const char* format, va_list ap) override { + vprintf(format, ap); + printf("\n"); + } +}; + +int64_t time = 0; + +class TestTimeProvider : public FlinkCompactionFilter::TimeProvider { + public: + int64_t CurrentTimestamp() const override { return time; } +}; + +std::random_device rd; // NOLINT +std::mt19937 mt(rd()); // NOLINT +std::uniform_int_distribution rnd(JAVA_MIN_LONG, + JAVA_MAX_LONG); // NOLINT + +int64_t ttl = 100; + +Slice key = Slice("key"); // NOLINT +char data[24]; +std::string new_list = ""; // NOLINT +std::string stub = ""; // NOLINT + +FlinkCompactionFilter::StateType state_type; +CompactionFilter::ValueType value_type; +FlinkCompactionFilter* filter; // NOLINT + +void SetTimestamp(int64_t timestamp, size_t offset = 0, char* value = data) { + for (unsigned long i = 0; i < sizeof(uint64_t); i++) { + value[offset + i] = + static_cast(static_cast(timestamp) >> + ((sizeof(int64_t) - 1 - i) * BITS_PER_BYTE)); + } +} + +CompactionFilter::Decision decide(size_t data_size = sizeof(data)) { + return filter->FilterV2(0, key, value_type, Slice(data, data_size), &new_list, + &stub); +} + +void Init( + FlinkCompactionFilter::StateType stype, CompactionFilter::ValueType vtype, + FlinkCompactionFilter::ListElementFilterFactory* fixed_len_filter_factory, + size_t timestamp_offset, bool expired = false) { + time = expired ? time + ttl + 20 : time; + state_type = stype; + value_type = vtype; + + auto config_holder = std::make_shared(); + auto time_provider = new TestTimeProvider(); + auto logger = std::make_shared(); + + filter = new FlinkCompactionFilter( + config_holder, + std::unique_ptr(time_provider), + logger); + auto config = new FlinkCompactionFilter::Config{ + state_type, timestamp_offset, ttl, QUERY_TIME_AFTER_NUM_ENTRIES, + std::unique_ptr( + fixed_len_filter_factory)}; + EXPECT_EQ(decide(), KKEEP); // test disabled config + EXPECT_TRUE(config_holder->Configure(config)); + EXPECT_FALSE(config_holder->Configure(config)); +} + +void InitValue(FlinkCompactionFilter::StateType stype, + CompactionFilter::ValueType vtype, bool expired = false, + size_t timestamp_offset = TEST_TIMESTAMP_OFFSET) { + time = rnd(mt); + SetTimestamp(time, timestamp_offset); + Init(stype, vtype, nullptr, timestamp_offset, expired); +} + +void InitList(CompactionFilter::ValueType vtype, bool all_expired = false, + bool first_elem_expired = false, size_t timestamp_offset = 0) { + time = rnd(mt); + SetTimestamp(first_elem_expired ? time - ttl - 20 : time, + timestamp_offset); // elem 1 ts + SetTimestamp(time, LIST_ELEM_FIXED_LEN + timestamp_offset); // elem 2 ts + auto fixed_len_filter_factory = + new FlinkCompactionFilter::FixedListElementFilterFactory( + LIST_ELEM_FIXED_LEN, static_cast(0)); + Init(LIST, vtype, fixed_len_filter_factory, timestamp_offset, all_expired); +} + +void Deinit() { delete filter; } + +TEST(FlinkStateTtlTest, CheckStateTypeEnumOrder) { // NOLINT + // if the order changes it also needs to be adjusted in Java client: + // in org.rocksdb.FlinkCompactionFilter + // and in org.rocksdb.FlinkCompactionFilterTest + EXPECT_EQ(DISABLED, 0); + EXPECT_EQ(VALUE, 1); + EXPECT_EQ(LIST, 2); +} + +TEST(FlinkStateTtlTest, SkipShortDataWithoutTimestamp) { // NOLINT + InitValue(VALUE, KVALUE, true); + EXPECT_EQ(decide(TIMESTAMP_BYTE_SIZE - 1), KKEEP); + Deinit(); +} + +TEST(FlinkValueStateTtlTest, Unexpired) { // NOLINT + InitValue(VALUE, KVALUE); + EXPECT_EQ(decide(), KKEEP); + Deinit(); +} + +TEST(FlinkValueStateTtlTest, Expired) { // NOLINT + InitValue(VALUE, KVALUE, true); + EXPECT_EQ(decide(), KREMOVE); + Deinit(); +} + +TEST(FlinkValueStateTtlTest, CachedTimeUpdate) { // NOLINT + InitValue(VALUE, KVALUE); + EXPECT_EQ(decide(), KKEEP); // also implicitly cache current timestamp + EXPIRE; // advance current timestamp to expire but cached should be used + // QUERY_TIME_AFTER_NUM_ENTRIES - 2: + // -1 -> for decide disabled in InitValue + // and -1 -> for decide right after InitValue + for (int64_t i = 0; i < QUERY_TIME_AFTER_NUM_ENTRIES - 2; i++) { + EXPECT_EQ(decide(), KKEEP); + } + EXPECT_EQ(decide(), KREMOVE); // advanced current timestamp should be updated + // in cache and expire state + Deinit(); +} + +TEST(FlinkValueStateTtlTest, WrongFilterValueType) { // NOLINT + InitValue(VALUE, KMERGE, true); + EXPECT_EQ(decide(), KKEEP); + Deinit(); +} + +TEST(FlinkListStateTtlTest, Unexpired) { // NOLINT + InitList(KMERGE); + EXPECT_EQ(decide(), KKEEP); + Deinit(); + + InitList(KVALUE); + EXPECT_EQ(decide(), KKEEP); + Deinit(); +} + +TEST(FlinkListStateTtlTest, Expired) { // NOLINT + InitList(KMERGE, true); + EXPECT_EQ(decide(), KREMOVE); + Deinit(); + + InitList(KVALUE, true); + EXPECT_EQ(decide(), KREMOVE); + Deinit(); +} + +TEST(FlinkListStateTtlTest, HalfExpired) { // NOLINT + InitList(KMERGE, false, true); + EXPECT_EQ(decide(), KCHANGE); + EXPECT_ARR_EQ(new_list.data(), data + LIST_ELEM_FIXED_LEN, + LIST_ELEM_FIXED_LEN); + Deinit(); + + InitList(KVALUE, false, true); + EXPECT_EQ(decide(), KCHANGE); + EXPECT_ARR_EQ(new_list.data(), data + LIST_ELEM_FIXED_LEN, + LIST_ELEM_FIXED_LEN); + Deinit(); +} + +TEST(FlinkListStateTtlTest, WrongFilterValueType) { // NOLINT + InitList(KBLOB, true); + EXPECT_EQ(decide(), KKEEP); + Deinit(); +} + +} // namespace flink +} // namespace ROCKSDB_NAMESPACE + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} From abcce6dd3868574879d7f725647eaf12405d1e57 Mon Sep 17 00:00:00 2001 From: Yun Tang Date: Fri, 23 Oct 2020 00:24:04 +0800 Subject: [PATCH 11/61] [FLINK-19710] Revert implementation of PerfContext back to __thread to avoid performance regression --- db/perf_context_test.cc | 83 ----------------------------------- monitoring/perf_context_imp.h | 2 +- 2 files changed, 1 insertion(+), 84 deletions(-) diff --git a/db/perf_context_test.cc b/db/perf_context_test.cc index bb8691b96..fca9523cd 100644 --- a/db/perf_context_test.cc +++ b/db/perf_context_test.cc @@ -706,89 +706,6 @@ TEST_F(PerfContextTest, MergeOperatorTime) { delete db; } -TEST_F(PerfContextTest, CopyAndMove) { - // Assignment operator - { - get_perf_context()->Reset(); - get_perf_context()->EnablePerLevelPerfContext(); - PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5); - ASSERT_EQ( - 1, - (*(get_perf_context()->level_to_perf_context))[5].bloom_filter_useful); - PerfContext perf_context_assign; - perf_context_assign = *get_perf_context(); - ASSERT_EQ( - 1, - (*(perf_context_assign.level_to_perf_context))[5].bloom_filter_useful); - get_perf_context()->ClearPerLevelPerfContext(); - get_perf_context()->Reset(); - ASSERT_EQ( - 1, - (*(perf_context_assign.level_to_perf_context))[5].bloom_filter_useful); - perf_context_assign.ClearPerLevelPerfContext(); - perf_context_assign.Reset(); - } - // Copy constructor - { - get_perf_context()->Reset(); - get_perf_context()->EnablePerLevelPerfContext(); - PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5); - ASSERT_EQ( - 1, - (*(get_perf_context()->level_to_perf_context))[5].bloom_filter_useful); - PerfContext perf_context_copy(*get_perf_context()); - ASSERT_EQ( - 1, (*(perf_context_copy.level_to_perf_context))[5].bloom_filter_useful); - get_perf_context()->ClearPerLevelPerfContext(); - get_perf_context()->Reset(); - ASSERT_EQ( - 1, (*(perf_context_copy.level_to_perf_context))[5].bloom_filter_useful); - perf_context_copy.ClearPerLevelPerfContext(); - perf_context_copy.Reset(); - } - // Move constructor - { - get_perf_context()->Reset(); - get_perf_context()->EnablePerLevelPerfContext(); - PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5); - ASSERT_EQ( - 1, - (*(get_perf_context()->level_to_perf_context))[5].bloom_filter_useful); - PerfContext perf_context_move = std::move(*get_perf_context()); - ASSERT_EQ( - 1, (*(perf_context_move.level_to_perf_context))[5].bloom_filter_useful); - get_perf_context()->ClearPerLevelPerfContext(); - get_perf_context()->Reset(); - ASSERT_EQ( - 1, (*(perf_context_move.level_to_perf_context))[5].bloom_filter_useful); - perf_context_move.ClearPerLevelPerfContext(); - perf_context_move.Reset(); - } -} - -TEST_F(PerfContextTest, PerfContextDisableEnable) { - get_perf_context()->Reset(); - get_perf_context()->EnablePerLevelPerfContext(); - PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_positive, 1, 0); - get_perf_context()->DisablePerLevelPerfContext(); - PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5); - get_perf_context()->EnablePerLevelPerfContext(); - PERF_COUNTER_BY_LEVEL_ADD(block_cache_hit_count, 1, 0); - get_perf_context()->DisablePerLevelPerfContext(); - PerfContext perf_context_copy(*get_perf_context()); - ASSERT_EQ(1, (*(perf_context_copy.level_to_perf_context))[0] - .bloom_filter_full_positive); - // this was set when per level perf context is disabled, should not be copied - ASSERT_NE( - 1, (*(perf_context_copy.level_to_perf_context))[5].bloom_filter_useful); - ASSERT_EQ( - 1, (*(perf_context_copy.level_to_perf_context))[0].block_cache_hit_count); - perf_context_copy.ClearPerLevelPerfContext(); - perf_context_copy.Reset(); - get_perf_context()->ClearPerLevelPerfContext(); - get_perf_context()->Reset(); -} - TEST_F(PerfContextTest, PerfContextByLevelGetSet) { get_perf_context()->Reset(); get_perf_context()->EnablePerLevelPerfContext(); diff --git a/monitoring/perf_context_imp.h b/monitoring/perf_context_imp.h index 5b66ff2ff..439a1e28c 100644 --- a/monitoring/perf_context_imp.h +++ b/monitoring/perf_context_imp.h @@ -16,7 +16,7 @@ extern PerfContext perf_context; extern thread_local PerfContext perf_context_; #define perf_context (*get_perf_context()) #else -extern thread_local PerfContext perf_context; +extern __thread PerfContext perf_context; #endif #endif From 06fe572af09c2150d78c432d44783b7d8f3ae5a6 Mon Sep 17 00:00:00 2001 From: Mika Naylor Date: Mon, 16 Aug 2021 23:28:15 +0800 Subject: [PATCH 12/61] [FLINK-23756] Update FrocksDB release document with more info Also make some slight improvements to the Maven upload script. --- FROCKSDB-RELEASE.md | 249 ++++++++++++++++++++++++++++++++++++ java/publish-frocksdbjni.sh | 44 +++++++ 2 files changed, 293 insertions(+) create mode 100644 FROCKSDB-RELEASE.md create mode 100644 java/publish-frocksdbjni.sh diff --git a/FROCKSDB-RELEASE.md b/FROCKSDB-RELEASE.md new file mode 100644 index 000000000..3ec3c2724 --- /dev/null +++ b/FROCKSDB-RELEASE.md @@ -0,0 +1,249 @@ +# FRocksDB Release Process + +## Summary + +FrocksDB-6.x releases are a fat jar file that contain the following binaries: +* .so files for linux32 (glibc and musl-libc) +* .so files for linux64 (glibc and musl-libc) +* .so files for linux [aarch64](https://en.wikipedia.org/wiki/AArch64) (glibc and musl-libc) +* .so files for linux [ppc64le](https://en.wikipedia.org/wiki/Ppc64le) (glibc and musl-libc) +* .jnilib file for Mac OSX +* .dll for Windows x64 + +To build the binaries for a FrocksDB release, building on native architectures is advised. Building the binaries for ppc64le and aarch64 *can* be done using QEMU, but you may run into emulation bugs and the build times will be dramatically slower (up to x20). + +We recommend building the binaries on environments with at least 4 cores, 16GB RAM and 40GB of storage. The following environments are recommended for use in the build process: +* Windows x64 +* Linux aarch64 +* Linux ppc64le +* Mac OSX + +## Build for Windows + +For the Windows binary build, we recommend using a base [AWS Windows EC2 instance](https://aws.amazon.com/windows/products/ec2/) with 4 cores, 16GB RAM, 40GB storage for the build. + +Firstly, install [chocolatey](https://chocolatey.org/install). Once installed, the following required components can be installed using Powershell: + + choco install git.install jdk8 maven visualstudio2017community visualstudio2017-workload-nativedesktop + +Open the "Developer Command Prompt for VS 2017" and run the following commands: + + git clone git@github.com:ververica/frocksdb.git + cd frocksdb + git checkout FRocksDB-6.20.3 # release branch + java\crossbuild\build-win.bat + +The resulting native binary will be built and available at `build\java\Release\rocksdbjni-shared.dll`. You can also find it under project folder with name `librocksdbjni-win64.dll`. +The result windows jar is `build\java\rocksdbjni_classes.jar`. + +There is also a how-to in CMakeLists.txt. + +**Once finished, extract the `librocksdbjni-win64.dll` from the build environment. You will need this .dll in the final crossbuild.** + +## Build for aarch64 + +For the Linux aarch64 binary build, we recommend using a base [AWS Ubuntu Server 20.04 LTS EC2](https://aws.amazon.com/windows/products/ec2/) with a 4 core Arm processor, 16GB RAM, 40GB storage for the build. You can also attempt to build with QEMU on a non-aarch64 processor, but you may run into emulation bugs and very long build times. + +### Building in aarch64 environment + +First, install the required packages such as Java 8 and make: + + sudo apt-get update + sudo apt-get install build-essential openjdk-8-jdk + +then, install and setup [Docker](https://docs.docker.com/engine/install/ubuntu/): + + sudo apt-get install apt-transport-https ca-certificates curl gnupg lsb-release + + curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg + echo "deb [arch=arm64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null + + sudo apt-get update + sudo apt-get install docker-ce docker-ce-cli containerd.io + + sudo groupadd docker + sudo usermod -aG docker $USER + newgrp docker + +Then, clone the FrocksDB repo: + + git clone https://github.com/ververica/frocksdb.git + cd frocksdb + git checkout FRocksDB-6.20.3 # release branch + + +First, build the glibc binary: + + make jclean clean rocksdbjavastaticdockerarm64v8 + +**Once finished, extract the `java/target/librocksdbjni-linux-aarch64.so` from the build environment. You will need this .so in the final crossbuild.** + +Next, build the musl-libc binary: + + make jclean clean rocksdbjavastaticdockerarm64v8musl + +**Once finished, extract the `java/target/librocksdbjni-linux-aarch64-musl.so` from the build environment. You will need this .so in the final crossbuild.** + +### Building via QEMU + +You can use QEMU on, for example, an `x86_64` system to build the aarch64 binaries. To set this up on an Ubuntu envirnment: + + sudo apt-get install qemu binfmt-support qemu-user-static + docker run --rm --privileged multiarch/qemu-user-static --reset -p yes + +To verify that you can now run aarch64 docker images: + + docker run --rm -t arm64v8/ubuntu uname -m + > aarch64 + +You can now attempt to build the aarch64 binaries as in the previous section. + +## Build in PPC64LE + +For the ppc64le binaries, we recommend building on a PowerPC machine if possible, as it can be tricky to spin up a ppc64le cloud environment. However, if a PowerPC machine is not available, [Travis-CI](https://www.travis-ci.com/) offers ppc64le build environments that work perfectly for building these binaries. If neither a machine or Travis are an option, you can use QEMU but the build may take a very long time and be prone to emulation errors. + +### Building in ppc64le environment + +As with the aarch64 environment, the ppc64le environment will require Java 8, Docker and build-essentials installed. Once installed, you can build the 2 binaries: + + make jclean clean rocksdbjavastaticdockerppc64le + +**Once finished, extract the `java/target/librocksdbjni-linux-ppc64le.so` from the build environment. You will need this .so in the final crossbuild.** + + make jclean clean rocksdbjavastaticdockerppc64lemusl + +**Once finished, extract the `java/target/librocksdbjni-linux-ppc64le-musl.so` from the build environment. You will need this .so in the final crossbuild.** + +### Building via Travis + +Travis-CI supports ppc64le build environments, and this can be a convienient way of building in the absence of a PowerPC machine. Assuming that you have an S3 bucket called **my-frocksdb-release-artifacts**, the following Travis configuration will build the release artifacts and push them to the S3 bucket: + +``` +dist: xenial +language: cpp +os: + - linux +arch: + - ppc64le + +services: + - docker +addons: + artifacts: + paths: + - $TRAVIS_BUILD_DIR/java/target/librocksdbjni-linux-ppc64le-musl.so + - $TRAVIS_BUILD_DIR/java/target/librocksdbjni-linux-ppc64le.so + +env: + global: + - ARTIFACTS_BUCKET=my-rocksdb-release-artifacts + jobs: + - CMD=rocksdbjavastaticdockerppc64le + - CMD=rocksdbjavastaticdockerppc64lemusl + +install: + - sudo apt-get install -y openjdk-8-jdk || exit $? + - export PATH=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture)/bin:$PATH + - export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture) + - echo "JAVA_HOME=${JAVA_HOME}" + - which java && java -version + - which javac && javac -version + +script: + - make jclean clean $CMD +``` + +**Make sure to set the `ARTIFACTS_KEY` and `ARTIFACTS_SECRET` environment variables in the Travis Job with valid AWS credentials to access the S3 bucket you defined.** + +**Once finished, the`librocksdbjni-linux-ppce64le.so` and `librocksdbjni-linux-ppce64le-musl.so` binaries will be in the S3 bucket. You will need these .so binaries in the final crossbuild.** + + +### Building via QEMU + +You can use QEMU on, for example, an `x86_64` system to build the ppc64le binaries. To set this up on an Ubuntu envirnment: + + sudo apt-get install qemu binfmt-support qemu-user-static + docker run --rm --privileged multiarch/qemu-user-static --reset -p yes + +To verify that you can now run ppc64le docker images: + + docker run --rm -t ppc64le/ubuntu uname -m + > ppc64le + +You can now attempt to build the ppc64le binaries as in the previous section. + +## Final crossbuild in Mac OSX + +Documentation for the final crossbuild for Mac OSX and Linux is described in [java/RELEASE.md](java/RELEASE.md) as has information on dependencies that should be installed. As above, this tends to be Java 8, build-essentials and Docker. + +Before you run this step, you should have 5 binaries from the previous build steps: + + 1. `librocksdbjni-win64.dll` from the Windows build step. + 2. `librocksdbjni-linux-aarch64.so` from the aarch64 build step. + 3. `librocksdbjni-linux-aarch64-musl.so` from the aarch64 build step. + 3. `librocksdbjni-linux-ppc64le.so` from the ppc64le build step. + 4. `librocksdbjni-linux-ppc64le-musl.so` from the ppc64le build step. + +To start the crossbuild within a Mac OSX environment: + + make jclean clean + mkdir -p java/target + cp /librocksdbjni-win64.dll java/target/librocksdbjni-win64.dll + cp /librocksdbjni-linux-ppc64le.so java/target/librocksdbjni-linux-ppc64le.so + cp /librocksdbjni-linux-ppc64le-musl.so java/target/librocksdbjni-linux-ppc64le-musl.so + cp /librocksdbjni-linux-aarch64.so java/target/librocksdbjni-linux-aarch64.so + cp /librocksdbjni-linux-aarch64-musl.so java/target/librocksdbjni-linux-aarch64-musl.so + FROCKSDB_VERSION=1.0 PORTABLE=1 ROCKSDB_DISABLE_JEMALLOC=true DEBUG_LEVEL=0 make frocksdbjavastaticreleasedocker + +*Note, we disable jemalloc on mac due to https://github.com/facebook/rocksdb/issues/5787*. + +Once finished, there should be a directory at `java/target/frocksdb-release` with the FRocksDB jar, javadoc jar, sources jar and pom in it. You can inspect the jar file and ensure that contains the binaries, history file, etc: + +``` +$ jar tf frocksdbjni-6.20.3-ververica-1.0.jar +META-INF/ +META-INF/MANIFEST.MF +HISTORY-JAVA.md +HISTORY.md +librocksdbjni-linux-aarch64-musl.so +librocksdbjni-linux-aarch64.so +librocksdbjni-linux-ppc64le-musl.so +librocksdbjni-linux-ppc64le.so +librocksdbjni-linux32-musl.so +librocksdbjni-linux32.so +librocksdbjni-linux64-musl.so +librocksdbjni-linux64.so +librocksdbjni-osx.jnilib +librocksdbjni-win64.dl +... +``` + +*Note that it contains linux32/64.so binaries as well as librocksdbjni-osx.jnilib*. + +## Push to Maven Central + +For this step, you will need the following: + +- The OSX Crossbuild artifacts built in `java/target/frocksdb-release` as above. +- A Sonatype account with access to the staging repository. If you do not have permission, open a ticket with Sonatype, [such as this one](https://issues.sonatype.org/browse/OSSRH-72185). +- A GPG key to sign the release, with your public key available for verification (for example, by uploading it to https://keys.openpgp.org/) + +To upload the release to the Sonatype staging repository: +```bash +VERSION= \ +USER= \ +PASSWORD= \ +KEYNAME= \ +PASSPHRASE= \ +java/publish-frocksdbjni.sh +``` + +Go to the staging repositories on Sonatype: + +https://oss.sonatype.org/#stagingRepositories + +Select the open staging repository and click on "Close". + +The staging repository will look something like `https://oss.sonatype.org/content/repositories/xxxx-1020`. You can use this staged release to test the artifacts and ensure they are correct. + +Once you have verified the artifacts are correct, press the "Release" button. **WARNING: this can not be undone**. Within 24-48 hours, the artifact will be available on Maven Central for use. diff --git a/java/publish-frocksdbjni.sh b/java/publish-frocksdbjni.sh new file mode 100644 index 000000000..2a6bd2865 --- /dev/null +++ b/java/publish-frocksdbjni.sh @@ -0,0 +1,44 @@ +#!/usr/bin/env bash +################################################################################ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +################################################################################ + +# fail on errors +set -e + +PREFIX=java/target/frocksdb-release/frocksdbjni-${VERSION} + +function deploy() { + FILE=$1 + CLASSIFIER=$2 + echo "Deploying file=${FILE} with classifier=${CLASSIFIER} to sonatype with prefix=${PREFIX}" + sonatype_user="${USER}" sonatype_pw="${PASSWORD}" mvn gpg:sign-and-deploy-file \ + --settings java/deploysettings.xml \ + -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ \ + -DrepositoryId=sonatype-nexus-staging \ + -DpomFile=${PREFIX}.pom \ + -Dfile=$FILE \ + -Dclassifier=$CLASSIFIER \ + -Dgpg.keyname="${KEYNAME}" \ + -Dgpg.passphrase="${PASSPHRASE}" +} + +PREFIX=java/target/frocksdb-release/frocksdbjni-${VERSION} + +deploy ${PREFIX}-sources.jar sources +deploy ${PREFIX}-javadoc.jar javadoc +deploy ${PREFIX}.jar From fa05ea41e06cd9012262c1ad387ca7d6cc549f50 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=A9=AC=E8=B6=8A?= Date: Thu, 27 Jul 2023 14:44:27 +0800 Subject: [PATCH 13/61] add jni support for CreateColumnFamilyWithImport --- java/CMakeLists.txt | 4 + java/Makefile | 1 + java/rocksjni/checkpoint.cc | 41 ++++++ .../export_import_files_metadatajni.cc | 133 ++++++++++++++++++ java/rocksjni/import_column_family_options.cc | 59 ++++++++ java/rocksjni/portal.h | 78 ++++++++++ java/rocksjni/rocksjni.cc | 57 ++++++++ .../src/main/java/org/rocksdb/Checkpoint.java | 10 ++ .../rocksdb/ExportImportFilesMetaData.java | 56 ++++++++ .../rocksdb/ImportColumnFamilyOptions.java | 46 ++++++ .../java/org/rocksdb/LiveFileMetaData.java | 14 ++ java/src/main/java/org/rocksdb/RocksDB.java | 55 ++++++++ .../test/java/org/rocksdb/CheckPointTest.java | 24 ++++ .../org/rocksdb/ImportColumnFamilyTest.java | 96 +++++++++++++ src.mk | 2 + 15 files changed, 676 insertions(+) create mode 100644 java/rocksjni/export_import_files_metadatajni.cc create mode 100644 java/rocksjni/import_column_family_options.cc create mode 100644 java/src/main/java/org/rocksdb/ExportImportFilesMetaData.java create mode 100644 java/src/main/java/org/rocksdb/ImportColumnFamilyOptions.java create mode 100644 java/src/test/java/org/rocksdb/ImportColumnFamilyTest.java diff --git a/java/CMakeLists.txt b/java/CMakeLists.txt index 8ddb3da40..9c4e9d308 100644 --- a/java/CMakeLists.txt +++ b/java/CMakeLists.txt @@ -34,7 +34,9 @@ set(JNI_NATIVE_SOURCES rocksjni/event_listener.cc rocksjni/event_listener_jnicallback.cc rocksjni/flink_compactionfilterjni.cc + rocksjni/export_import_files_metadatajni.cc rocksjni/filter.cc + rocksjni/import_column_family_options.cc rocksjni/ingest_external_file_options.cc rocksjni/iterator.cc rocksjni/jnicallback.cc @@ -150,6 +152,7 @@ set(JAVA_MAIN_CLASSES src/main/java/org/rocksdb/EnvOptions.java src/main/java/org/rocksdb/EventListener.java src/main/java/org/rocksdb/Experimental.java + src/main/java/org/rocksdb/ExportImportFilesMetaData.java src/main/java/org/rocksdb/ExternalFileIngestionInfo.java src/main/java/org/rocksdb/Filter.java src/main/java/org/rocksdb/FileOperationInfo.java @@ -162,6 +165,7 @@ set(JAVA_MAIN_CLASSES src/main/java/org/rocksdb/HistogramData.java src/main/java/org/rocksdb/HistogramType.java src/main/java/org/rocksdb/Holder.java + src/main/java/org/rocksdb/ImportColumnFamilyOptions.java src/main/java/org/rocksdb/IndexShorteningMode.java src/main/java/org/rocksdb/IndexType.java src/main/java/org/rocksdb/InfoLogLevel.java diff --git a/java/Makefile b/java/Makefile index 69359733f..5f32dc7e5 100644 --- a/java/Makefile +++ b/java/Makefile @@ -140,6 +140,7 @@ JAVA_TESTS = \ org.rocksdb.util.JNIComparatorTest\ org.rocksdb.FilterTest\ org.rocksdb.FlushTest\ + org.rocksdb.ImportColumnFamilyTest\ org.rocksdb.InfoLogLevelTest\ org.rocksdb.KeyMayExistTest\ org.rocksdb.ConcurrentTaskLimiterTest\ diff --git a/java/rocksjni/checkpoint.cc b/java/rocksjni/checkpoint.cc index d7cfd813b..92db8400c 100644 --- a/java/rocksjni/checkpoint.cc +++ b/java/rocksjni/checkpoint.cc @@ -69,3 +69,44 @@ void Java_org_rocksdb_Checkpoint_createCheckpoint(JNIEnv* env, jobject /*jobj*/, ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, s); } } + +/* + * Class: org_rocksdb_Checkpoint + * Method: exportColumnFamily + * Signature: (JJLjava/lang/String;)Lorg/rocksdb/ExportImportFilesMetaData; + */ +jobject Java_org_rocksdb_Checkpoint_exportColumnFamily( + JNIEnv* env, jobject /*jobj*/, jlong jcheckpoint_handle, + jlong jcolumn_family_handle, jstring jexport_path) { + const char* export_path = env->GetStringUTFChars(jexport_path, 0); + if (export_path == nullptr) { + // exception thrown: OutOfMemoryError + return nullptr; + } + + auto* checkpoint = + reinterpret_cast(jcheckpoint_handle); + + auto* column_family_handle = + reinterpret_cast( + jcolumn_family_handle); + + ROCKSDB_NAMESPACE::ExportImportFilesMetaData* metadata = nullptr; + + ROCKSDB_NAMESPACE::Status s = checkpoint->ExportColumnFamily( + column_family_handle, export_path, &metadata); + + env->ReleaseStringUTFChars(jexport_path, export_path); + + if (!s.ok()) { + ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, s); + } + + jobject jexport_import_files_meta_data = nullptr; + if (metadata != nullptr) { + jexport_import_files_meta_data = + ROCKSDB_NAMESPACE::ExportImportFilesMetaDataJni:: + fromCppExportImportFilesMetaData(env, metadata); + } + return jexport_import_files_meta_data; +} diff --git a/java/rocksjni/export_import_files_metadatajni.cc b/java/rocksjni/export_import_files_metadatajni.cc new file mode 100644 index 000000000..a1de61933 --- /dev/null +++ b/java/rocksjni/export_import_files_metadatajni.cc @@ -0,0 +1,133 @@ +// Copyright (c) Meta Platforms, Inc. and affiliates. +// +// 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). + +#include "include/org_rocksdb_ExportImportFilesMetaData.h" +#include "include/org_rocksdb_LiveFileMetaData.h" +#include "rocksjni/portal.h" + +/* + * Class: org_rocksdb_ExportImportFilesMetaData + * Method: newExportImportFilesMetaDataHandle + * Signature: ([BI[J)J + */ +jlong Java_org_rocksdb_ExportImportFilesMetaData_newExportImportFilesMetaDataHandle( + JNIEnv* env, jobject, jbyteArray j_db_comparator_name, + jint j_db_comparator_name_len, jlongArray j_live_file_meta_data_array) { + std::string db_comparator_name; + jboolean has_exception = JNI_FALSE; + + if (j_db_comparator_name_len > 0) { + db_comparator_name = ROCKSDB_NAMESPACE::JniUtil::byteString( + env, j_db_comparator_name, j_db_comparator_name_len, + [](const char* str, const size_t len) { return std::string(str, len); }, + &has_exception); + if (has_exception == JNI_TRUE) { + // exception occurred + return 0; + } + } + + std::vector live_file_metas; + jlong* ptr_live_file_meta_data_array = + env->GetLongArrayElements(j_live_file_meta_data_array, nullptr); + if (ptr_live_file_meta_data_array == nullptr) { + // exception thrown: OutOfMemoryError + return 0; + } + const jsize array_size = env->GetArrayLength(j_live_file_meta_data_array); + for (jsize i = 0; i < array_size; ++i) { + auto* ptr_level_file_meta = + reinterpret_cast( + ptr_live_file_meta_data_array[i]); + live_file_metas.push_back(*ptr_level_file_meta); + } + + env->ReleaseLongArrayElements(j_live_file_meta_data_array, + ptr_live_file_meta_data_array, JNI_ABORT); + auto* export_import_files_meta_data = + new ROCKSDB_NAMESPACE::ExportImportFilesMetaData; + export_import_files_meta_data->db_comparator_name = db_comparator_name; + export_import_files_meta_data->files = live_file_metas; + return GET_CPLUSPLUS_POINTER(export_import_files_meta_data); +} + +/* + * Class: org_rocksdb_LiveFileMetaData + * Method: newLiveFileMetaDataHandle + * Signature: ([BIILjava/lang/String;Ljava/lang/String;JJJ[BI[BIJZJJ)J + */ +jlong Java_org_rocksdb_LiveFileMetaData_newLiveFileMetaDataHandle( + JNIEnv* env, jobject, jbyteArray j_column_family_name, + jint j_column_family_name_len, jint j_level, jstring j_file_name, + jstring j_path, jlong j_size, jlong j_smallest_seqno, jlong j_largest_seqno, + jbyteArray j_smallest_key, jint j_smallest_key_len, + jbyteArray j_largest_key, jint j_largest_key_len, jlong j_num_read_sampled, + jboolean j_being_compacted, jlong j_num_entries, jlong j_num_deletions) { + std::string column_family_name; + jboolean has_exception = JNI_FALSE; + + if (j_column_family_name_len > 0) { + column_family_name = ROCKSDB_NAMESPACE::JniUtil::byteString( + env, j_column_family_name, j_column_family_name_len, + [](const char* str, const size_t len) { return std::string(str, len); }, + &has_exception); + if (has_exception == JNI_TRUE) { + // exception occurred + return 0; + } + } + + const char* file_name = env->GetStringUTFChars(j_file_name, nullptr); + if (file_name == nullptr) { + // exception thrown: OutOfMemoryError + return 0; + } + + const char* path = env->GetStringUTFChars(j_path, nullptr); + if (path == nullptr) { + // exception thrown: OutOfMemoryError + return 0; + } + + std::string smallest_key; + if (j_smallest_key_len > 0) { + smallest_key = ROCKSDB_NAMESPACE::JniUtil::byteString( + env, j_smallest_key, j_smallest_key_len, + [](const char* str, const size_t len) { return std::string(str, len); }, + &has_exception); + if (has_exception == JNI_TRUE) { + // exception occurred + return 0; + } + } + + std::string largest_key; + if (j_largest_key_len > 0) { + largest_key = ROCKSDB_NAMESPACE::JniUtil::byteString( + env, j_largest_key, j_largest_key_len, + [](const char* str, const size_t len) { return std::string(str, len); }, + &has_exception); + if (has_exception == JNI_TRUE) { + // exception occurred + return 0; + } + } + auto* live_file_meta = new ROCKSDB_NAMESPACE::LiveFileMetaData; + live_file_meta->column_family_name = column_family_name; + live_file_meta->level = static_cast(j_level); + live_file_meta->db_path = path; + live_file_meta->name = file_name; + live_file_meta->size = j_size; + live_file_meta->smallest_seqno = j_smallest_seqno; + live_file_meta->largest_seqno = j_largest_seqno; + live_file_meta->smallestkey = smallest_key; + live_file_meta->largestkey = largest_key; + live_file_meta->num_reads_sampled = j_num_read_sampled; + live_file_meta->being_compacted = j_being_compacted; + live_file_meta->num_entries = j_num_entries; + live_file_meta->num_deletions = j_num_deletions; + return GET_CPLUSPLUS_POINTER(live_file_meta); +} diff --git a/java/rocksjni/import_column_family_options.cc b/java/rocksjni/import_column_family_options.cc new file mode 100644 index 000000000..1a9bded51 --- /dev/null +++ b/java/rocksjni/import_column_family_options.cc @@ -0,0 +1,59 @@ +// Copyright (c) Meta Platforms, Inc. and affiliates. +// +// 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). + +#include + +#include "include/org_rocksdb_ImportColumnFamilyOptions.h" +#include "rocksdb/options.h" +#include "rocksjni/cplusplus_to_java_convert.h" + +/* + * Class: org_rocksdb_ImportColumnFamilyOptions + * Method: newImportColumnFamilyOptions + * Signature: ()J + */ +jlong Java_org_rocksdb_ImportColumnFamilyOptions_newImportColumnFamilyOptions( + JNIEnv *, jclass) { + ROCKSDB_NAMESPACE::ImportColumnFamilyOptions *opts = + new ROCKSDB_NAMESPACE::ImportColumnFamilyOptions(); + return GET_CPLUSPLUS_POINTER(opts); +} + +/* + * Class: org_rocksdb_ImportColumnFamilyOptions + * Method: setMoveFiles + * Signature: (JZ)V + */ +void Java_org_rocksdb_ImportColumnFamilyOptions_setMoveFiles( + JNIEnv *, jobject, jlong jhandle, jboolean jmove_files) { + auto *options = + reinterpret_cast(jhandle); + options->move_files = static_cast(jmove_files); +} + +/* + * Class: org_rocksdb_ImportColumnFamilyOptions + * Method: moveFiles + * Signature: (J)Z + */ +jboolean Java_org_rocksdb_ImportColumnFamilyOptions_moveFiles(JNIEnv *, jobject, + jlong jhandle) { + auto *options = + reinterpret_cast(jhandle); + return static_cast(options->move_files); +} + +/* + * Class: org_rocksdb_ImportColumnFamilyOptions + * Method: disposeInternal + * Signature: (J)V + */ +void Java_org_rocksdb_ImportColumnFamilyOptions_disposeInternal(JNIEnv *, + jobject, + jlong jhandle) { + delete reinterpret_cast( + jhandle); +} \ No newline at end of file diff --git a/java/rocksjni/portal.h b/java/rocksjni/portal.h index f75e002b8..fc9763195 100644 --- a/java/rocksjni/portal.h +++ b/java/rocksjni/portal.h @@ -7548,6 +7548,84 @@ class LevelMetaDataJni : public JavaClass { } }; +class ExportImportFilesMetaDataJni : public JavaClass { + public: + /** + * Create a new Java org.rocksdb.ExportImportFilesMetaData object. + * + * @param env A pointer to the Java environment + * @param export_import_files_meta_data A Cpp export import files meta data + * object + * + * @return A reference to a Java org.rocksdb.ExportImportFilesMetaData object, + * or nullptr if an an exception occurs + */ + static jobject fromCppExportImportFilesMetaData( + JNIEnv* env, ROCKSDB_NAMESPACE::ExportImportFilesMetaData* + export_import_files_meta_data) { + jclass jclazz = getJClass(env); + if (jclazz == nullptr) { + // exception occurred accessing class + return nullptr; + } + + jmethodID mid = env->GetMethodID(jclazz, "", + "([B[Lorg/rocksdb/LiveFileMetaData;)V"); + if (mid == nullptr) { + // exception thrown: NoSuchMethodException or OutOfMemoryError + return nullptr; + } + + jbyteArray jdb_comparator_name = ROCKSDB_NAMESPACE::JniUtil::copyBytes( + env, export_import_files_meta_data->db_comparator_name); + if (jdb_comparator_name == nullptr) { + // exception occurred creating java byte array + return nullptr; + } + + const jsize jlen = + static_cast(export_import_files_meta_data->files.size()); + jobjectArray jfiles = + env->NewObjectArray(jlen, LiveFileMetaDataJni::getJClass(env), nullptr); + if (jfiles == nullptr) { + // exception thrown: OutOfMemoryError + return nullptr; + } + + jsize i = 0; + for (auto it = export_import_files_meta_data->files.begin(); + it != export_import_files_meta_data->files.end(); ++it) { + jobject jfile = LiveFileMetaDataJni::fromCppLiveFileMetaData(env, &(*it)); + if (jfile == nullptr) { + // exception occurred + env->DeleteLocalRef(jdb_comparator_name); + env->DeleteLocalRef(jfiles); + return nullptr; + } + env->SetObjectArrayElement(jfiles, i++, jfile); + } + + jobject jexport_import_files_meta_data = + env->NewObject(jclazz, mid, jdb_comparator_name, jfiles); + + if (env->ExceptionCheck()) { + env->DeleteLocalRef(jdb_comparator_name); + env->DeleteLocalRef(jfiles); + return nullptr; + } + + // cleanup + env->DeleteLocalRef(jdb_comparator_name); + env->DeleteLocalRef(jfiles); + + return jexport_import_files_meta_data; + } + + static jclass getJClass(JNIEnv* env) { + return JavaClass::getJClass(env, "org/rocksdb/ExportImportFilesMetaData"); + } +}; + class ColumnFamilyMetaDataJni : public JavaClass { public: /** diff --git a/java/rocksjni/rocksjni.cc b/java/rocksjni/rocksjni.cc index ced72e841..8c2b999e0 100644 --- a/java/rocksjni/rocksjni.cc +++ b/java/rocksjni/rocksjni.cc @@ -489,6 +489,63 @@ jlongArray Java_org_rocksdb_RocksDB_createColumnFamilies__J_3J_3_3B( return jcf_handles; } +/* + * Class: org_rocksdb_RocksDB + * Method: createColumnFamilyWithImport + * Signature: (J[BIJJ[J)J + */ +jlong Java_org_rocksdb_RocksDB_createColumnFamilyWithImport( + JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jcf_name, + jint jcf_name_len, jlong j_cf_options, jlong j_cf_import_options, + jlongArray j_metadata_handle_array) { + auto* db = reinterpret_cast(jdb_handle); + jboolean has_exception = JNI_FALSE; + const std::string cf_name = + ROCKSDB_NAMESPACE::JniUtil::byteString( + env, jcf_name, jcf_name_len, + [](const char* str, const size_t len) { + return std::string(str, len); + }, + &has_exception); + if (has_exception == JNI_TRUE) { + // exception occurred + return 0; + } + auto* cf_options = + reinterpret_cast(j_cf_options); + + auto* cf_import_options = + reinterpret_cast( + j_cf_import_options); + + std::vector metadatas; + jlong* ptr_metadata_handle_array = + env->GetLongArrayElements(j_metadata_handle_array, nullptr); + if (j_metadata_handle_array == nullptr) { + // exception thrown: OutOfMemoryError + return 0; + } + const jsize array_size = env->GetArrayLength(j_metadata_handle_array); + for (jsize i = 0; i < array_size; ++i) { + const ROCKSDB_NAMESPACE::ExportImportFilesMetaData* metadata_ptr = + reinterpret_cast( + ptr_metadata_handle_array[i]); + metadatas.push_back(metadata_ptr); + } + env->ReleaseLongArrayElements(j_metadata_handle_array, + ptr_metadata_handle_array, JNI_ABORT); + + ROCKSDB_NAMESPACE::ColumnFamilyHandle* cf_handle = nullptr; + ROCKSDB_NAMESPACE::Status s = db->CreateColumnFamilyWithImport( + *cf_options, cf_name, *cf_import_options, metadatas, &cf_handle); + if (!s.ok()) { + // error occurred + ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, s); + return 0; + } + return GET_CPLUSPLUS_POINTER(cf_handle); +} + /* * Class: org_rocksdb_RocksDB * Method: dropColumnFamily diff --git a/java/src/main/java/org/rocksdb/Checkpoint.java b/java/src/main/java/org/rocksdb/Checkpoint.java index c9b3886c0..318d11c64 100644 --- a/java/src/main/java/org/rocksdb/Checkpoint.java +++ b/java/src/main/java/org/rocksdb/Checkpoint.java @@ -5,6 +5,8 @@ package org.rocksdb; +import java.util.*; + /** * Provides Checkpoint functionality. Checkpoints * provide persistent snapshots of RocksDB databases. @@ -50,6 +52,11 @@ public void createCheckpoint(final String checkpointPath) createCheckpoint(nativeHandle_, checkpointPath); } + public ExportImportFilesMetaData exportColumnFamily(final ColumnFamilyHandle columnFamilyHandle, + final String exportPath) throws RocksDBException { + return exportColumnFamily(nativeHandle_, columnFamilyHandle.nativeHandle_, exportPath); + } + private Checkpoint(final RocksDB db) { super(newCheckpoint(db.nativeHandle_)); } @@ -59,4 +66,7 @@ private Checkpoint(final RocksDB db) { private native void createCheckpoint(long handle, String checkpointPath) throws RocksDBException; + + private native ExportImportFilesMetaData exportColumnFamily( + long handle, long columnFamilyHandle, String exportPath) throws RocksDBException; } diff --git a/java/src/main/java/org/rocksdb/ExportImportFilesMetaData.java b/java/src/main/java/org/rocksdb/ExportImportFilesMetaData.java new file mode 100644 index 000000000..30892fc1e --- /dev/null +++ b/java/src/main/java/org/rocksdb/ExportImportFilesMetaData.java @@ -0,0 +1,56 @@ +// Copyright (c) Meta Platforms, Inc. and affiliates. +// +// 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). + +package org.rocksdb; + +import java.util.Arrays; +import java.util.List; + +/** + * The metadata that describes a column family. + */ +public class ExportImportFilesMetaData { + private final byte[] dbComparatorName; + private final LiveFileMetaData[] files; + + /** + * Called from JNI C++ + */ + public ExportImportFilesMetaData(final byte[] dbComparatorName, final LiveFileMetaData[] files) { + this.dbComparatorName = dbComparatorName; + this.files = files; + } + + /** + * The name of the db comparator. + * + * @return the dbComparatorName + */ + public byte[] dbComparatorName() { + return dbComparatorName; + } + + /** + * The metadata of all files in this column family. + * + * @return the levels files + */ + public List files() { + return Arrays.asList(files); + } + + public long newExportImportFilesMetaDataHandle() { + final long[] liveFileMetaDataHandles = new long[files.length]; + for (int i = 0; i < files.length; i++) { + liveFileMetaDataHandles[i] = files[i].newLiveFileMetaDataHandle(); + } + return newExportImportFilesMetaDataHandle( + dbComparatorName, dbComparatorName.length, liveFileMetaDataHandles); + } + + private native long newExportImportFilesMetaDataHandle(final byte[] dbComparatorName, + final int dbComparatorNameLen, final long[] liveFileMetaDataHandles); +} diff --git a/java/src/main/java/org/rocksdb/ImportColumnFamilyOptions.java b/java/src/main/java/org/rocksdb/ImportColumnFamilyOptions.java new file mode 100644 index 000000000..acd89e92b --- /dev/null +++ b/java/src/main/java/org/rocksdb/ImportColumnFamilyOptions.java @@ -0,0 +1,46 @@ +// Copyright (c) Meta Platforms, Inc. and affiliates. +// +// 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). + +package org.rocksdb; + +/** + * ImportColumnFamilyOptions is used by ImportColumnFamily() + *

+ * Note that dispose() must be called before this instance become out-of-scope + * to release the allocated memory in c++. + * + */ +public class ImportColumnFamilyOptions extends RocksObject { + public ImportColumnFamilyOptions() { + super(newImportColumnFamilyOptions()); + } + + /** + * Can be set to true to move the files instead of copying them. + * + * @return true if files will be moved + */ + public boolean moveFiles() { + return moveFiles(nativeHandle_); + } + + /** + * Can be set to true to move the files instead of copying them. + * + * @param moveFiles true if files should be moved instead of copied + * + * @return the reference to the current IngestExternalFileOptions. + */ + public ImportColumnFamilyOptions setMoveFiles(final boolean moveFiles) { + setMoveFiles(nativeHandle_, moveFiles); + return this; + } + + private static native long newImportColumnFamilyOptions(); + private native boolean moveFiles(final long handle); + private native void setMoveFiles(final long handle, final boolean move_files); + @Override protected final native void disposeInternal(final long handle); +} diff --git a/java/src/main/java/org/rocksdb/LiveFileMetaData.java b/java/src/main/java/org/rocksdb/LiveFileMetaData.java index 35d883e18..239dbf662 100644 --- a/java/src/main/java/org/rocksdb/LiveFileMetaData.java +++ b/java/src/main/java/org/rocksdb/LiveFileMetaData.java @@ -52,4 +52,18 @@ public byte[] columnFamilyName() { public int level() { return level; } + + public long newLiveFileMetaDataHandle() { + return newLiveFileMetaDataHandle(columnFamilyName(), columnFamilyName().length, level(), + fileName(), path(), size(), smallestSeqno(), largestSeqno(), smallestKey(), + smallestKey().length, largestKey(), largestKey().length, numReadsSampled(), + beingCompacted(), numEntries(), numDeletions()); + } + + private native long newLiveFileMetaDataHandle(final byte[] columnFamilyName, + final int columnFamilyNameLength, final int level, final String fileName, final String path, + final long size, final long smallestSeqno, final long largestSeqno, final byte[] smallestKey, + final int smallestKeyLength, final byte[] largestKey, final int largestKeyLength, + final long numReadsSampled, final boolean beingCompacted, final long numEntries, + final long numDeletions); } diff --git a/java/src/main/java/org/rocksdb/RocksDB.java b/java/src/main/java/org/rocksdb/RocksDB.java index fb35208bc..f46cf6846 100644 --- a/java/src/main/java/org/rocksdb/RocksDB.java +++ b/java/src/main/java/org/rocksdb/RocksDB.java @@ -749,6 +749,58 @@ public List createColumnFamilies( return columnFamilyHandles; } + /** + * Creates a new column family with the name columnFamilyName and + * import external SST files specified in `metadata` allocates a + * ColumnFamilyHandle within an internal structure. + * The ColumnFamilyHandle is automatically disposed with DB disposal. + * + * @param columnFamilyDescriptor column family to be created. + * @return {@link org.rocksdb.ColumnFamilyHandle} instance. + * + * @throws RocksDBException thrown if error happens in underlying + * native library. + */ + /** + * Creates a new column family with the name columnFamilyName and + * import external SST files specified in `metadata` allocates a + * ColumnFamilyHandle within an internal structure. + * The ColumnFamilyHandle is automatically disposed with DB disposal. + * + * @param columnFamilyDescriptor column family to be created. + * @return {@link org.rocksdb.ColumnFamilyHandle} instance. + * + * @throws RocksDBException thrown if error happens in underlying + * native library. + */ + public ColumnFamilyHandle createColumnFamilyWithImport( + final ColumnFamilyDescriptor columnFamilyDescriptor, + final ImportColumnFamilyOptions importColumnFamilyOptions, + final ExportImportFilesMetaData metadata) throws RocksDBException { + List metadatas = new ArrayList<>(); + metadatas.add(metadata); + return createColumnFamilyWithImport( + columnFamilyDescriptor, importColumnFamilyOptions, metadatas); + } + + public ColumnFamilyHandle createColumnFamilyWithImport( + final ColumnFamilyDescriptor columnFamilyDescriptor, + final ImportColumnFamilyOptions importColumnFamilyOptions, + final List metadatas) throws RocksDBException { + final int metadataNum = metadatas.size(); + final long[] metadataHandeList = new long[metadataNum]; + for (int i = 0; i < metadataNum; i++) { + metadataHandeList[i] = metadatas.get(i).newExportImportFilesMetaDataHandle(); + } + final ColumnFamilyHandle columnFamilyHandle = new ColumnFamilyHandle(this, + createColumnFamilyWithImport(nativeHandle_, columnFamilyDescriptor.getName(), + columnFamilyDescriptor.getName().length, + columnFamilyDescriptor.getOptions().nativeHandle_, + importColumnFamilyOptions.nativeHandle_, metadataHandeList)); + ownedColumnFamilyHandles.add(columnFamilyHandle); + return columnFamilyHandle; + } + /** * Drops the column family specified by {@code columnFamilyHandle}. This call * only records a drop record in the manifest and prevents the column @@ -4394,6 +4446,9 @@ private native long[] createColumnFamilies(final long handle, private native long[] createColumnFamilies( final long handle, final long[] columnFamilyOptionsHandles, final byte[][] columnFamilyNames) throws RocksDBException; + private native long createColumnFamilyWithImport(final long handle, final byte[] columnFamilyName, + final int columnFamilyNamelen, final long columnFamilyOptions, + final long importColumnFamilyOptions, final long[] metadataHandeList) throws RocksDBException; private native void dropColumnFamily( final long handle, final long cfHandle) throws RocksDBException; private native void dropColumnFamilies(final long handle, diff --git a/java/src/test/java/org/rocksdb/CheckPointTest.java b/java/src/test/java/org/rocksdb/CheckPointTest.java index 2b3cc7a3b..744d96f5c 100644 --- a/java/src/test/java/org/rocksdb/CheckPointTest.java +++ b/java/src/test/java/org/rocksdb/CheckPointTest.java @@ -57,6 +57,30 @@ public void checkPoint() throws RocksDBException { } } + @Test + public void exportColumnFamily() throws RocksDBException { + try (final Options options = new Options().setCreateIfMissing(true)) { + try (final RocksDB db = RocksDB.open(options, dbFolder.getRoot().getAbsolutePath())) { + db.put("key".getBytes(), "value".getBytes()); + try (final Checkpoint checkpoint = Checkpoint.create(db)) { + ExportImportFilesMetaData metadata1 = + checkpoint.exportColumnFamily(db.getDefaultColumnFamily(), + checkpointFolder.getRoot().getAbsolutePath() + "/export_column_family1"); + assertThat(metadata1.files().size()).isEqualTo(1); + assertThat(metadata1.dbComparatorName()) + .isEqualTo("leveldb.BytewiseComparator".getBytes()); + db.put("key2".getBytes(), "value2".getBytes()); + ExportImportFilesMetaData metadata2 = + checkpoint.exportColumnFamily(db.getDefaultColumnFamily(), + checkpointFolder.getRoot().getAbsolutePath() + "/export_column_family2"); + assertThat(metadata2.files().size()).isEqualTo(2); + assertThat(metadata2.dbComparatorName()) + .isEqualTo("leveldb.BytewiseComparator".getBytes()); + } + } + } + } + @Test(expected = IllegalArgumentException.class) public void failIfDbIsNull() { try (final Checkpoint ignored = Checkpoint.create(null)) { diff --git a/java/src/test/java/org/rocksdb/ImportColumnFamilyTest.java b/java/src/test/java/org/rocksdb/ImportColumnFamilyTest.java new file mode 100644 index 000000000..476900601 --- /dev/null +++ b/java/src/test/java/org/rocksdb/ImportColumnFamilyTest.java @@ -0,0 +1,96 @@ +// Copyright (c) Meta Platforms, Inc. and affiliates. +// +// 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). + +package org.rocksdb; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.fail; + +import java.io.File; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; +import org.rocksdb.util.BytewiseComparator; + +public class ImportColumnFamilyTest { + private static final String SST_FILE_NAME = "test.sst"; + private static final String DB_DIRECTORY_NAME = "test_db"; + + @ClassRule + public static final RocksNativeLibraryResource ROCKS_NATIVE_LIBRARY_RESOURCE = + new RocksNativeLibraryResource(); + + @Rule public TemporaryFolder dbFolder = new TemporaryFolder(); + + @Rule public TemporaryFolder checkpointFolder = new TemporaryFolder(); + + @Test + public void testImportColumnFamily() throws RocksDBException { + try (final Options options = new Options().setCreateIfMissing(true)) { + try (final RocksDB db = RocksDB.open(options, dbFolder.getRoot().getAbsolutePath())) { + db.put("key".getBytes(), "value".getBytes()); + db.put("key1".getBytes(), "value1".getBytes()); + + try (final Checkpoint checkpoint = Checkpoint.create(db)) { + ExportImportFilesMetaData default_cf_metadata = + checkpoint.exportColumnFamily(db.getDefaultColumnFamily(), + checkpointFolder.getRoot().getAbsolutePath() + "/default_cf_metadata"); + ColumnFamilyDescriptor columnFamilyDescriptor = + new ColumnFamilyDescriptor("new_cf".getBytes()); + ImportColumnFamilyOptions importColumnFamilyOptions = new ImportColumnFamilyOptions(); + final ColumnFamilyHandle importCfHandle = db.createColumnFamilyWithImport( + columnFamilyDescriptor, importColumnFamilyOptions, default_cf_metadata); + assertThat(db.get(importCfHandle, "key".getBytes())).isEqualTo("value".getBytes()); + assertThat(db.get(importCfHandle, "key1".getBytes())).isEqualTo("value1".getBytes()); + } + } + } + } + + @Test + public void ImportMultiColumnFamilyTest() throws RocksDBException { + try (final Options options = new Options().setCreateIfMissing(true)) { + try (final RocksDB db1 = RocksDB.open(options, dbFolder.getRoot().getAbsolutePath() + "db1"); + final RocksDB db2 = + RocksDB.open(options, dbFolder.getRoot().getAbsolutePath() + "db2");) { + db1.put("key".getBytes(), "value".getBytes()); + db1.put("key1".getBytes(), "value1".getBytes()); + db2.put("key2".getBytes(), "value2".getBytes()); + db2.put("key3".getBytes(), "value3".getBytes()); + try (final Checkpoint checkpoint1 = Checkpoint.create(db1); + final Checkpoint checkpoint2 = Checkpoint.create(db2);) { + ExportImportFilesMetaData default_cf_metadata1 = + checkpoint1.exportColumnFamily(db1.getDefaultColumnFamily(), + checkpointFolder.getRoot().getAbsolutePath() + "/default_cf_metadata1"); + ExportImportFilesMetaData default_cf_metadata2 = + checkpoint2.exportColumnFamily(db2.getDefaultColumnFamily(), + checkpointFolder.getRoot().getAbsolutePath() + "/default_cf_metadata2"); + + ColumnFamilyDescriptor columnFamilyDescriptor = + new ColumnFamilyDescriptor("new_cf".getBytes()); + ImportColumnFamilyOptions importColumnFamilyOptions = new ImportColumnFamilyOptions(); + + List importMetaDatas = new ArrayList(); + importMetaDatas.add(default_cf_metadata1); + importMetaDatas.add(default_cf_metadata2); + + final ColumnFamilyHandle importCfHandle = db1.createColumnFamilyWithImport( + columnFamilyDescriptor, importColumnFamilyOptions, importMetaDatas); + assertThat(db1.get(importCfHandle, "key".getBytes())).isEqualTo("value".getBytes()); + assertThat(db1.get(importCfHandle, "key1".getBytes())).isEqualTo("value1".getBytes()); + assertThat(db1.get(importCfHandle, "key2".getBytes())).isEqualTo("value2".getBytes()); + assertThat(db1.get(importCfHandle, "key3".getBytes())).isEqualTo("value3".getBytes()); + } + } + } + } +} diff --git a/src.mk b/src.mk index 629fca047..8ef691668 100644 --- a/src.mk +++ b/src.mk @@ -658,11 +658,13 @@ JNI_NATIVE_SOURCES = \ java/rocksjni/compression_options.cc \ java/rocksjni/concurrent_task_limiter.cc \ java/rocksjni/config_options.cc \ + java/rocksjni/export_import_files_metadatajni.cc \ java/rocksjni/env.cc \ java/rocksjni/env_options.cc \ java/rocksjni/event_listener.cc \ java/rocksjni/event_listener_jnicallback.cc \ java/rocksjni/flink_compactionfilterjni.cc \ + java/rocksjni/import_column_family_options.cc \ java/rocksjni/ingest_external_file_options.cc \ java/rocksjni/filter.cc \ java/rocksjni/iterator.cc \ From e7b6d68b6eca99f0f8780d30889e45e80df07ab0 Mon Sep 17 00:00:00 2001 From: Zakelly Date: Wed, 6 Mar 2024 14:17:12 +0800 Subject: [PATCH 14/61] [build] Setting up templates for issues and PRs (#1) --- .github/ISSUE_TEMPLATE/bug_report.md | 29 ++++++++++++++++++ .github/ISSUE_TEMPLATE/config.yml | 8 +++++ .github/ISSUE_TEMPLATE/work_item.md | 20 +++++++++++++ .github/pull_request_template.md | 44 ++++++++++++++++++++++++++++ issue_template.md | 7 ----- 5 files changed, 101 insertions(+), 7 deletions(-) create mode 100644 .github/ISSUE_TEMPLATE/bug_report.md create mode 100644 .github/ISSUE_TEMPLATE/config.yml create mode 100644 .github/ISSUE_TEMPLATE/work_item.md create mode 100644 .github/pull_request_template.md delete mode 100644 issue_template.md diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 000000000..044c642ce --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,29 @@ +--- +name: Bug report +about: Create a report to help us improve +title: '' +labels: bug +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Steps to reproduce the behavior: +1. Compile '...' +2. Run '....' +3. See error + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Desktop (please complete the following information):** + - OS: [e.g. CentOS 7.8] + +**Additional context** +Add any other context about the problem here. diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 000000000..e3e7745a4 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,8 @@ +blank_issues_enabled: false +contact_links: + - name: Have questions + url: https://github.com/ververica/ForSt/discussions/categories/q-a + about: Please ask and answer questions here. + - name: New Ideas + url: https://github.com/ververica/ForSt/discussions/categories/ideas + about: Please suggest your new ideas here. \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/work_item.md b/.github/ISSUE_TEMPLATE/work_item.md new file mode 100644 index 000000000..d3dea472d --- /dev/null +++ b/.github/ISSUE_TEMPLATE/work_item.md @@ -0,0 +1,20 @@ +--- +name: Work Item +about: Suggest/Log a work item (For big ideas and proposals, please go to New Ideas) +title: '' +labels: '' +assignees: '' + +--- + +**What is this for** +A clear and concise description of what the item is. + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 000000000..9429374eb --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,44 @@ + + +## What is the purpose of the change + +*(For example: This pull request enables caching all the java classes that will be frequently used.)* + + +## Brief change log + +*(for example:)* + - *A global cache container* + - *Cache entries for each objects* + + +## Verifying this change + +*(Please pick either of the following options)* + +This change is a trivial rework / code cleanup without any test coverage. + +*(or)* + +This change is already covered by existing tests, such as *(please describe tests)*. + +*(or)* + +This change added tests and can be verified as follows: + +*(example:)* + - *first step* + - *second step* + - *third step, and xxx behaves as expected* \ No newline at end of file diff --git a/issue_template.md b/issue_template.md deleted file mode 100644 index ca52f5ead..000000000 --- a/issue_template.md +++ /dev/null @@ -1,7 +0,0 @@ -> Note: Please use Issues only for bug reports. For questions, discussions, feature requests, etc. post to dev group: https://groups.google.com/forum/#!forum/rocksdb or https://www.facebook.com/groups/rocksdb.dev - -### Expected behavior - -### Actual behavior - -### Steps to reproduce the behavior From 6f910e2772e770bbeab87bd417dd5e88a6b91019 Mon Sep 17 00:00:00 2001 From: Zakelly Date: Thu, 7 Mar 2024 12:05:10 +0800 Subject: [PATCH 15/61] [build] Remove buckify output in sanity check (#3) This fixes #2 --- .github/workflows/sanity_check.yml | 5 +- TARGETS | 5612 ---------------------------- 2 files changed, 1 insertion(+), 5616 deletions(-) delete mode 100644 TARGETS diff --git a/.github/workflows/sanity_check.yml b/.github/workflows/sanity_check.yml index efc9d99cf..093b2e230 100644 --- a/.github/workflows/sanity_check.yml +++ b/.github/workflows/sanity_check.yml @@ -38,8 +38,5 @@ jobs: - name: Check format run: VERBOSE_CHECK=1 make check-format - - name: Compare buckify output - run: make check-buck-targets - - name: Simple source code checks - run: make check-sources + run: make check-sources \ No newline at end of file diff --git a/TARGETS b/TARGETS deleted file mode 100644 index d334291f3..000000000 --- a/TARGETS +++ /dev/null @@ -1,5612 +0,0 @@ -# This file @generated by: -#$ python3 buckifier/buckify_rocksdb.py -# --> DO NOT EDIT MANUALLY <-- -# This file is a Facebook-specific integration for buck builds, so can -# only be validated by Facebook employees. -# -# @noautodeps @nocodemods -load("//rocks/buckifier:defs.bzl", "cpp_library_wrapper","rocks_cpp_library_wrapper","cpp_binary_wrapper","cpp_unittest_wrapper","fancy_bench_wrapper","add_c_test_wrapper") - - -cpp_library_wrapper(name="rocksdb_lib", srcs=[ - "cache/cache.cc", - "cache/cache_entry_roles.cc", - "cache/cache_helpers.cc", - "cache/cache_key.cc", - "cache/cache_reservation_manager.cc", - "cache/charged_cache.cc", - "cache/clock_cache.cc", - "cache/compressed_secondary_cache.cc", - "cache/lru_cache.cc", - "cache/secondary_cache.cc", - "cache/secondary_cache_adapter.cc", - "cache/sharded_cache.cc", - "db/arena_wrapped_db_iter.cc", - "db/blob/blob_contents.cc", - "db/blob/blob_fetcher.cc", - "db/blob/blob_file_addition.cc", - "db/blob/blob_file_builder.cc", - "db/blob/blob_file_cache.cc", - "db/blob/blob_file_garbage.cc", - "db/blob/blob_file_meta.cc", - "db/blob/blob_file_reader.cc", - "db/blob/blob_garbage_meter.cc", - "db/blob/blob_log_format.cc", - "db/blob/blob_log_sequential_reader.cc", - "db/blob/blob_log_writer.cc", - "db/blob/blob_source.cc", - "db/blob/prefetch_buffer_collection.cc", - "db/builder.cc", - "db/c.cc", - "db/column_family.cc", - "db/compaction/compaction.cc", - "db/compaction/compaction_iterator.cc", - "db/compaction/compaction_job.cc", - "db/compaction/compaction_outputs.cc", - "db/compaction/compaction_picker.cc", - "db/compaction/compaction_picker_fifo.cc", - "db/compaction/compaction_picker_level.cc", - "db/compaction/compaction_picker_universal.cc", - "db/compaction/compaction_service_job.cc", - "db/compaction/compaction_state.cc", - "db/compaction/sst_partitioner.cc", - "db/compaction/subcompaction_state.cc", - "db/convenience.cc", - "db/db_filesnapshot.cc", - "db/db_impl/compacted_db_impl.cc", - "db/db_impl/db_impl.cc", - "db/db_impl/db_impl_compaction_flush.cc", - "db/db_impl/db_impl_debug.cc", - "db/db_impl/db_impl_experimental.cc", - "db/db_impl/db_impl_files.cc", - "db/db_impl/db_impl_open.cc", - "db/db_impl/db_impl_readonly.cc", - "db/db_impl/db_impl_secondary.cc", - "db/db_impl/db_impl_write.cc", - "db/db_info_dumper.cc", - "db/db_iter.cc", - "db/dbformat.cc", - "db/error_handler.cc", - "db/event_helpers.cc", - "db/experimental.cc", - "db/external_sst_file_ingestion_job.cc", - "db/file_indexer.cc", - "db/flush_job.cc", - "db/flush_scheduler.cc", - "db/forward_iterator.cc", - "db/import_column_family_job.cc", - "db/internal_stats.cc", - "db/log_reader.cc", - "db/log_writer.cc", - "db/logs_with_prep_tracker.cc", - "db/malloc_stats.cc", - "db/memtable.cc", - "db/memtable_list.cc", - "db/merge_helper.cc", - "db/merge_operator.cc", - "db/output_validator.cc", - "db/periodic_task_scheduler.cc", - "db/range_del_aggregator.cc", - "db/range_tombstone_fragmenter.cc", - "db/repair.cc", - "db/seqno_to_time_mapping.cc", - "db/snapshot_impl.cc", - "db/table_cache.cc", - "db/table_properties_collector.cc", - "db/transaction_log_impl.cc", - "db/trim_history_scheduler.cc", - "db/version_builder.cc", - "db/version_edit.cc", - "db/version_edit_handler.cc", - "db/version_set.cc", - "db/wal_edit.cc", - "db/wal_manager.cc", - "db/wide/wide_column_serialization.cc", - "db/wide/wide_columns.cc", - "db/write_batch.cc", - "db/write_batch_base.cc", - "db/write_controller.cc", - "db/write_stall_stats.cc", - "db/write_thread.cc", - "env/composite_env.cc", - "env/env.cc", - "env/env_chroot.cc", - "env/env_encryption.cc", - "env/env_posix.cc", - "env/file_system.cc", - "env/file_system_tracer.cc", - "env/fs_posix.cc", - "env/fs_remap.cc", - "env/io_posix.cc", - "env/mock_env.cc", - "env/unique_id_gen.cc", - "file/delete_scheduler.cc", - "file/file_prefetch_buffer.cc", - "file/file_util.cc", - "file/filename.cc", - "file/line_file_reader.cc", - "file/random_access_file_reader.cc", - "file/read_write_util.cc", - "file/readahead_raf.cc", - "file/sequence_file_reader.cc", - "file/sst_file_manager_impl.cc", - "file/writable_file_writer.cc", - "logging/auto_roll_logger.cc", - "logging/event_logger.cc", - "logging/log_buffer.cc", - "memory/arena.cc", - "memory/concurrent_arena.cc", - "memory/jemalloc_nodump_allocator.cc", - "memory/memkind_kmem_allocator.cc", - "memory/memory_allocator.cc", - "memtable/alloc_tracker.cc", - "memtable/hash_linklist_rep.cc", - "memtable/hash_skiplist_rep.cc", - "memtable/skiplistrep.cc", - "memtable/vectorrep.cc", - "memtable/write_buffer_manager.cc", - "monitoring/histogram.cc", - "monitoring/histogram_windowing.cc", - "monitoring/in_memory_stats_history.cc", - "monitoring/instrumented_mutex.cc", - "monitoring/iostats_context.cc", - "monitoring/perf_context.cc", - "monitoring/perf_level.cc", - "monitoring/persistent_stats_history.cc", - "monitoring/statistics.cc", - "monitoring/thread_status_impl.cc", - "monitoring/thread_status_updater.cc", - "monitoring/thread_status_updater_debug.cc", - "monitoring/thread_status_util.cc", - "monitoring/thread_status_util_debug.cc", - "options/cf_options.cc", - "options/configurable.cc", - "options/customizable.cc", - "options/db_options.cc", - "options/options.cc", - "options/options_helper.cc", - "options/options_parser.cc", - "port/mmap.cc", - "port/port_posix.cc", - "port/stack_trace.cc", - "port/win/env_default.cc", - "port/win/env_win.cc", - "port/win/io_win.cc", - "port/win/port_win.cc", - "port/win/win_logger.cc", - "port/win/win_thread.cc", - "table/adaptive/adaptive_table_factory.cc", - "table/block_based/binary_search_index_reader.cc", - "table/block_based/block.cc", - "table/block_based/block_based_table_builder.cc", - "table/block_based/block_based_table_factory.cc", - "table/block_based/block_based_table_iterator.cc", - "table/block_based/block_based_table_reader.cc", - "table/block_based/block_builder.cc", - "table/block_based/block_cache.cc", - "table/block_based/block_prefetcher.cc", - "table/block_based/block_prefix_index.cc", - "table/block_based/data_block_footer.cc", - "table/block_based/data_block_hash_index.cc", - "table/block_based/filter_block_reader_common.cc", - "table/block_based/filter_policy.cc", - "table/block_based/flush_block_policy.cc", - "table/block_based/full_filter_block.cc", - "table/block_based/hash_index_reader.cc", - "table/block_based/index_builder.cc", - "table/block_based/index_reader_common.cc", - "table/block_based/parsed_full_filter_block.cc", - "table/block_based/partitioned_filter_block.cc", - "table/block_based/partitioned_index_iterator.cc", - "table/block_based/partitioned_index_reader.cc", - "table/block_based/reader_common.cc", - "table/block_based/uncompression_dict_reader.cc", - "table/block_fetcher.cc", - "table/compaction_merging_iterator.cc", - "table/cuckoo/cuckoo_table_builder.cc", - "table/cuckoo/cuckoo_table_factory.cc", - "table/cuckoo/cuckoo_table_reader.cc", - "table/format.cc", - "table/get_context.cc", - "table/iterator.cc", - "table/merging_iterator.cc", - "table/meta_blocks.cc", - "table/persistent_cache_helper.cc", - "table/plain/plain_table_bloom.cc", - "table/plain/plain_table_builder.cc", - "table/plain/plain_table_factory.cc", - "table/plain/plain_table_index.cc", - "table/plain/plain_table_key_coding.cc", - "table/plain/plain_table_reader.cc", - "table/sst_file_dumper.cc", - "table/sst_file_reader.cc", - "table/sst_file_writer.cc", - "table/table_factory.cc", - "table/table_properties.cc", - "table/two_level_iterator.cc", - "table/unique_id.cc", - "test_util/sync_point.cc", - "test_util/sync_point_impl.cc", - "test_util/transaction_test_util.cc", - "tools/dump/db_dump_tool.cc", - "tools/io_tracer_parser_tool.cc", - "tools/ldb_cmd.cc", - "tools/ldb_tool.cc", - "tools/sst_dump_tool.cc", - "trace_replay/block_cache_tracer.cc", - "trace_replay/io_tracer.cc", - "trace_replay/trace_record.cc", - "trace_replay/trace_record_handler.cc", - "trace_replay/trace_record_result.cc", - "trace_replay/trace_replay.cc", - "util/async_file_reader.cc", - "util/build_version.cc", - "util/cleanable.cc", - "util/coding.cc", - "util/compaction_job_stats_impl.cc", - "util/comparator.cc", - "util/compression.cc", - "util/compression_context_cache.cc", - "util/concurrent_task_limiter_impl.cc", - "util/crc32c.cc", - "util/crc32c_arm64.cc", - "util/data_structure.cc", - "util/dynamic_bloom.cc", - "util/file_checksum_helper.cc", - "util/hash.cc", - "util/murmurhash.cc", - "util/random.cc", - "util/rate_limiter.cc", - "util/ribbon_config.cc", - "util/slice.cc", - "util/status.cc", - "util/stderr_logger.cc", - "util/string_util.cc", - "util/thread_local.cc", - "util/threadpool_imp.cc", - "util/udt_util.cc", - "util/write_batch_util.cc", - "util/xxhash.cc", - "utilities/agg_merge/agg_merge.cc", - "utilities/backup/backup_engine.cc", - "utilities/blob_db/blob_compaction_filter.cc", - "utilities/blob_db/blob_db.cc", - "utilities/blob_db/blob_db_impl.cc", - "utilities/blob_db/blob_db_impl_filesnapshot.cc", - "utilities/blob_db/blob_dump_tool.cc", - "utilities/blob_db/blob_file.cc", - "utilities/cache_dump_load.cc", - "utilities/cache_dump_load_impl.cc", - "utilities/cassandra/cassandra_compaction_filter.cc", - "utilities/cassandra/format.cc", - "utilities/cassandra/merge_operator.cc", - "utilities/checkpoint/checkpoint_impl.cc", - "utilities/compaction_filters.cc", - "utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc", - "utilities/convenience/info_log_finder.cc", - "utilities/counted_fs.cc", - "utilities/debug.cc", - "utilities/env_mirror.cc", - "utilities/env_timed.cc", - "utilities/fault_injection_env.cc", - "utilities/fault_injection_fs.cc", - "utilities/fault_injection_secondary_cache.cc", - "utilities/flink/flink_compaction_filter.cc", - "utilities/leveldb_options/leveldb_options.cc", - "utilities/memory/memory_util.cc", - "utilities/merge_operators.cc", - "utilities/merge_operators/bytesxor.cc", - "utilities/merge_operators/max.cc", - "utilities/merge_operators/put.cc", - "utilities/merge_operators/sortlist.cc", - "utilities/merge_operators/string_append/stringappend.cc", - "utilities/merge_operators/string_append/stringappend2.cc", - "utilities/merge_operators/uint64add.cc", - "utilities/object_registry.cc", - "utilities/option_change_migration/option_change_migration.cc", - "utilities/options/options_util.cc", - "utilities/persistent_cache/block_cache_tier.cc", - "utilities/persistent_cache/block_cache_tier_file.cc", - "utilities/persistent_cache/block_cache_tier_metadata.cc", - "utilities/persistent_cache/persistent_cache_tier.cc", - "utilities/persistent_cache/volatile_tier_impl.cc", - "utilities/simulator_cache/cache_simulator.cc", - "utilities/simulator_cache/sim_cache.cc", - "utilities/table_properties_collectors/compact_on_deletion_collector.cc", - "utilities/trace/file_trace_reader_writer.cc", - "utilities/trace/replayer_impl.cc", - "utilities/transactions/lock/lock_manager.cc", - "utilities/transactions/lock/point/point_lock_manager.cc", - "utilities/transactions/lock/point/point_lock_tracker.cc", - "utilities/transactions/lock/range/range_tree/lib/locktree/concurrent_tree.cc", - "utilities/transactions/lock/range/range_tree/lib/locktree/keyrange.cc", - "utilities/transactions/lock/range/range_tree/lib/locktree/lock_request.cc", - "utilities/transactions/lock/range/range_tree/lib/locktree/locktree.cc", - "utilities/transactions/lock/range/range_tree/lib/locktree/manager.cc", - "utilities/transactions/lock/range/range_tree/lib/locktree/range_buffer.cc", - "utilities/transactions/lock/range/range_tree/lib/locktree/treenode.cc", - "utilities/transactions/lock/range/range_tree/lib/locktree/txnid_set.cc", - "utilities/transactions/lock/range/range_tree/lib/locktree/wfg.cc", - "utilities/transactions/lock/range/range_tree/lib/standalone_port.cc", - "utilities/transactions/lock/range/range_tree/lib/util/dbt.cc", - "utilities/transactions/lock/range/range_tree/lib/util/memarena.cc", - "utilities/transactions/lock/range/range_tree/range_tree_lock_manager.cc", - "utilities/transactions/lock/range/range_tree/range_tree_lock_tracker.cc", - "utilities/transactions/optimistic_transaction.cc", - "utilities/transactions/optimistic_transaction_db_impl.cc", - "utilities/transactions/pessimistic_transaction.cc", - "utilities/transactions/pessimistic_transaction_db.cc", - "utilities/transactions/snapshot_checker.cc", - "utilities/transactions/transaction_base.cc", - "utilities/transactions/transaction_db_mutex_impl.cc", - "utilities/transactions/transaction_util.cc", - "utilities/transactions/write_prepared_txn.cc", - "utilities/transactions/write_prepared_txn_db.cc", - "utilities/transactions/write_unprepared_txn.cc", - "utilities/transactions/write_unprepared_txn_db.cc", - "utilities/ttl/db_ttl_impl.cc", - "utilities/wal_filter.cc", - "utilities/write_batch_with_index/write_batch_with_index.cc", - "utilities/write_batch_with_index/write_batch_with_index_internal.cc", - ], deps=[ - "//folly/container:f14_hash", - "//folly/experimental/coro:blocking_wait", - "//folly/experimental/coro:collect", - "//folly/experimental/coro:coroutine", - "//folly/experimental/coro:task", - "//folly/synchronization:distributed_mutex", - ], headers=None, link_whole=False, extra_test_libs=False) - -cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[], deps=[":rocksdb_lib"], headers=None, link_whole=True, extra_test_libs=False) - -cpp_library_wrapper(name="rocksdb_test_lib", srcs=[ - "db/db_test_util.cc", - "db/db_with_timestamp_test_util.cc", - "table/mock_table.cc", - "test_util/mock_time_env.cc", - "test_util/secondary_cache_test_util.cc", - "test_util/testharness.cc", - "test_util/testutil.cc", - "tools/block_cache_analyzer/block_cache_trace_analyzer.cc", - "tools/trace_analyzer_tool.cc", - "utilities/agg_merge/test_agg_merge.cc", - "utilities/cassandra/test_utils.cc", - ], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=True) - -cpp_library_wrapper(name="rocksdb_tools_lib", srcs=[ - "test_util/testutil.cc", - "tools/block_cache_analyzer/block_cache_trace_analyzer.cc", - "tools/db_bench_tool.cc", - "tools/simulated_hybrid_file_system.cc", - "tools/trace_analyzer_tool.cc", - ], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=False) - -cpp_library_wrapper(name="rocksdb_cache_bench_tools_lib", srcs=["cache/cache_bench_tool.cc"], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=False) - -rocks_cpp_library_wrapper(name="rocksdb_stress_lib", srcs=[ - "db_stress_tool/batched_ops_stress.cc", - "db_stress_tool/cf_consistency_stress.cc", - "db_stress_tool/db_stress_common.cc", - "db_stress_tool/db_stress_driver.cc", - "db_stress_tool/db_stress_gflags.cc", - "db_stress_tool/db_stress_listener.cc", - "db_stress_tool/db_stress_shared_state.cc", - "db_stress_tool/db_stress_stat.cc", - "db_stress_tool/db_stress_test_base.cc", - "db_stress_tool/db_stress_tool.cc", - "db_stress_tool/expected_state.cc", - "db_stress_tool/expected_value.cc", - "db_stress_tool/multi_ops_txns_stress.cc", - "db_stress_tool/no_batched_ops_stress.cc", - "test_util/testutil.cc", - "tools/block_cache_analyzer/block_cache_trace_analyzer.cc", - "tools/trace_analyzer_tool.cc", - ], headers=None) - - -cpp_binary_wrapper(name="db_stress", srcs=["db_stress_tool/db_stress.cc"], deps=[":rocksdb_stress_lib"], extra_preprocessor_flags=[], extra_bench_libs=False) - -cpp_binary_wrapper(name="ribbon_bench", srcs=["microbench/ribbon_bench.cc"], deps=[], extra_preprocessor_flags=[], extra_bench_libs=True) - -cpp_binary_wrapper(name="db_basic_bench", srcs=["microbench/db_basic_bench.cc"], deps=[], extra_preprocessor_flags=[], extra_bench_libs=True) - -add_c_test_wrapper() - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_0", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:51200/threads:8': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:51200/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2438, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_1", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:51200/threads:8': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_2", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:409600/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:409600/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}}, slow=False, expected_runtime=2446, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_3", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:51200/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'DataBlockSeek/iterations:1000000': ['real_time', - 'cpu_time', - 'seek_ns', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_4", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:51200/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'RandomAccessFileReaderRead/enable_statistics:1/iterations:1000000': ['real_time', - 'cpu_time', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_5", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:51200/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_6", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:409600/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:51200/threads:8': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_7", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:51200/threads:8': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'RandomAccessFileReaderRead/enable_statistics:0/iterations:1000000': ['real_time', - 'cpu_time', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct']}}, slow=False, expected_runtime=2438, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_8", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:409600/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_9", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:51200/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:409600/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_10", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryPositive/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_11", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:51200/threads:8': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads']}}, slow=False, expected_runtime=2446, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_12", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_13", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:409600/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_14", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:51200/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:51200/threads:8': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_0_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88891, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_1_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88804, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_2_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88803, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_3_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88891, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_4_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88809, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_5_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88803, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_6_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88813, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_7_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88813, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_8_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88709, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_9_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88711, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_10_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88819, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_11_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88711, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_12_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88709, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_13_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88709, sl_iterations=3, regression_threshold=10) - - -fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_14_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'neg_qu_pct', - 'threads'], - 'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size', - 'get_mean', - 'threads', - 'real_time', - 'cpu_time', - 'neg_qu_pct'], - 'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time', - 'put_mean', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time', - 'cpu_time', - 'db_size', - 'threads'], - 'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time', - 'cpu_time', - 'db_size', - 'threads']}, - 'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'size'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads', - 'fp_pct'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads'], - 'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time', - 'cpu_time', - 'threads']}}, slow=True, expected_runtime=88711, sl_iterations=3, regression_threshold=10) - - - # Generate a test rule for each entry in ROCKS_TESTS - # Do not build the tests in opt mode, since SyncPoint and other test code - # will not be included. - -cpp_unittest_wrapper(name="agg_merge_test", - srcs=["utilities/agg_merge/agg_merge_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="arena_test", - srcs=["memory/arena_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="auto_roll_logger_test", - srcs=["logging/auto_roll_logger_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="autovector_test", - srcs=["util/autovector_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="backup_engine_test", - srcs=["utilities/backup/backup_engine_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="blob_counting_iterator_test", - srcs=["db/blob/blob_counting_iterator_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="blob_db_test", - srcs=["utilities/blob_db/blob_db_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="blob_file_addition_test", - srcs=["db/blob/blob_file_addition_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="blob_file_builder_test", - srcs=["db/blob/blob_file_builder_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="blob_file_cache_test", - srcs=["db/blob/blob_file_cache_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="blob_file_garbage_test", - srcs=["db/blob/blob_file_garbage_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="blob_file_reader_test", - srcs=["db/blob/blob_file_reader_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="blob_garbage_meter_test", - srcs=["db/blob/blob_garbage_meter_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="blob_source_test", - srcs=["db/blob/blob_source_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="block_based_table_reader_test", - srcs=["table/block_based/block_based_table_reader_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="block_cache_trace_analyzer_test", - srcs=["tools/block_cache_analyzer/block_cache_trace_analyzer_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="block_cache_tracer_test", - srcs=["trace_replay/block_cache_tracer_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="block_fetcher_test", - srcs=["table/block_fetcher_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="block_test", - srcs=["table/block_based/block_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="bloom_test", - srcs=["util/bloom_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="cache_reservation_manager_test", - srcs=["cache/cache_reservation_manager_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="cache_simulator_test", - srcs=["utilities/simulator_cache/cache_simulator_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="cache_test", - srcs=["cache/cache_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="cassandra_format_test", - srcs=["utilities/cassandra/cassandra_format_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="cassandra_functional_test", - srcs=["utilities/cassandra/cassandra_functional_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="cassandra_row_merge_test", - srcs=["utilities/cassandra/cassandra_row_merge_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="cassandra_serialize_test", - srcs=["utilities/cassandra/cassandra_serialize_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="checkpoint_test", - srcs=["utilities/checkpoint/checkpoint_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="cleanable_test", - srcs=["table/cleanable_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="clipping_iterator_test", - srcs=["db/compaction/clipping_iterator_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="coding_test", - srcs=["util/coding_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="column_family_test", - srcs=["db/column_family_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="compact_files_test", - srcs=["db/compact_files_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="compact_on_deletion_collector_test", - srcs=["utilities/table_properties_collectors/compact_on_deletion_collector_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="compaction_iterator_test", - srcs=["db/compaction/compaction_iterator_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="compaction_job_stats_test", - srcs=["db/compaction/compaction_job_stats_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="compaction_job_test", - srcs=["db/compaction/compaction_job_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="compaction_picker_test", - srcs=["db/compaction/compaction_picker_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="compaction_service_test", - srcs=["db/compaction/compaction_service_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="comparator_db_test", - srcs=["db/comparator_db_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="compressed_secondary_cache_test", - srcs=["cache/compressed_secondary_cache_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="configurable_test", - srcs=["options/configurable_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="corruption_test", - srcs=["db/corruption_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="crc32c_test", - srcs=["util/crc32c_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="cuckoo_table_builder_test", - srcs=["table/cuckoo/cuckoo_table_builder_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="cuckoo_table_db_test", - srcs=["db/cuckoo_table_db_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="cuckoo_table_reader_test", - srcs=["table/cuckoo/cuckoo_table_reader_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="customizable_test", - srcs=["options/customizable_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="data_block_hash_index_test", - srcs=["table/block_based/data_block_hash_index_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_basic_test", - srcs=["db/db_basic_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_blob_basic_test", - srcs=["db/blob/db_blob_basic_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_blob_compaction_test", - srcs=["db/blob/db_blob_compaction_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_blob_corruption_test", - srcs=["db/blob/db_blob_corruption_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_blob_index_test", - srcs=["db/blob/db_blob_index_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_block_cache_test", - srcs=["db/db_block_cache_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_bloom_filter_test", - srcs=["db/db_bloom_filter_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_clip_test", - srcs=["db/db_clip_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_compaction_filter_test", - srcs=["db/db_compaction_filter_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_compaction_test", - srcs=["db/db_compaction_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_dynamic_level_test", - srcs=["db/db_dynamic_level_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_encryption_test", - srcs=["db/db_encryption_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_flush_test", - srcs=["db/db_flush_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_inplace_update_test", - srcs=["db/db_inplace_update_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_io_failure_test", - srcs=["db/db_io_failure_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_iter_stress_test", - srcs=["db/db_iter_stress_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_iter_test", - srcs=["db/db_iter_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_iterator_test", - srcs=["db/db_iterator_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_kv_checksum_test", - srcs=["db/db_kv_checksum_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_log_iter_test", - srcs=["db/db_log_iter_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_logical_block_size_cache_test", - srcs=["db/db_logical_block_size_cache_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_memtable_test", - srcs=["db/db_memtable_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_merge_operand_test", - srcs=["db/db_merge_operand_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_merge_operator_test", - srcs=["db/db_merge_operator_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_options_test", - srcs=["db/db_options_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_properties_test", - srcs=["db/db_properties_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_range_del_test", - srcs=["db/db_range_del_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_rate_limiter_test", - srcs=["db/db_rate_limiter_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_readonly_with_timestamp_test", - srcs=["db/db_readonly_with_timestamp_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_secondary_test", - srcs=["db/db_secondary_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_sst_test", - srcs=["db/db_sst_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_statistics_test", - srcs=["db/db_statistics_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_table_properties_test", - srcs=["db/db_table_properties_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_tailing_iter_test", - srcs=["db/db_tailing_iter_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_test", - srcs=["db/db_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_test2", - srcs=["db/db_test2.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_universal_compaction_test", - srcs=["db/db_universal_compaction_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_wal_test", - srcs=["db/db_wal_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_wide_basic_test", - srcs=["db/wide/db_wide_basic_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_with_timestamp_basic_test", - srcs=["db/db_with_timestamp_basic_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_with_timestamp_compaction_test", - srcs=["db/db_with_timestamp_compaction_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_write_buffer_manager_test", - srcs=["db/db_write_buffer_manager_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="db_write_test", - srcs=["db/db_write_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="dbformat_test", - srcs=["db/dbformat_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="defer_test", - srcs=["util/defer_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="delete_scheduler_test", - srcs=["file/delete_scheduler_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="deletefile_test", - srcs=["db/deletefile_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="dynamic_bloom_test", - srcs=["util/dynamic_bloom_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_library_wrapper(name="env_basic_test_lib", srcs=["env/env_basic_test.cc"], deps=[":rocksdb_test_lib"], headers=None, link_whole=False, extra_test_libs=True) - -cpp_unittest_wrapper(name="env_basic_test", - srcs=["env/env_basic_test.cc"], - deps=[":env_basic_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="env_logger_test", - srcs=["logging/env_logger_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="env_test", - srcs=["env/env_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="env_timed_test", - srcs=["utilities/env_timed_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="error_handler_fs_test", - srcs=["db/error_handler_fs_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="event_logger_test", - srcs=["logging/event_logger_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="external_sst_file_basic_test", - srcs=["db/external_sst_file_basic_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="external_sst_file_test", - srcs=["db/external_sst_file_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="fault_injection_test", - srcs=["db/fault_injection_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="file_indexer_test", - srcs=["db/file_indexer_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="file_reader_writer_test", - srcs=["util/file_reader_writer_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="filelock_test", - srcs=["util/filelock_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="filename_test", - srcs=["db/filename_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - -cpp_unittest_wrapper(name="flink_compaction_filter_test", - srcs=["utilities/flink/flink_compaction_filter_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - -cpp_unittest_wrapper(name="flush_job_test", - srcs=["db/flush_job_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="full_filter_block_test", - srcs=["table/block_based/full_filter_block_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="hash_table_test", - srcs=["utilities/persistent_cache/hash_table_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="hash_test", - srcs=["util/hash_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="heap_test", - srcs=["util/heap_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="histogram_test", - srcs=["monitoring/histogram_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="import_column_family_test", - srcs=["db/import_column_family_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="inlineskiplist_test", - srcs=["memtable/inlineskiplist_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="io_posix_test", - srcs=["env/io_posix_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="io_tracer_parser_test", - srcs=["tools/io_tracer_parser_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="io_tracer_test", - srcs=["trace_replay/io_tracer_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="iostats_context_test", - srcs=["monitoring/iostats_context_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="ldb_cmd_test", - srcs=["tools/ldb_cmd_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="listener_test", - srcs=["db/listener_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="log_test", - srcs=["db/log_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="lru_cache_test", - srcs=["cache/lru_cache_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="manual_compaction_test", - srcs=["db/manual_compaction_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="memory_allocator_test", - srcs=["memory/memory_allocator_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="memory_test", - srcs=["utilities/memory/memory_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="memtable_list_test", - srcs=["db/memtable_list_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="merge_helper_test", - srcs=["db/merge_helper_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="merge_test", - srcs=["db/merge_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="merger_test", - srcs=["table/merger_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="mock_env_test", - srcs=["env/mock_env_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="object_registry_test", - srcs=["utilities/object_registry_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="obsolete_files_test", - srcs=["db/obsolete_files_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="optimistic_transaction_test", - srcs=["utilities/transactions/optimistic_transaction_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="option_change_migration_test", - srcs=["utilities/option_change_migration/option_change_migration_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="options_file_test", - srcs=["db/options_file_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="options_settable_test", - srcs=["options/options_settable_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="options_test", - srcs=["options/options_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="options_util_test", - srcs=["utilities/options/options_util_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="partitioned_filter_block_test", - srcs=["table/block_based/partitioned_filter_block_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="perf_context_test", - srcs=["db/perf_context_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="periodic_task_scheduler_test", - srcs=["db/periodic_task_scheduler_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="persistent_cache_test", - srcs=["utilities/persistent_cache/persistent_cache_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="plain_table_db_test", - srcs=["db/plain_table_db_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="point_lock_manager_test", - srcs=["utilities/transactions/lock/point/point_lock_manager_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="prefetch_test", - srcs=["file/prefetch_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="prefix_test", - srcs=["db/prefix_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="random_access_file_reader_test", - srcs=["file/random_access_file_reader_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="random_test", - srcs=["util/random_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="range_del_aggregator_test", - srcs=["db/range_del_aggregator_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="range_locking_test", - srcs=["utilities/transactions/lock/range/range_locking_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="range_tombstone_fragmenter_test", - srcs=["db/range_tombstone_fragmenter_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="rate_limiter_test", - srcs=["util/rate_limiter_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="reduce_levels_test", - srcs=["tools/reduce_levels_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="repair_test", - srcs=["db/repair_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="repeatable_thread_test", - srcs=["util/repeatable_thread_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="ribbon_test", - srcs=["util/ribbon_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="seqno_time_test", - srcs=["db/seqno_time_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="sim_cache_test", - srcs=["utilities/simulator_cache/sim_cache_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="skiplist_test", - srcs=["memtable/skiplist_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="slice_test", - srcs=["util/slice_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="slice_transform_test", - srcs=["util/slice_transform_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="sst_dump_test", - srcs=["tools/sst_dump_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="sst_file_reader_test", - srcs=["table/sst_file_reader_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="statistics_test", - srcs=["monitoring/statistics_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="stats_history_test", - srcs=["monitoring/stats_history_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="stringappend_test", - srcs=["utilities/merge_operators/string_append/stringappend_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="table_properties_collector_test", - srcs=["db/table_properties_collector_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="table_test", - srcs=["table/table_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="testutil_test", - srcs=["test_util/testutil_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="thread_list_test", - srcs=["util/thread_list_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="thread_local_test", - srcs=["util/thread_local_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="tiered_compaction_test", - srcs=["db/compaction/tiered_compaction_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="timer_queue_test", - srcs=["util/timer_queue_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="timer_test", - srcs=["util/timer_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="timestamped_snapshot_test", - srcs=["utilities/transactions/timestamped_snapshot_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="trace_analyzer_test", - srcs=["tools/trace_analyzer_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="transaction_test", - srcs=["utilities/transactions/transaction_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="ttl_test", - srcs=["utilities/ttl/ttl_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="udt_util_test", - srcs=["util/udt_util_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="util_merge_operators_test", - srcs=["utilities/util_merge_operators_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="version_builder_test", - srcs=["db/version_builder_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="version_edit_test", - srcs=["db/version_edit_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="version_set_test", - srcs=["db/version_set_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="wal_manager_test", - srcs=["db/wal_manager_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="wide_column_serialization_test", - srcs=["db/wide/wide_column_serialization_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="work_queue_test", - srcs=["util/work_queue_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="write_batch_test", - srcs=["db/write_batch_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="write_batch_with_index_test", - srcs=["utilities/write_batch_with_index/write_batch_with_index_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="write_buffer_manager_test", - srcs=["memtable/write_buffer_manager_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="write_callback_test", - srcs=["db/write_callback_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="write_committed_transaction_ts_test", - srcs=["utilities/transactions/write_committed_transaction_ts_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="write_controller_test", - srcs=["db/write_controller_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="write_prepared_transaction_test", - srcs=["utilities/transactions/write_prepared_transaction_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - - -cpp_unittest_wrapper(name="write_unprepared_transaction_test", - srcs=["utilities/transactions/write_unprepared_transaction_test.cc"], - deps=[":rocksdb_test_lib"], - extra_compiler_flags=[]) - From df5916ac5f65795b4645ea017cda8e80eba2ccb5 Mon Sep 17 00:00:00 2001 From: Yanfei Lei Date: Thu, 7 Mar 2024 18:18:26 +0800 Subject: [PATCH 16/61] [build] Fix 'using namespace' in fliink compaction filter (#4) --- java/rocksjni/flink_compactionfilterjni.cc | 39 +++++++++++----------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/java/rocksjni/flink_compactionfilterjni.cc b/java/rocksjni/flink_compactionfilterjni.cc index 9f0954b43..4354f2878 100644 --- a/java/rocksjni/flink_compactionfilterjni.cc +++ b/java/rocksjni/flink_compactionfilterjni.cc @@ -12,7 +12,7 @@ #include "rocksjni/jnicallback.h" #include "utilities/flink/flink_compaction_filter.h" -using namespace ROCKSDB_NAMESPACE::flink; +namespace flink = ROCKSDB_NAMESPACE::flink; class JniCallbackBase : public ROCKSDB_NAMESPACE::JniCallback { public: @@ -94,7 +94,7 @@ class JavaListElemenFilterFactory assert(m_jcreate_filter_methodid != nullptr); } - FlinkCompactionFilter::ListElementFilter* CreateListElementFilter( + flink::FlinkCompactionFilter::ListElementFilter* CreateListElementFilter( std::shared_ptr /*logger*/) const override { jboolean attached_thread = JNI_FALSE; JNIEnv* env = getJniEnv(&attached_thread); @@ -141,15 +141,15 @@ class JavaTimeProvider jmethodID m_jcurrent_timestamp_methodid; }; -static FlinkCompactionFilter::ListElementFilterFactory* +static flink::FlinkCompactionFilter::ListElementFilterFactory* createListElementFilterFactory(JNIEnv* env, jint ji_list_elem_len, jobject jlist_filter_factory) { - FlinkCompactionFilter::ListElementFilterFactory* list_filter_factory = + flink::FlinkCompactionFilter::ListElementFilterFactory* list_filter_factory = nullptr; if (ji_list_elem_len > 0) { auto fixed_size = static_cast(ji_list_elem_len); list_filter_factory = - new FlinkCompactionFilter::FixedListElementFilterFactory( + new flink::FlinkCompactionFilter::FixedListElementFilterFactory( fixed_size, static_cast(0)); } else if (jlist_filter_factory != nullptr) { list_filter_factory = @@ -165,10 +165,9 @@ createListElementFilterFactory(JNIEnv* env, jint ji_list_elem_len, */ jlong Java_org_rocksdb_FlinkCompactionFilter_createNewFlinkCompactionFilterConfigHolder( JNIEnv* /* env */, jclass /* jcls */) { - using namespace ROCKSDB_NAMESPACE::flink; return reinterpret_cast( - new std::shared_ptr( - new FlinkCompactionFilter::ConfigHolder())); + new std::shared_ptr( + new flink::FlinkCompactionFilter::ConfigHolder())); } /* @@ -178,10 +177,8 @@ jlong Java_org_rocksdb_FlinkCompactionFilter_createNewFlinkCompactionFilterConfi */ void Java_org_rocksdb_FlinkCompactionFilter_disposeFlinkCompactionFilterConfigHolder( JNIEnv* /* env */, jclass /* jcls */, jlong handle) { - using namespace ROCKSDB_NAMESPACE::flink; - auto* config_holder = - reinterpret_cast*>( - handle); + auto* config_holder = reinterpret_cast< + std::shared_ptr*>(handle); delete config_holder; } @@ -193,9 +190,9 @@ void Java_org_rocksdb_FlinkCompactionFilter_disposeFlinkCompactionFilterConfigHo jlong Java_org_rocksdb_FlinkCompactionFilter_createNewFlinkCompactionFilter0( JNIEnv* env, jclass /* jcls */, jlong config_holder_handle, jobject jtime_provider, jlong logger_handle) { - using namespace ROCKSDB_NAMESPACE::flink; auto config_holder = - *(reinterpret_cast*>( + *(reinterpret_cast< + std::shared_ptr*>( config_holder_handle)); auto time_provider = new JavaTimeProvider(env, jtime_provider); auto logger = @@ -204,9 +201,10 @@ jlong Java_org_rocksdb_FlinkCompactionFilter_createNewFlinkCompactionFilter0( : *(reinterpret_cast< std::shared_ptr*>( logger_handle)); - return reinterpret_cast(new FlinkCompactionFilter( + return reinterpret_cast(new flink::FlinkCompactionFilter( config_holder, - std::unique_ptr(time_provider), + std::unique_ptr( + time_provider), logger)); } @@ -221,19 +219,20 @@ jboolean Java_org_rocksdb_FlinkCompactionFilter_configureFlinkCompactionFilter( jlong jquery_time_after_num_entries, jint ji_list_elem_len, jobject jlist_filter_factory) { auto state_type = - static_cast(ji_state_type); + static_cast(ji_state_type); auto timestamp_offset = static_cast(ji_timestamp_offset); auto ttl = static_cast(jl_ttl_milli); auto query_time_after_num_entries = static_cast(jquery_time_after_num_entries); auto config_holder = - *(reinterpret_cast*>( + *(reinterpret_cast< + std::shared_ptr*>( handle)); auto list_filter_factory = createListElementFilterFactory( env, ji_list_elem_len, jlist_filter_factory); - auto config = new FlinkCompactionFilter::Config{ + auto config = new flink::FlinkCompactionFilter::Config{ state_type, timestamp_offset, ttl, query_time_after_num_entries, - std::unique_ptr( + std::unique_ptr( list_filter_factory)}; return static_cast(config_holder->Configure(config)); } \ No newline at end of file From 61f9574773fbfdae7b2f71bd8f861605afead3ec Mon Sep 17 00:00:00 2001 From: yhx <38719192+masteryhx@users.noreply.github.com> Date: Tue, 12 Mar 2024 11:25:14 +0800 Subject: [PATCH 17/61] [env] Introduce interface of env_flink (#5) --- CMakeLists.txt | 3 +- env/flink/env_flink.cc | 10 ++++ env/flink/env_flink.h | 101 +++++++++++++++++++++++++++++++++++++++++ src.mk | 1 + 4 files changed, 114 insertions(+), 1 deletion(-) create mode 100644 env/flink/env_flink.cc create mode 100644 env/flink/env_flink.h diff --git a/CMakeLists.txt b/CMakeLists.txt index b07c3db94..daaceff56 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1016,7 +1016,8 @@ else() port/port_posix.cc env/env_posix.cc env/fs_posix.cc - env/io_posix.cc) + env/io_posix.cc + env/flink/env_flink.cc) endif() if(USE_FOLLY_LITE) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc new file mode 100644 index 000000000..87183f131 --- /dev/null +++ b/env/flink/env_flink.cc @@ -0,0 +1,10 @@ +// Copyright (c) 2021-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). + +// TODO: +// 1. Register flink env to ObjectLibrary +// 2. Implement all methods of env_flink.h + +#include "env_flink.h" \ No newline at end of file diff --git a/env/flink/env_flink.h b/env/flink/env_flink.h new file mode 100644 index 000000000..d1912a3de --- /dev/null +++ b/env/flink/env_flink.h @@ -0,0 +1,101 @@ +// Copyright (c) 2021-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). + +#pragma once + +#include "rocksdb/env.h" +#include "rocksdb/file_system.h" +#include "rocksdb/status.h" + +namespace ROCKSDB_NAMESPACE { + +// FlinkFileSystem extended from FileSystemWrapper which delegate necessary +// methods to Flink FileSystem based on JNI. For other methods, base FileSystem +// will proxy its methods. +class FlinkFileSystem : public FileSystemWrapper { + public: + // Create FlinkFileSystem with base_fs proxying all other methods and + // base_path + static Status Create(const std::shared_ptr& /*base_fs*/, + const std::string& /*base_path*/, + std::unique_ptr* /*fs*/); + + // Define some names + static const char* kClassName() { return "FlinkFileSystem"; } + const char* Name() const override { return kClassName(); } + static const char* kNickName() { return "flink"; } + const char* NickName() const override { return kNickName(); } + + // Constructor and Destructor + explicit FlinkFileSystem(const std::shared_ptr& base, + const std::string& fsname); + ~FlinkFileSystem() override; + + // Several methods current FileSystem must implement + + std::string GetId() const override; + Status ValidateOptions(const DBOptions& /*db_opts*/, + const ColumnFamilyOptions& /*cf_opts*/) const override; + IOStatus NewSequentialFile(const std::string& /*fname*/, + const FileOptions& /*options*/, + std::unique_ptr* /*result*/, + IODebugContext* /*dbg*/) override; + IOStatus NewRandomAccessFile(const std::string& /*fname*/, + const FileOptions& /*options*/, + std::unique_ptr* /*result*/, + IODebugContext* /*dbg*/) override; + IOStatus NewWritableFile(const std::string& /*fname*/, + const FileOptions& /*options*/, + std::unique_ptr* /*result*/, + IODebugContext* /*dbg*/) override; + IOStatus NewDirectory(const std::string& /*name*/, + const IOOptions& /*options*/, + std::unique_ptr* /*result*/, + IODebugContext* /*dbg*/) override; + IOStatus FileExists(const std::string& /*fname*/, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus GetChildren(const std::string& /*path*/, + const IOOptions& /*options*/, + std::vector* /*result*/, + IODebugContext* /*dbg*/) override; + IOStatus DeleteFile(const std::string& /*fname*/, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus CreateDir(const std::string& /*name*/, const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus CreateDirIfMissing(const std::string& /*name*/, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus DeleteDir(const std::string& /*name*/, const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus GetFileSize(const std::string& /*fname*/, + const IOOptions& /*options*/, uint64_t* /*size*/, + IODebugContext* /*dbg*/) override; + IOStatus GetFileModificationTime(const std::string& /*fname*/, + const IOOptions& /*options*/, + uint64_t* /*time*/, + IODebugContext* /*dbg*/) override; + IOStatus RenameFile(const std::string& /*src*/, const std::string& /*target*/, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus LockFile(const std::string& /*fname*/, const IOOptions& /*options*/, + FileLock** /*lock*/, IODebugContext* /*dbg*/) override; + IOStatus UnlockFile(FileLock* /*lock*/, const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus IsDirectory(const std::string& /*path*/, + const IOOptions& /*options*/, bool* /*is_dir*/, + IODebugContext* /*dbg*/) override; + + private: + std::string base_path_; +}; + +// Returns a `FlinkEnv` with base_path +Status NewFlinkEnv(const std::string& base_path, std::unique_ptr* env); +// Returns a `FlinkFileSystem` with base_path +Status NewFlinkFileSystem(const std::string& base_path, + std::shared_ptr* fs); +} // namespace ROCKSDB_NAMESPACE diff --git a/src.mk b/src.mk index 8ef691668..bf7d51533 100644 --- a/src.mk +++ b/src.mk @@ -111,6 +111,7 @@ LIB_SOURCES = \ env/io_posix.cc \ env/mock_env.cc \ env/unique_id_gen.cc \ + env/flink/env_flink.cc \ file/delete_scheduler.cc \ file/file_prefetch_buffer.cc \ file/file_util.cc \ From 44debe7a9de2c1a50405bd7501830670b9542451 Mon Sep 17 00:00:00 2001 From: "jinse.ljz" Date: Tue, 12 Mar 2024 12:56:06 +0800 Subject: [PATCH 18/61] [env] Introduce JvmUtils to support global JNIEnv --- CMakeLists.txt | 7 +++- env/flink/jvm_util.cc | 59 ++++++++++++++++++++++++++++++++++ env/flink/jvm_util.h | 74 +++++++++++++++++++++++++++++++++++++++++++ src.mk | 1 + 4 files changed, 140 insertions(+), 1 deletion(-) create mode 100644 env/flink/jvm_util.cc create mode 100644 env/flink/jvm_util.h diff --git a/CMakeLists.txt b/CMakeLists.txt index daaceff56..babe2406d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1017,7 +1017,8 @@ else() env/env_posix.cc env/fs_posix.cc env/io_posix.cc - env/flink/env_flink.cc) + env/flink/env_flink.cc + env/flink/jvm_util.cc) endif() if(USE_FOLLY_LITE) @@ -1151,6 +1152,10 @@ endif() if(WITH_JNI OR JNI) message(STATUS "JNI library is enabled") add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/java) + include_directories(${JNI_INCLUDE_DIRS}) + if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux") + include_directories(${JNI_INCLUDE_DIRS}/linux) + endif () else() message(STATUS "JNI library is disabled") endif() diff --git a/env/flink/jvm_util.cc b/env/flink/jvm_util.cc new file mode 100644 index 000000000..8e2c6f07a --- /dev/null +++ b/env/flink/jvm_util.cc @@ -0,0 +1,59 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "env/flink/jvm_util.h" + +namespace ROCKSDB_NAMESPACE { + +std::atomic jvm_ = std::atomic(nullptr); + +JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { + JNIEnv* env = nullptr; + if (vm->GetEnv((void**)&env, JNI_VERSION_1_8) != JNI_OK) { + return -1; + } + + jvm_.store(vm); + return JNI_VERSION_1_8; +} + +JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) { + jvm_.store(nullptr); +} + +void setJVM(JavaVM* jvm) { jvm_.store(jvm); } + +JNIEnv* getJNIEnv(bool attach) { + JavaVM* jvm = jvm_.load(); + if (jvm == nullptr) { + return nullptr; + } + + thread_local JavaEnv env; + if (env.getEnv() == nullptr) { + auto status = jvm->GetEnv((void**)&(env.getEnv()), JNI_VERSION_1_8); + if (attach && (status == JNI_EDETACHED || env.getEnv() == nullptr)) { + if (jvm->AttachCurrentThread((void**)&(env.getEnv()), nullptr) == + JNI_OK) { + env.setNeedDetach(); + } + } + } + return env.getEnv(); +} +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/jvm_util.h b/env/flink/jvm_util.h new file mode 100644 index 000000000..5c5b5fc83 --- /dev/null +++ b/env/flink/jvm_util.h @@ -0,0 +1,74 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include +#include + +#include "jni.h" +#include "rocksdb/env.h" + +namespace ROCKSDB_NAMESPACE { + +extern std::atomic jvm_; + +#ifdef __cplusplus +extern "C" { +#endif + +JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved); +JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved); + +#ifdef __cplusplus +} +#endif + +void setJVM(JavaVM* jvm); + +JNIEnv* getJNIEnv(bool attach = true); + +static inline std::string parseJavaString(JNIEnv* jni_env, + jstring java_string) { + const char* chars = jni_env->GetStringUTFChars(java_string, nullptr); + auto length = jni_env->GetStringUTFLength(java_string); + std::string native_string = std::string(chars, length); + jni_env->ReleaseStringUTFChars(java_string, chars); + return native_string; +} + +class JavaEnv { + public: + ~JavaEnv() { + if (env_ != nullptr && need_detach_) { + jvm_.load()->DetachCurrentThread(); + need_detach_ = false; + } + } + + JNIEnv*& getEnv() { return env_; } + + void setNeedDetach() { need_detach_ = true; } + + private: + JNIEnv* env_ = nullptr; + bool need_detach_ = false; +}; +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/src.mk b/src.mk index bf7d51533..6746ac3df 100644 --- a/src.mk +++ b/src.mk @@ -112,6 +112,7 @@ LIB_SOURCES = \ env/mock_env.cc \ env/unique_id_gen.cc \ env/flink/env_flink.cc \ + env/flink/jvm_util.cc \ file/delete_scheduler.cc \ file/file_prefetch_buffer.cc \ file/file_util.cc \ From 4a511b33d33ff41d1231fd8d3361b1916e94dbac Mon Sep 17 00:00:00 2001 From: yhx Date: Tue, 12 Mar 2024 16:11:25 +0800 Subject: [PATCH 19/61] [env] Introduce interface of env_flink (#7) --- CMakeLists.txt | 3 +- env/flink/jni_helper.cc | 76 +++++++++++++++++++++++++++++++++++++++++ env/flink/jni_helper.h | 45 ++++++++++++++++++++++++ src.mk | 1 + 4 files changed, 124 insertions(+), 1 deletion(-) create mode 100644 env/flink/jni_helper.cc create mode 100644 env/flink/jni_helper.h diff --git a/CMakeLists.txt b/CMakeLists.txt index babe2406d..9ad7a5cb0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1018,7 +1018,8 @@ else() env/fs_posix.cc env/io_posix.cc env/flink/env_flink.cc - env/flink/jvm_util.cc) + env/flink/jvm_util.cc + env/flink/jni_helper.cc) endif() if(USE_FOLLY_LITE) diff --git a/env/flink/jni_helper.cc b/env/flink/jni_helper.cc new file mode 100644 index 000000000..8d1ac5acf --- /dev/null +++ b/env/flink/jni_helper.cc @@ -0,0 +1,76 @@ +// Copyright (c) 2019-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). + +#include "jni_helper.h" + +namespace ROCKSDB_NAMESPACE { + +JavaClassCache::JavaClassCache(JNIEnv *env) : jni_env_(env) { + // Set all class names + cached_java_classes_[JavaClassCache::JC_URI].className = "java/net/URI"; + cached_java_classes_[JavaClassCache::JC_BYTE_BUFFER].className = + "java/nio/ByteBuffer"; + cached_java_classes_[JavaClassCache::JC_THROWABLE].className = + "java/lang/Throwable"; + cached_java_classes_[JavaClassCache::JC_FLINK_PATH].className = + "org/apache/flink/core/fs/Path"; + cached_java_classes_[JavaClassCache::JC_FLINK_FILE_SYSTEM].className = + "org/apache/flink/state/forst/fs/ForStFlinkFileSystem"; + cached_java_classes_[JavaClassCache::JC_FLINK_FILE_STATUS].className = + "org/apache/flink/core/fs/FileStatus"; + cached_java_classes_[JavaClassCache::JC_FLINK_FS_INPUT_STREAM].className = + "org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream"; + cached_java_classes_[JavaClassCache::JC_FLINK_FS_OUTPUT_STREAM].className = + "org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream"; + + // Try best to create and set the jclass objects based on the class names set + // above + int numCachedClasses = + sizeof(cached_java_classes_) / sizeof(javaClassAndName); + for (int i = 0; i < numCachedClasses; i++) { + initCachedClass(cached_java_classes_[i].className, + &cached_java_classes_[i].javaClass); + } +} + +JavaClassCache::~JavaClassCache() { + // Release all global ref of cached jclasses + for (const auto &item : cached_java_classes_) { + if (item.javaClass) { + jni_env_->DeleteGlobalRef(item.javaClass); + } + } +} + +Status JavaClassCache::initCachedClass(const char *className, + jclass *cachedJclass) { + jclass tempLocalClassRef = jni_env_->FindClass(className); + if (!tempLocalClassRef) { + return Status::IOError("Exception when FindClass, class name: " + + std::string(className)); + } + *cachedJclass = (jclass)jni_env_->NewGlobalRef(tempLocalClassRef); + if (!*cachedJclass) { + return Status::IOError("Exception when NewGlobalRef, class name " + + std::string(className)); + } + + jni_env_->DeleteLocalRef(tempLocalClassRef); + return Status::OK(); +} + +Status JavaClassCache::GetJClass(CachedJavaClass cachedJavaClass, + jclass *javaClass) { + jclass targetClass = cached_java_classes_[cachedJavaClass].javaClass; + Status status = Status::OK(); + if (!targetClass) { + status = initCachedClass(cached_java_classes_[cachedJavaClass].className, + &targetClass); + } + *javaClass = targetClass; + return status; +} + +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/jni_helper.h b/env/flink/jni_helper.h new file mode 100644 index 000000000..39d9e9f9a --- /dev/null +++ b/env/flink/jni_helper.h @@ -0,0 +1,45 @@ +// Copyright (c) 2019-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). + +#include "jni.h" +#include "rocksdb/status.h" + +namespace ROCKSDB_NAMESPACE { + +// A cache for java classes to avoid calling FindClass frequently +class JavaClassCache { + public: + // Frequently-used class type representing jclasses which will be cached. + typedef enum { + JC_URI, + JC_BYTE_BUFFER, + JC_THROWABLE, + JC_FLINK_PATH, + JC_FLINK_FILE_SYSTEM, + JC_FLINK_FILE_STATUS, + JC_FLINK_FS_INPUT_STREAM, + JC_FLINK_FS_OUTPUT_STREAM, + NUM_CACHED_CLASSES + } CachedJavaClass; + + // Constructor and Destructor + explicit JavaClassCache(JNIEnv* env); + ~JavaClassCache(); + + // Get jclass by specific CachedJavaClass + Status GetJClass(CachedJavaClass cachedJavaClass, jclass* javaClass); + + private: + typedef struct { + jclass javaClass; + const char* className; + } javaClassAndName; + + JNIEnv* jni_env_; + javaClassAndName cached_java_classes_[JavaClassCache::NUM_CACHED_CLASSES]; + + Status initCachedClass(const char* className, jclass* cachedClass); +}; +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/src.mk b/src.mk index 6746ac3df..9629e7ec8 100644 --- a/src.mk +++ b/src.mk @@ -113,6 +113,7 @@ LIB_SOURCES = \ env/unique_id_gen.cc \ env/flink/env_flink.cc \ env/flink/jvm_util.cc \ + env/flink/jni_helper.cc \ file/delete_scheduler.cc \ file/file_prefetch_buffer.cc \ file/file_util.cc \ From 09ba94fc277a872445f29a4d95e94b656b852fd2 Mon Sep 17 00:00:00 2001 From: Zakelly Date: Tue, 12 Mar 2024 17:23:59 +0800 Subject: [PATCH 20/61] [build] license and READMEs (#9) --- CONTRIBUTING.md | 48 +- COPYING | 339 ----- DEFAULT_OPTIONS_HISTORY.md | 24 - DUMP_FORMAT.md | 16 - FROCKSDB-RELEASE.md | 249 ---- HISTORY.md | 2453 ------------------------------------ LICENSE.Apache => LICENSE | 0 README.md | 15 +- 8 files changed, 43 insertions(+), 3101 deletions(-) delete mode 100644 COPYING delete mode 100644 DEFAULT_OPTIONS_HISTORY.md delete mode 100644 DUMP_FORMAT.md delete mode 100644 FROCKSDB-RELEASE.md delete mode 100644 HISTORY.md rename LICENSE.Apache => LICENSE (100%) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 190100b42..d7ca7890d 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,17 +1,45 @@ -# Contributing to RocksDB +# Contributing to ForSt ## Code of Conduct The code of conduct is described in [`CODE_OF_CONDUCT.md`](CODE_OF_CONDUCT.md) -## Contributor License Agreement ("CLA") +## Basic Development Workflow +As most open-source projects in github, ForSt contributors work on their forks, and send pull requests to ForSt’s repo. After a reviewer approves the pull request and all the CI check are passed, a ForSt team member will merge it. -In order to accept your pull request, we need you to submit a CLA. You -only need to do this once, so if you've done this for another Facebook -open source project, you're good to go. If you are submitting a pull -request for the first time, just let us know that you have completed -the CLA and we can cross-check with your GitHub username. +## Code style +ForSt follows the RocksDB's code format. +RocksDB follows Google C++ Style: https://google.github.io/styleguide/cppguide.html +Note: a common pattern in existing RocksDB code is using non-nullable Type* for output parameters, in the old Google C++ Style, but this guideline has changed. The new guideline prefers (non-const) references for output parameters. +For formatting, we limit each line to 80 characters. Most formatting can be done automatically by running +``` +build_tools/format-diff.sh +``` +or simply ```make format``` if you use GNU make. If you lack of dependencies to run it, the script will print out instructions for you to install them. -Complete your CLA here: -If you prefer to sign a paper copy, we can send you a PDF. Send us an -e-mail or create a new github issue to request the CLA in PDF format. +## License Claim +ForSt is licensed under Apache 2.0 License. But since the RocksDB has its own license, we keep the license claim on top of each existing files, and use/add Apache 2.0 License on top of each new created files. +``` +/* Copyright 2024-present, the ForSt authors. All Rights Reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +``` + +## Submit patches +Before you submit a patch, we strongly recommend that you share your ideas with others +in the community via [Issues](https://github.com/ververica/ForSt/issues) or +[Discussions](https://github.com/ververica/ForSt/discussions). Of course, you do not +need to do this if you are submitting a patch that can already be associated with an +issue, or a minor patch like a typo fix. You can then submit your patch via +[Pull Requests](https://github.com/ververica/ForSt/pulls), which requires a GitHub account. diff --git a/COPYING b/COPYING deleted file mode 100644 index d159169d1..000000000 --- a/COPYING +++ /dev/null @@ -1,339 +0,0 @@ - GNU GENERAL PUBLIC LICENSE - Version 2, June 1991 - - Copyright (C) 1989, 1991 Free Software Foundation, Inc., - 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -License is intended to guarantee your freedom to share and change free -software--to make sure the software is free for all its users. This -General Public License applies to most of the Free Software -Foundation's software and to any other program whose authors commit to -using it. (Some other Free Software Foundation software is covered by -the GNU Lesser General Public License instead.) You can apply it to -your programs, too. - - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -this service if you wish), that you receive source code or can get it -if you want it, that you can change the software or use pieces of it -in new free programs; and that you know you can do these things. - - To protect your rights, we need to make restrictions that forbid -anyone to deny you these rights or to ask you to surrender the rights. -These restrictions translate to certain responsibilities for you if you -distribute copies of the software, or if you modify it. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must give the recipients all the rights that -you have. You must make sure that they, too, receive or can get the -source code. And you must show them these terms so they know their -rights. - - We protect your rights with two steps: (1) copyright the software, and -(2) offer you this license which gives you legal permission to copy, -distribute and/or modify the software. - - Also, for each author's protection and ours, we want to make certain -that everyone understands that there is no warranty for this free -software. If the software is modified by someone else and passed on, we -want its recipients to know that what they have is not the original, so -that any problems introduced by others will not reflect on the original -authors' reputations. - - Finally, any free program is threatened constantly by software -patents. We wish to avoid the danger that redistributors of a free -program will individually obtain patent licenses, in effect making the -program proprietary. To prevent this, we have made it clear that any -patent must be licensed for everyone's free use or not licensed at all. - - The precise terms and conditions for copying, distribution and -modification follow. - - GNU GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License applies to any program or other work which contains -a notice placed by the copyright holder saying it may be distributed -under the terms of this General Public License. The "Program", below, -refers to any such program or work, and a "work based on the Program" -means either the Program or any derivative work under copyright law: -that is to say, a work containing the Program or a portion of it, -either verbatim or with modifications and/or translated into another -language. (Hereinafter, translation is included without limitation in -the term "modification".) Each licensee is addressed as "you". - -Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running the Program is not restricted, and the output from the Program -is covered only if its contents constitute a work based on the -Program (independent of having been made by running the Program). -Whether that is true depends on what the Program does. - - 1. You may copy and distribute verbatim copies of the Program's -source code as you receive it, in any medium, provided that you -conspicuously and appropriately publish on each copy an appropriate -copyright notice and disclaimer of warranty; keep intact all the -notices that refer to this License and to the absence of any warranty; -and give any other recipients of the Program a copy of this License -along with the Program. - -You may charge a fee for the physical act of transferring a copy, and -you may at your option offer warranty protection in exchange for a fee. - - 2. You may modify your copy or copies of the Program or any portion -of it, thus forming a work based on the Program, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) You must cause the modified files to carry prominent notices - stating that you changed the files and the date of any change. - - b) You must cause any work that you distribute or publish, that in - whole or in part contains or is derived from the Program or any - part thereof, to be licensed as a whole at no charge to all third - parties under the terms of this License. - - c) If the modified program normally reads commands interactively - when run, you must cause it, when started running for such - interactive use in the most ordinary way, to print or display an - announcement including an appropriate copyright notice and a - notice that there is no warranty (or else, saying that you provide - a warranty) and that users may redistribute the program under - these conditions, and telling the user how to view a copy of this - License. (Exception: if the Program itself is interactive but - does not normally print such an announcement, your work based on - the Program is not required to print an announcement.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Program, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Program, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Program. - -In addition, mere aggregation of another work not based on the Program -with the Program (or with a work based on the Program) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may copy and distribute the Program (or a work based on it, -under Section 2) in object code or executable form under the terms of -Sections 1 and 2 above provided that you also do one of the following: - - a) Accompany it with the complete corresponding machine-readable - source code, which must be distributed under the terms of Sections - 1 and 2 above on a medium customarily used for software interchange; or, - - b) Accompany it with a written offer, valid for at least three - years, to give any third party, for a charge no more than your - cost of physically performing source distribution, a complete - machine-readable copy of the corresponding source code, to be - distributed under the terms of Sections 1 and 2 above on a medium - customarily used for software interchange; or, - - c) Accompany it with the information you received as to the offer - to distribute corresponding source code. (This alternative is - allowed only for noncommercial distribution and only if you - received the program in object code or executable form with such - an offer, in accord with Subsection b above.) - -The source code for a work means the preferred form of the work for -making modifications to it. For an executable work, complete source -code means all the source code for all modules it contains, plus any -associated interface definition files, plus the scripts used to -control compilation and installation of the executable. However, as a -special exception, the source code distributed need not include -anything that is normally distributed (in either source or binary -form) with the major components (compiler, kernel, and so on) of the -operating system on which the executable runs, unless that component -itself accompanies the executable. - -If distribution of executable or object code is made by offering -access to copy from a designated place, then offering equivalent -access to copy the source code from the same place counts as -distribution of the source code, even though third parties are not -compelled to copy the source along with the object code. - - 4. You may not copy, modify, sublicense, or distribute the Program -except as expressly provided under this License. Any attempt -otherwise to copy, modify, sublicense or distribute the Program is -void, and will automatically terminate your rights under this License. -However, parties who have received copies, or rights, from you under -this License will not have their licenses terminated so long as such -parties remain in full compliance. - - 5. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Program or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Program (or any work based on the -Program), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Program or works based on it. - - 6. Each time you redistribute the Program (or any work based on the -Program), the recipient automatically receives a license from the -original licensor to copy, distribute or modify the Program subject to -these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties to -this License. - - 7. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Program at all. For example, if a patent -license would not permit royalty-free redistribution of the Program by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Program. - -If any portion of this section is held invalid or unenforceable under -any particular circumstance, the balance of the section is intended to -apply and the section as a whole is intended to apply in other -circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system, which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 8. If the distribution and/or use of the Program is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Program under this License -may add an explicit geographical distribution limitation excluding -those countries, so that distribution is permitted only in or among -countries not thus excluded. In such case, this License incorporates -the limitation as if written in the body of this License. - - 9. The Free Software Foundation may publish revised and/or new versions -of the General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - -Each version is given a distinguishing version number. If the Program -specifies a version number of this License which applies to it and "any -later version", you have the option of following the terms and conditions -either of that version or of any later version published by the Free -Software Foundation. If the Program does not specify a version number of -this License, you may choose any version ever published by the Free Software -Foundation. - - 10. If you wish to incorporate parts of the Program into other free -programs whose distribution conditions are different, write to the author -to ask for permission. For software which is copyrighted by the Free -Software Foundation, write to the Free Software Foundation; we sometimes -make exceptions for this. Our decision will be guided by the two goals -of preserving the free status of all derivatives of our free software and -of promoting the sharing and reuse of software generally. - - NO WARRANTY - - 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY -FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN -OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES -PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED -OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS -TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE -PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, -REPAIR OR CORRECTION. - - 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR -REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, -INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING -OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED -TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY -YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER -PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE -POSSIBILITY OF SUCH DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -convey the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License along - with this program; if not, write to the Free Software Foundation, Inc., - 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. - -Also add information on how to contact you by electronic and paper mail. - -If the program is interactive, make it output a short notice like this -when it starts in an interactive mode: - - Gnomovision version 69, Copyright (C) year name of author - Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, the commands you use may -be called something other than `show w' and `show c'; they could even be -mouse-clicks or menu items--whatever suits your program. - -You should also get your employer (if you work as a programmer) or your -school, if any, to sign a "copyright disclaimer" for the program, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the program - `Gnomovision' (which makes passes at compilers) written by James Hacker. - - , 1 April 1989 - Ty Coon, President of Vice - -This General Public License does not permit incorporating your program into -proprietary programs. If your program is a subroutine library, you may -consider it more useful to permit linking proprietary applications with the -library. If this is what you want to do, use the GNU Lesser General -Public License instead of this License. diff --git a/DEFAULT_OPTIONS_HISTORY.md b/DEFAULT_OPTIONS_HISTORY.md deleted file mode 100644 index 82c64d523..000000000 --- a/DEFAULT_OPTIONS_HISTORY.md +++ /dev/null @@ -1,24 +0,0 @@ -# RocksDB default options change log (NO LONGER MAINTAINED) -## Unreleased -* delayed_write_rate takes the rate given by rate_limiter if not specified. - -## 5.2 -* Change the default of delayed slowdown value to 16MB/s and further increase the L0 stop condition to 36 files. - -## 5.0 (11/17/2016) -* Options::allow_concurrent_memtable_write and Options::enable_write_thread_adaptive_yield are now true by default -* Options.level0_stop_writes_trigger default value changes from 24 to 32. - -## 4.8.0 (5/2/2016) -* options.max_open_files changes from 5000 to -1. It improves performance, but users need to set file descriptor limit to be large enough and watch memory usage for index and bloom filters. -* options.base_background_compactions changes from max_background_compactions to 1. When users set higher max_background_compactions but the write throughput is not high, the writes are less spiky to disks. -* options.wal_recovery_mode changes from kTolerateCorruptedTailRecords to kPointInTimeRecovery. Avoid some false positive when file system or hardware reorder the writes for file data and metadata. - -## 4.7.0 (4/8/2016) -* options.write_buffer_size changes from 4MB to 64MB. -* options.target_file_size_base changes from 2MB to 64MB. -* options.max_bytes_for_level_base changes from 10MB to 256MB. -* options.soft_pending_compaction_bytes_limit changes from 0 (disabled) to 64GB. -* options.hard_pending_compaction_bytes_limit changes from 0 (disabled) to 256GB. -* table_cache_numshardbits changes from 4 to 6. -* max_file_opening_threads changes from 1 to 16. diff --git a/DUMP_FORMAT.md b/DUMP_FORMAT.md deleted file mode 100644 index 009dabad5..000000000 --- a/DUMP_FORMAT.md +++ /dev/null @@ -1,16 +0,0 @@ -## RocksDB dump format - -The version 1 RocksDB dump format is fairly simple: - -1) The dump starts with the magic 8 byte identifier "ROCKDUMP" - -2) The magic is followed by an 8 byte big-endian version which is 0x00000001. - -3) Next are arbitrarily sized chunks of bytes prepended by 4 byte little endian number indicating how large each chunk is. - -4) The first chunk is special and is a json string indicating some things about the creation of this dump. It contains the following keys: -* database-path: The path of the database this dump was created from. -* hostname: The hostname of the machine where the dump was created. -* creation-time: Unix seconds since epoc when this dump was created. - -5) Following the info dump the slices paired into are key/value pairs. diff --git a/FROCKSDB-RELEASE.md b/FROCKSDB-RELEASE.md deleted file mode 100644 index 3ec3c2724..000000000 --- a/FROCKSDB-RELEASE.md +++ /dev/null @@ -1,249 +0,0 @@ -# FRocksDB Release Process - -## Summary - -FrocksDB-6.x releases are a fat jar file that contain the following binaries: -* .so files for linux32 (glibc and musl-libc) -* .so files for linux64 (glibc and musl-libc) -* .so files for linux [aarch64](https://en.wikipedia.org/wiki/AArch64) (glibc and musl-libc) -* .so files for linux [ppc64le](https://en.wikipedia.org/wiki/Ppc64le) (glibc and musl-libc) -* .jnilib file for Mac OSX -* .dll for Windows x64 - -To build the binaries for a FrocksDB release, building on native architectures is advised. Building the binaries for ppc64le and aarch64 *can* be done using QEMU, but you may run into emulation bugs and the build times will be dramatically slower (up to x20). - -We recommend building the binaries on environments with at least 4 cores, 16GB RAM and 40GB of storage. The following environments are recommended for use in the build process: -* Windows x64 -* Linux aarch64 -* Linux ppc64le -* Mac OSX - -## Build for Windows - -For the Windows binary build, we recommend using a base [AWS Windows EC2 instance](https://aws.amazon.com/windows/products/ec2/) with 4 cores, 16GB RAM, 40GB storage for the build. - -Firstly, install [chocolatey](https://chocolatey.org/install). Once installed, the following required components can be installed using Powershell: - - choco install git.install jdk8 maven visualstudio2017community visualstudio2017-workload-nativedesktop - -Open the "Developer Command Prompt for VS 2017" and run the following commands: - - git clone git@github.com:ververica/frocksdb.git - cd frocksdb - git checkout FRocksDB-6.20.3 # release branch - java\crossbuild\build-win.bat - -The resulting native binary will be built and available at `build\java\Release\rocksdbjni-shared.dll`. You can also find it under project folder with name `librocksdbjni-win64.dll`. -The result windows jar is `build\java\rocksdbjni_classes.jar`. - -There is also a how-to in CMakeLists.txt. - -**Once finished, extract the `librocksdbjni-win64.dll` from the build environment. You will need this .dll in the final crossbuild.** - -## Build for aarch64 - -For the Linux aarch64 binary build, we recommend using a base [AWS Ubuntu Server 20.04 LTS EC2](https://aws.amazon.com/windows/products/ec2/) with a 4 core Arm processor, 16GB RAM, 40GB storage for the build. You can also attempt to build with QEMU on a non-aarch64 processor, but you may run into emulation bugs and very long build times. - -### Building in aarch64 environment - -First, install the required packages such as Java 8 and make: - - sudo apt-get update - sudo apt-get install build-essential openjdk-8-jdk - -then, install and setup [Docker](https://docs.docker.com/engine/install/ubuntu/): - - sudo apt-get install apt-transport-https ca-certificates curl gnupg lsb-release - - curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg - echo "deb [arch=arm64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null - - sudo apt-get update - sudo apt-get install docker-ce docker-ce-cli containerd.io - - sudo groupadd docker - sudo usermod -aG docker $USER - newgrp docker - -Then, clone the FrocksDB repo: - - git clone https://github.com/ververica/frocksdb.git - cd frocksdb - git checkout FRocksDB-6.20.3 # release branch - - -First, build the glibc binary: - - make jclean clean rocksdbjavastaticdockerarm64v8 - -**Once finished, extract the `java/target/librocksdbjni-linux-aarch64.so` from the build environment. You will need this .so in the final crossbuild.** - -Next, build the musl-libc binary: - - make jclean clean rocksdbjavastaticdockerarm64v8musl - -**Once finished, extract the `java/target/librocksdbjni-linux-aarch64-musl.so` from the build environment. You will need this .so in the final crossbuild.** - -### Building via QEMU - -You can use QEMU on, for example, an `x86_64` system to build the aarch64 binaries. To set this up on an Ubuntu envirnment: - - sudo apt-get install qemu binfmt-support qemu-user-static - docker run --rm --privileged multiarch/qemu-user-static --reset -p yes - -To verify that you can now run aarch64 docker images: - - docker run --rm -t arm64v8/ubuntu uname -m - > aarch64 - -You can now attempt to build the aarch64 binaries as in the previous section. - -## Build in PPC64LE - -For the ppc64le binaries, we recommend building on a PowerPC machine if possible, as it can be tricky to spin up a ppc64le cloud environment. However, if a PowerPC machine is not available, [Travis-CI](https://www.travis-ci.com/) offers ppc64le build environments that work perfectly for building these binaries. If neither a machine or Travis are an option, you can use QEMU but the build may take a very long time and be prone to emulation errors. - -### Building in ppc64le environment - -As with the aarch64 environment, the ppc64le environment will require Java 8, Docker and build-essentials installed. Once installed, you can build the 2 binaries: - - make jclean clean rocksdbjavastaticdockerppc64le - -**Once finished, extract the `java/target/librocksdbjni-linux-ppc64le.so` from the build environment. You will need this .so in the final crossbuild.** - - make jclean clean rocksdbjavastaticdockerppc64lemusl - -**Once finished, extract the `java/target/librocksdbjni-linux-ppc64le-musl.so` from the build environment. You will need this .so in the final crossbuild.** - -### Building via Travis - -Travis-CI supports ppc64le build environments, and this can be a convienient way of building in the absence of a PowerPC machine. Assuming that you have an S3 bucket called **my-frocksdb-release-artifacts**, the following Travis configuration will build the release artifacts and push them to the S3 bucket: - -``` -dist: xenial -language: cpp -os: - - linux -arch: - - ppc64le - -services: - - docker -addons: - artifacts: - paths: - - $TRAVIS_BUILD_DIR/java/target/librocksdbjni-linux-ppc64le-musl.so - - $TRAVIS_BUILD_DIR/java/target/librocksdbjni-linux-ppc64le.so - -env: - global: - - ARTIFACTS_BUCKET=my-rocksdb-release-artifacts - jobs: - - CMD=rocksdbjavastaticdockerppc64le - - CMD=rocksdbjavastaticdockerppc64lemusl - -install: - - sudo apt-get install -y openjdk-8-jdk || exit $? - - export PATH=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture)/bin:$PATH - - export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture) - - echo "JAVA_HOME=${JAVA_HOME}" - - which java && java -version - - which javac && javac -version - -script: - - make jclean clean $CMD -``` - -**Make sure to set the `ARTIFACTS_KEY` and `ARTIFACTS_SECRET` environment variables in the Travis Job with valid AWS credentials to access the S3 bucket you defined.** - -**Once finished, the`librocksdbjni-linux-ppce64le.so` and `librocksdbjni-linux-ppce64le-musl.so` binaries will be in the S3 bucket. You will need these .so binaries in the final crossbuild.** - - -### Building via QEMU - -You can use QEMU on, for example, an `x86_64` system to build the ppc64le binaries. To set this up on an Ubuntu envirnment: - - sudo apt-get install qemu binfmt-support qemu-user-static - docker run --rm --privileged multiarch/qemu-user-static --reset -p yes - -To verify that you can now run ppc64le docker images: - - docker run --rm -t ppc64le/ubuntu uname -m - > ppc64le - -You can now attempt to build the ppc64le binaries as in the previous section. - -## Final crossbuild in Mac OSX - -Documentation for the final crossbuild for Mac OSX and Linux is described in [java/RELEASE.md](java/RELEASE.md) as has information on dependencies that should be installed. As above, this tends to be Java 8, build-essentials and Docker. - -Before you run this step, you should have 5 binaries from the previous build steps: - - 1. `librocksdbjni-win64.dll` from the Windows build step. - 2. `librocksdbjni-linux-aarch64.so` from the aarch64 build step. - 3. `librocksdbjni-linux-aarch64-musl.so` from the aarch64 build step. - 3. `librocksdbjni-linux-ppc64le.so` from the ppc64le build step. - 4. `librocksdbjni-linux-ppc64le-musl.so` from the ppc64le build step. - -To start the crossbuild within a Mac OSX environment: - - make jclean clean - mkdir -p java/target - cp /librocksdbjni-win64.dll java/target/librocksdbjni-win64.dll - cp /librocksdbjni-linux-ppc64le.so java/target/librocksdbjni-linux-ppc64le.so - cp /librocksdbjni-linux-ppc64le-musl.so java/target/librocksdbjni-linux-ppc64le-musl.so - cp /librocksdbjni-linux-aarch64.so java/target/librocksdbjni-linux-aarch64.so - cp /librocksdbjni-linux-aarch64-musl.so java/target/librocksdbjni-linux-aarch64-musl.so - FROCKSDB_VERSION=1.0 PORTABLE=1 ROCKSDB_DISABLE_JEMALLOC=true DEBUG_LEVEL=0 make frocksdbjavastaticreleasedocker - -*Note, we disable jemalloc on mac due to https://github.com/facebook/rocksdb/issues/5787*. - -Once finished, there should be a directory at `java/target/frocksdb-release` with the FRocksDB jar, javadoc jar, sources jar and pom in it. You can inspect the jar file and ensure that contains the binaries, history file, etc: - -``` -$ jar tf frocksdbjni-6.20.3-ververica-1.0.jar -META-INF/ -META-INF/MANIFEST.MF -HISTORY-JAVA.md -HISTORY.md -librocksdbjni-linux-aarch64-musl.so -librocksdbjni-linux-aarch64.so -librocksdbjni-linux-ppc64le-musl.so -librocksdbjni-linux-ppc64le.so -librocksdbjni-linux32-musl.so -librocksdbjni-linux32.so -librocksdbjni-linux64-musl.so -librocksdbjni-linux64.so -librocksdbjni-osx.jnilib -librocksdbjni-win64.dl -... -``` - -*Note that it contains linux32/64.so binaries as well as librocksdbjni-osx.jnilib*. - -## Push to Maven Central - -For this step, you will need the following: - -- The OSX Crossbuild artifacts built in `java/target/frocksdb-release` as above. -- A Sonatype account with access to the staging repository. If you do not have permission, open a ticket with Sonatype, [such as this one](https://issues.sonatype.org/browse/OSSRH-72185). -- A GPG key to sign the release, with your public key available for verification (for example, by uploading it to https://keys.openpgp.org/) - -To upload the release to the Sonatype staging repository: -```bash -VERSION= \ -USER= \ -PASSWORD= \ -KEYNAME= \ -PASSPHRASE= \ -java/publish-frocksdbjni.sh -``` - -Go to the staging repositories on Sonatype: - -https://oss.sonatype.org/#stagingRepositories - -Select the open staging repository and click on "Close". - -The staging repository will look something like `https://oss.sonatype.org/content/repositories/xxxx-1020`. You can use this staged release to test the artifacts and ensure they are correct. - -Once you have verified the artifacts are correct, press the "Release" button. **WARNING: this can not be undone**. Within 24-48 hours, the artifact will be available on Maven Central for use. diff --git a/HISTORY.md b/HISTORY.md deleted file mode 100644 index 36a925ff5..000000000 --- a/HISTORY.md +++ /dev/null @@ -1,2453 +0,0 @@ -# Rocksdb Change Log -> NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt` - -## 8.5.3 (09/01/2023) -### Bug Fixes -* Fixed a race condition in `GenericRateLimiter` that could cause it to stop granting requests - -## 8.5.2 (08/31/2023) -### Bug fixes -* Fix a bug where iterator may return incorrect result for DeleteRange() users if there was an error reading from a file. - -## 8.5.1 (08/31/2023) -### Bug fixes -* Fix a bug where if there is an error reading from offset 0 of a file from L1+ and that the file is not the first file in the sorted run, data can be lost in compaction and read/scan can return incorrect results. - -## 8.5.0 (07/21/2023) -### Public API Changes -* Removed recently added APIs `GeneralCache` and `MakeSharedGeneralCache()` as our plan changed to stop exposing a general-purpose cache interface. The old forms of these APIs, `Cache` and `NewLRUCache()`, are still available, although general-purpose caching support will be dropped eventually. - -### Behavior Changes -* Option `periodic_compaction_seconds` no longer supports FIFO compaction: setting it has no effect on FIFO compactions. FIFO compaction users should only set option `ttl` instead. -* Move prefetching responsibility to page cache for compaction read for non directIO use case - -### Performance Improvements -* In case of direct_io, if buffer passed by callee is already aligned, RandomAccessFileRead::Read will avoid realloacting a new buffer, reducing memcpy and use already passed aligned buffer. -* Small efficiency improvement to HyperClockCache by reducing chance of compiler-generated heap allocations - -### Bug Fixes -* Fix use_after_free bug in async_io MultiReads when underlying FS enabled kFSBuffer. kFSBuffer is when underlying FS pass their own buffer instead of using RocksDB scratch in FSReadRequest. Right now it's an experimental feature. -* Fix a bug in FileTTLBooster that can cause users with a large number of levels (more than 65) to see errors like "runtime error: shift exponent .. is too large.." (#11673). - -## 8.4.0 (06/26/2023) -### New Features -* Add FSReadRequest::fs_scratch which is a data buffer allocated and provided by underlying FileSystem to RocksDB during reads, when FS wants to provide its own buffer with data instead of using RocksDB provided FSReadRequest::scratch. This can help in cpu optimization by avoiding copy from file system's buffer to RocksDB buffer. More details on how to use/enable it in file_system.h. Right now its supported only for MultiReads(async + sync) with non direct io. -* Start logging non-zero user-defined timestamp sizes in WAL to signal user key format in subsequent records and use it during recovery. This change will break recovery from WAL files written by early versions that contain user-defined timestamps. The workaround is to ensure there are no WAL files to recover (i.e. by flushing before close) before upgrade. -* Added new property "rocksdb.obsolete-sst-files-size-property" that reports the size of SST files that have become obsolete but have not yet been deleted or scheduled for deletion -* Start to record the value of the flag `AdvancedColumnFamilyOptions.persist_user_defined_timestamps` in the Manifest and table properties for a SST file when it is created. And use the recorded flag when creating a table reader for the SST file. This flag is only explicitly record if it's false. -* Add a new option OptimisticTransactionDBOptions::shared_lock_buckets that enables sharing mutexes for validating transactions between DB instances, for better balancing memory efficiency and validation contention across DB instances. Different column families and DBs also now use different hash seeds in this validation, so that the same set of key names will not contend across DBs or column families. -* Add a new ticker `rocksdb.files.marked.trash.deleted` to track the number of trash files deleted by background thread from the trash queue. -* Add an API NewTieredVolatileCache() in include/rocksdb/cache.h to allocate an instance of a block cache with a primary block cache tier and a compressed secondary cache tier. A cache of this type distributes memory reservations against the block cache, such as WriteBufferManager, table reader memory etc., proportionally across both the primary and compressed secondary cache. -* Add `WaitForCompact()` to wait for all flush and compactions jobs to finish. Jobs to wait include the unscheduled (queued, but not scheduled yet). -* Add `WriteBatch::Release()` that releases the batch's serialized data to the caller. - -### Public API Changes -* Add C API `rocksdb_options_add_compact_on_deletion_collector_factory_del_ratio`. -* change the FileSystem::use_async_io() API to SupportedOps API in order to extend it to various operations supported by underlying FileSystem. Right now it contains FSSupportedOps::kAsyncIO and FSSupportedOps::kFSBuffer. More details about FSSupportedOps in filesystem.h -* Add new tickers: `rocksdb.error.handler.bg.error.count`, `rocksdb.error.handler.bg.io.error.count`, `rocksdb.error.handler.bg.retryable.io.error.count` to replace the misspelled ones: `rocksdb.error.handler.bg.errro.count`, `rocksdb.error.handler.bg.io.errro.count`, `rocksdb.error.handler.bg.retryable.io.errro.count` ('error' instead of 'errro'). Users should switch to use the new tickers before 9.0 release as the misspelled old tickers will be completely removed then. -* Overload the API CreateColumnFamilyWithImport() to support creating ColumnFamily by importing multiple ColumnFamilies It requires that CFs should not overlap in user key range. - -### Behavior Changes -* Change the default value for option `level_compaction_dynamic_level_bytes` to true. This affects users who use leveled compaction and do not set this option explicitly. These users may see additional background compactions following DB open. These compactions help to shape the LSM according to `level_compaction_dynamic_level_bytes` such that the size of each level Ln is approximately size of Ln-1 * `max_bytes_for_level_multiplier`. Turning on this option has other benefits too: see more detail in wiki: https://github.com/facebook/rocksdb/wiki/Leveled-Compaction#option-level_compaction_dynamic_level_bytes-and-levels-target-size and in option comment in advanced_options.h (#11525). -* For Leveled Compaction users, `CompactRange()` will now always try to compact to the last non-empty level. (#11468) -For Leveled Compaction users, `CompactRange()` with `bottommost_level_compaction = BottommostLevelCompaction::kIfHaveCompactionFilter` will behave similar to `kForceOptimized` in that it will skip files created during this manual compaction when compacting files in the bottommost level. (#11468) -* RocksDB will try to drop range tombstones during non-bottommost compaction when it is safe to do so. (#11459) -* When a DB is openend with `allow_ingest_behind=true` (currently only Universal compaction is supported), files in the last level, i.e. the ingested files, will not be included in any compaction. (#11489) -* Statistics `rocksdb.sst.read.micros` scope is expanded to all SST reads except for file ingestion and column family import (some compaction reads were previously excluded). - -### Bug Fixes -* Reduced cases of illegally using Env::Default() during static destruction by never destroying the internal PosixEnv itself (except for builds checking for memory leaks). (#11538) -* Fix extra prefetching during seek in async_io when BlockBasedTableOptions.num_file_reads_for_auto_readahead is 1 leading to extra reads than required. -* Fix a bug where compactions that are qualified to be run as 2 subcompactions were only run as one subcompaction. -* Fix a use-after-move bug in block.cc. - -## 8.3.0 (05/19/2023) -### New Features -* Introduced a new option `block_protection_bytes_per_key`, which can be used to enable per key-value integrity protection for in-memory blocks in block cache (#11287). -* Added `JemallocAllocatorOptions::num_arenas`. Setting `num_arenas > 1` may mitigate mutex contention in the allocator, particularly in scenarios where block allocations commonly bypass jemalloc tcache. -* Improve the operational safety of publishing a DB or SST files to many hosts by using different block cache hash seeds on different hosts. The exact behavior is controlled by new option `ShardedCacheOptions::hash_seed`, which also documents the solved problem in more detail. -* Introduced a new option `CompactionOptionsFIFO::file_temperature_age_thresholds` that allows FIFO compaction to compact files to different temperatures based on key age (#11428). -* Added a new ticker stat to count how many times RocksDB detected a corruption while verifying a block checksum: `BLOCK_CHECKSUM_MISMATCH_COUNT`. -* New statistics `rocksdb.file.read.db.open.micros` that measures read time of block-based SST tables or blob files during db open. -* New statistics tickers for various iterator seek behaviors and relevant filtering, as \*`_LEVEL_SEEK_`\*. (#11460) - -### Public API Changes -* EXPERIMENTAL: Add new API `DB::ClipColumnFamily` to clip the key in CF to a certain range. It will physically deletes all keys outside the range including tombstones. -* Add `MakeSharedCache()` construction functions to various cache Options objects, and deprecated the `NewWhateverCache()` functions with long parameter lists. -* Changed the meaning of various Bloom filter stats (prefix vs. whole key), with iterator-related filtering only being tracked in the new \*`_LEVEL_SEEK_`\*. stats. (#11460) - -### Behavior changes -* For x86, CPU features are no longer detected at runtime nor in build scripts, but in source code using common preprocessor defines. This will likely unlock some small performance improvements on some newer hardware, but could hurt performance of the kCRC32c checksum, which is no longer the default, on some "portable" builds. See PR #11419 for details. - -### Bug Fixes -* Delete an empty WAL file on DB open if the log number is less than the min log number to keep -* Delete temp OPTIONS file on DB open if there is a failure to write it out or rename it - -### Performance Improvements -* Improved the I/O efficiency of prefetching SST metadata by recording more information in the DB manifest. Opening files written with previous versions will still rely on heuristics for how much to prefetch (#11406). - -## 8.2.0 (04/24/2023) -### Public API Changes -* `SstFileWriter::DeleteRange()` now returns `Status::InvalidArgument` if the range's end key comes before its start key according to the user comparator. Previously the behavior was undefined. -* Add `multi_get_for_update` to C API. -* Remove unnecessary constructor for CompressionOptions. - -### Behavior changes -* Changed default block cache size from an 8MB to 32MB LRUCache, which increases the default number of cache shards from 16 to 64. This change is intended to minimize cache mutex contention under stress conditions. See https://github.com/facebook/rocksdb/wiki/Block-Cache for more information. -* For level compaction with `level_compaction_dynamic_level_bytes=true`, RocksDB now trivially moves levels down to fill LSM starting from bottommost level during DB open. See more in comments for option `level_compaction_dynamic_level_bytes` (#11321). -* User-provided `ReadOptions` take effect for more reads of non-`CacheEntryRole::kDataBlock` blocks. -* For level compaction with `level_compaction_dynamic_level_bytes=true`, RocksDB now drains unnecessary levels through background compaction automatically (#11340). This together with #11321 makes it automatic to migrate other compaction settings to level compaction with `level_compaction_dynamic_level_bytes=true`. In addition, a live DB that becomes smaller will now have unnecessary levels drained which can help to reduce read and space amp. -* If `CompactRange()` is called with `CompactRangeOptions::bottommost_level_compaction=kForce*` to compact from L0 to L1, RocksDB now will try to do trivial move from L0 to L1 and then do an intra L1 compaction, instead of a L0 to L1 compaction with trivial move disabled (#11375)). - -### Bug Fixes -* In the DB::VerifyFileChecksums API, ensure that file system reads of SST files are equal to the readahead_size in ReadOptions, if specified. Previously, each read was 2x the readahead_size. -* In block cache tracing, fixed some cases of bad hit/miss information (and more) with MultiGet. - -### New Features -* Add experimental `PerfContext` counters `iter_{next|prev|seek}_count` for db iterator, each counting the times of corresponding API being called. -* Allow runtime changes to whether `WriteBufferManager` allows stall or not by calling `SetAllowStall()` -* Added statistics tickers BYTES_COMPRESSED_FROM, BYTES_COMPRESSED_TO, BYTES_COMPRESSION_BYPASSED, BYTES_COMPRESSION_REJECTED, NUMBER_BLOCK_COMPRESSION_BYPASSED, and NUMBER_BLOCK_COMPRESSION_REJECTED. Disabled/deprecated histograms BYTES_COMPRESSED and BYTES_DECOMPRESSED, and ticker NUMBER_BLOCK_NOT_COMPRESSED. The new tickers offer more inight into compression ratios, rejected vs. disabled compression, etc. (#11388) -* New statistics `rocksdb.file.read.{flush|compaction}.micros` that measure read time of block-based SST tables or blob files during flush or compaction. - -## 8.1.0 (03/18/2023) -### Behavior changes -* Compaction output file cutting logic now considers range tombstone start keys. For example, SST partitioner now may receive ParitionRequest for range tombstone start keys. -* If the async_io ReadOption is specified for MultiGet or NewIterator on a platform that doesn't support IO uring, the option is ignored and synchronous IO is used. - -### Bug Fixes -* Fixed an issue for backward iteration when user defined timestamp is enabled in combination with BlobDB. -* Fixed a couple of cases where a Merge operand encountered during iteration wasn't reflected in the `internal_merge_count` PerfContext counter. -* Fixed a bug in CreateColumnFamilyWithImport()/ExportColumnFamily() which did not support range tombstones (#11252). -* Fixed a bug where an excluded column family from an atomic flush contains unflushed data that should've been included in this atomic flush (i.e, data of seqno less than the max seqno of this atomic flush), leading to potential data loss in this excluded column family when `WriteOptions::disableWAL == true` (#11148). - -### New Features -* Add statistics rocksdb.secondary.cache.filter.hits, rocksdb.secondary.cache.index.hits, and rocksdb.secondary.cache.filter.hits -* Added a new PerfContext counter `internal_merge_point_lookup_count` which tracks the number of Merge operands applied while serving point lookup queries. -* Add new statistics rocksdb.table.open.prefetch.tail.read.bytes, rocksdb.table.open.prefetch.tail.{miss|hit} -* Add support for SecondaryCache with HyperClockCache (`HyperClockCacheOptions` inherits `secondary_cache` option from `ShardedCacheOptions`) -* Add new db properties `rocksdb.cf-write-stall-stats`, `rocksdb.db-write-stall-stats`and APIs to examine them in a structured way. In particular, users of `GetMapProperty()` with property `kCFWriteStallStats`/`kDBWriteStallStats` can now use the functions in `WriteStallStatsMapKeys` to find stats in the map. - -### Public API Changes -* Changed various functions and features in `Cache` that are mostly relevant to custom implementations or wrappers. Especially, asychronous lookup functionality is moved from `Lookup()` to a new `StartAsyncLookup()` function. - -## 8.0.0 (02/19/2023) -### Behavior changes -* `ReadOptions::verify_checksums=false` disables checksum verification for more reads of non-`CacheEntryRole::kDataBlock` blocks. -* In case of scan with async_io enabled, if posix doesn't support IOUring, Status::NotSupported error will be returned to the users. Initially that error was swallowed and reads were switched to synchronous reads. - -### Bug Fixes -* Fixed a data race on `ColumnFamilyData::flush_reason` caused by concurrent flushes. -* Fixed an issue in `Get` and `MultiGet` when user-defined timestamps is enabled in combination with BlobDB. -* Fixed some atypical behaviors for `LockWAL()` such as allowing concurrent/recursive use and not expecting `UnlockWAL()` after non-OK result. See API comments. -* Fixed a feature interaction bug where for blobs `GetEntity` would expose the blob reference instead of the blob value. -* Fixed `DisableManualCompaction()` and `CompactRangeOptions::canceled` to cancel compactions even when they are waiting on conflicting compactions to finish -* Fixed a bug in which a successful `GetMergeOperands()` could transiently return `Status::MergeInProgress()` -* Return the correct error (Status::NotSupported()) to MultiGet caller when ReadOptions::async_io flag is true and IO uring is not enabled. Previously, Status::Corruption() was being returned when the actual failure was lack of async IO support. -* Fixed a bug in DB open/recovery from a compressed WAL that was caused due to incorrect handling of certain record fragments with the same offset within a WAL block. - -### Feature Removal -* Remove RocksDB Lite. -* The feature block_cache_compressed is removed. Statistics related to it are removed too. -* Remove deprecated Env::LoadEnv(). Use Env::CreateFromString() instead. -* Remove deprecated FileSystem::Load(). Use FileSystem::CreateFromString() instead. -* Removed the deprecated version of these utility functions and the corresponding Java bindings: `LoadOptionsFromFile`, `LoadLatestOptions`, `CheckOptionsCompatibility`. -* Remove the FactoryFunc from the LoadObject method from the Customizable helper methods. - -### Public API Changes -* Moved rarely-needed Cache class definition to new advanced_cache.h, and added a CacheWrapper class to advanced_cache.h. Minor changes to SimCache API definitions. -* Completely removed the following deprecated/obsolete statistics: the tickers `BLOCK_CACHE_INDEX_BYTES_EVICT`, `BLOCK_CACHE_FILTER_BYTES_EVICT`, `BLOOM_FILTER_MICROS`, `NO_FILE_CLOSES`, `STALL_L0_SLOWDOWN_MICROS`, `STALL_MEMTABLE_COMPACTION_MICROS`, `STALL_L0_NUM_FILES_MICROS`, `RATE_LIMIT_DELAY_MILLIS`, `NO_ITERATORS`, `NUMBER_FILTERED_DELETES`, `WRITE_TIMEDOUT`, `BLOB_DB_GC_NUM_KEYS_OVERWRITTEN`, `BLOB_DB_GC_NUM_KEYS_EXPIRED`, `BLOB_DB_GC_BYTES_OVERWRITTEN`, `BLOB_DB_GC_BYTES_EXPIRED`, `BLOCK_CACHE_COMPRESSION_DICT_BYTES_EVICT` as well as the histograms `STALL_L0_SLOWDOWN_COUNT`, `STALL_MEMTABLE_COMPACTION_COUNT`, `STALL_L0_NUM_FILES_COUNT`, `HARD_RATE_LIMIT_DELAY_COUNT`, `SOFT_RATE_LIMIT_DELAY_COUNT`, `BLOB_DB_GC_MICROS`, and `NUM_DATA_BLOCKS_READ_PER_LEVEL`. Note that as a result, the C++ enum values of the still supported statistics have changed. Developers are advised to not rely on the actual numeric values. -* Deprecated IngestExternalFileOptions::write_global_seqno and change default to false. This option only needs to be set to true to generate a DB compatible with RocksDB versions before 5.16.0. -* Remove deprecated APIs `GetColumnFamilyOptionsFrom{Map|String}(const ColumnFamilyOptions&, ..)`, `GetDBOptionsFrom{Map|String}(const DBOptions&, ..)`, `GetBlockBasedTableOptionsFrom{Map|String}(const BlockBasedTableOptions& table_options, ..)` and ` GetPlainTableOptionsFrom{Map|String}(const PlainTableOptions& table_options,..)`. -* Added a subcode of `Status::Corruption`, `Status::SubCode::kMergeOperatorFailed`, for users to identify corruption failures originating in the merge operator, as opposed to RocksDB's internally identified data corruptions - -### Build Changes -* The `make` build now builds a shared library by default instead of a static library. Use `LIB_MODE=static` to override. - -### New Features -* Compaction filters are now supported for wide-column entities by means of the `FilterV3` API. See the comment of the API for more details. -* Added `do_not_compress_roles` to `CompressedSecondaryCacheOptions` to disable compression on certain kinds of block. Filter blocks are now not compressed by CompressedSecondaryCache by default. -* Added a new `MultiGetEntity` API that enables batched wide-column point lookups. See the API comments for more details. - -## 7.10.0 (01/23/2023) -### Behavior changes -* Make best-efforts recovery verify SST unique ID before Version construction (#10962) -* Introduce `epoch_number` and sort L0 files by `epoch_number` instead of `largest_seqno`. `epoch_number` represents the order of a file being flushed or ingested/imported. Compaction output file will be assigned with the minimum `epoch_number` among input files'. For L0, larger `epoch_number` indicates newer L0 file. - -### Bug Fixes -* Fixed a regression in iterator where range tombstones after `iterate_upper_bound` is processed. -* Fixed a memory leak in MultiGet with async_io read option, caused by IO errors during table file open -* Fixed a bug that multi-level FIFO compaction deletes one file in non-L0 even when `CompactionOptionsFIFO::max_table_files_size` is no exceeded since #10348 or 7.8.0. -* Fixed a bug caused by `DB::SyncWAL()` affecting `track_and_verify_wals_in_manifest`. Without the fix, application may see "open error: Corruption: Missing WAL with log number" while trying to open the db. The corruption is a false alarm but prevents DB open (#10892). -* Fixed a BackupEngine bug in which RestoreDBFromLatestBackup would fail if the latest backup was deleted and there is another valid backup available. -* Fix L0 file misorder corruption caused by ingesting files of overlapping seqnos with memtable entries' through introducing `epoch_number`. Before the fix, `force_consistency_checks=true` may catch the corruption before it's exposed to readers, in which case writes returning `Status::Corruption` would be expected. Also replace the previous incomplete fix (#5958) to the same corruption with this new and more complete fix. -* Fixed a bug in LockWAL() leading to re-locking mutex (#11020). -* Fixed a heap use after free bug in async scan prefetching when the scan thread and another thread try to read and load the same seek block into cache. -* Fixed a heap use after free in async scan prefetching if dictionary compression is enabled, in which case sync read of the compression dictionary gets mixed with async prefetching -* Fixed a data race bug of `CompactRange()` under `change_level=true` acts on overlapping range with an ongoing file ingestion for level compaction. This will either result in overlapping file ranges corruption at a certain level caught by `force_consistency_checks=true` or protentially two same keys both with seqno 0 in two different levels (i.e, new data ends up in lower/older level). The latter will be caught by assertion in debug build but go silently and result in read returning wrong result in release build. This fix is general so it also replaced previous fixes to a similar problem for `CompactFiles()` (#4665), general `CompactRange()` and auto compaction (commit 5c64fb6 and 87dfc1d). -* Fixed a bug in compaction output cutting where small output files were produced due to TTL file cutting states were not being updated (#11075). - -### New Features -* When an SstPartitionerFactory is configured, CompactRange() now automatically selects for compaction any files overlapping a partition boundary that is in the compaction range, even if no actual entries are in the requested compaction range. With this feature, manual compaction can be used to (re-)establish SST partition points when SstPartitioner changes, without a full compaction. -* Add BackupEngine feature to exclude files from backup that are known to be backed up elsewhere, using `CreateBackupOptions::exclude_files_callback`. To restore the DB, the excluded files must be provided in alternative backup directories using `RestoreOptions::alternate_dirs`. - -### Public API Changes -* Substantial changes have been made to the Cache class to support internal development goals. Direct use of Cache class members is discouraged and further breaking modifications are expected in the future. SecondaryCache has some related changes and implementations will need to be updated. (Unlike Cache, SecondaryCache is still intended to support user implementations, and disruptive changes will be avoided.) (#10975) -* Add `MergeOperationOutput::op_failure_scope` for merge operator users to control the blast radius of merge operator failures. Existing merge operator users do not need to make any change to preserve the old behavior - -### Performance Improvements -* Updated xxHash source code, which should improve kXXH3 checksum speed, at least on ARM (#11098). -* Improved CPU efficiency of DB reads, from block cache access improvements (#10975). - -## 7.9.0 (11/21/2022) -### Performance Improvements -* Fixed an iterator performance regression for delete range users when scanning through a consecutive sequence of range tombstones (#10877). - -### Bug Fixes -* Fix memory corruption error in scans if async_io is enabled. Memory corruption happened if there is IOError while reading the data leading to empty buffer and other buffer already in progress of async read goes again for reading. -* Fix failed memtable flush retry bug that could cause wrongly ordered updates, which would surface to writers as `Status::Corruption` in case of `force_consistency_checks=true` (default). It affects use cases that enable both parallel flush (`max_background_flushes > 1` or `max_background_jobs >= 8`) and non-default memtable count (`max_write_buffer_number > 2`). -* Fixed an issue where the `READ_NUM_MERGE_OPERANDS` ticker was not updated when the base key-value or tombstone was read from an SST file. -* Fixed a memory safety bug when using a SecondaryCache with `block_cache_compressed`. `block_cache_compressed` no longer attempts to use SecondaryCache features. -* Fixed a regression in scan for async_io. During seek, valid buffers were getting cleared causing a regression. -* Tiered Storage: fixed excessive keys written to penultimate level in non-debug builds. - -### New Features -* Add basic support for user-defined timestamp to Merge (#10819). -* Add stats for ReadAsync time spent and async read errors. -* Basic support for the wide-column data model is now available. Wide-column entities can be stored using the `PutEntity` API, and retrieved using `GetEntity` and the new `columns` API of iterator. For compatibility, the classic APIs `Get` and `MultiGet`, as well as iterator's `value` API return the value of the anonymous default column of wide-column entities; also, `GetEntity` and iterator's `columns` return any plain key-values in the form of an entity which only has the anonymous default column. `Merge` (and `GetMergeOperands`) currently also apply to the default column; any other columns of entities are unaffected by `Merge` operations. Note that some features like compaction filters, transactions, user-defined timestamps, and the SST file writer do not yet support wide-column entities; also, there is currently no `MultiGet`-like API to retrieve multiple entities at once. We plan to gradually close the above gaps and also implement new features like column-level operations (e.g. updating or querying only certain columns of an entity). -* Marked HyperClockCache as a production-ready alternative to LRUCache for the block cache. HyperClockCache greatly improves hot-path CPU efficiency under high parallel load or high contention, with some documented caveats and limitations. As much as 4.5x higher ops/sec vs. LRUCache has been seen in db_bench under high parallel load. -* Add periodic diagnostics to info_log (LOG file) for HyperClockCache block cache if performance is degraded by bad `estimated_entry_charge` option. - -### Public API Changes -* Marked `block_cache_compressed` as a deprecated feature. Use SecondaryCache instead. -* Added a `SecondaryCache::InsertSaved()` API, with default implementation depending on `Insert()`. Some implementations might need to add a custom implementation of `InsertSaved()`. (Details in API comments.) - -## 7.8.0 (10/22/2022) -### New Features -* `DeleteRange()` now supports user-defined timestamp. -* Provide support for async_io with tailing iterators when ReadOptions.tailing is enabled during scans. -* Tiered Storage: allow data moving up from the last level to the penultimate level if the input level is penultimate level or above. -* Added `DB::Properties::kFastBlockCacheEntryStats`, which is similar to `DB::Properties::kBlockCacheEntryStats`, except returns cached (stale) values in more cases to reduce overhead. -* FIFO compaction now supports migrating from a multi-level DB via DB::Open(). During the migration phase, FIFO compaction picker will: -* picks the sst file with the smallest starting key in the bottom-most non-empty level. -* Note that during the migration phase, the file purge order will only be an approximation of "FIFO" as files in lower-level might sometime contain newer keys than files in upper-level. -* Added an option `ignore_max_compaction_bytes_for_input` to ignore max_compaction_bytes limit when adding files to be compacted from input level. This should help reduce write amplification. The option is enabled by default. -* Tiered Storage: allow data moving up from the last level even if it's a last level only compaction, as long as the penultimate level is empty. -* Add a new option IOOptions.do_not_recurse that can be used by underlying file systems to skip recursing through sub directories and list only files in GetChildren API. -* Add option `preserve_internal_time_seconds` to preserve the time information for the latest data. Which can be used to determine the age of data when `preclude_last_level_data_seconds` is enabled. The time information is attached with SST in table property `rocksdb.seqno.time.map` which can be parsed by tool ldb or sst_dump. - -### Bug Fixes -* Fix a bug in io_uring_prep_cancel in AbortIO API for posix which expects sqe->addr to match with read request submitted and wrong paramter was being passed. -* Fixed a regression in iterator performance when the entire DB is a single memtable introduced in #10449. The fix is in #10705 and #10716. -* Fixed an optimistic transaction validation bug caused by DBImpl::GetLatestSequenceForKey() returning non-latest seq for merge (#10724). -* Fixed a bug in iterator refresh which could segfault for DeleteRange users (#10739). -* Fixed a bug causing manual flush with `flush_opts.wait=false` to stall when database has stopped all writes (#10001). -* Fixed a bug in iterator refresh that was not freeing up SuperVersion, which could cause excessive resource pinniung (#10770). -* Fixed a bug where RocksDB could be doing compaction endlessly when allow_ingest_behind is true and the bottommost level is not filled (#10767). -* Fixed a memory safety bug in experimental HyperClockCache (#10768) -* Fixed some cases where `ldb update_manifest` and `ldb unsafe_remove_sst_file` are not usable because they were requiring the DB files to match the existing manifest state (before updating the manifest to match a desired state). - -### Performance Improvements -* Try to align the compaction output file boundaries to the next level ones, which can reduce more than 10% compaction load for the default level compaction. The feature is enabled by default, to disable, set `AdvancedColumnFamilyOptions.level_compaction_dynamic_file_size` to false. As a side effect, it can create SSTs larger than the target_file_size (capped at 2x target_file_size) or smaller files. -* Improve RoundRobin TTL compaction, which is going to be the same as normal RoundRobin compaction to move the compaction cursor. -* Fix a small CPU regression caused by a change that UserComparatorWrapper was made Customizable, because Customizable itself has small CPU overhead for initialization. - -### Behavior Changes -* Sanitize min_write_buffer_number_to_merge to 1 if atomic flush is enabled to prevent unexpected data loss when WAL is disabled in a multi-column-family setting (#10773). -* With periodic stat dumper waits up every options.stats_dump_period_sec seconds, it won't dump stats for a CF if it has no change in the period, unless 7 periods have been skipped. -* Only periodic stats dumper triggered by options.stats_dump_period_sec will update stats interval. Ones triggered by DB::GetProperty() will not update stats interval and will report based on an interval since the last time stats dump period. - -### Public API changes -* Make kXXH3 checksum the new default, because it is faster on common hardware, especially with kCRC32c affected by a performance bug in some versions of clang (https://github.com/facebook/rocksdb/issues/9891). DBs written with this new setting can be read by RocksDB 6.27 and newer. -* Refactor the classes, APIs and data structures for block cache tracing to allow a user provided trace writer to be used. Introduced an abstract BlockCacheTraceWriter class that takes a structured BlockCacheTraceRecord. The BlockCacheTraceWriter implementation can then format and log the record in whatever way it sees fit. The default BlockCacheTraceWriterImpl does file tracing using a user provided TraceWriter. More details in rocksdb/includb/block_cache_trace_writer.h. - -## 7.7.0 (09/18/2022) -### Bug Fixes -* Fixed a hang when an operation such as `GetLiveFiles` or `CreateNewBackup` is asked to trigger and wait for memtable flush on a read-only DB. Such indirect requests for memtable flush are now ignored on a read-only DB. -* Fixed bug where `FlushWAL(true /* sync */)` (used by `GetLiveFilesStorageInfo()`, which is used by checkpoint and backup) could cause parallel writes at the tail of a WAL file to never be synced. -* Fix periodic_task unable to re-register the same task type, which may cause `SetOptions()` fail to update periodical_task time like: `stats_dump_period_sec`, `stats_persist_period_sec`. -* Fixed a bug in the rocksdb.prefetched.bytes.discarded stat. It was counting the prefetch buffer size, rather than the actual number of bytes discarded from the buffer. -* Fix bug where the directory containing CURRENT can left unsynced after CURRENT is updated to point to the latest MANIFEST, which leads to risk of unsync data loss of CURRENT. -* Update rocksdb.multiget.io.batch.size stat in non-async MultiGet as well. -* Fix a bug in key range overlap checking with concurrent compactions when user-defined timestamp is enabled. User-defined timestamps should be EXCLUDED when checking if two ranges overlap. -* Fixed a bug where the blob cache prepopulating logic did not consider the secondary cache (see #10603). -* Fixed the rocksdb.num.sst.read.per.level, rocksdb.num.index.and.filter.blocks.read.per.level and rocksdb.num.level.read.per.multiget stats in the MultiGet coroutines - -### Public API changes -* Add `rocksdb_column_family_handle_get_id`, `rocksdb_column_family_handle_get_name` to get name, id of column family in C API -* Add a new stat rocksdb.async.prefetch.abort.micros to measure time spent waiting for async prefetch reads to abort - -### Java API Changes -* Add CompactionPriority.RoundRobin. -* Revert to using the default metadata charge policy when creating an LRU cache via the Java API. - -### Behavior Change -* DBOptions::verify_sst_unique_id_in_manifest is now an on-by-default feature that verifies SST file identity whenever they are opened by a DB, rather than only at DB::Open time. -* Right now, when the option migration tool (OptionChangeMigration()) migrates to FIFO compaction, it compacts all the data into one single SST file and move to L0. This might create a problem for some users: the giant file may be soon deleted to satisfy max_table_files_size, and might cayse the DB to be almost empty. We change the behavior so that the files are cut to be smaller, but these files might not follow the data insertion order. With the change, after the migration, migrated data might not be dropped by insertion order by FIFO compaction. -* When a block is firstly found from `CompressedSecondaryCache`, we just insert a dummy block into the primary cache and don’t erase the block from `CompressedSecondaryCache`. A standalone handle is returned to the caller. Only if the block is found again from `CompressedSecondaryCache` before the dummy block is evicted, we erase the block from `CompressedSecondaryCache` and insert it into the primary cache. -* When a block is firstly evicted from the primary cache to `CompressedSecondaryCache`, we just insert a dummy block in `CompressedSecondaryCache`. Only if it is evicted again before the dummy block is evicted from the cache, it is treated as a hot block and is inserted into `CompressedSecondaryCache`. -* Improved the estimation of memory used by cached blobs by taking into account the size of the object owning the blob value and also the allocator overhead if `malloc_usable_size` is available (see #10583). -* Blob values now have their own category in the cache occupancy statistics, as opposed to being lumped into the "Misc" bucket (see #10601). -* Change the optimize_multiget_for_io experimental ReadOptions flag to default on. - -### New Features -* RocksDB does internal auto prefetching if it notices 2 sequential reads if readahead_size is not specified. New option `num_file_reads_for_auto_readahead` is added in BlockBasedTableOptions which indicates after how many sequential reads internal auto prefetching should be start (default is 2). -* Added new perf context counters `block_cache_standalone_handle_count`, `block_cache_real_handle_count`,`compressed_sec_cache_insert_real_count`, `compressed_sec_cache_insert_dummy_count`, `compressed_sec_cache_uncompressed_bytes`, and `compressed_sec_cache_compressed_bytes`. -* Memory for blobs which are to be inserted into the blob cache is now allocated using the cache's allocator (see #10628 and #10647). -* HyperClockCache is an experimental, lock-free Cache alternative for block cache that offers much improved CPU efficiency under high parallel load or high contention, with some caveats. As much as 4.5x higher ops/sec vs. LRUCache has been seen in db_bench under high parallel load. -* `CompressedSecondaryCacheOptions::enable_custom_split_merge` is added for enabling the custom split and merge feature, which split the compressed value into chunks so that they may better fit jemalloc bins. - -### Performance Improvements -* Iterator performance is improved for `DeleteRange()` users. Internally, iterator will skip to the end of a range tombstone when possible, instead of looping through each key and check individually if a key is range deleted. -* Eliminated some allocations and copies in the blob read path. Also, `PinnableSlice` now only points to the blob value and pins the backing resource (cache entry or buffer) in all cases, instead of containing a copy of the blob value. See #10625 and #10647. -* In case of scans with async_io enabled, few optimizations have been added to issue more asynchronous requests in parallel in order to avoid synchronous prefetching. -* `DeleteRange()` users should see improvement in get/iterator performance from mutable memtable (see #10547). - -## 7.6.0 (08/19/2022) -### New Features -* Added `prepopulate_blob_cache` to ColumnFamilyOptions. If enabled, prepopulate warm/hot blobs which are already in memory into blob cache at the time of flush. On a flush, the blob that is in memory (in memtables) get flushed to the device. If using Direct IO, additional IO is incurred to read this blob back into memory again, which is avoided by enabling this option. This further helps if the workload exhibits high temporal locality, where most of the reads go to recently written data. This also helps in case of the remote file system since it involves network traffic and higher latencies. -* Support using secondary cache with the blob cache. When creating a blob cache, the user can set a secondary blob cache by configuring `secondary_cache` in LRUCacheOptions. -* Charge memory usage of blob cache when the backing cache of the blob cache and the block cache are different. If an operation reserving memory for blob cache exceeds the avaible space left in the block cache at some point (i.e, causing a cache full under `LRUCacheOptions::strict_capacity_limit` = true), creation will fail with `Status::MemoryLimit()`. To opt in this feature, enable charging `CacheEntryRole::kBlobCache` in `BlockBasedTableOptions::cache_usage_options`. -* Improve subcompaction range partition so that it is likely to be more even. More evenly distribution of subcompaction will improve compaction throughput for some workloads. All input files' index blocks to sample some anchor key points from which we pick positions to partition the input range. This would introduce some CPU overhead in compaction preparation phase, if subcompaction is enabled, but it should be a small fraction of the CPU usage of the whole compaction process. This also brings a behavier change: subcompaction number is much more likely to maxed out than before. -* Add CompactionPri::kRoundRobin, a compaction picking mode that cycles through all the files with a compact cursor in a round-robin manner. This feature is available since 7.5. -* Provide support for subcompactions for user_defined_timestamp. -* Added an option `memtable_protection_bytes_per_key` that turns on memtable per key-value checksum protection. Each memtable entry will be suffixed by a checksum that is computed during writes, and verified in reads/compaction. Detected corruption will be logged and with corruption status returned to user. -* Added a blob-specific cache priority level - bottom level. Blobs are typically lower-value targets for caching than data blocks, since 1) with BlobDB, data blocks containing blob references conceptually form an index structure which has to be consulted before we can read the blob value, and 2) cached blobs represent only a single key-value, while cached data blocks generally contain multiple KVs. The user can specify the new option `low_pri_pool_ratio` in `LRUCacheOptions` to configure the ratio of capacity reserved for low priority cache entries (and therefore the remaining ratio is the space reserved for the bottom level), or configuring the new argument `low_pri_pool_ratio` in `NewLRUCache()` to achieve the same effect. - -### Public API changes -* Removed Customizable support for RateLimiter and removed its CreateFromString() and Type() functions. -* `CompactRangeOptions::exclusive_manual_compaction` is now false by default. This ensures RocksDB does not introduce artificial parallelism limitations by default. -* Tiered Storage: change `bottommost_temperture` to `last_level_temperture`. The old option name is kept only for migration, please use the new option. The behavior is changed to apply temperature for the `last_level` SST files only. -* Added a new experimental ReadOption flag called optimize_multiget_for_io, which when set attempts to reduce MultiGet latency by spawning coroutines for keys in multiple levels. - -### Bug Fixes -* Fix a bug starting in 7.4.0 in which some fsync operations might be skipped in a DB after any DropColumnFamily on that DB, until it is re-opened. This can lead to data loss on power loss. (For custom FileSystem implementations, this could lead to `FSDirectory::Fsync` or `FSDirectory::Close` after the first `FSDirectory::Close`; Also, valgrind could report call to `close()` with `fd=-1`.) -* Fix a bug where `GenericRateLimiter` could revert the bandwidth set dynamically using `SetBytesPerSecond()` when a user configures a structure enclosing it, e.g., using `GetOptionsFromString()` to configure an `Options` that references an existing `RateLimiter` object. -* Fix race conditions in `GenericRateLimiter`. -* Fix a bug in `FIFOCompactionPicker::PickTTLCompaction` where total_size calculating might cause underflow -* Fix data race bug in hash linked list memtable. With this bug, read request might temporarily miss an old record in the memtable in a race condition to the hash bucket. -* Fix a bug that `best_efforts_recovery` may fail to open the db with mmap read. -* Fixed a bug where blobs read during compaction would pollute the cache. -* Fixed a data race in LRUCache when used with a secondary_cache. -* Fixed a bug where blobs read by iterators would be inserted into the cache even with the `fill_cache` read option set to false. -* Fixed the segfault caused by `AllocateData()` in `CompressedSecondaryCache::SplitValueIntoChunks()` and `MergeChunksIntoValueTest`. -* Fixed a bug in BlobDB where a mix of inlined and blob values could result in an incorrect value being passed to the compaction filter (see #10391). -* Fixed a memory leak bug in stress tests caused by `FaultInjectionSecondaryCache`. - -### Behavior Change -* Added checksum handshake during the copying of decompressed WAL fragment. This together with #9875, #10037, #10212, #10114 and #10319 provides end-to-end integrity protection for write batch during recovery. -* To minimize the internal fragmentation caused by the variable size of the compressed blocks in `CompressedSecondaryCache`, the original block is split according to the jemalloc bin size in `Insert()` and then merged back in `Lookup()`. -* PosixLogger is removed and by default EnvLogger will be used for info logging. The behavior of the two loggers should be very similar when using the default Posix Env. -* Remove [min|max]_timestamp from VersionEdit for now since they are not tracked in MANIFEST anyway but consume two empty std::string (up to 64 bytes) for each file. Should they be added back in the future, we should store them more compactly. -* Improve universal tiered storage compaction picker to avoid extra major compaction triggered by size amplification. If `preclude_last_level_data_seconds` is enabled, the size amplification is calculated within non last_level data only which skip the last level and use the penultimate level as the size base. -* If an error is hit when writing to a file (append, sync, etc), RocksDB is more strict with not issuing more operations to it, except closing the file, with exceptions of some WAL file operations in error recovery path. -* A `WriteBufferManager` constructed with `allow_stall == false` will no longer trigger write stall implicitly by thrashing until memtable count limit is reached. Instead, a column family can continue accumulating writes while that CF is flushing, which means memory may increase. Users who prefer stalling writes must now explicitly set `allow_stall == true`. -* Add `CompressedSecondaryCache` into the stress tests. -* Block cache keys have changed, which will cause any persistent caches to miss between versions. - -### Performance Improvements -* Instead of constructing `FragmentedRangeTombstoneList` during every read operation, it is now constructed once and stored in immutable memtables. This improves speed of querying range tombstones from immutable memtables. -* When using iterators with the integrated BlobDB implementation, blob cache handles are now released immediately when the iterator's position changes. -* MultiGet can now do more IO in parallel by reading data blocks from SST files in multiple levels, if the optimize_multiget_for_io ReadOption flag is set. - -## 7.5.0 (07/15/2022) -### New Features -* Mempurge option flag `experimental_mempurge_threshold` is now a ColumnFamilyOptions and can now be dynamically configured using `SetOptions()`. -* Support backward iteration when `ReadOptions::iter_start_ts` is set. -* Provide support for ReadOptions.async_io with direct_io to improve Seek latency by using async IO to parallelize child iterator seek and doing asynchronous prefetching on sequential scans. -* Added support for blob caching in order to cache frequently used blobs for BlobDB. - * User can configure the new ColumnFamilyOptions `blob_cache` to enable/disable blob caching. - * Either sharing the backend cache with the block cache or using a completely separate cache is supported. - * A new abstraction interface called `BlobSource` for blob read logic gives all users access to blobs, whether they are in the blob cache, secondary cache, or (remote) storage. Blobs can be potentially read both while handling user reads (`Get`, `MultiGet`, or iterator) and during compaction (while dealing with compaction filters, Merges, or garbage collection) but eventually all blob reads go through `Version::GetBlob` or, for MultiGet, `Version::MultiGetBlob` (and then get dispatched to the interface -- `BlobSource`). -* Add experimental tiered compaction feature `AdvancedColumnFamilyOptions::preclude_last_level_data_seconds`, which makes sure the new data inserted within preclude_last_level_data_seconds won't be placed on cold tier (the feature is not complete). - -### Public API changes -* Add metadata related structs and functions in C API, including - * `rocksdb_get_column_family_metadata()` and `rocksdb_get_column_family_metadata_cf()` to obtain `rocksdb_column_family_metadata_t`. - * `rocksdb_column_family_metadata_t` and its get functions & destroy function. - * `rocksdb_level_metadata_t` and its and its get functions & destroy function. - * `rocksdb_file_metadata_t` and its and get functions & destroy functions. -* Add suggest_compact_range() and suggest_compact_range_cf() to C API. -* When using block cache strict capacity limit (`LRUCache` with `strict_capacity_limit=true`), DB operations now fail with Status code `kAborted` subcode `kMemoryLimit` (`IsMemoryLimit()`) instead of `kIncomplete` (`IsIncomplete()`) when the capacity limit is reached, because Incomplete can mean other specific things for some operations. In more detail, `Cache::Insert()` now returns the updated Status code and this usually propagates through RocksDB to the user on failure. -* NewClockCache calls temporarily return an LRUCache (with similar characteristics as the desired ClockCache). This is because ClockCache is being replaced by a new version (the old one had unknown bugs) but this is still under development. -* Add two functions `int ReserveThreads(int threads_to_be_reserved)` and `int ReleaseThreads(threads_to_be_released)` into `Env` class. In the default implementation, both return 0. Newly added `xxxEnv` class that inherits `Env` should implement these two functions for thread reservation/releasing features. -* Add `rocksdb_options_get_prepopulate_blob_cache` and `rocksdb_options_set_prepopulate_blob_cache` to C API. -* Add `prepopulateBlobCache` and `setPrepopulateBlobCache` to Java API. - -### Bug Fixes -* Fix a bug in which backup/checkpoint can include a WAL deleted by RocksDB. -* Fix a bug where concurrent compactions might cause unnecessary further write stalling. In some cases, this might cause write rate to drop to minimum. -* Fix a bug in Logger where if dbname and db_log_dir are on different filesystems, dbname creation would fail wrt to db_log_dir path returning an error and fails to open the DB. -* Fix a CPU and memory efficiency issue introduce by https://github.com/facebook/rocksdb/pull/8336 which made InternalKeyComparator configurable as an unintended side effect. - -## Behavior Change -* In leveled compaction with dynamic levelling, level multiplier is not anymore adjusted due to oversized L0. Instead, compaction score is adjusted by increasing size level target by adding incoming bytes from upper levels. This would deprioritize compactions from upper levels if more data from L0 is coming. This is to fix some unnecessary full stalling due to drastic change of level targets, while not wasting write bandwidth for compaction while writes are overloaded. -* For track_and_verify_wals_in_manifest, revert to the original behavior before #10087: syncing of live WAL file is not tracked, and we track only the synced sizes of **closed** WALs. (PR #10330). -* WAL compression now computes/verifies checksum during compression/decompression. - -### Performance Improvements -* Rather than doing total sort against all files in a level, SortFileByOverlappingRatio() to only find the top 50 files based on score. This can improve write throughput for the use cases where data is loaded in increasing key order and there are a lot of files in one LSM-tree, where applying compaction results is the bottleneck. -* In leveled compaction, L0->L1 trivial move will allow more than one file to be moved in one compaction. This would allow L0 files to be moved down faster when data is loaded in sequential order, making slowdown or stop condition harder to hit. Also seek L0->L1 trivial move when only some files qualify. -* In leveled compaction, try to trivial move more than one files if possible, up to 4 files or max_compaction_bytes. This is to allow higher write throughput for some use cases where data is loaded in sequential order, where appying compaction results is the bottleneck. - -## 7.4.0 (06/19/2022) -### Bug Fixes -* Fixed a bug in calculating key-value integrity protection for users of in-place memtable updates. In particular, the affected users would be those who configure `protection_bytes_per_key > 0` on `WriteBatch` or `WriteOptions`, and configure `inplace_callback != nullptr`. -* Fixed a bug where a snapshot taken during SST file ingestion would be unstable. -* Fixed a bug for non-TransactionDB with avoid_flush_during_recovery = true and TransactionDB where in case of crash, min_log_number_to_keep may not change on recovery and persisting a new MANIFEST with advanced log_numbers for some column families, results in "column family inconsistency" error on second recovery. As a solution, RocksDB will persist the new MANIFEST after successfully syncing the new WAL. If a future recovery starts from the new MANIFEST, then it means the new WAL is successfully synced. Due to the sentinel empty write batch at the beginning, kPointInTimeRecovery of WAL is guaranteed to go after this point. If future recovery starts from the old MANIFEST, it means the writing the new MANIFEST failed. We won't have the "SST ahead of WAL" error. -* Fixed a bug where RocksDB DB::Open() may creates and writes to two new MANIFEST files even before recovery succeeds. Now writes to MANIFEST are persisted only after recovery is successful. -* Fix a race condition in WAL size tracking which is caused by an unsafe iterator access after container is changed. -* Fix unprotected concurrent accesses to `WritableFileWriter::filesize_` by `DB::SyncWAL()` and `DB::Put()` in two write queue mode. -* Fix a bug in WAL tracking. Before this PR (#10087), calling `SyncWAL()` on the only WAL file of the db will not log the event in MANIFEST, thus allowing a subsequent `DB::Open` even if the WAL file is missing or corrupted. -* Fix a bug that could return wrong results with `index_type=kHashSearch` and using `SetOptions` to change the `prefix_extractor`. -* Fixed a bug in WAL tracking with wal_compression. WAL compression writes a kSetCompressionType record which is not associated with any sequence number. As result, WalManager::GetSortedWalsOfType() will skip these WALs and not return them to caller, e.g. Checkpoint, Backup, causing the operations to fail. -* Avoid a crash if the IDENTITY file is accidentally truncated to empty. A new DB ID will be written and generated on Open. -* Fixed a possible corruption for users of `manual_wal_flush` and/or `FlushWAL(true /* sync */)`, together with `track_and_verify_wals_in_manifest == true`. For those users, losing unsynced data (e.g., due to power loss) could make future DB opens fail with a `Status::Corruption` complaining about missing WAL data. -* Fixed a bug in `WriteBatchInternal::Append()` where WAL termination point in write batch was not considered and the function appends an incorrect number of checksums. -* Fixed a crash bug introduced in 7.3.0 affecting users of MultiGet with `kDataBlockBinaryAndHash`. - -### Public API changes -* Add new API GetUnixTime in Snapshot class which returns the unix time at which Snapshot is taken. -* Add transaction `get_pinned` and `multi_get` to C API. -* Add two-phase commit support to C API. -* Add `rocksdb_transaction_get_writebatch_wi` and `rocksdb_transaction_rebuild_from_writebatch` to C API. -* Add `rocksdb_options_get_blob_file_starting_level` and `rocksdb_options_set_blob_file_starting_level` to C API. -* Add `blobFileStartingLevel` and `setBlobFileStartingLevel` to Java API. -* Add SingleDelete for DB in C API -* Add User Defined Timestamp in C API. - * `rocksdb_comparator_with_ts_create` to create timestamp aware comparator - * Put, Get, Delete, SingleDelete, MultiGet APIs has corresponding timestamp aware APIs with suffix `with_ts` - * And Add C API's for Transaction, SstFileWriter, Compaction as mentioned [here](https://github.com/facebook/rocksdb/wiki/User-defined-Timestamp-(Experimental)) -* The contract for implementations of Comparator::IsSameLengthImmediateSuccessor has been updated to work around a design bug in `auto_prefix_mode`. -* The API documentation for `auto_prefix_mode` now notes some corner cases in which it returns different results than `total_order_seek`, due to design bugs that are not easily fixed. Users using built-in comparators and keys at least the size of a fixed prefix length are not affected. -* Obsoleted the NUM_DATA_BLOCKS_READ_PER_LEVEL stat and introduced the NUM_LEVEL_READ_PER_MULTIGET and MULTIGET_COROUTINE_COUNT stats -* Introduced `WriteOptions::protection_bytes_per_key`, which can be used to enable key-value integrity protection for live updates. - -### New Features -* Add FileSystem::ReadAsync API in io_tracing -* Add blob garbage collection parameters `blob_garbage_collection_policy` and `blob_garbage_collection_age_cutoff` to both force-enable and force-disable GC, as well as selectively override age cutoff when using CompactRange. -* Add an extra sanity check in `GetSortedWalFiles()` (also used by `GetLiveFilesStorageInfo()`, `BackupEngine`, and `Checkpoint`) to reduce risk of successfully created backup or checkpoint failing to open because of missing WAL file. -* Add a new column family option `blob_file_starting_level` to enable writing blob files during flushes and compactions starting from the specified LSM tree level. -* Add support for timestamped snapshots (#9879) -* Provide support for AbortIO in posix to cancel submitted asynchronous requests using io_uring. -* Add support for rate-limiting batched `MultiGet()` APIs -* Added several new tickers, perf context statistics, and DB properties to BlobDB - * Added new DB properties "rocksdb.blob-cache-capacity", "rocksdb.blob-cache-usage", "rocksdb.blob-cache-pinned-usage" to show blob cache usage. - * Added new perf context statistics `blob_cache_hit_count`, `blob_read_count`, `blob_read_byte`, `blob_read_time`, `blob_checksum_time` and `blob_decompress_time`. - * Added new tickers `BLOB_DB_CACHE_MISS`, `BLOB_DB_CACHE_HIT`, `BLOB_DB_CACHE_ADD`, `BLOB_DB_CACHE_ADD_FAILURES`, `BLOB_DB_CACHE_BYTES_READ` and `BLOB_DB_CACHE_BYTES_WRITE`. - -### Behavior changes -* DB::Open(), DB::OpenAsSecondary() will fail if a Logger cannot be created (#9984) -* DB::Write does not hold global `mutex_` if this db instance does not need to switch wal and mem-table (#7516). -* Removed support for reading Bloom filters using obsolete block-based filter format. (Support for writing such filters was dropped in 7.0.) For good read performance on old DBs using these filters, a full compaction is required. -* Per KV checksum in write batch is verified before a write batch is written to WAL to detect any corruption to the write batch (#10114). - -### Performance Improvements -* When compiled with folly (Meta-internal integration; experimental in open source build), improve the locking performance (CPU efficiency) of LRUCache by using folly DistributedMutex in place of standard mutex. - -## 7.3.0 (05/20/2022) -### Bug Fixes -* Fixed a bug where manual flush would block forever even though flush options had wait=false. -* Fixed a bug where RocksDB could corrupt DBs with `avoid_flush_during_recovery == true` by removing valid WALs, leading to `Status::Corruption` with message like "SST file is ahead of WALs" when attempting to reopen. -* Fixed a bug in async_io path where incorrect length of data is read by FilePrefetchBuffer if data is consumed from two populated buffers and request for more data is sent. -* Fixed a CompactionFilter bug. Compaction filter used to use `Delete` to remove keys, even if the keys should be removed with `SingleDelete`. Mixing `Delete` and `SingleDelete` may cause undefined behavior. -* Fixed a bug in `WritableFileWriter::WriteDirect` and `WritableFileWriter::WriteDirectWithChecksum`. The rate_limiter_priority specified in ReadOptions was not passed to the RateLimiter when requesting a token. -* Fixed a bug which might cause process crash when I/O error happens when reading an index block in MultiGet(). - -### New Features -* DB::GetLiveFilesStorageInfo is ready for production use. -* Add new stats PREFETCHED_BYTES_DISCARDED which records number of prefetched bytes discarded by RocksDB FilePrefetchBuffer on destruction and POLL_WAIT_MICROS records wait time for FS::Poll API completion. -* RemoteCompaction supports table_properties_collector_factories override on compaction worker. -* Start tracking SST unique id in MANIFEST, which will be used to verify with SST properties during DB open to make sure the SST file is not overwritten or misplaced. A db option `verify_sst_unique_id_in_manifest` is introduced to enable/disable the verification, if enabled all SST files will be opened during DB-open to verify the unique id (default is false), so it's recommended to use it with `max_open_files = -1` to pre-open the files. -* Added the ability to concurrently read data blocks from multiple files in a level in batched MultiGet. This can be enabled by setting the async_io option in ReadOptions. Using this feature requires a FileSystem that supports ReadAsync (PosixFileSystem is not supported yet for this), and for RocksDB to be compiled with folly and c++20. -* Charge memory usage of file metadata. RocksDB holds one file metadata structure in-memory per on-disk table file. If an operation reserving memory for file metadata exceeds the avaible space left in the block -cache at some point (i.e, causing a cache full under `LRUCacheOptions::strict_capacity_limit` = true), creation will fail with `Status::MemoryLimit()`. To opt in this feature, enable charging `CacheEntryRole::kFileMetadata` in `BlockBasedTableOptions::cache_usage_options`. - -### Public API changes -* Add rollback_deletion_type_callback to TransactionDBOptions so that write-prepared transactions know whether to issue a Delete or SingleDelete to cancel a previous key written during prior prepare phase. The PR aims to prevent mixing SingleDeletes and Deletes for the same key that can lead to undefined behaviors for write-prepared transactions. -* EXPERIMENTAL: Add new API AbortIO in file_system to abort the read requests submitted asynchronously. -* CompactionFilter::Decision has a new value: kRemoveWithSingleDelete. If CompactionFilter returns this decision, then CompactionIterator will use `SingleDelete` to mark a key as removed. -* Renamed CompactionFilter::Decision::kRemoveWithSingleDelete to kPurge since the latter sounds more general and hides the implementation details of how compaction iterator handles keys. -* Added ability to specify functions for Prepare and Validate to OptionsTypeInfo. Added methods to OptionTypeInfo to set the functions via an API. These methods are intended for RocksDB plugin developers for configuration management. -* Added a new immutable db options, enforce_single_del_contracts. If set to false (default is true), compaction will NOT fail due to a single delete followed by a delete for the same key. The purpose of this temporay option is to help existing use cases migrate. -* Introduce `BlockBasedTableOptions::cache_usage_options` and use that to replace `BlockBasedTableOptions::reserve_table_builder_memory` and `BlockBasedTableOptions::reserve_table_reader_memory`. -* Changed `GetUniqueIdFromTableProperties` to return a 128-bit unique identifier, which will be the standard size now. The old functionality (192-bit) is available from `GetExtendedUniqueIdFromTableProperties`. Both functions are no longer "experimental" and are ready for production use. -* In IOOptions, mark `prio` as deprecated for future removal. -* In `file_system.h`, mark `IOPriority` as deprecated for future removal. -* Add an option, `CompressionOptions::use_zstd_dict_trainer`, to indicate whether zstd dictionary trainer should be used for generating zstd compression dictionaries. The default value of this option is true for backward compatibility. When this option is set to false, zstd API `ZDICT_finalizeDictionary` is used to generate compression dictionaries. -* Seek API which positions itself every LevelIterator on the correct data block in the correct SST file which can be parallelized if ReadOptions.async_io option is enabled. -* Add new stat number_async_seek in PerfContext that indicates number of async calls made by seek to prefetch data. -* Add support for user-defined timestamps to read only DB. - -### Bug Fixes -* RocksDB calls FileSystem::Poll API during FilePrefetchBuffer destruction which impacts performance as it waits for read requets completion which is not needed anymore. Calling FileSystem::AbortIO to abort those requests instead fixes that performance issue. -* Fixed unnecessary block cache contention when queries within a MultiGet batch and across parallel batches access the same data block, which previously could cause severely degraded performance in this unusual case. (In more typical MultiGet cases, this fix is expected to yield a small or negligible performance improvement.) - -### Behavior changes -* Enforce the existing contract of SingleDelete so that SingleDelete cannot be mixed with Delete because it leads to undefined behavior. Fix a number of unit tests that violate the contract but happen to pass. -* ldb `--try_load_options` default to true if `--db` is specified and not creating a new DB, the user can still explicitly disable that by `--try_load_options=false` (or explicitly enable that by `--try_load_options`). -* During Flush write or Compaction write/read, the WriteController is used to determine whether DB writes are stalled or slowed down. The priority (Env::IOPriority) can then be determined accordingly and be passed in IOOptions to the file system. - -### Performance Improvements -* Avoid calling malloc_usable_size() in LRU Cache's mutex. -* Reduce DB mutex holding time when finding obsolete files to delete. When a file is trivial moved to another level, the internal files will be referenced twice internally and sometimes opened twice too. If a deletion candidate file is not the last reference, we need to destroy the reference and close the file but not deleting the file. Right now we determine it by building a set of all live files. With the improvement, we check the file against all live LSM-tree versions instead. - -## 7.2.0 (04/15/2022) -### Bug Fixes -* Fixed bug which caused rocksdb failure in the situation when rocksdb was accessible using UNC path -* Fixed a race condition when 2PC is disabled and WAL tracking in the MANIFEST is enabled. The race condition is between two background flush threads trying to install flush results, causing a WAL deletion not tracked in the MANIFEST. A future DB open may fail. -* Fixed a heap use-after-free race with DropColumnFamily. -* Fixed a bug that `rocksdb.read.block.compaction.micros` cannot track compaction stats (#9722). -* Fixed `file_type`, `relative_filename` and `directory` fields returned by `GetLiveFilesMetaData()`, which were added in inheriting from `FileStorageInfo`. -* Fixed a bug affecting `track_and_verify_wals_in_manifest`. Without the fix, application may see "open error: Corruption: Missing WAL with log number" while trying to open the db. The corruption is a false alarm but prevents DB open (#9766). -* Fix segfault in FilePrefetchBuffer with async_io as it doesn't wait for pending jobs to complete on destruction. -* Fix ERROR_HANDLER_AUTORESUME_RETRY_COUNT stat whose value was set wrong in portal.h -* Fixed a bug for non-TransactionDB with avoid_flush_during_recovery = true and TransactionDB where in case of crash, min_log_number_to_keep may not change on recovery and persisting a new MANIFEST with advanced log_numbers for some column families, results in "column family inconsistency" error on second recovery. As a solution the corrupted WALs whose numbers are larger than the corrupted wal and smaller than the new WAL will be moved to archive folder. -* Fixed a bug in RocksDB DB::Open() which may creates and writes to two new MANIFEST files even before recovery succeeds. Now writes to MANIFEST are persisted only after recovery is successful. - -### New Features -* For db_bench when --seed=0 or --seed is not set then it uses the current time as the seed value. Previously it used the value 1000. -* For db_bench when --benchmark lists multiple tests and each test uses a seed for a RNG then the seeds across tests will no longer be repeated. -* Added an option to dynamically charge an updating estimated memory usage of block-based table reader to block cache if block cache available. To enable this feature, set `BlockBasedTableOptions::reserve_table_reader_memory = true`. -* Add new stat ASYNC_READ_BYTES that calculates number of bytes read during async read call and users can check if async code path is being called by RocksDB internal automatic prefetching for sequential reads. -* Enable async prefetching if ReadOptions.readahead_size is set along with ReadOptions.async_io in FilePrefetchBuffer. -* Add event listener support on remote compaction compactor side. -* Added a dedicated integer DB property `rocksdb.live-blob-file-garbage-size` that exposes the total amount of garbage in the blob files in the current version. -* RocksDB does internal auto prefetching if it notices sequential reads. It starts with readahead size `initial_auto_readahead_size` which now can be configured through BlockBasedTableOptions. -* Add a merge operator that allows users to register specific aggregation function so that they can does aggregation using different aggregation types for different keys. See comments in include/rocksdb/utilities/agg_merge.h for actual usage. The feature is experimental and the format is subject to change and we won't provide a migration tool. -* Meta-internal / Experimental: Improve CPU performance by replacing many uses of std::unordered_map with folly::F14FastMap when RocksDB is compiled together with Folly. -* Experimental: Add CompressedSecondaryCache, a concrete implementation of rocksdb::SecondaryCache, that integrates with compression libraries (e.g. LZ4) to hold compressed blocks. - -### Behavior changes -* Disallow usage of commit-time-write-batch for write-prepared/write-unprepared transactions if TransactionOptions::use_only_the_last_commit_time_batch_for_recovery is false to prevent two (or more) uncommitted versions of the same key in the database. Otherwise, bottommost compaction may violate the internal key uniqueness invariant of SSTs if the sequence numbers of both internal keys are zeroed out (#9794). -* Make DB::GetUpdatesSince() return NotSupported early for write-prepared/write-unprepared transactions, as the API contract indicates. - -### Public API changes -* Exposed APIs to examine results of block cache stats collections in a structured way. In particular, users of `GetMapProperty()` with property `kBlockCacheEntryStats` can now use the functions in `BlockCacheEntryStatsMapKeys` to find stats in the map. -* Add `fail_if_not_bottommost_level` to IngestExternalFileOptions so that ingestion will fail if the file(s) cannot be ingested to the bottommost level. -* Add output parameter `is_in_sec_cache` to `SecondaryCache::Lookup()`. It is to indicate whether the handle is possibly erased from the secondary cache after the Lookup. - -## 7.1.0 (03/23/2022) -### New Features -* Allow WriteBatchWithIndex to index a WriteBatch that includes keys with user-defined timestamps. The index itself does not have timestamp. -* Add support for user-defined timestamps to write-committed transaction without API change. The `TransactionDB` layer APIs do not allow timestamps because we require that all user-defined-timestamps-aware operations go through the `Transaction` APIs. -* Added BlobDB options to `ldb` -* `BlockBasedTableOptions::detect_filter_construct_corruption` can now be dynamically configured using `DB::SetOptions`. -* Automatically recover from retryable read IO errors during backgorund flush/compaction. -* Experimental support for preserving file Temperatures through backup and restore, and for updating DB metadata for outside changes to file Temperature (`UpdateManifestForFilesState` or `ldb update_manifest --update_temperatures`). -* Experimental support for async_io in ReadOptions which is used by FilePrefetchBuffer to prefetch some of the data asynchronously, if reads are sequential and auto readahead is enabled by rocksdb internally. - -### Bug Fixes -* Fixed a major performance bug in which Bloom filters generated by pre-7.0 releases are not read by early 7.0.x releases (and vice-versa) due to changes to FilterPolicy::Name() in #9590. This can severely impact read performance and read I/O on upgrade or downgrade with existing DB, but not data correctness. -* Fixed a data race on `versions_` between `DBImpl::ResumeImpl()` and threads waiting for recovery to complete (#9496) -* Fixed a bug caused by race among flush, incoming writes and taking snapshots. Queries to snapshots created with these race condition can return incorrect result, e.g. resurfacing deleted data. -* Fixed a bug that DB flush uses `options.compression` even `options.compression_per_level` is set. -* Fixed a bug that DisableManualCompaction may assert when disable an unscheduled manual compaction. -* Fix a race condition when cancel manual compaction with `DisableManualCompaction`. Also DB close can cancel the manual compaction thread. -* Fixed a potential timer crash when open close DB concurrently. -* Fixed a race condition for `alive_log_files_` in non-two-write-queues mode. The race is between the write_thread_ in WriteToWAL() and another thread executing `FindObsoleteFiles()`. The race condition will be caught if `__glibcxx_requires_nonempty` is enabled. -* Fixed a bug that `Iterator::Refresh()` reads stale keys after DeleteRange() performed. -* Fixed a race condition when disable and re-enable manual compaction. -* Fixed automatic error recovery failure in atomic flush. -* Fixed a race condition when mmaping a WritableFile on POSIX. - -### Public API changes -* Added pure virtual FilterPolicy::CompatibilityName(), which is needed for fixing major performance bug involving FilterPolicy naming in SST metadata without affecting Customizable aspect of FilterPolicy. This change only affects those with their own custom or wrapper FilterPolicy classes. -* `options.compression_per_level` is dynamically changeable with `SetOptions()`. -* Added `WriteOptions::rate_limiter_priority`. When set to something other than `Env::IO_TOTAL`, the internal rate limiter (`DBOptions::rate_limiter`) will be charged at the specified priority for writes associated with the API to which the `WriteOptions` was provided. Currently the support covers automatic WAL flushes, which happen during live updates (`Put()`, `Write()`, `Delete()`, etc.) when `WriteOptions::disableWAL == false` and `DBOptions::manual_wal_flush == false`. -* Add DB::OpenAndTrimHistory API. This API will open DB and trim data to the timestamp specified by trim_ts (The data with timestamp larger than specified trim bound will be removed). This API should only be used at a timestamp-enabled column families recovery. If the column family doesn't have timestamp enabled, this API won't trim any data on that column family. This API is not compatible with avoid_flush_during_recovery option. -* Remove BlockBasedTableOptions.hash_index_allow_collision which already takes no effect. - -## 7.0.0 (02/20/2022) -### Bug Fixes -* Fixed a major bug in which batched MultiGet could return old values for keys deleted by DeleteRange when memtable Bloom filter is enabled (memtable_prefix_bloom_size_ratio > 0). (The fix includes a substantial MultiGet performance improvement in the unusual case of both memtable_whole_key_filtering and prefix_extractor.) -* Fixed more cases of EventListener::OnTableFileCreated called with OK status, file_size==0, and no SST file kept. Now the status is Aborted. -* Fixed a read-after-free bug in `DB::GetMergeOperands()`. -* Fix a data loss bug for 2PC write-committed transaction caused by concurrent transaction commit and memtable switch (#9571). -* Fixed NUM_INDEX_AND_FILTER_BLOCKS_READ_PER_LEVEL, NUM_DATA_BLOCKS_READ_PER_LEVEL, and NUM_SST_READ_PER_LEVEL stats to be reported once per MultiGet batch per level. - -### Performance Improvements -* Mitigated the overhead of building the file location hash table used by the online LSM tree consistency checks, which can improve performance for certain workloads (see #9351). -* Switched to using a sorted `std::vector` instead of `std::map` for storing the metadata objects for blob files, which can improve performance for certain workloads, especially when the number of blob files is high. -* DisableManualCompaction() doesn't have to wait scheduled manual compaction to be executed in thread-pool to cancel the job. - -### Public API changes -* Require C++17 compatible compiler (GCC >= 7, Clang >= 5, Visual Studio >= 2017) for compiling RocksDB and any code using RocksDB headers. See #9388. -* Added `ReadOptions::rate_limiter_priority`. When set to something other than `Env::IO_TOTAL`, the internal rate limiter (`DBOptions::rate_limiter`) will be charged at the specified priority for file reads associated with the API to which the `ReadOptions` was provided. -* Remove HDFS support from main repo. -* Remove librados support from main repo. -* Remove obsolete backupable_db.h and type alias `BackupableDBOptions`. Use backup_engine.h and `BackupEngineOptions`. Similar renamings are in the C and Java APIs. -* Removed obsolete utility_db.h and `UtilityDB::OpenTtlDB`. Use db_ttl.h and `DBWithTTL::Open`. -* Remove deprecated API DB::AddFile from main repo. -* Remove deprecated API ObjectLibrary::Register() and the (now obsolete) Regex public API. Use ObjectLibrary::AddFactory() with PatternEntry instead. -* Remove deprecated option DBOption::table_cache_remove_scan_count_limit. -* Remove deprecated API AdvancedColumnFamilyOptions::soft_rate_limit. -* Remove deprecated API AdvancedColumnFamilyOptions::hard_rate_limit. -* Remove deprecated API DBOption::base_background_compactions. -* Remove deprecated API DBOptions::purge_redundant_kvs_while_flush. -* Remove deprecated overloads of API DB::CompactRange. -* Remove deprecated option DBOptions::skip_log_error_on_recovery. -* Remove ReadOptions::iter_start_seqnum which has been deprecated. -* Remove DBOptions::preserved_deletes and DB::SetPreserveDeletesSequenceNumber(). -* Remove deprecated API AdvancedColumnFamilyOptions::rate_limit_delay_max_milliseconds. -* Removed timestamp from WriteOptions. Accordingly, added to DB APIs Put, Delete, SingleDelete, etc. accepting an additional argument 'timestamp'. Added Put, Delete, SingleDelete, etc to WriteBatch accepting an additional argument 'timestamp'. Removed WriteBatch::AssignTimestamps(vector) API. Renamed WriteBatch::AssignTimestamp() to WriteBatch::UpdateTimestamps() with clarified comments. -* Changed type of cache buffer passed to `Cache::CreateCallback` from `void*` to `const void*`. -* Significant updates to FilterPolicy-related APIs and configuration: - * Remove public API support for deprecated, inefficient block-based filter (use_block_based_builder=true). - * Old code and configuration strings that would enable it now quietly enable full filters instead, though any built-in FilterPolicy can still read block-based filters. This includes changing the longstanding default behavior of the Java API. - * Remove deprecated FilterPolicy::CreateFilter() and FilterPolicy::KeyMayMatch() - * Remove `rocksdb_filterpolicy_create()` from C API, as the only C API support for custom filter policies is now obsolete. - * If temporary memory usage in full filter creation is a problem, consider using partitioned filters, smaller SST files, or setting reserve_table_builder_memory=true. - * Remove support for "filter_policy=experimental_ribbon" configuration - string. Use something like "filter_policy=ribbonfilter:10" instead. - * Allow configuration string like "filter_policy=bloomfilter:10" without - bool, to minimize acknowledgement of obsolete block-based filter. - * Made FilterPolicy Customizable. Configuration of filter_policy is now accurately saved in OPTIONS file and can be loaded with LoadOptionsFromFile. (Loading an OPTIONS file generated by a previous version only enables reading and using existing filters, not generating new filters. Previously, no filter_policy would be configured from a saved OPTIONS file.) - * Change meaning of nullptr return from GetBuilderWithContext() from "use - block-based filter" to "generate no filter in this case." - * Also, when user specifies bits_per_key < 0.5, we now round this down - to "no filter" because we expect a filter with >= 80% FP rate is - unlikely to be worth the CPU cost of accessing it (esp with - cache_index_and_filter_blocks=1 or partition_filters=1). - * bits_per_key >= 0.5 and < 1.0 is still rounded up to 1.0 (for 62% FP - rate) - * Remove class definitions for FilterBitsBuilder and FilterBitsReader from - public API, so these can evolve more easily as implementation details. - Custom FilterPolicy can still decide what kind of built-in filter to use - under what conditions. - * Also removed deprecated functions - * FilterPolicy::GetFilterBitsBuilder() - * NewExperimentalRibbonFilterPolicy() - * Remove default implementations of - * FilterPolicy::GetBuilderWithContext() -* Remove default implementation of Name() from FileSystemWrapper. -* Rename `SizeApproximationOptions.include_memtabtles` to `SizeApproximationOptions.include_memtables`. -* Remove deprecated option DBOptions::max_mem_compaction_level. -* Return Status::InvalidArgument from ObjectRegistry::NewObject if a factory exists but the object ould not be created (returns NotFound if the factory is missing). -* Remove deprecated overloads of API DB::GetApproximateSizes. -* Remove deprecated option DBOptions::new_table_reader_for_compaction_inputs. -* Add Transaction::SetReadTimestampForValidation() and Transaction::SetCommitTimestamp(). Default impl returns NotSupported(). -* Add support for decimal patterns to ObjectLibrary::PatternEntry -* Remove deprecated remote compaction APIs `CompactionService::Start()` and `CompactionService::WaitForComplete()`. Please use `CompactionService::StartV2()`, `CompactionService::WaitForCompleteV2()` instead, which provides the same information plus extra data like priority, db_id, etc. -* `ColumnFamilyOptions::OldDefaults` and `DBOptions::OldDefaults` are marked deprecated, as they are no longer maintained. -* Add subcompaction callback APIs: `OnSubcompactionBegin()` and `OnSubcompactionCompleted()`. -* Add file Temperature information to `FileOperationInfo` in event listener API. -* Change the type of SizeApproximationFlags from enum to enum class. Also update the signature of DB::GetApproximateSizes API from uint8_t to SizeApproximationFlags. -* Add Temperature hints information from RocksDB in API `NewSequentialFile()`. backup and checkpoint operations need to open the source files with `NewSequentialFile()`, which will have the temperature hints. Other operations are not covered. - -### Behavior Changes -* Disallow the combination of DBOptions.use_direct_io_for_flush_and_compaction == true and DBOptions.writable_file_max_buffer_size == 0. This combination can cause WritableFileWriter::Append() to loop forever, and it does not make much sense in direct IO. -* `ReadOptions::total_order_seek` no longer affects `DB::Get()`. The original motivation for this interaction has been obsolete since RocksDB has been able to detect whether the current prefix extractor is compatible with that used to generate table files, probably RocksDB 5.14.0. - -## New Features -* Introduced an option `BlockBasedTableOptions::detect_filter_construct_corruption` for detecting corruption during Bloom Filter (format_version >= 5) and Ribbon Filter construction. -* Improved the SstDumpTool to read the comparator from table properties and use it to read the SST File. -* Extended the column family statistics in the info log so the total amount of garbage in the blob files and the blob file space amplification factor are also logged. Also exposed the blob file space amp via the `rocksdb.blob-stats` DB property. -* Introduced the API rocksdb_create_dir_if_missing in c.h that calls underlying file system's CreateDirIfMissing API to create the directory. -* Added last level and non-last level read statistics: `LAST_LEVEL_READ_*`, `NON_LAST_LEVEL_READ_*`. -* Experimental: Add support for new APIs ReadAsync in FSRandomAccessFile that reads the data asynchronously and Poll API in FileSystem that checks if requested read request has completed or not. ReadAsync takes a callback function. Poll API checks for completion of read IO requests and should call callback functions to indicate completion of read requests. - -## 6.29.0 (01/21/2022) -Note: The next release will be major release 7.0. See https://github.com/facebook/rocksdb/issues/9390 for more info. -### Public API change -* Added values to `TraceFilterType`: `kTraceFilterIteratorSeek`, `kTraceFilterIteratorSeekForPrev`, and `kTraceFilterMultiGet`. They can be set in `TraceOptions` to filter out the operation types after which they are named. -* Added `TraceOptions::preserve_write_order`. When enabled it guarantees write records are traced in the same order they are logged to WAL and applied to the DB. By default it is disabled (false) to match the legacy behavior and prevent regression. -* Made the Env class extend the Customizable class. Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method. -* `Options::OldDefaults` is marked deprecated, as it is no longer maintained. -* Add ObjectLibrary::AddFactory and ObjectLibrary::PatternEntry classes. This method and associated class are the preferred mechanism for registering factories with the ObjectLibrary going forward. The ObjectLibrary::Register method, which uses regular expressions and may be problematic, is deprecated and will be in a future release. -* Changed `BlockBasedTableOptions::block_size` from `size_t` to `uint64_t`. -* Added API warning against using `Iterator::Refresh()` together with `DB::DeleteRange()`, which are incompatible and have always risked causing the refreshed iterator to return incorrect results. -* Made `AdvancedColumnFamilyOptions.bottommost_temperature` dynamically changeable with `SetOptions()`. - -### Behavior Changes -* `DB::DestroyColumnFamilyHandle()` will return Status::InvalidArgument() if called with `DB::DefaultColumnFamily()`. -* On 32-bit platforms, mmap reads are no longer quietly disabled, just discouraged. - -### New Features -* Added `Options::DisableExtraChecks()` that can be used to improve peak write performance by disabling checks that should not be necessary in the absence of software logic errors or CPU+memory hardware errors. (Default options are slowly moving toward some performance overheads for extra correctness checking.) - -### Performance Improvements -* Improved read performance when a prefix extractor is used (Seek, Get, MultiGet), even compared to version 6.25 baseline (see bug fix below), by optimizing the common case of prefix extractor compatible with table file and unchanging. - -### Bug Fixes -* Fix a bug that FlushMemTable may return ok even flush not succeed. -* Fixed a bug of Sync() and Fsync() not using `fcntl(F_FULLFSYNC)` on OS X and iOS. -* Fixed a significant performance regression in version 6.26 when a prefix extractor is used on the read path (Seek, Get, MultiGet). (Excessive time was spent in SliceTransform::AsString().) -* Fixed a race condition in SstFileManagerImpl error recovery code that can cause a crash during process shutdown. - -### New Features -* Added RocksJava support for MacOS universal binary (ARM+x86) - -## 6.28.0 (2021-12-17) -### New Features -* Introduced 'CommitWithTimestamp' as a new tag. Currently, there is no API for user to trigger a write with this tag to the WAL. This is part of the efforts to support write-commited transactions with user-defined timestamps. -* Introduce SimulatedHybridFileSystem which can help simulating HDD latency in db_bench. Tiered Storage latency simulation can be enabled using -simulate_hybrid_fs_file (note that it doesn't work if db_bench is interrupted in the middle). -simulate_hdd can also be used to simulate all files on HDD. - -### Bug Fixes -* Fixed a bug in rocksdb automatic implicit prefetching which got broken because of new feature adaptive_readahead and internal prefetching got disabled when iterator moves from one file to next. -* Fixed a bug in TableOptions.prepopulate_block_cache which causes segmentation fault when used with TableOptions.partition_filters = true and TableOptions.cache_index_and_filter_blocks = true. -* Fixed a bug affecting custom memtable factories which are not registered with the `ObjectRegistry`. The bug could result in failure to save the OPTIONS file. -* Fixed a bug causing two duplicate entries to be appended to a file opened in non-direct mode and tracked by `FaultInjectionTestFS`. -* Fixed a bug in TableOptions.prepopulate_block_cache to support block-based filters also. -* Block cache keys no longer use `FSRandomAccessFile::GetUniqueId()` (previously used when available), so a filesystem recycling unique ids can no longer lead to incorrect result or crash (#7405). For files generated by RocksDB >= 6.24, the cache keys are stable across DB::Open and DB directory move / copy / import / export / migration, etc. Although collisions are still theoretically possible, they are (a) impossible in many common cases, (b) not dependent on environmental factors, and (c) much less likely than a CPU miscalculation while executing RocksDB. -* Fixed a bug in C bindings causing iterator to return incorrect result (#9343). - -### Behavior Changes -* MemTableList::TrimHistory now use allocated bytes when max_write_buffer_size_to_maintain > 0(default in TrasactionDB, introduced in PR#5022) Fix #8371. - -### Public API change -* Extend WriteBatch::AssignTimestamp and AssignTimestamps API so that both functions can accept an optional `checker` argument that performs additional checking on timestamp sizes. -* Introduce a new EventListener callback that will be called upon the end of automatic error recovery. -* Add IncreaseFullHistoryTsLow API so users can advance each column family's full_history_ts_low seperately. -* Add GetFullHistoryTsLow API so users can query current full_history_low value of specified column family. - -### Performance Improvements -* Replaced map property `TableProperties::properties_offsets` with uint64_t property `external_sst_file_global_seqno_offset` to save table properties's memory. -* Block cache accesses are faster by RocksDB using cache keys of fixed size (16 bytes). - -### Java API Changes -* Removed Java API `TableProperties.getPropertiesOffsets()` as it exposed internal details to external users. - -## 6.27.0 (2021-11-19) -### New Features -* Added new ChecksumType kXXH3 which is faster than kCRC32c on almost all x86\_64 hardware. -* Added a new online consistency check for BlobDB which validates that the number/total size of garbage blobs does not exceed the number/total size of all blobs in any given blob file. -* Provided support for tracking per-sst user-defined timestamp information in MANIFEST. -* Added new option "adaptive_readahead" in ReadOptions. For iterators, RocksDB does auto-readahead on noticing sequential reads and by enabling this option, readahead_size of current file (if reads are sequential) will be carried forward to next file instead of starting from the scratch at each level (except L0 level files). If reads are not sequential it will fall back to 8KB. This option is applicable only for RocksDB internal prefetch buffer and isn't supported with underlying file system prefetching. -* Added the read count and read bytes related stats to Statistics for tiered storage hot, warm, and cold file reads. -* Added an option to dynamically charge an updating estimated memory usage of block-based table building to block cache if block cache available. It currently only includes charging memory usage of constructing (new) Bloom Filter and Ribbon Filter to block cache. To enable this feature, set `BlockBasedTableOptions::reserve_table_builder_memory = true`. -* Add a new API OnIOError in listener.h that notifies listeners when an IO error occurs during FileSystem operation along with filename, status etc. -* Added compaction readahead support for blob files to the integrated BlobDB implementation, which can improve compaction performance when the database resides on higher-latency storage like HDDs or remote filesystems. Readahead can be configured using the column family option `blob_compaction_readahead_size`. - -### Bug Fixes -* Prevent a `CompactRange()` with `CompactRangeOptions::change_level == true` from possibly causing corruption to the LSM state (overlapping files within a level) when run in parallel with another manual compaction. Note that setting `force_consistency_checks == true` (the default) would cause the DB to enter read-only mode in this scenario and return `Status::Corruption`, rather than committing any corruption. -* Fixed a bug in CompactionIterator when write-prepared transaction is used. A released earliest write conflict snapshot may cause assertion failure in dbg mode and unexpected key in opt mode. -* Fix ticker WRITE_WITH_WAL("rocksdb.write.wal"), this bug is caused by a bad extra `RecordTick(stats_, WRITE_WITH_WAL)` (at 2 place), this fix remove the extra `RecordTick`s and fix the corresponding test case. -* EventListener::OnTableFileCreated was previously called with OK status and file_size==0 in cases of no SST file contents written (because there was no content to add) and the empty file deleted before calling the listener. Now the status is Aborted. -* Fixed a bug in CompactionIterator when write-preared transaction is used. Releasing earliest_snapshot during compaction may cause a SingleDelete to be output after a PUT of the same user key whose seq has been zeroed. -* Added input sanitization on negative bytes passed into `GenericRateLimiter::Request`. -* Fixed an assertion failure in CompactionIterator when write-prepared transaction is used. We prove that certain operations can lead to a Delete being followed by a SingleDelete (same user key). We can drop the SingleDelete. -* Fixed a bug of timestamp-based GC which can cause all versions of a key under full_history_ts_low to be dropped. This bug will be triggered when some of the ikeys' timestamps are lower than full_history_ts_low, while others are newer. -* In some cases outside of the DB read and compaction paths, SST block checksums are now checked where they were not before. -* Explicitly check for and disallow the `BlockBasedTableOptions` if insertion into one of {`block_cache`, `block_cache_compressed`, `persistent_cache`} can show up in another of these. (RocksDB expects to be able to use the same key for different physical data among tiers.) -* Users who configured a dedicated thread pool for bottommost compactions by explicitly adding threads to the `Env::Priority::BOTTOM` pool will no longer see RocksDB schedule automatic compactions exceeding the DB's compaction concurrency limit. For details on per-DB compaction concurrency limit, see API docs of `max_background_compactions` and `max_background_jobs`. -* Fixed a bug of background flush thread picking more memtables to flush and prematurely advancing column family's log_number. -* Fixed an assertion failure in ManifestTailer. -* Fixed a bug that could, with WAL enabled, cause backups, checkpoints, and `GetSortedWalFiles()` to fail randomly with an error like `IO error: 001234.log: No such file or directory` - -### Behavior Changes -* `NUM_FILES_IN_SINGLE_COMPACTION` was only counting the first input level files, now it's including all input files. -* `TransactionUtil::CheckKeyForConflicts` can also perform conflict-checking based on user-defined timestamps in addition to sequence numbers. -* Removed `GenericRateLimiter`'s minimum refill bytes per period previously enforced. - -### Public API change -* When options.ttl is used with leveled compaction with compactinon priority kMinOverlappingRatio, files exceeding half of TTL value will be prioritized more, so that by the time TTL is reached, fewer extra compactions will be scheduled to clear them up. At the same time, when compacting files with data older than half of TTL, output files may be cut off based on those files' boundaries, in order for the early TTL compaction to work properly. -* Made FileSystem and RateLimiter extend the Customizable class and added a CreateFromString method. Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method. -* Clarified in API comments that RocksDB is not exception safe for callbacks and custom extensions. An exception propagating into RocksDB can lead to undefined behavior, including data loss, unreported corruption, deadlocks, and more. -* Marked `WriteBufferManager` as `final` because it is not intended for extension. -* Removed unimportant implementation details from table_properties.h -* Add API `FSDirectory::FsyncWithDirOptions()`, which provides extra information like directory fsync reason in `DirFsyncOptions`. File system like btrfs is using that to skip directory fsync for creating a new file, or when renaming a file, fsync the target file instead of the directory, which improves the `DB::Open()` speed by ~20%. -* `DB::Open()` is not going be blocked by obsolete file purge if `DBOptions::avoid_unnecessary_blocking_io` is set to true. -* In builds where glibc provides `gettid()`, info log ("LOG" file) lines now print a system-wide thread ID from `gettid()` instead of the process-local `pthread_self()`. For all users, the thread ID format is changed from hexadecimal to decimal integer. -* In builds where glibc provides `pthread_setname_np()`, the background thread names no longer contain an ID suffix. For example, "rocksdb:bottom7" (and all other threads in the `Env::Priority::BOTTOM` pool) are now named "rocksdb:bottom". Previously large thread pools could breach the name size limit (e.g., naming "rocksdb:bottom10" would fail). -* Deprecating `ReadOptions::iter_start_seqnum` and `DBOptions::preserve_deletes`, please try using user defined timestamp feature instead. The options will be removed in a future release, currently it logs a warning message when using. - -### Performance Improvements -* Released some memory related to filter construction earlier in `BlockBasedTableBuilder` for `FullFilter` and `PartitionedFilter` case (#9070) - -### Behavior Changes -* `NUM_FILES_IN_SINGLE_COMPACTION` was only counting the first input level files, now it's including all input files. - -## 6.26.0 (2021-10-20) -### Bug Fixes -* Fixes a bug in directed IO mode when calling MultiGet() for blobs in the same blob file. The bug is caused by not sorting the blob read requests by file offsets. -* Fix the incorrect disabling of SST rate limited deletion when the WAL and DB are in different directories. Only WAL rate limited deletion should be disabled if its in a different directory. -* Fix `DisableManualCompaction()` to cancel compactions even when they are waiting on automatic compactions to drain due to `CompactRangeOptions::exclusive_manual_compactions == true`. -* Fix contract of `Env::ReopenWritableFile()` and `FileSystem::ReopenWritableFile()` to specify any existing file must not be deleted or truncated. -* Fixed bug in calls to `IngestExternalFiles()` with files for multiple column families. The bug could have introduced a delay in ingested file keys becoming visible after `IngestExternalFiles()` returned. Furthermore, mutations to ingested file keys while they were invisible could have been dropped (not necessarily immediately). -* Fixed a possible race condition impacting users of `WriteBufferManager` who constructed it with `allow_stall == true`. The race condition led to undefined behavior (in our experience, typically a process crash). -* Fixed a bug where stalled writes would remain stalled forever after the user calls `WriteBufferManager::SetBufferSize()` with `new_size == 0` to dynamically disable memory limiting. -* Make `DB::close()` thread-safe. -* Fix a bug in atomic flush where one bg flush thread will wait forever for a preceding bg flush thread to commit its result to MANIFEST but encounters an error which is mapped to a soft error (DB not stopped). -* Fix a bug in `BackupEngine` where some internal callers of `GenericRateLimiter::Request()` do not honor `bytes <= GetSingleBurstBytes()`. - -### New Features -* Print information about blob files when using "ldb list_live_files_metadata" -* Provided support for SingleDelete with user defined timestamp. -* Experimental new function DB::GetLiveFilesStorageInfo offers essentially a unified version of other functions like GetLiveFiles, GetLiveFilesChecksumInfo, and GetSortedWalFiles. Checkpoints and backups could show small behavioral changes and/or improved performance as they now use this new API. -* Add remote compaction read/write bytes statistics: `REMOTE_COMPACT_READ_BYTES`, `REMOTE_COMPACT_WRITE_BYTES`. -* Introduce an experimental feature to dump out the blocks from block cache and insert them to the secondary cache to reduce the cache warmup time (e.g., used while migrating DB instance). More information are in `class CacheDumper` and `CacheDumpedLoader` at `rocksdb/utilities/cache_dump_load.h` Note that, this feature is subject to the potential change in the future, it is still experimental. -* Introduced a new BlobDB configuration option `blob_garbage_collection_force_threshold`, which can be used to trigger compactions targeting the SST files which reference the oldest blob files when the ratio of garbage in those blob files meets or exceeds the specified threshold. This can reduce space amplification with skewed workloads where the affected SST files might not otherwise get picked up for compaction. -* Added EXPERIMENTAL support for table file (SST) unique identifiers that are stable and universally unique, available with new function `GetUniqueIdFromTableProperties`. Only SST files from RocksDB >= 6.24 support unique IDs. -* Added `GetMapProperty()` support for "rocksdb.dbstats" (`DB::Properties::kDBStats`). As a map property, it includes DB-level internal stats accumulated over the DB's lifetime, such as user write related stats and uptime. - -### Public API change -* Made SystemClock extend the Customizable class and added a CreateFromString method. Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method. -* Made SliceTransform extend the Customizable class and added a CreateFromString method. Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method. The Capped and Prefixed transform classes return a short name (no length); use GetId for the fully qualified name. -* Made FileChecksumGenFactory, SstPartitionerFactory, TablePropertiesCollectorFactory, and WalFilter extend the Customizable class and added a CreateFromString method. -* Some fields of SstFileMetaData are deprecated for compatibility with new base class FileStorageInfo. -* Add `file_temperature` to `IngestExternalFileArg` such that when ingesting SST files, we are able to indicate the temperature of the this batch of files. -* If `DB::Close()` failed with a non aborted status, calling `DB::Close()` again will return the original status instead of Status::OK. -* Add CacheTier to advanced_options.h to describe the cache tier we used. Add a `lowest_used_cache_tier` option to `DBOptions` (immutable) and pass it to BlockBasedTableReader. By default it is `CacheTier::kNonVolatileBlockTier`, which means, we always use both block cache (kVolatileTier) and secondary cache (kNonVolatileBlockTier). By set it to `CacheTier::kVolatileTier`, the DB will not use the secondary cache. -* Even when options.max_compaction_bytes is hit, compaction output files are only cut when it aligns with grandparent files' boundaries. options.max_compaction_bytes could be slightly violated with the change, but the violation is no more than one target SST file size, which is usually much smaller. - -### Performance Improvements -* Improved CPU efficiency of building block-based table (SST) files (#9039 and #9040). - -### Java API Changes -* Add Java API bindings for new integrated BlobDB options -* `keyMayExist()` supports ByteBuffer. -* Fix multiget throwing Null Pointer Exception for num of keys > 70k (https://github.com/facebook/rocksdb/issues/8039). - -## 6.25.0 (2021-09-20) -### Bug Fixes -* Allow secondary instance to refresh iterator. Assign read seq after referencing SuperVersion. -* Fixed a bug of secondary instance's last_sequence going backward, and reads on the secondary fail to see recent updates from the primary. -* Fixed a bug that could lead to duplicate DB ID or DB session ID in POSIX environments without /proc/sys/kernel/random/uuid. -* Fix a race in DumpStats() with column family destruction due to not taking a Ref on each entry while iterating the ColumnFamilySet. -* Fix a race in item ref counting in LRUCache when promoting an item from the SecondaryCache. -* Fix a race in BackupEngine if RateLimiter is reconfigured during concurrent Restore operations. -* Fix a bug on POSIX in which failure to create a lock file (e.g. out of space) can prevent future LockFile attempts in the same process on the same file from succeeding. -* Fix a bug that backup_rate_limiter and restore_rate_limiter in BackupEngine could not limit read rates. -* Fix the implementation of `prepopulate_block_cache = kFlushOnly` to only apply to flushes rather than to all generated files. -* Fix WAL log data corruption when using DBOptions.manual_wal_flush(true) and WriteOptions.sync(true) together. The sync WAL should work with locked log_write_mutex_. -* Add checks for validity of the IO uring completion queue entries, and fail the BlockBasedTableReader MultiGet sub-batch if there's an invalid completion -* Add an interface RocksDbIOUringEnable() that, if defined by the user, will allow them to enable/disable the use of IO uring by RocksDB -* Fix the bug that when direct I/O is used and MultiRead() returns a short result, RandomAccessFileReader::MultiRead() still returns full size buffer, with returned short value together with some data in original buffer. This bug is unlikely cause incorrect results, because (1) since FileSystem layer is expected to retry on short result, returning short results is only possible when asking more bytes in the end of the file, which RocksDB doesn't do when using MultiRead(); (2) checksum is unlikely to match. - -### New Features -* RemoteCompaction's interface now includes `db_name`, `db_id`, `session_id`, which could help the user uniquely identify compaction job between db instances and sessions. -* Added a ticker statistic, "rocksdb.verify_checksum.read.bytes", reporting how many bytes were read from file to serve `VerifyChecksum()` and `VerifyFileChecksums()` queries. -* Added ticker statistics, "rocksdb.backup.read.bytes" and "rocksdb.backup.write.bytes", reporting how many bytes were read and written during backup. -* Added properties for BlobDB: `rocksdb.num-blob-files`, `rocksdb.blob-stats`, `rocksdb.total-blob-file-size`, and `rocksdb.live-blob-file-size`. The existing property `rocksdb.estimate_live-data-size` was also extended to include live bytes residing in blob files. -* Added two new RateLimiter IOPriorities: `Env::IO_USER`,`Env::IO_MID`. `Env::IO_USER` will have superior priority over all other RateLimiter IOPriorities without being subject to fair scheduling constraint. -* `SstFileWriter` now supports `Put`s and `Delete`s with user-defined timestamps. Note that the ingestion logic itself is not timestamp-aware yet. -* Allow a single write batch to include keys from multiple column families whose timestamps' formats can differ. For example, some column families may disable timestamp, while others enable timestamp. -* Add compaction priority information in RemoteCompaction, which can be used to schedule high priority job first. -* Added new callback APIs `OnBlobFileCreationStarted`,`OnBlobFileCreated`and `OnBlobFileDeleted` in `EventListener` class of listener.h. It notifies listeners during creation/deletion of individual blob files in Integrated BlobDB. It also log blob file creation finished event and deletion event in LOG file. -* Batch blob read requests for `DB::MultiGet` using `MultiRead`. -* Add support for fallback to local compaction, the user can return `CompactionServiceJobStatus::kUseLocal` to instruct RocksDB to run the compaction locally instead of waiting for the remote compaction result. -* Add built-in rate limiter's implementation of `RateLimiter::GetTotalPendingRequest(int64_t* total_pending_requests, const Env::IOPriority pri)` for the total number of requests that are pending for bytes in the rate limiter. -* Charge memory usage during data buffering, from which training samples are gathered for dictionary compression, to block cache. Unbuffering data can now be triggered if the block cache becomes full and `strict_capacity_limit=true` for the block cache, in addition to existing conditions that can trigger unbuffering. - -### Public API change -* Remove obsolete implementation details FullKey and ParseFullKey from public API -* Change `SstFileMetaData::size` from `size_t` to `uint64_t`. -* Made Statistics extend the Customizable class and added a CreateFromString method. Implementations of Statistics need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method. -* Extended `FlushJobInfo` and `CompactionJobInfo` in listener.h to provide information about the blob files generated by a flush/compaction and garbage collected during compaction in Integrated BlobDB. Added struct members `blob_file_addition_infos` and `blob_file_garbage_infos` that contain this information. -* Extended parameter `output_file_names` of `CompactFiles` API to also include paths of the blob files generated by the compaction in Integrated BlobDB. -* Most `BackupEngine` functions now return `IOStatus` instead of `Status`. Most existing code should be compatible with this change but some calls might need to be updated. -* Add a new field `level_at_creation` in `TablePropertiesCollectorFactory::Context` to capture the level at creating the SST file (i.e, table), of which the properties are being collected. - -### Miscellaneous -* Add a paranoid check where in case FileSystem layer doesn't fill the buffer but returns succeed, checksum is unlikely to match even if buffer contains a previous block. The byte modified is not useful anyway, so it isn't expected to change any behavior when FileSystem is satisfying its contract. - -## 6.24.0 (2021-08-20) -### Bug Fixes -* If the primary's CURRENT file is missing or inaccessible, the secondary instance should not hang repeatedly trying to switch to a new MANIFEST. It should instead return the error code encountered while accessing the file. -* Restoring backups with BackupEngine is now a logically atomic operation, so that if a restore operation is interrupted, DB::Open on it will fail. Using BackupEngineOptions::sync (default) ensures atomicity even in case of power loss or OS crash. -* Fixed a race related to the destruction of `ColumnFamilyData` objects. The earlier logic unlocked the DB mutex before destroying the thread-local `SuperVersion` pointers, which could result in a process crash if another thread managed to get a reference to the `ColumnFamilyData` object. -* Removed a call to `RenameFile()` on a non-existent info log file ("LOG") when opening a new DB. Such a call was guaranteed to fail though did not impact applications since we swallowed the error. Now we also stopped swallowing errors in renaming "LOG" file. -* Fixed an issue where `OnFlushCompleted` was not called for atomic flush. -* Fixed a bug affecting the batched `MultiGet` API when used with keys spanning multiple column families and `sorted_input == false`. -* Fixed a potential incorrect result in opt mode and assertion failures caused by releasing snapshot(s) during compaction. -* Fixed passing of BlobFileCompletionCallback to Compaction job and Atomic flush job which was default paramter (nullptr). BlobFileCompletitionCallback is internal callback that manages addition of blob files to SSTFileManager. -* Fixed MultiGet not updating the block_read_count and block_read_byte PerfContext counters. - -### New Features -* Made the EventListener extend the Customizable class. -* EventListeners that have a non-empty Name() and that are registered with the ObjectRegistry can now be serialized to/from the OPTIONS file. -* Insert warm blocks (data blocks, uncompressed dict blocks, index and filter blocks) in Block cache during flush under option BlockBasedTableOptions.prepopulate_block_cache. Previously it was enabled for only data blocks. -* BlockBasedTableOptions.prepopulate_block_cache can be dynamically configured using DB::SetOptions. -* Add CompactionOptionsFIFO.age_for_warm, which allows RocksDB to move old files to warm tier in FIFO compactions. Note that file temperature is still an experimental feature. -* Add a comment to suggest btrfs user to disable file preallocation by setting `options.allow_fallocate=false`. -* Fast forward option in Trace replay changed to double type to allow replaying at a lower speed, by settings the value between 0 and 1. This option can be set via `ReplayOptions` in `Replayer::Replay()`, or via `--trace_replay_fast_forward` in db_bench. -* Add property `LiveSstFilesSizeAtTemperature` to retrieve sst file size at different temperature. -* Added a stat rocksdb.secondary.cache.hits. -* Added a PerfContext counter secondary_cache_hit_count. -* The integrated BlobDB implementation now supports the tickers `BLOB_DB_BLOB_FILE_BYTES_READ`, `BLOB_DB_GC_NUM_KEYS_RELOCATED`, and `BLOB_DB_GC_BYTES_RELOCATED`, as well as the histograms `BLOB_DB_COMPRESSION_MICROS` and `BLOB_DB_DECOMPRESSION_MICROS`. -* Added hybrid configuration of Ribbon filter and Bloom filter where some LSM levels use Ribbon for memory space efficiency and some use Bloom for speed. See NewRibbonFilterPolicy. This also changes the default behavior of NewRibbonFilterPolicy to use Bloom for flushes under Leveled and Universal compaction and Ribbon otherwise. The C API function `rocksdb_filterpolicy_create_ribbon` is unchanged but adds new `rocksdb_filterpolicy_create_ribbon_hybrid`. - -### Public API change -* Added APIs to decode and replay trace file via Replayer class. Added `DB::NewDefaultReplayer()` to create a default Replayer instance. Added `TraceReader::Reset()` to restart reading a trace file. Created trace_record.h, trace_record_result.h and utilities/replayer.h files to access the decoded Trace records, replay them, and query the actual operation results. -* Added Configurable::GetOptionsMap to the public API for use in creating new Customizable classes. -* Generalized bits_per_key parameters in C API from int to double for greater configurability. Although this is a compatible change for existing C source code, anything depending on C API signatures, such as foreign function interfaces, will need to be updated. - -### Performance Improvements -* Try to avoid updating DBOptions if `SetDBOptions()` does not change any option value. - -### Behavior Changes -* `StringAppendOperator` additionally accepts a string as the delimiter. -* BackupEngineOptions::sync (default true) now applies to restoring backups in addition to creating backups. This could slow down restores, but ensures they are fully persisted before returning OK. (Consider increasing max_background_operations to improve performance.) - -## 6.23.0 (2021-07-16) -### Behavior Changes -* Obsolete keys in the bottommost level that were preserved for a snapshot will now be cleaned upon snapshot release in all cases. This form of compaction (snapshot release triggered compaction) previously had an artificial limitation that multiple tombstones needed to be present. -### Bug Fixes -* Blob file checksums are now printed in hexadecimal format when using the `manifest_dump` `ldb` command. -* `GetLiveFilesMetaData()` now populates the `temperature`, `oldest_ancester_time`, and `file_creation_time` fields of its `LiveFileMetaData` results when the information is available. Previously these fields always contained zero indicating unknown. -* Fix mismatches of OnCompaction{Begin,Completed} in case of DisableManualCompaction(). -* Fix continuous logging of an existing background error on every user write -* Fix a bug that `Get()` return Status::OK() and an empty value for non-existent key when `read_options.read_tier = kBlockCacheTier`. -* Fix a bug that stat in `get_context` didn't accumulate to statistics when query is failed. -* Fixed handling of DBOptions::wal_dir with LoadLatestOptions() or ldb --try_load_options on a copied or moved DB. Previously, when the WAL directory is same as DB directory (default), a copied or moved DB would reference the old path of the DB as the WAL directory, potentially corrupting both copies. Under this change, the wal_dir from DB::GetOptions() or LoadLatestOptions() may now be empty, indicating that the current DB directory is used for WALs. This is also a subtle API change. - -### New Features -* ldb has a new feature, `list_live_files_metadata`, that shows the live SST files, as well as their LSM storage level and the column family they belong to. -* The new BlobDB implementation now tracks the amount of garbage in each blob file in the MANIFEST. -* Integrated BlobDB now supports Merge with base values (Put/Delete etc.). -* RemoteCompaction supports sub-compaction, the job_id in the user interface is changed from `int` to `uint64_t` to support sub-compaction id. -* Expose statistics option in RemoteCompaction worker. - -### Public API change -* Added APIs to the Customizable class to allow developers to create their own Customizable classes. Created the utilities/customizable_util.h file to contain helper methods for developing new Customizable classes. -* Change signature of SecondaryCache::Name(). Make SecondaryCache customizable and add SecondaryCache::CreateFromString method. - -## 6.22.0 (2021-06-18) -### Behavior Changes -* Added two additional tickers, MEMTABLE_PAYLOAD_BYTES_AT_FLUSH and MEMTABLE_GARBAGE_BYTES_AT_FLUSH. These stats can be used to estimate the ratio of "garbage" (outdated) bytes in the memtable that are discarded at flush time. -* Added API comments clarifying safe usage of Disable/EnableManualCompaction and EventListener callbacks for compaction. -### Bug Fixes -* fs_posix.cc GetFreeSpace() always report disk space available to root even when running as non-root. Linux defaults often have disk mounts with 5 to 10 percent of total space reserved only for root. Out of space could result for non-root users. -* Subcompactions are now disabled when user-defined timestamps are used, since the subcompaction boundary picking logic is currently not timestamp-aware, which could lead to incorrect results when different subcompactions process keys that only differ by timestamp. -* Fix an issue that `DeleteFilesInRange()` may cause ongoing compaction reports corruption exception, or ASSERT for debug build. There's no actual data loss or corruption that we find. -* Fixed confusingly duplicated output in LOG for periodic stats ("DUMPING STATS"), including "Compaction Stats" and "File Read Latency Histogram By Level". -* Fixed performance bugs in background gathering of block cache entry statistics, that could consume a lot of CPU when there are many column families with a shared block cache. - -### New Features -* Marked the Ribbon filter and optimize_filters_for_memory features as production-ready, each enabling memory savings for Bloom-like filters. Use `NewRibbonFilterPolicy` in place of `NewBloomFilterPolicy` to use Ribbon filters instead of Bloom, or `ribbonfilter` in place of `bloomfilter` in configuration string. -* Allow `DBWithTTL` to use `DeleteRange` api just like other DBs. `DeleteRangeCF()` which executes `WriteBatchInternal::DeleteRange()` has been added to the handler in `DBWithTTLImpl::Write()` to implement it. -* Add BlockBasedTableOptions.prepopulate_block_cache. If enabled, it prepopulate warm/hot data blocks which are already in memory into block cache at the time of flush. On a flush, the data block that is in memory (in memtables) get flushed to the device. If using Direct IO, additional IO is incurred to read this data back into memory again, which is avoided by enabling this option and it also helps with Distributed FileSystem. More details in include/rocksdb/table.h. -* Added a `cancel` field to `CompactRangeOptions`, allowing individual in-process manual range compactions to be cancelled. - -### New Features -* Added BlobMetaData to the ColumnFamilyMetaData to return information about blob files - -### Public API change -* Added GetAllColumnFamilyMetaData API to retrieve the ColumnFamilyMetaData about all column families. - -## 6.21.0 (2021-05-21) -### Bug Fixes -* Fixed a bug in handling file rename error in distributed/network file systems when the server succeeds but client returns error. The bug can cause CURRENT file to point to non-existing MANIFEST file, thus DB cannot be opened. -* Fixed a bug where ingested files were written with incorrect boundary key metadata. In rare cases this could have led to a level's files being wrongly ordered and queries for the boundary keys returning wrong results. -* Fixed a data race between insertion into memtables and the retrieval of the DB properties `rocksdb.cur-size-active-mem-table`, `rocksdb.cur-size-all-mem-tables`, and `rocksdb.size-all-mem-tables`. -* Fixed the false-positive alert when recovering from the WAL file. Avoid reporting "SST file is ahead of WAL" on a newly created empty column family, if the previous WAL file is corrupted. -* Fixed a bug where `GetLiveFiles()` output included a non-existent file called "OPTIONS-000000". Backups and checkpoints, which use `GetLiveFiles()`, failed on DBs impacted by this bug. Read-write DBs were impacted when the latest OPTIONS file failed to write and `fail_if_options_file_error == false`. Read-only DBs were impacted when no OPTIONS files existed. -* Handle return code by io_uring_submit_and_wait() and io_uring_wait_cqe(). -* In the IngestExternalFile() API, only try to sync the ingested file if the file is linked and the FileSystem/Env supports reopening a writable file. -* Fixed a bug that `AdvancedColumnFamilyOptions.max_compaction_bytes` is under-calculated for manual compaction (`CompactRange()`). Manual compaction is split to multiple compactions if the compaction size exceed the `max_compaction_bytes`. The bug creates much larger compaction which size exceed the user setting. On the other hand, larger manual compaction size can increase the subcompaction parallelism, you can tune that by setting `max_compaction_bytes`. - -### Behavior Changes -* Due to the fix of false-postive alert of "SST file is ahead of WAL", all the CFs with no SST file (CF empty) will bypass the consistency check. We fixed a false-positive, but introduced a very rare true-negative which will be triggered in the following conditions: A CF with some delete operations in the last a few queries which will result in an empty CF (those are flushed to SST file and a compaction triggered which combines this file and all other SST files and generates an empty CF, or there is another reason to write a manifest entry for this CF after a flush that generates no SST file from an empty CF). The deletion entries are logged in a WAL and this WAL was corrupted, while the CF's log number points to the next WAL (due to the flush). Therefore, the DB can only recover to the point without these trailing deletions and cause the inconsistent DB status. - -### New Features -* Add new option allow_stall passed during instance creation of WriteBufferManager. When allow_stall is set, WriteBufferManager will stall all writers shared across multiple DBs and columns if memory usage goes beyond specified WriteBufferManager::buffer_size (soft limit). Stall will be cleared when memory is freed after flush and memory usage goes down below buffer_size. -* Allow `CompactionFilter`s to apply in more table file creation scenarios such as flush and recovery. For compatibility, `CompactionFilter`s by default apply during compaction. Users can customize this behavior by overriding `CompactionFilterFactory::ShouldFilterTableFileCreation()`. -* Added more fields to FilterBuildingContext with LSM details, for custom filter policies that vary behavior based on where they are in the LSM-tree. -* Added DB::Properties::kBlockCacheEntryStats for querying statistics on what percentage of block cache is used by various kinds of blocks, etc. using DB::GetProperty and DB::GetMapProperty. The same information is now dumped to info LOG periodically according to `stats_dump_period_sec`. -* Add an experimental Remote Compaction feature, which allows the user to run Compaction on a different host or process. The feature is still under development, currently only works on some basic use cases. The interface will be changed without backward/forward compatibility support. -* RocksDB would validate total entries read in flush, and compare with counter inserted into it. If flush_verify_memtable_count = true (default), flush will fail. Otherwise, only log to info logs. -* Add `TableProperties::num_filter_entries`, which can be used with `TableProperties::filter_size` to calculate the effective bits per filter entry (unique user key or prefix) for a table file. - -### Performance Improvements -* BlockPrefetcher is used by iterators to prefetch data if they anticipate more data to be used in future. It is enabled implicitly by rocksdb. Added change to take in account read pattern if reads are sequential. This would disable prefetching for random reads in MultiGet and iterators as readahead_size is increased exponential doing large prefetches. - -### Public API change -* Removed a parameter from TableFactory::NewTableBuilder, which should not be called by user code because TableBuilder is not a public API. -* Removed unused structure `CompactionFilterContext`. -* The `skip_filters` parameter to SstFileWriter is now considered deprecated. Use `BlockBasedTableOptions::filter_policy` to control generation of filters. -* ClockCache is known to have bugs that could lead to crash or corruption, so should not be used until fixed. Use NewLRUCache instead. -* Added a new pure virtual function `ApplyToAllEntries` to `Cache`, to replace `ApplyToAllCacheEntries`. Custom `Cache` implementations must add an implementation. Because this function is for gathering statistics, an empty implementation could be acceptable for some applications. -* Added the ObjectRegistry to the ConfigOptions class. This registry instance will be used to find any customizable loadable objects during initialization. -* Expanded the ObjectRegistry functionality to allow nested ObjectRegistry instances. Added methods to register a set of functions with the registry/library as a group. -* Deprecated backupable_db.h and BackupableDBOptions in favor of new versions with appropriate names: backup_engine.h and BackupEngineOptions. Old API compatibility is preserved. - -### Default Option Change -* When options.arena_block_size <= 0 (default value 0), still use writer_buffer_size / 8 but cap to 1MB. Too large alloation size might not be friendly to allocator and might cause performance issues in extreme cases. - -### Build -* By default, try to build with liburing. For make, if ROCKSDB_USE_IO_URING is not set, treat as enable, which means RocksDB will try to build with liburing. Users can disable it with ROCKSDB_USE_IO_URING=0. For cmake, add WITH_LIBURING to control it, with default on. - -## 6.20.0 (2021-04-16) -### Behavior Changes -* `ColumnFamilyOptions::sample_for_compression` now takes effect for creation of all block-based tables. Previously it only took effect for block-based tables created by flush. -* `CompactFiles()` can no longer compact files from lower level to up level, which has the risk to corrupt DB (details: #8063). The validation is also added to all compactions. -* Fixed some cases in which DB::OpenForReadOnly() could write to the filesystem. If you want a Logger with a read-only DB, you must now set DBOptions::info_log yourself, such as using CreateLoggerFromOptions(). -* get_iostats_context() will never return nullptr. If thread-local support is not available, and user does not opt-out iostats context, then compilation will fail. The same applies to perf context as well. -* Added support for WriteBatchWithIndex::NewIteratorWithBase when overwrite_key=false. Previously, this combination was not supported and would assert or return nullptr. -* Improve the behavior of WriteBatchWithIndex for Merge operations. Now more operations may be stored in order to return the correct merged result. - -### Bug Fixes -* Use thread-safe `strerror_r()` to get error messages. -* Fixed a potential hang in shutdown for a DB whose `Env` has high-pri thread pool disabled (`Env::GetBackgroundThreads(Env::Priority::HIGH) == 0`) -* Made BackupEngine thread-safe and added documentation comments to clarify what is safe for multiple BackupEngine objects accessing the same backup directory. -* Fixed crash (divide by zero) when compression dictionary is applied to a file containing only range tombstones. -* Fixed a backward iteration bug with partitioned filter enabled: not including the prefix of the last key of the previous filter partition in current filter partition can cause wrong iteration result. -* Fixed a bug that allowed `DBOptions::max_open_files` to be set with a non-negative integer with `ColumnFamilyOptions::compaction_style = kCompactionStyleFIFO`. - -### Performance Improvements -* On ARM platform, use `yield` instead of `wfe` to relax cpu to gain better performance. - -### Public API change -* Added `TableProperties::slow_compression_estimated_data_size` and `TableProperties::fast_compression_estimated_data_size`. When `ColumnFamilyOptions::sample_for_compression > 0`, they estimate what `TableProperties::data_size` would have been if the "fast" or "slow" (see `ColumnFamilyOptions::sample_for_compression` API doc for definitions) compression had been used instead. -* Update DB::StartIOTrace and remove Env object from the arguments as its redundant and DB already has Env object that is passed down to IOTracer::StartIOTrace -* Added `FlushReason::kWalFull`, which is reported when a memtable is flushed due to the WAL reaching its size limit; those flushes were previously reported as `FlushReason::kWriteBufferManager`. Also, changed the reason for flushes triggered by the write buffer manager to `FlushReason::kWriteBufferManager`; they were previously reported as `FlushReason::kWriteBufferFull`. -* Extend file_checksum_dump ldb command and DB::GetLiveFilesChecksumInfo API for IntegratedBlobDB and get checksum of blob files along with SST files. - -### New Features -* Added the ability to open BackupEngine backups as read-only DBs, using BackupInfo::name_for_open and env_for_open provided by BackupEngine::GetBackupInfo() with include_file_details=true. -* Added BackupEngine support for integrated BlobDB, with blob files shared between backups when table files are shared. Because of current limitations, blob files always use the kLegacyCrc32cAndFileSize naming scheme, and incremental backups must read and checksum all blob files in a DB, even for files that are already backed up. -* Added an optional output parameter to BackupEngine::CreateNewBackup(WithMetadata) to return the BackupID of the new backup. -* Added BackupEngine::GetBackupInfo / GetLatestBackupInfo for querying individual backups. -* Made the Ribbon filter a long-term supported feature in terms of the SST schema(compatible with version >= 6.15.0) though the API for enabling it is expected to change. - -## 6.19.0 (2021-03-21) -### Bug Fixes -* Fixed the truncation error found in APIs/tools when dumping block-based SST files in a human-readable format. After fix, the block-based table can be fully dumped as a readable file. -* When hitting a write slowdown condition, no write delay (previously 1 millisecond) is imposed until `delayed_write_rate` is actually exceeded, with an initial burst allowance of 1 millisecond worth of bytes. Also, beyond the initial burst allowance, `delayed_write_rate` is now more strictly enforced, especially with multiple column families. - -### Public API change -* Changed default `BackupableDBOptions::share_files_with_checksum` to `true` and deprecated `false` because of potential for data loss. Note that accepting this change in behavior can temporarily increase backup data usage because files are not shared between backups using the two different settings. Also removed obsolete option kFlagMatchInterimNaming. -* Add a new option BlockBasedTableOptions::max_auto_readahead_size. RocksDB does auto-readahead for iterators on noticing more than two reads for a table file if user doesn't provide readahead_size. The readahead starts at 8KB and doubles on every additional read upto max_auto_readahead_size and now max_auto_readahead_size can be configured dynamically as well. Found that 256 KB readahead size provides the best performance, based on experiments, for auto readahead. Experiment data is in PR #3282. If value is set 0 then no automatic prefetching will be done by rocksdb. Also changing the value will only affect files opened after the change. -* Add suppport to extend DB::VerifyFileChecksums API to also verify blob files checksum. -* When using the new BlobDB, the amount of data written by flushes/compactions is now broken down into table files and blob files in the compaction statistics; namely, Write(GB) denotes the amount of data written to table files, while Wblob(GB) means the amount of data written to blob files. -* New default BlockBasedTableOptions::format_version=5 to enable new Bloom filter implementation by default, compatible with RocksDB versions >= 6.6.0. -* Add new SetBufferSize API to WriteBufferManager to allow dynamic management of memory allotted to all write buffers. This allows user code to adjust memory monitoring provided by WriteBufferManager as process memory needs change datasets grow and shrink. -* Clarified the required semantics of Read() functions in FileSystem and Env APIs. Please ensure any custom implementations are compliant. -* For the new integrated BlobDB implementation, compaction statistics now include the amount of data read from blob files during compaction (due to garbage collection or compaction filters). Write amplification metrics have also been extended to account for data read from blob files. -* Add EqualWithoutTimestamp() to Comparator. -* Extend support to track blob files in SSTFileManager whenever a blob file is created/deleted. Blob files will be scheduled to delete via SSTFileManager and SStFileManager will now take blob files in account while calculating size and space limits along with SST files. -* Add new Append and PositionedAppend API with checksum handoff to legacy Env. - -### New Features -* Support compaction filters for the new implementation of BlobDB. Add `FilterBlobByKey()` to `CompactionFilter`. Subclasses can override this method so that compaction filters can determine whether the actual blob value has to be read during compaction. Use a new `kUndetermined` in `CompactionFilter::Decision` to indicated that further action is necessary for compaction filter to make a decision. -* Add support to extend retrieval of checksums for blob files from the MANIFEST when checkpointing. During backup, rocksdb can detect corruption in blob files during file copies. -* Add new options for db_bench --benchmarks: flush, waitforcompaction, compact0, compact1. -* Add an option to BackupEngine::GetBackupInfo to include the name and size of each backed-up file. Especially in the presence of file sharing among backups, this offers detailed insight into backup space usage. -* Enable backward iteration on keys with user-defined timestamps. -* Add statistics and info log for error handler: counters for bg error, bg io error, bg retryable io error, auto resume count, auto resume total retry number, and auto resume sucess; Histogram for auto resume retry count in each recovery call. Note that, each auto resume attempt will have one or multiple retries. - -### Behavior Changes -* During flush, only WAL sync retryable IO error is mapped to hard error, which will stall the writes. When WAL is used but only SST file write has retryable IO error, it will be mapped to soft error and write will not be affected. - -## 6.18.0 (2021-02-19) -### Behavior Changes -* When retryable IO error occurs during compaction, it is mapped to soft error and set the BG error. However, auto resume is not called to clean the soft error since compaction will reschedule by itself. In this change, When retryable IO error occurs during compaction, BG error is not set. User will be informed the error via EventHelper. -* Introduce a new trace file format for query tracing and replay and trace file version is bump up to 0.2. A payload map is added as the first portion of the payload. We will not have backward compatible issues when adding new entries to trace records. Added the iterator_upper_bound and iterator_lower_bound in Seek and SeekForPrev tracing function. Added them as the new payload member for iterator tracing. - -### New Features -* Add support for key-value integrity protection in live updates from the user buffers provided to `WriteBatch` through the write to RocksDB's in-memory update buffer (memtable). This is intended to detect some cases of in-memory data corruption, due to either software or hardware errors. Users can enable protection by constructing their `WriteBatch` with `protection_bytes_per_key == 8`. -* Add support for updating `full_history_ts_low` option in manual compaction, which is for old timestamp data GC. -* Add a mechanism for using Makefile to build external plugin code into the RocksDB libraries/binaries. This intends to simplify compatibility and distribution for plugins (e.g., special-purpose `FileSystem`s) whose source code resides outside the RocksDB repo. See "plugin/README.md" for developer details, and "PLUGINS.md" for a listing of available plugins. -* Added memory pre-fetching for experimental Ribbon filter, which especially optimizes performance with batched MultiGet. -* A new, experimental version of BlobDB (key-value separation) is now available. The new implementation is integrated into the RocksDB core, i.e. it is accessible via the usual `rocksdb::DB` API, as opposed to the separate `rocksdb::blob_db::BlobDB` interface used by the earlier version, and can be configured on a per-column family basis using the configuration options `enable_blob_files`, `min_blob_size`, `blob_file_size`, `blob_compression_type`, `enable_blob_garbage_collection`, and `blob_garbage_collection_age_cutoff`. It extends RocksDB's consistency guarantees to blobs, and offers more features and better performance. Note that some features, most notably `Merge`, compaction filters, and backup/restore are not yet supported, and there is no support for migrating a database created by the old implementation. - -### Bug Fixes -* Since 6.15.0, `TransactionDB` returns error `Status`es from calls to `DeleteRange()` and calls to `Write()` where the `WriteBatch` contains a range deletion. Previously such operations may have succeeded while not providing the expected transactional guarantees. There are certain cases where range deletion can still be used on such DBs; see the API doc on `TransactionDB::DeleteRange()` for details. -* `OptimisticTransactionDB` now returns error `Status`es from calls to `DeleteRange()` and calls to `Write()` where the `WriteBatch` contains a range deletion. Previously such operations may have succeeded while not providing the expected transactional guarantees. -* Fix `WRITE_PREPARED`, `WRITE_UNPREPARED` TransactionDB `MultiGet()` may return uncommitted data with snapshot. -* In DB::OpenForReadOnly, if any error happens while checking Manifest file path, it was overridden by Status::NotFound. It has been fixed and now actual error is returned. - -### Public API Change -* Added a "only_mutable_options" flag to the ConfigOptions. When this flag is "true", the Configurable functions and convenience methods (such as GetDBOptionsFromString) will only deal with options that are marked as mutable. When this flag is true, only options marked as mutable can be configured (a Status::InvalidArgument will be returned) and options not marked as mutable will not be returned or compared. The default is "false", meaning to compare all options. -* Add new Append and PositionedAppend APIs to FileSystem to bring the data verification information (data checksum information) from upper layer (e.g., WritableFileWriter) to the storage layer. In this way, the customized FileSystem is able to verify the correctness of data being written to the storage on time. Add checksum_handoff_file_types to DBOptions. User can use this option to control which file types (Currently supported file tyes: kWALFile, kTableFile, kDescriptorFile.) should use the new Append and PositionedAppend APIs to handoff the verification information. Currently, RocksDB only use crc32c to calculate the checksum for write handoff. -* Add an option, `CompressionOptions::max_dict_buffer_bytes`, to limit the in-memory buffering for selecting samples for generating/training a dictionary. The limit is currently loosely adhered to. - - -## 6.17.0 (2021-01-15) -### Behavior Changes -* When verifying full file checksum with `DB::VerifyFileChecksums()`, we now fail with `Status::InvalidArgument` if the name of the checksum generator used for verification does not match the name of the checksum generator used for protecting the file when it was created. -* Since RocksDB does not continue write the same file if a file write fails for any reason, the file scope write IO error is treated the same as retryable IO error. More information about error handling of file scope IO error is included in `ErrorHandler::SetBGError`. - -### Bug Fixes -* Version older than 6.15 cannot decode VersionEdits `WalAddition` and `WalDeletion`, fixed this by changing the encoded format of them to be ignorable by older versions. -* Fix a race condition between DB startups and shutdowns in managing the periodic background worker threads. One effect of this race condition could be the process being terminated. - -### Public API Change -* Add a public API WriteBufferManager::dummy_entries_in_cache_usage() which reports the size of dummy entries stored in cache (passed to WriteBufferManager). Dummy entries are used to account for DataBlocks. -* Add a SystemClock class that contains the time-related methods from Env. The original methods in Env may be deprecated in a future release. This class will allow easier testing, development, and expansion of time-related features. -* Add a public API GetRocksBuildProperties and GetRocksBuildInfoAsString to get properties about the current build. These properties may include settings related to the GIT settings (branch, timestamp). This change also sets the "build date" based on the GIT properties, rather than the actual build time, thereby enabling more reproducible builds. - -## 6.16.0 (2020-12-18) -### Behavior Changes -* Attempting to write a merge operand without explicitly configuring `merge_operator` now fails immediately, causing the DB to enter read-only mode. Previously, failure was deferred until the `merge_operator` was needed by a user read or a background operation. - -### Bug Fixes -* Truncated WALs ending in incomplete records can no longer produce gaps in the recovered data when `WALRecoveryMode::kPointInTimeRecovery` is used. Gaps are still possible when WALs are truncated exactly on record boundaries; for complete protection, users should enable `track_and_verify_wals_in_manifest`. -* Fix a bug where compressed blocks read by MultiGet are not inserted into the compressed block cache when use_direct_reads = true. -* Fixed the issue of full scanning on obsolete files when there are too many outstanding compactions with ConcurrentTaskLimiter enabled. -* Fixed the logic of populating native data structure for `read_amp_bytes_per_bit` during OPTIONS file parsing on big-endian architecture. Without this fix, original code introduced in PR7659, when running on big-endian machine, can mistakenly store read_amp_bytes_per_bit (an uint32) in little endian format. Future access to `read_amp_bytes_per_bit` will give wrong values. Little endian architecture is not affected. -* Fixed prefix extractor with timestamp issues. -* Fixed a bug in atomic flush: in two-phase commit mode, the minimum WAL log number to keep is incorrect. -* Fixed a bug related to checkpoint in PR7789: if there are multiple column families, and the checkpoint is not opened as read only, then in rare cases, data loss may happen in the checkpoint. Since backup engine relies on checkpoint, it may also be affected. -* When ldb --try_load_options is used with the --column_family option, the ColumnFamilyOptions for the specified column family was not loaded from the OPTIONS file. Fix it so its loaded from OPTIONS and then overridden with command line overrides. - -### New Features -* User defined timestamp feature supports `CompactRange` and `GetApproximateSizes`. -* Support getting aggregated table properties (kAggregatedTableProperties and kAggregatedTablePropertiesAtLevel) with DB::GetMapProperty, for easier access to the data in a structured format. -* Experimental option BlockBasedTableOptions::optimize_filters_for_memory now works with experimental Ribbon filter (as well as Bloom filter). - -### Public API Change -* Deprecated public but rarely-used FilterBitsBuilder::CalculateNumEntry, which is replaced with ApproximateNumEntries taking a size_t parameter and returning size_t. -* To improve portability the functions `Env::GetChildren` and `Env::GetChildrenFileAttributes` will no longer return entries for the special directories `.` or `..`. -* Added a new option `track_and_verify_wals_in_manifest`. If `true`, the log numbers and sizes of the synced WALs are tracked in MANIFEST, then during DB recovery, if a synced WAL is missing from disk, or the WAL's size does not match the recorded size in MANIFEST, an error will be reported and the recovery will be aborted. Note that this option does not work with secondary instance. -* `rocksdb_approximate_sizes` and `rocksdb_approximate_sizes_cf` in the C API now requires an error pointer (`char** errptr`) for receiving any error. -* All overloads of DB::GetApproximateSizes now return Status, so that any failure to obtain the sizes is indicated to the caller. - -## 6.15.0 (2020-11-13) -### Bug Fixes -* Fixed a bug in the following combination of features: indexes with user keys (`format_version >= 3`), indexes are partitioned (`index_type == kTwoLevelIndexSearch`), and some index partitions are pinned in memory (`BlockBasedTableOptions::pin_l0_filter_and_index_blocks_in_cache`). The bug could cause keys to be truncated when read from the index leading to wrong read results or other unexpected behavior. -* Fixed a bug when indexes are partitioned (`index_type == kTwoLevelIndexSearch`), some index partitions are pinned in memory (`BlockBasedTableOptions::pin_l0_filter_and_index_blocks_in_cache`), and partitions reads could be mixed between block cache and directly from the file (e.g., with `enable_index_compression == 1` and `mmap_read == 1`, partitions that were stored uncompressed due to poor compression ratio would be read directly from the file via mmap, while partitions that were stored compressed would be read from block cache). The bug could cause index partitions to be mistakenly considered empty during reads leading to wrong read results. -* Since 6.12, memtable lookup should report unrecognized value_type as corruption (#7121). -* Since 6.14, fix false positive flush/compaction `Status::Corruption` failure when `paranoid_file_checks == true` and range tombstones were written to the compaction output files. -* Since 6.14, fix a bug that could cause a stalled write to crash with mixed of slowdown and no_slowdown writes (`WriteOptions.no_slowdown=true`). -* Fixed a bug which causes hang in closing DB when refit level is set in opt build. It was because ContinueBackgroundWork() was called in assert statement which is a no op. It was introduced in 6.14. -* Fixed a bug which causes Get() to return incorrect result when a key's merge operand is applied twice. This can occur if the thread performing Get() runs concurrently with a background flush thread and another thread writing to the MANIFEST file (PR6069). -* Reverted a behavior change silently introduced in 6.14.2, in which the effects of the `ignore_unknown_options` flag (used in option parsing/loading functions) changed. -* Reverted a behavior change silently introduced in 6.14, in which options parsing/loading functions began returning `NotFound` instead of `InvalidArgument` for option names not available in the present version. -* Fixed MultiGet bugs it doesn't return valid data with user defined timestamp. -* Fixed a potential bug caused by evaluating `TableBuilder::NeedCompact()` before `TableBuilder::Finish()` in compaction job. For example, the `NeedCompact()` method of `CompactOnDeletionCollector` returned by built-in `CompactOnDeletionCollectorFactory` requires `BlockBasedTable::Finish()` to return the correct result. The bug can cause a compaction-generated file not to be marked for future compaction based on deletion ratio. -* Fixed a seek issue with prefix extractor and timestamp. -* Fixed a bug of encoding and parsing BlockBasedTableOptions::read_amp_bytes_per_bit as a 64-bit integer. -* Fixed a bug of a recovery corner case, details in PR7621. - -### Public API Change -* Deprecate `BlockBasedTableOptions::pin_l0_filter_and_index_blocks_in_cache` and `BlockBasedTableOptions::pin_top_level_index_and_filter`. These options still take effect until users migrate to the replacement APIs in `BlockBasedTableOptions::metadata_cache_options`. Migration guidance can be found in the API comments on the deprecated options. -* Add new API `DB::VerifyFileChecksums` to verify SST file checksum with corresponding entries in the MANIFEST if present. Current implementation requires scanning and recomputing file checksums. - -### Behavior Changes -* The dictionary compression settings specified in `ColumnFamilyOptions::compression_opts` now additionally affect files generated by flush and compaction to non-bottommost level. Previously those settings at most affected files generated by compaction to bottommost level, depending on whether `ColumnFamilyOptions::bottommost_compression_opts` overrode them. Users who relied on dictionary compression settings in `ColumnFamilyOptions::compression_opts` affecting only the bottommost level can keep the behavior by moving their dictionary settings to `ColumnFamilyOptions::bottommost_compression_opts` and setting its `enabled` flag. -* When the `enabled` flag is set in `ColumnFamilyOptions::bottommost_compression_opts`, those compression options now take effect regardless of the value in `ColumnFamilyOptions::bottommost_compression`. Previously, those compression options only took effect when `ColumnFamilyOptions::bottommost_compression != kDisableCompressionOption`. Now, they additionally take effect when `ColumnFamilyOptions::bottommost_compression == kDisableCompressionOption` (such a setting causes bottommost compression type to fall back to `ColumnFamilyOptions::compression_per_level` if configured, and otherwise fall back to `ColumnFamilyOptions::compression`). - -### New Features -* An EXPERIMENTAL new Bloom alternative that saves about 30% space compared to Bloom filters, with about 3-4x construction time and similar query times is available using NewExperimentalRibbonFilterPolicy. - -## 6.14 (2020-10-09) -### Bug fixes -* Fixed a bug after a `CompactRange()` with `CompactRangeOptions::change_level` set fails due to a conflict in the level change step, which caused all subsequent calls to `CompactRange()` with `CompactRangeOptions::change_level` set to incorrectly fail with a `Status::NotSupported("another thread is refitting")` error. -* Fixed a bug that the bottom most level compaction could still be a trivial move even if `BottommostLevelCompaction.kForce` or `kForceOptimized` is set. - -### Public API Change -* The methods to create and manage EncrypedEnv have been changed. The EncryptionProvider is now passed to NewEncryptedEnv as a shared pointer, rather than a raw pointer. Comparably, the CTREncryptedProvider now takes a shared pointer, rather than a reference, to a BlockCipher. CreateFromString methods have been added to BlockCipher and EncryptionProvider to provide a single API by which different ciphers and providers can be created, respectively. -* The internal classes (CTREncryptionProvider, ROT13BlockCipher, CTRCipherStream) associated with the EncryptedEnv have been moved out of the public API. To create a CTREncryptionProvider, one can either use EncryptionProvider::NewCTRProvider, or EncryptionProvider::CreateFromString("CTR"). To create a new ROT13BlockCipher, one can either use BlockCipher::NewROT13Cipher or BlockCipher::CreateFromString("ROT13"). -* The EncryptionProvider::AddCipher method has been added to allow keys to be added to an EncryptionProvider. This API will allow future providers to support multiple cipher keys. -* Add a new option "allow_data_in_errors". When this new option is set by users, it allows users to opt-in to get error messages containing corrupted keys/values. Corrupt keys, values will be logged in the messages, logs, status etc. that will help users with the useful information regarding affected data. By default value of this option is set false to prevent users data to be exposed in the messages so currently, data will be redacted from logs, messages, status by default. -* AdvancedColumnFamilyOptions::force_consistency_checks is now true by default, for more proactive DB corruption detection at virtually no cost (estimated two extra CPU cycles per million on a major production workload). Corruptions reported by these checks now mention "force_consistency_checks" in case a false positive corruption report is suspected and the option needs to be disabled (unlikely). Since existing column families have a saved setting for force_consistency_checks, only new column families will pick up the new default. - -### General Improvements -* The settings of the DBOptions and ColumnFamilyOptions are now managed by Configurable objects (see New Features). The same convenience methods to configure these options still exist but the backend implementation has been unified under a common implementation. - -### New Features - -* Methods to configure serialize, and compare -- such as TableFactory -- are exposed directly through the Configurable base class (from which these objects inherit). This change will allow for better and more thorough configuration management and retrieval in the future. The options for a Configurable object can be set via the ConfigureFromMap, ConfigureFromString, or ConfigureOption method. The serialized version of the options of an object can be retrieved via the GetOptionString, ToString, or GetOption methods. The list of options supported by an object can be obtained via the GetOptionNames method. The "raw" object (such as the BlockBasedTableOption) for an option may be retrieved via the GetOptions method. Configurable options can be compared via the AreEquivalent method. The settings within a Configurable object may be validated via the ValidateOptions method. The object may be intialized (at which point only mutable options may be updated) via the PrepareOptions method. -* Introduce options.check_flush_compaction_key_order with default value to be true. With this option, during flush and compaction, key order will be checked when writing to each SST file. If the order is violated, the flush or compaction will fail. -* Added is_full_compaction to CompactionJobStats, so that the information is available through the EventListener interface. -* Add more stats for MultiGet in Histogram to get number of data blocks, index blocks, filter blocks and sst files read from file system per level. -* SST files have a new table property called db_host_id, which is set to the hostname by default. A new option in DBOptions, db_host_id, allows the property value to be overridden with a user specified string, or disable it completely by making the option string empty. -* Methods to create customizable extensions -- such as TableFactory -- are exposed directly through the Customizable base class (from which these objects inherit). This change will allow these Customizable classes to be loaded and configured in a standard way (via CreateFromString). More information on how to write and use Customizable classes is in the customizable.h header file. - -## 6.13 (2020-09-12) -### Bug fixes -* Fix a performance regression introduced in 6.4 that makes a upper bound check for every Next() even if keys are within a data block that is within the upper bound. -* Fix a possible corruption to the LSM state (overlapping files within a level) when a `CompactRange()` for refitting levels (`CompactRangeOptions::change_level == true`) and another manual compaction are executed in parallel. -* Sanitize `recycle_log_file_num` to zero when the user attempts to enable it in combination with `WALRecoveryMode::kTolerateCorruptedTailRecords`. Previously the two features were allowed together, which compromised the user's configured crash-recovery guarantees. -* Fix a bug where a level refitting in CompactRange() might race with an automatic compaction that puts the data to the target level of the refitting. The bug has been there for years. -* Fixed a bug in version 6.12 in which BackupEngine::CreateNewBackup could fail intermittently with non-OK status when backing up a read-write DB configured with a DBOptions::file_checksum_gen_factory. -* Fix useless no-op compactions scheduled upon snapshot release when options.disable-auto-compactions = true. -* Fix a bug when max_write_buffer_size_to_maintain is set, immutable flushed memtable destruction is delayed until the next super version is installed. A memtable is not added to delete list because of its reference hold by super version and super version doesn't switch because of empt delete list. So memory usage keeps on increasing beyond write_buffer_size + max_write_buffer_size_to_maintain. -* Avoid converting MERGES to PUTS when allow_ingest_behind is true. -* Fix compression dictionary sampling together with `SstFileWriter`. Previously, the dictionary would be trained/finalized immediately with zero samples. Now, the whole `SstFileWriter` file is buffered in memory and then sampled. -* Fix a bug with `avoid_unnecessary_blocking_io=1` and creating backups (BackupEngine::CreateNewBackup) or checkpoints (Checkpoint::Create). With this setting and WAL enabled, these operations could randomly fail with non-OK status. -* Fix a bug in which bottommost compaction continues to advance the underlying InternalIterator to skip tombstones even after shutdown. - -### New Features -* A new field `std::string requested_checksum_func_name` is added to `FileChecksumGenContext`, which enables the checksum factory to create generators for a suite of different functions. -* Added a new subcommand, `ldb unsafe_remove_sst_file`, which removes a lost or corrupt SST file from a DB's metadata. This command involves data loss and must not be used on a live DB. - -### Performance Improvements -* Reduce thread number for multiple DB instances by re-using one global thread for statistics dumping and persisting. -* Reduce write-amp in heavy write bursts in `kCompactionStyleLevel` compaction style with `level_compaction_dynamic_level_bytes` set. -* BackupEngine incremental backups no longer read DB table files that are already saved to a shared part of the backup directory, unless `share_files_with_checksum` is used with `kLegacyCrc32cAndFileSize` naming (discouraged). - * For `share_files_with_checksum`, we are confident there is no regression (vs. pre-6.12) in detecting DB or backup corruption at backup creation time, mostly because the old design did not leverage this extra checksum computation for detecting inconsistencies at backup creation time. - * For `share_table_files` without "checksum" (not recommended), there is a regression in detecting fundamentally unsafe use of the option, greatly mitigated by file size checking (under "Behavior Changes"). Almost no reason to use `share_files_with_checksum=false` should remain. - * `DB::VerifyChecksum` and `BackupEngine::VerifyBackup` with checksum checking are still able to catch corruptions that `CreateNewBackup` does not. - -### Public API Change -* Expose kTypeDeleteWithTimestamp in EntryType and update GetEntryType() accordingly. -* Added file_checksum and file_checksum_func_name to TableFileCreationInfo, which can pass the table file checksum information through the OnTableFileCreated callback during flush and compaction. -* A warning is added to `DB::DeleteFile()` API describing its known problems and deprecation plan. -* Add a new stats level, i.e. StatsLevel::kExceptTickers (PR7329) to exclude tickers even if application passes a non-null Statistics object. -* Added a new status code IOStatus::IOFenced() for the Env/FileSystem to indicate that writes from this instance are fenced off. Like any other background error, this error is returned to the user in Put/Merge/Delete/Flush calls and can be checked using Status::IsIOFenced(). - -### Behavior Changes -* File abstraction `FSRandomAccessFile.Prefetch()` default return status is changed from `OK` to `NotSupported`. If the user inherited file doesn't implement prefetch, RocksDB will create internal prefetch buffer to improve read performance. -* When retryabel IO error happens during Flush (manifest write error is excluded) and WAL is disabled, originally it is mapped to kHardError. Now,it is mapped to soft error. So DB will not stall the writes unless the memtable is full. At the same time, when auto resume is triggered to recover the retryable IO error during Flush, SwitchMemtable is not called to avoid generating to many small immutable memtables. If WAL is enabled, no behavior changes. -* When considering whether a table file is already backed up in a shared part of backup directory, BackupEngine would already query the sizes of source (DB) and pre-existing destination (backup) files. BackupEngine now uses these file sizes to detect corruption, as at least one of (a) old backup, (b) backup in progress, or (c) current DB is corrupt if there's a size mismatch. - -### Others -* Error in prefetching partitioned index blocks will not be swallowed. It will fail the query and return the IOError users. - -## 6.12 (2020-07-28) -### Public API Change -* Encryption file classes now exposed for inheritance in env_encryption.h -* File I/O listener is extended to cover more I/O operations. Now class `EventListener` in listener.h contains new callback functions: `OnFileFlushFinish()`, `OnFileSyncFinish()`, `OnFileRangeSyncFinish()`, `OnFileTruncateFinish()`, and ``OnFileCloseFinish()``. -* `FileOperationInfo` now reports `duration` measured by `std::chrono::steady_clock` and `start_ts` measured by `std::chrono::system_clock` instead of start and finish timestamps measured by `system_clock`. Note that `system_clock` is called before `steady_clock` in program order at operation starts. -* `DB::GetDbSessionId(std::string& session_id)` is added. `session_id` stores a unique identifier that gets reset every time the DB is opened. This DB session ID should be unique among all open DB instances on all hosts, and should be unique among re-openings of the same or other DBs. This identifier is recorded in the LOG file on the line starting with "DB Session ID:". -* `DB::OpenForReadOnly()` now returns `Status::NotFound` when the specified DB directory does not exist. Previously the error returned depended on the underlying `Env`. This change is available in all 6.11 releases as well. -* A parameter `verify_with_checksum` is added to `BackupEngine::VerifyBackup`, which is false by default. If it is ture, `BackupEngine::VerifyBackup` verifies checksums and file sizes of backup files. Pass `false` for `verify_with_checksum` to maintain the previous behavior and performance of `BackupEngine::VerifyBackup`, by only verifying sizes of backup files. - -### Behavior Changes -* Best-efforts recovery ignores CURRENT file completely. If CURRENT file is missing during recovery, best-efforts recovery still proceeds with MANIFEST file(s). -* In best-efforts recovery, an error that is not Corruption or IOError::kNotFound or IOError::kPathNotFound will be overwritten silently. Fix this by checking all non-ok cases and return early. -* When `file_checksum_gen_factory` is set to `GetFileChecksumGenCrc32cFactory()`, BackupEngine will compare the crc32c checksums of table files computed when creating a backup to the expected checksums stored in the DB manifest, and will fail `CreateNewBackup()` on mismatch (corruption). If the `file_checksum_gen_factory` is not set or set to any other customized factory, there is no checksum verification to detect if SST files in a DB are corrupt when read, copied, and independently checksummed by BackupEngine. -* When a DB sets `stats_dump_period_sec > 0`, either as the initial value for DB open or as a dynamic option change, the first stats dump is staggered in the following X seconds, where X is an integer in `[0, stats_dump_period_sec)`. Subsequent stats dumps are still spaced `stats_dump_period_sec` seconds apart. -* When the paranoid_file_checks option is true, a hash is generated of all keys and values are generated when the SST file is written, and then the values are read back in to validate the file. A corruption is signaled if the two hashes do not match. - -### Bug fixes -* Compressed block cache was automatically disabled with read-only DBs by mistake. Now it is fixed: compressed block cache will be in effective with read-only DB too. -* Fix a bug of wrong iterator result if another thread finishes an update and a DB flush between two statement. -* Disable file deletion after MANIFEST write/sync failure until db re-open or Resume() so that subsequent re-open will not see MANIFEST referencing deleted SSTs. -* Fix a bug when index_type == kTwoLevelIndexSearch in PartitionedIndexBuilder to update FlushPolicy to point to internal key partitioner when it changes from user-key mode to internal-key mode in index partition. -* Make compaction report InternalKey corruption while iterating over the input. -* Fix a bug which may cause MultiGet to be slow because it may read more data than requested, but this won't affect correctness. The bug was introduced in 6.10 release. -* Fail recovery and report once hitting a physical log record checksum mismatch, while reading MANIFEST. RocksDB should not continue processing the MANIFEST any further. -* Fixed a bug in size-amp-triggered and periodic-triggered universal compaction, where the compression settings for the first input level were used rather than the compression settings for the output (bottom) level. - -### New Features -* DB identity (`db_id`) and DB session identity (`db_session_id`) are added to table properties and stored in SST files. SST files generated from SstFileWriter and Repairer have DB identity “SST Writer” and “DB Repairer”, respectively. Their DB session IDs are generated in the same way as `DB::GetDbSessionId`. The session ID for SstFileWriter (resp., Repairer) resets every time `SstFileWriter::Open` (resp., `Repairer::Run`) is called. -* Added experimental option BlockBasedTableOptions::optimize_filters_for_memory for reducing allocated memory size of Bloom filters (~10% savings with Jemalloc) while preserving the same general accuracy. To have an effect, the option requires format_version=5 and malloc_usable_size. Enabling this option is forward and backward compatible with existing format_version=5. -* `BackupableDBOptions::share_files_with_checksum_naming` is added with new default behavior for naming backup files with `share_files_with_checksum`, to address performance and backup integrity issues. See API comments for details. -* Added auto resume function to automatically recover the DB from background Retryable IO Error. When retryable IOError happens during flush and WAL write, the error is mapped to Hard Error and DB will be in read mode. When retryable IO Error happens during compaction, the error will be mapped to Soft Error. DB is still in write/read mode. Autoresume function will create a thread for a DB to call DB->ResumeImpl() to try the recover for Retryable IO Error during flush and WAL write. Compaction will be rescheduled by itself if retryable IO Error happens. Auto resume may also cause other Retryable IO Error during the recovery, so the recovery will fail. Retry the auto resume may solve the issue, so we use max_bgerror_resume_count to decide how many resume cycles will be tried in total. If it is <=0, auto resume retryable IO Error is disabled. Default is INT_MAX, which will lead to a infinit auto resume. bgerror_resume_retry_interval decides the time interval between two auto resumes. -* Option `max_subcompactions` can be set dynamically using DB::SetDBOptions(). -* Added experimental ColumnFamilyOptions::sst_partitioner_factory to define determine the partitioning of sst files. This helps compaction to split the files on interesting boundaries (key prefixes) to make propagation of sst files less write amplifying (covering the whole key space). - -### Performance Improvements -* Eliminate key copies for internal comparisons while accessing ingested block-based tables. -* Reduce key comparisons during random access in all block-based tables. -* BackupEngine avoids unnecessary repeated checksum computation for backing up a table file to the `shared_checksum` directory when using `share_files_with_checksum_naming = kUseDbSessionId` (new default), except on SST files generated before this version of RocksDB, which fall back on using `kLegacyCrc32cAndFileSize`. - -## 6.11 (2020-06-12) -### Bug Fixes -* Fix consistency checking error swallowing in some cases when options.force_consistency_checks = true. -* Fix possible false NotFound status from batched MultiGet using index type kHashSearch. -* Fix corruption caused by enabling delete triggered compaction (NewCompactOnDeletionCollectorFactory) in universal compaction mode, along with parallel compactions. The bug can result in two parallel compactions picking the same input files, resulting in the DB resurrecting older and deleted versions of some keys. -* Fix a use-after-free bug in best-efforts recovery. column_family_memtables_ needs to point to valid ColumnFamilySet. -* Let best-efforts recovery ignore corrupted files during table loading. -* Fix corrupt key read from ingested file when iterator direction switches from reverse to forward at a key that is a prefix of another key in the same file. It is only possible in files with a non-zero global seqno. -* Fix abnormally large estimate from GetApproximateSizes when a range starts near the end of one SST file and near the beginning of another. Now GetApproximateSizes consistently and fairly includes the size of SST metadata in addition to data blocks, attributing metadata proportionally among the data blocks based on their size. -* Fix potential file descriptor leakage in PosixEnv's IsDirectory() and NewRandomAccessFile(). -* Fix false negative from the VerifyChecksum() API when there is a checksum mismatch in an index partition block in a BlockBasedTable format table file (index_type is kTwoLevelIndexSearch). -* Fix sst_dump to return non-zero exit code if the specified file is not a recognized SST file or fails requested checks. -* Fix incorrect results from batched MultiGet for duplicate keys, when the duplicate key matches the largest key of an SST file and the value type for the key in the file is a merge value. - -### Public API Change -* Flush(..., column_family) may return Status::ColumnFamilyDropped() instead of Status::InvalidArgument() if column_family is dropped while processing the flush request. -* BlobDB now explicitly disallows using the default column family's storage directories as blob directory. -* DeleteRange now returns `Status::InvalidArgument` if the range's end key comes before its start key according to the user comparator. Previously the behavior was undefined. -* ldb now uses options.force_consistency_checks = true by default and "--disable_consistency_checks" is added to disable it. -* DB::OpenForReadOnly no longer creates files or directories if the named DB does not exist, unless create_if_missing is set to true. -* The consistency checks that validate LSM state changes (table file additions/deletions during flushes and compactions) are now stricter, more efficient, and no longer optional, i.e. they are performed even if `force_consistency_checks` is `false`. -* Disable delete triggered compaction (NewCompactOnDeletionCollectorFactory) in universal compaction mode and num_levels = 1 in order to avoid a corruption bug. -* `pin_l0_filter_and_index_blocks_in_cache` no longer applies to L0 files larger than `1.5 * write_buffer_size` to give more predictable memory usage. Such L0 files may exist due to intra-L0 compaction, external file ingestion, or user dynamically changing `write_buffer_size` (note, however, that files that are already pinned will continue being pinned, even after such a dynamic change). -* In point-in-time wal recovery mode, fail database recovery in case of IOError while reading the WAL to avoid data loss. -* A new method `Env::LowerThreadPoolCPUPriority(Priority, CpuPriority)` is added to `Env` to be able to lower to a specific priority such as `CpuPriority::kIdle`. - -### New Features -* sst_dump to add a new --readahead_size argument. Users can specify read size when scanning the data. Sst_dump also tries to prefetch tail part of the SST files so usually some number of I/Os are saved there too. -* Generate file checksum in SstFileWriter if Options.file_checksum_gen_factory is set. The checksum and checksum function name are stored in ExternalSstFileInfo after the sst file write is finished. -* Add a value_size_soft_limit in read options which limits the cumulative value size of keys read in batches in MultiGet. Once the cumulative value size of found keys exceeds read_options.value_size_soft_limit, all the remaining keys are returned with status Abort without further finding their values. By default the value_size_soft_limit is std::numeric_limits::max(). -* Enable SST file ingestion with file checksum information when calling IngestExternalFiles(const std::vector& args). Added files_checksums and files_checksum_func_names to IngestExternalFileArg such that user can ingest the sst files with their file checksum information. Added verify_file_checksum to IngestExternalFileOptions (default is True). To be backward compatible, if DB does not enable file checksum or user does not provide checksum information (vectors of files_checksums and files_checksum_func_names are both empty), verification of file checksum is always sucessful. If DB enables file checksum, DB will always generate the checksum for each ingested SST file during Prepare stage of ingestion and store the checksum in Manifest, unless verify_file_checksum is False and checksum information is provided by the application. In this case, we only verify the checksum function name and directly store the ingested checksum in Manifest. If verify_file_checksum is set to True, DB will verify the ingested checksum and function name with the genrated ones. Any mismatch will fail the ingestion. Note that, if IngestExternalFileOptions::write_global_seqno is True, the seqno will be changed in the ingested file. Therefore, the checksum of the file will be changed. In this case, a new checksum will be generated after the seqno is updated and be stored in the Manifest. - -### Performance Improvements -* Eliminate redundant key comparisons during random access in block-based tables. - -## 6.10 (2020-05-02) -### Bug Fixes -* Fix wrong result being read from ingested file. May happen when a key in the file happen to be prefix of another key also in the file. The issue can further cause more data corruption. The issue exists with rocksdb >= 5.0.0 since DB::IngestExternalFile() was introduced. -* Finish implementation of BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey. It's now ready for use. Significantly reduces read amplification in some setups, especially for iterator seeks. -* Fix a bug by updating CURRENT file so that it points to the correct MANIFEST file after best-efforts recovery. -* Fixed a bug where ColumnFamilyHandle objects were not cleaned up in case an error happened during BlobDB's open after the base DB had been opened. -* Fix a potential undefined behavior caused by trying to dereference nullable pointer (timestamp argument) in DB::MultiGet. -* Fix a bug caused by not including user timestamp in MultiGet LookupKey construction. This can lead to wrong query result since the trailing bytes of a user key, if not shorter than timestamp, will be mistaken for user timestamp. -* Fix a bug caused by using wrong compare function when sorting the input keys of MultiGet with timestamps. -* Upgraded version of bzip library (1.0.6 -> 1.0.8) used with RocksJava to address potential vulnerabilities if an attacker can manipulate compressed data saved and loaded by RocksDB (not normal). See issue #6703. - -### Public API Change -* Add a ConfigOptions argument to the APIs dealing with converting options to and from strings and files. The ConfigOptions is meant to replace some of the options (such as input_strings_escaped and ignore_unknown_options) and allow for more parameters to be passed in the future without changing the function signature. -* Add NewFileChecksumGenCrc32cFactory to the file checksum public API, such that the builtin Crc32c based file checksum generator factory can be used by applications. -* Add IsDirectory to Env and FS to indicate if a path is a directory. - -### New Features -* Added support for pipelined & parallel compression optimization for `BlockBasedTableBuilder`. This optimization makes block building, block compression and block appending a pipeline, and uses multiple threads to accelerate block compression. Users can set `CompressionOptions::parallel_threads` greater than 1 to enable compression parallelism. This feature is experimental for now. -* Provide an allocator for memkind to be used with block cache. This is to work with memory technologies (Intel DCPMM is one such technology currently available) that require different libraries for allocation and management (such as PMDK and memkind). The high capacities available make it possible to provision large caches (up to several TBs in size) beyond what is achievable with DRAM. -* Option `max_background_flushes` can be set dynamically using DB::SetDBOptions(). -* Added functionality in sst_dump tool to check the compressed file size for different compression levels and print the time spent on compressing files with each compression type. Added arguments `--compression_level_from` and `--compression_level_to` to report size of all compression levels and one compression_type must be specified with it so that it will report compressed sizes of one compression type with different levels. -* Added statistics for redundant insertions into block cache: rocksdb.block.cache.*add.redundant. (There is currently no coordination to ensure that only one thread loads a table block when many threads are trying to access that same table block.) - -### Bug Fixes -* Fix a bug when making options.bottommost_compression, options.compression_opts and options.bottommost_compression_opts dynamically changeable: the modified values are not written to option files or returned back to users when being queried. -* Fix a bug where index key comparisons were unaccounted in `PerfContext::user_key_comparison_count` for lookups in files written with `format_version >= 3`. -* Fix many bloom.filter statistics not being updated in batch MultiGet. - -### Performance Improvements -* Improve performance of batch MultiGet with partitioned filters, by sharing block cache lookups to applicable filter blocks. -* Reduced memory copies when fetching and uncompressing compressed blocks from sst files. - -## 6.9.0 (2020-03-29) -### Behavior changes -* Since RocksDB 6.8, ttl-based FIFO compaction can drop a file whose oldest key becomes older than options.ttl while others have not. This fix reverts this and makes ttl-based FIFO compaction use the file's flush time as the criterion. This fix also requires that max_open_files = -1 and compaction_options_fifo.allow_compaction = false to function properly. - -### Public API Change -* Fix spelling so that API now has correctly spelled transaction state name `COMMITTED`, while the old misspelled `COMMITED` is still available as an alias. -* Updated default format_version in BlockBasedTableOptions from 2 to 4. SST files generated with the new default can be read by RocksDB versions 5.16 and newer, and use more efficient encoding of keys in index blocks. -* A new parameter `CreateBackupOptions` is added to both `BackupEngine::CreateNewBackup` and `BackupEngine::CreateNewBackupWithMetadata`, you can decrease CPU priority of `BackupEngine`'s background threads by setting `decrease_background_thread_cpu_priority` and `background_thread_cpu_priority` in `CreateBackupOptions`. -* Updated the public API of SST file checksum. Introduce the FileChecksumGenFactory to create the FileChecksumGenerator for each SST file, such that the FileChecksumGenerator is not shared and it can be more general for checksum implementations. Changed the FileChecksumGenerator interface from Value, Extend, and GetChecksum to Update, Finalize, and GetChecksum. Finalize should be only called once after all data is processed to generate the final checksum. Temproal data should be maintained by the FileChecksumGenerator object itself and finally it can return the checksum string. - -### Bug Fixes -* Fix a bug where range tombstone blocks in ingested files were cached incorrectly during ingestion. If range tombstones were read from those incorrectly cached blocks, the keys they covered would be exposed. -* Fix a data race that might cause crash when calling DB::GetCreationTimeOfOldestFile() by a small chance. The bug was introduced in 6.6 Release. -* Fix a bug where a boolean value optimize_filters_for_hits was for max threads when calling load table handles after a flush or compaction. The value is correct to 1. The bug should not cause user visible problems. -* Fix a bug which might crash the service when write buffer manager fails to insert the dummy handle to the block cache. - -### Performance Improvements -* In CompactRange, for levels starting from 0, if the level does not have any file with any key falling in the specified range, the level is skipped. So instead of always compacting from level 0, the compaction starts from the first level with keys in the specified range until the last such level. -* Reduced memory copy when reading sst footer and blobdb in direct IO mode. -* When restarting a database with large numbers of sst files, large amount of CPU time is spent on getting logical block size of the sst files, which slows down the starting progress, this inefficiency is optimized away with an internal cache for the logical block sizes. - -### New Features -* Basic support for user timestamp in iterator. Seek/SeekToFirst/Next and lower/upper bounds are supported. Reverse iteration is not supported. Merge is not considered. -* When file lock failure when the lock is held by the current process, return acquiring time and thread ID in the error message. -* Added a new option, best_efforts_recovery (default: false), to allow database to open in a db dir with missing table files. During best efforts recovery, missing table files are ignored, and database recovers to the most recent state without missing table file. Cross-column-family consistency is not guaranteed even if WAL is enabled. -* options.bottommost_compression, options.compression_opts and options.bottommost_compression_opts are now dynamically changeable. - -## 6.8.0 (2020-02-24) -### Java API Changes -* Major breaking changes to Java comparators, toward standardizing on ByteBuffer for performant, locale-neutral operations on keys (#6252). -* Added overloads of common API methods using direct ByteBuffers for keys and values (#2283). - -### Bug Fixes -* Fix incorrect results while block-based table uses kHashSearch, together with Prev()/SeekForPrev(). -* Fix a bug that prevents opening a DB after two consecutive crash with TransactionDB, where the first crash recovers from a corrupted WAL with kPointInTimeRecovery but the second cannot. -* Fixed issue #6316 that can cause a corruption of the MANIFEST file in the middle when writing to it fails due to no disk space. -* Add DBOptions::skip_checking_sst_file_sizes_on_db_open. It disables potentially expensive checking of all sst file sizes in DB::Open(). -* BlobDB now ignores trivially moved files when updating the mapping between blob files and SSTs. This should mitigate issue #6338 where out of order flush/compaction notifications could trigger an assertion with the earlier code. -* Batched MultiGet() ignores IO errors while reading data blocks, causing it to potentially continue looking for a key and returning stale results. -* `WriteBatchWithIndex::DeleteRange` returns `Status::NotSupported`. Previously it returned success even though reads on the batch did not account for range tombstones. The corresponding language bindings now cannot be used. In C, that includes `rocksdb_writebatch_wi_delete_range`, `rocksdb_writebatch_wi_delete_range_cf`, `rocksdb_writebatch_wi_delete_rangev`, and `rocksdb_writebatch_wi_delete_rangev_cf`. In Java, that includes `WriteBatchWithIndex::deleteRange`. -* Assign new MANIFEST file number when caller tries to create a new MANIFEST by calling LogAndApply(..., new_descriptor_log=true). This bug can cause MANIFEST being overwritten during recovery if options.write_dbid_to_manifest = true and there are WAL file(s). - -### Performance Improvements -* Perfom readahead when reading from option files. Inside DB, options.log_readahead_size will be used as the readahead size. In other cases, a default 512KB is used. - -### Public API Change -* The BlobDB garbage collector now emits the statistics `BLOB_DB_GC_NUM_FILES` (number of blob files obsoleted during GC), `BLOB_DB_GC_NUM_NEW_FILES` (number of new blob files generated during GC), `BLOB_DB_GC_FAILURES` (number of failed GC passes), `BLOB_DB_GC_NUM_KEYS_RELOCATED` (number of blobs relocated during GC), and `BLOB_DB_GC_BYTES_RELOCATED` (total size of blobs relocated during GC). On the other hand, the following statistics, which are not relevant for the new GC implementation, are now deprecated: `BLOB_DB_GC_NUM_KEYS_OVERWRITTEN`, `BLOB_DB_GC_NUM_KEYS_EXPIRED`, `BLOB_DB_GC_BYTES_OVERWRITTEN`, `BLOB_DB_GC_BYTES_EXPIRED`, and `BLOB_DB_GC_MICROS`. -* Disable recycle_log_file_num when an inconsistent recovery modes are requested: kPointInTimeRecovery and kAbsoluteConsistency - -### New Features -* Added the checksum for each SST file generated by Flush or Compaction. Added sst_file_checksum_func to Options such that user can plugin their own SST file checksum function via override the FileChecksumFunc class. If user does not set the sst_file_checksum_func, SST file checksum calculation will not be enabled. The checksum information inlcuding uint32_t checksum value and a checksum function name (string). The checksum information is stored in FileMetadata in version store and also logged to MANIFEST. A new tool is added to LDB such that user can dump out a list of file checksum information from MANIFEST (stored in an unordered_map). -* `db_bench` now supports `value_size_distribution_type`, `value_size_min`, `value_size_max` options for generating random variable sized value. Added `blob_db_compression_type` option for BlobDB to enable blob compression. -* Replace RocksDB namespace "rocksdb" with flag "ROCKSDB_NAMESPACE" which if is not defined, defined as "rocksdb" in header file rocksdb_namespace.h. - -## 6.7.0 (2020-01-21) -### Public API Change -* Added a rocksdb::FileSystem class in include/rocksdb/file_system.h to encapsulate file creation/read/write operations, and an option DBOptions::file_system to allow a user to pass in an instance of rocksdb::FileSystem. If its a non-null value, this will take precendence over DBOptions::env for file operations. A new API rocksdb::FileSystem::Default() returns a platform default object. The DBOptions::env option and Env::Default() API will continue to be used for threading and other OS related functions, and where DBOptions::file_system is not specified, for file operations. For storage developers who are accustomed to rocksdb::Env, the interface in rocksdb::FileSystem is new and will probably undergo some changes as more storage systems are ported to it from rocksdb::Env. As of now, no env other than Posix has been ported to the new interface. -* A new rocksdb::NewSstFileManager() API that allows the caller to pass in separate Env and FileSystem objects. -* Changed Java API for RocksDB.keyMayExist functions to use Holder instead of StringBuilder, so that retrieved values need not decode to Strings. -* A new `OptimisticTransactionDBOptions` Option that allows users to configure occ validation policy. The default policy changes from kValidateSerial to kValidateParallel to reduce mutex contention. - -### Bug Fixes -* Fix a bug that can cause unnecessary bg thread to be scheduled(#6104). -* Fix crash caused by concurrent CF iterations and drops(#6147). -* Fix a race condition for cfd->log_number_ between manifest switch and memtable switch (PR 6249) when number of column families is greater than 1. -* Fix a bug on fractional cascading index when multiple files at the same level contain the same smallest user key, and those user keys are for merge operands. In this case, Get() the exact key may miss some merge operands. -* Delcare kHashSearch index type feature-incompatible with index_block_restart_interval larger than 1. -* Fixed an issue where the thread pools were not resized upon setting `max_background_jobs` dynamically through the `SetDBOptions` interface. -* Fix a bug that can cause write threads to hang when a slowdown/stall happens and there is a mix of writers with WriteOptions::no_slowdown set/unset. -* Fixed an issue where an incorrect "number of input records" value was used to compute the "records dropped" statistics for compactions. -* Fix a regression bug that causes segfault when hash is used, max_open_files != -1 and total order seek is used and switched back. - -### New Features -* It is now possible to enable periodic compactions for the base DB when using BlobDB. -* BlobDB now garbage collects non-TTL blobs when `enable_garbage_collection` is set to `true` in `BlobDBOptions`. Garbage collection is performed during compaction: any valid blobs located in the oldest N files (where N is the number of non-TTL blob files multiplied by the value of `BlobDBOptions::garbage_collection_cutoff`) encountered during compaction get relocated to new blob files, and old blob files are dropped once they are no longer needed. Note: we recommend enabling periodic compactions for the base DB when using this feature to deal with the case when some old blob files are kept alive by SSTs that otherwise do not get picked for compaction. -* `db_bench` now supports the `garbage_collection_cutoff` option for BlobDB. -* Introduce ReadOptions.auto_prefix_mode. When set to true, iterator will return the same result as total order seek, but may choose to use prefix seek internally based on seek key and iterator upper bound. -* MultiGet() can use IO Uring to parallelize read from the same SST file. This featuer is by default disabled. It can be enabled with environment variable ROCKSDB_USE_IO_URING. - -## 6.6.2 (2020-01-13) -### Bug Fixes -* Fixed a bug where non-L0 compaction input files were not considered to compute the `creation_time` of new compaction outputs. - -## 6.6.1 (2020-01-02) -### Bug Fixes -* Fix a bug in WriteBatchWithIndex::MultiGetFromBatchAndDB, which is called by Transaction::MultiGet, that causes due to stale pointer access when the number of keys is > 32 -* Fixed two performance issues related to memtable history trimming. First, a new SuperVersion is now created only if some memtables were actually trimmed. Second, trimming is only scheduled if there is at least one flushed memtable that is kept in memory for the purposes of transaction conflict checking. -* BlobDB no longer updates the SST to blob file mapping upon failed compactions. -* Fix a bug in which a snapshot read through an iterator could be affected by a DeleteRange after the snapshot (#6062). -* Fixed a bug where BlobDB was comparing the `ColumnFamilyHandle` pointers themselves instead of only the column family IDs when checking whether an API call uses the default column family or not. -* Delete superversions in BackgroundCallPurge. -* Fix use-after-free and double-deleting files in BackgroundCallPurge(). - -## 6.6.0 (2019-11-25) -### Bug Fixes -* Fix data corruption caused by output of intra-L0 compaction on ingested file not being placed in correct order in L0. -* Fix a data race between Version::GetColumnFamilyMetaData() and Compaction::MarkFilesBeingCompacted() for access to being_compacted (#6056). The current fix acquires the db mutex during Version::GetColumnFamilyMetaData(), which may cause regression. -* Fix a bug in DBIter that is_blob_ state isn't updated when iterating backward using seek. -* Fix a bug when format_version=3, partitioned filters, and prefix search are used in conjunction. The bug could result into Seek::(prefix) returning NotFound for an existing prefix. -* Revert the feature "Merging iterator to avoid child iterator reseek for some cases (#5286)" since it might cause strong results when reseek happens with a different iterator upper bound. -* Fix a bug causing a crash during ingest external file when background compaction cause severe error (file not found). -* Fix a bug when partitioned filters and prefix search are used in conjunction, ::SeekForPrev could return invalid for an existing prefix. ::SeekForPrev might be called by the user, or internally on ::Prev, or within ::Seek if the return value involves Delete or a Merge operand. -* Fix OnFlushCompleted fired before flush result persisted in MANIFEST when there's concurrent flush job. The bug exists since OnFlushCompleted was introduced in rocksdb 3.8. -* Fixed an sst_dump crash on some plain table SST files. -* Fixed a memory leak in some error cases of opening plain table SST files. -* Fix a bug when a crash happens while calling WriteLevel0TableForRecovery for multiple column families, leading to a column family's log number greater than the first corrutped log number when the DB is being opened in PointInTime recovery mode during next recovery attempt (#5856). - -### New Features -* Universal compaction to support options.periodic_compaction_seconds. A full compaction will be triggered if any file is over the threshold. -* `GetLiveFilesMetaData` and `GetColumnFamilyMetaData` now expose the file number of SST files as well as the oldest blob file referenced by each SST. -* A batched MultiGet API (DB::MultiGet()) that supports retrieving keys from multiple column families. -* Full and partitioned filters in the block-based table use an improved Bloom filter implementation, enabled with format_version 5 (or above) because previous releases cannot read this filter. This replacement is faster and more accurate, especially for high bits per key or millions of keys in a single (full) filter. For example, the new Bloom filter has the same false positive rate at 9.55 bits per key as the old one at 10 bits per key, and a lower false positive rate at 16 bits per key than the old one at 100 bits per key. -* Added AVX2 instructions to USE_SSE builds to accelerate the new Bloom filter and XXH3-based hash function on compatible x86_64 platforms (Haswell and later, ~2014). -* Support options.ttl or options.periodic_compaction_seconds with options.max_open_files = -1. File's oldest ancester time and file creation time will be written to manifest. If it is availalbe, this information will be used instead of creation_time and file_creation_time in table properties. -* Setting options.ttl for universal compaction now has the same meaning as setting periodic_compaction_seconds. -* SstFileMetaData also returns file creation time and oldest ancester time. -* The `sst_dump` command line tool `recompress` command now displays how many blocks were compressed and how many were not, in particular how many were not compressed because the compression ratio was not met (12.5% threshold for GoodCompressionRatio), as seen in the `number.block.not_compressed` counter stat since version 6.0.0. -* The block cache usage is now takes into account the overhead of metadata per each entry. This results into more accurate management of memory. A side-effect of this feature is that less items are fit into the block cache of the same size, which would result to higher cache miss rates. This can be remedied by increasing the block cache size or passing kDontChargeCacheMetadata to its constuctor to restore the old behavior. -* When using BlobDB, a mapping is maintained and persisted in the MANIFEST between each SST file and the oldest non-TTL blob file it references. -* `db_bench` now supports and by default issues non-TTL Puts to BlobDB. TTL Puts can be enabled by specifying a non-zero value for the `blob_db_max_ttl_range` command line parameter explicitly. -* `sst_dump` now supports printing BlobDB blob indexes in a human-readable format. This can be enabled by specifying the `decode_blob_index` flag on the command line. -* A number of new information elements are now exposed through the EventListener interface. For flushes, the file numbers of the new SST file and the oldest blob file referenced by the SST are propagated. For compactions, the level, file number, and the oldest blob file referenced are passed to the client for each compaction input and output file. - -### Public API Change -* RocksDB release 4.1 or older will not be able to open DB generated by the new release. 4.2 was released on Feb 23, 2016. -* TTL Compactions in Level compaction style now initiate successive cascading compactions on a key range so that it reaches the bottom level quickly on TTL expiry. `creation_time` table property for compaction output files is now set to the minimum of the creation times of all compaction inputs. -* With FIFO compaction style, options.periodic_compaction_seconds will have the same meaning as options.ttl. Whichever stricter will be used. With the default options.periodic_compaction_seconds value with options.ttl's default of 0, RocksDB will give a default of 30 days. -* Added an API GetCreationTimeOfOldestFile(uint64_t* creation_time) to get the file_creation_time of the oldest SST file in the DB. -* FilterPolicy now exposes additional API to make it possible to choose filter configurations based on context, such as table level and compaction style. See `LevelAndStyleCustomFilterPolicy` in db_bloom_filter_test.cc. While most existing custom implementations of FilterPolicy should continue to work as before, those wrapping the return of NewBloomFilterPolicy will require overriding new function `GetBuilderWithContext()`, because calling `GetFilterBitsBuilder()` on the FilterPolicy returned by NewBloomFilterPolicy is no longer supported. -* An unlikely usage of FilterPolicy is no longer supported. Calling GetFilterBitsBuilder() on the FilterPolicy returned by NewBloomFilterPolicy will now cause an assertion violation in debug builds, because RocksDB has internally migrated to a more elaborate interface that is expected to evolve further. Custom implementations of FilterPolicy should work as before, except those wrapping the return of NewBloomFilterPolicy, which will require a new override of a protected function in FilterPolicy. -* NewBloomFilterPolicy now takes bits_per_key as a double instead of an int. This permits finer control over the memory vs. accuracy trade-off in the new Bloom filter implementation and should not change source code compatibility. -* The option BackupableDBOptions::max_valid_backups_to_open is now only used when opening BackupEngineReadOnly. When opening a read/write BackupEngine, anything but the default value logs a warning and is treated as the default. This change ensures that backup deletion has proper accounting of shared files to ensure they are deleted when no longer referenced by a backup. -* Deprecate `snap_refresh_nanos` option. -* Added DisableManualCompaction/EnableManualCompaction to stop and resume manual compaction. -* Add TryCatchUpWithPrimary() to StackableDB in non-LITE mode. -* Add a new Env::LoadEnv() overloaded function to return a shared_ptr to Env. -* Flush sets file name to "(nil)" for OnTableFileCreationCompleted() if the flush does not produce any L0. This can happen if the file is empty thus delete by RocksDB. - -### Default Option Changes -* Changed the default value of periodic_compaction_seconds to `UINT64_MAX - 1` which allows RocksDB to auto-tune periodic compaction scheduling. When using the default value, periodic compactions are now auto-enabled if a compaction filter is used. A value of `0` will turn off the feature completely. -* Changed the default value of ttl to `UINT64_MAX - 1` which allows RocksDB to auto-tune ttl value. When using the default value, TTL will be auto-enabled to 30 days, when the feature is supported. To revert the old behavior, you can explicitly set it to 0. - -### Performance Improvements -* For 64-bit hashing, RocksDB is standardizing on a slightly modified preview version of XXH3. This function is now used for many non-persisted hashes, along with fastrange64() in place of the modulus operator, and some benchmarks show a slight improvement. -* Level iterator to invlidate the iterator more often in prefix seek and the level is filtered out by prefix bloom. - -## 6.5.2 (2019-11-15) -### Bug Fixes -* Fix a assertion failure in MultiGet() when BlockBasedTableOptions::no_block_cache is true and there is no compressed block cache -* Fix a buffer overrun problem in BlockBasedTable::MultiGet() when compression is enabled and no compressed block cache is configured. -* If a call to BackupEngine::PurgeOldBackups or BackupEngine::DeleteBackup suffered a crash, power failure, or I/O error, files could be left over from old backups that could only be purged with a call to GarbageCollect. Any call to PurgeOldBackups, DeleteBackup, or GarbageCollect should now suffice to purge such files. - -## 6.5.1 (2019-10-16) -### Bug Fixes -* Revert the feature "Merging iterator to avoid child iterator reseek for some cases (#5286)" since it might cause strange results when reseek happens with a different iterator upper bound. -* Fix a bug in BlockBasedTableIterator that might return incorrect results when reseek happens with a different iterator upper bound. -* Fix a bug when partitioned filters and prefix search are used in conjunction, ::SeekForPrev could return invalid for an existing prefix. ::SeekForPrev might be called by the user, or internally on ::Prev, or within ::Seek if the return value involves Delete or a Merge operand. - -## 6.5.0 (2019-09-13) -### Bug Fixes -* Fixed a number of data races in BlobDB. -* Fix a bug where the compaction snapshot refresh feature is not disabled as advertised when `snap_refresh_nanos` is set to 0.. -* Fix bloom filter lookups by the MultiGet batching API when BlockBasedTableOptions::whole_key_filtering is false, by checking that a key is in the perfix_extractor domain and extracting the prefix before looking up. -* Fix a bug in file ingestion caused by incorrect file number allocation when the number of column families involved in the ingestion exceeds 2. - -### New Features -* Introduced DBOptions::max_write_batch_group_size_bytes to configure maximum limit on number of bytes that are written in a single batch of WAL or memtable write. It is followed when the leader write size is larger than 1/8 of this limit. -* VerifyChecksum() by default will issue readahead. Allow ReadOptions to be passed in to those functions to override the readhead size. For checksum verifying before external SST file ingestion, a new option IngestExternalFileOptions.verify_checksums_readahead_size, is added for this readahead setting. -* When user uses options.force_consistency_check in RocksDb, instead of crashing the process, we now pass the error back to the users without killing the process. -* Add an option `memtable_insert_hint_per_batch` to WriteOptions. If it is true, each WriteBatch will maintain its own insert hints for each memtable in concurrent write. See include/rocksdb/options.h for more details. - -### Public API Change -* Added max_write_buffer_size_to_maintain option to better control memory usage of immutable memtables. -* Added a lightweight API GetCurrentWalFile() to get last live WAL filename and size. Meant to be used as a helper for backup/restore tooling in a larger ecosystem such as MySQL with a MyRocks storage engine. -* The MemTable Bloom filter, when enabled, now always uses cache locality. Options::bloom_locality now only affects the PlainTable SST format. - -### Performance Improvements -* Improve the speed of the MemTable Bloom filter, reducing the write overhead of enabling it by 1/3 to 1/2, with similar benefit to read performance. - -## 6.4.0 (2019-07-30) -### Default Option Change -* LRUCacheOptions.high_pri_pool_ratio is set to 0.5 (previously 0.0) by default, which means that by default midpoint insertion is enabled. The same change is made for the default value of high_pri_pool_ratio argument in NewLRUCache(). When block cache is not explicitly created, the small block cache created by BlockBasedTable will still has this option to be 0.0. -* Change BlockBasedTableOptions.cache_index_and_filter_blocks_with_high_priority's default value from false to true. - -### Public API Change -* Filter and compression dictionary blocks are now handled similarly to data blocks with regards to the block cache: instead of storing objects in the cache, only the blocks themselves are cached. In addition, filter and compression dictionary blocks (as well as filter partitions) no longer get evicted from the cache when a table is closed. -* Due to the above refactoring, block cache eviction statistics for filter and compression dictionary blocks are temporarily broken. We plan to reintroduce them in a later phase. -* The semantics of the per-block-type block read counts in the performance context now match those of the generic block_read_count. -* Errors related to the retrieval of the compression dictionary are now propagated to the user. -* db_bench adds a "benchmark" stats_history, which prints out the whole stats history. -* Overload GetAllKeyVersions() to support non-default column family. -* Added new APIs ExportColumnFamily() and CreateColumnFamilyWithImport() to support export and import of a Column Family. https://github.com/facebook/rocksdb/issues/3469 -* ldb sometimes uses a string-append merge operator if no merge operator is passed in. This is to allow users to print keys from a DB with a merge operator. -* Replaces old Registra with ObjectRegistry to allow user to create custom object from string, also add LoadEnv() to Env. -* Added new overload of GetApproximateSizes which gets SizeApproximationOptions object and returns a Status. The older overloads are redirecting their calls to this new method and no longer assert if the include_flags doesn't have either of INCLUDE_MEMTABLES or INCLUDE_FILES bits set. It's recommended to use the new method only, as it is more type safe and returns a meaningful status in case of errors. -* LDBCommandRunner::RunCommand() to return the status code as an integer, rather than call exit() using the code. - -### New Features -* Add argument `--secondary_path` to ldb to open the database as the secondary instance. This would keep the original DB intact. -* Compression dictionary blocks are now prefetched and pinned in the cache (based on the customer's settings) the same way as index and filter blocks. -* Added DBOptions::log_readahead_size which specifies the number of bytes to prefetch when reading the log. This is mostly useful for reading a remotely located log, as it can save the number of round-trips. If 0 (default), then the prefetching is disabled. -* Added new option in SizeApproximationOptions used with DB::GetApproximateSizes. When approximating the files total size that is used to store a keys range, allow approximation with an error margin of up to total_files_size * files_size_error_margin. This allows to take some shortcuts in files size approximation, resulting in better performance, while guaranteeing the resulting error is within a reasonable margin. -* Support loading custom objects in unit tests. In the affected unit tests, RocksDB will create custom Env objects based on environment variable TEST_ENV_URI. Users need to make sure custom object types are properly registered. For example, a static library should expose a `RegisterCustomObjects` function. By linking the unit test binary with the static library, the unit test can execute this function. - -### Performance Improvements -* Reduce iterator key comparison for upper/lower bound check. -* Improve performance of row_cache: make reads with newer snapshots than data in an SST file share the same cache key, except in some transaction cases. -* The compression dictionary is no longer copied to a new object upon retrieval. - -### Bug Fixes -* Fix ingested file and directory not being fsync. -* Return TryAgain status in place of Corruption when new tail is not visible to TransactionLogIterator. -* Fixed a regression where the fill_cache read option also affected index blocks. -* Fixed an issue where using cache_index_and_filter_blocks==false affected partitions of partitioned indexes/filters as well. - -## 6.3.2 (2019-08-15) -### Public API Change -* The semantics of the per-block-type block read counts in the performance context now match those of the generic block_read_count. - -### Bug Fixes -* Fixed a regression where the fill_cache read option also affected index blocks. -* Fixed an issue where using cache_index_and_filter_blocks==false affected partitions of partitioned indexes as well. - -## 6.3.1 (2019-07-24) -### Bug Fixes -* Fix auto rolling bug introduced in 6.3.0, which causes segfault if log file creation fails. - -## 6.3.0 (2019-06-18) -### Public API Change -* Now DB::Close() will return Aborted() error when there is unreleased snapshot. Users can retry after all snapshots are released. -* Index blocks are now handled similarly to data blocks with regards to the block cache: instead of storing objects in the cache, only the blocks themselves are cached. In addition, index blocks no longer get evicted from the cache when a table is closed, can now use the compressed block cache (if any), and can be shared among multiple table readers. -* Partitions of partitioned indexes no longer affect the read amplification statistics. -* Due to the above refactoring, block cache eviction statistics for indexes are temporarily broken. We plan to reintroduce them in a later phase. -* options.keep_log_file_num will be enforced strictly all the time. File names of all log files will be tracked, which may take significantly amount of memory if options.keep_log_file_num is large and either of options.max_log_file_size or options.log_file_time_to_roll is set. -* Add initial support for Get/Put with user timestamps. Users can specify timestamps via ReadOptions and WriteOptions when calling DB::Get and DB::Put. -* Accessing a partition of a partitioned filter or index through a pinned reference is no longer considered a cache hit. -* Add C bindings for secondary instance, i.e. DBImplSecondary. -* Rate limited deletion of WALs is only enabled if DBOptions::wal_dir is not set, or explicitly set to db_name passed to DB::Open and DBOptions::db_paths is empty, or same as db_paths[0].path - -### New Features -* Add an option `snap_refresh_nanos` (default to 0) to periodically refresh the snapshot list in compaction jobs. Assign to 0 to disable the feature. -* Add an option `unordered_write` which trades snapshot guarantees with higher write throughput. When used with WRITE_PREPARED transactions with two_write_queues=true, it offers higher throughput with however no compromise on guarantees. -* Allow DBImplSecondary to remove memtables with obsolete data after replaying MANIFEST and WAL. -* Add an option `failed_move_fall_back_to_copy` (default is true) for external SST ingestion. When `move_files` is true and hard link fails, ingestion falls back to copy if `failed_move_fall_back_to_copy` is true. Otherwise, ingestion reports an error. -* Add command `list_file_range_deletes` in ldb, which prints out tombstones in SST files. - -### Performance Improvements -* Reduce binary search when iterator reseek into the same data block. -* DBIter::Next() can skip user key checking if previous entry's seqnum is 0. -* Merging iterator to avoid child iterator reseek for some cases -* Log Writer will flush after finishing the whole record, rather than a fragment. -* Lower MultiGet batching API latency by reading data blocks from disk in parallel - -### General Improvements -* Added new status code kColumnFamilyDropped to distinguish between Column Family Dropped and DB Shutdown in progress. -* Improve ColumnFamilyOptions validation when creating a new column family. - -### Bug Fixes -* Fix a bug in WAL replay of secondary instance by skipping write batches with older sequence numbers than the current last sequence number. -* Fix flush's/compaction's merge processing logic which allowed `Put`s covered by range tombstones to reappear. Note `Put`s may exist even if the user only ever called `Merge()` due to an internal conversion during compaction to the bottommost level. -* Fix/improve memtable earliest sequence assignment and WAL replay so that WAL entries of unflushed column families will not be skipped after replaying the MANIFEST and increasing db sequence due to another flushed/compacted column family. -* Fix a bug caused by secondary not skipping the beginning of new MANIFEST. -* On DB open, delete WAL trash files left behind in wal_dir - -## 6.2.0 (2019-04-30) -### New Features -* Add an option `strict_bytes_per_sync` that causes a file-writing thread to block rather than exceed the limit on bytes pending writeback specified by `bytes_per_sync` or `wal_bytes_per_sync`. -* Improve range scan performance by avoiding per-key upper bound check in BlockBasedTableIterator. -* Introduce Periodic Compaction for Level style compaction. Files are re-compacted periodically and put in the same level. -* Block-based table index now contains exact highest key in the file, rather than an upper bound. This may improve Get() and iterator Seek() performance in some situations, especially when direct IO is enabled and block cache is disabled. A setting BlockBasedTableOptions::index_shortening is introduced to control this behavior. Set it to kShortenSeparatorsAndSuccessor to get the old behavior. -* When reading from option file/string/map, customized envs can be filled according to object registry. -* Improve range scan performance when using explicit user readahead by not creating new table readers for every iterator. -* Add index type BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey. It significantly reduces read amplification in some setups, especially for iterator seeks. It's not fully implemented yet: IO errors are not handled right. - -### Public API Change -* Change the behavior of OptimizeForPointLookup(): move away from hash-based block-based-table index, and use whole key memtable filtering. -* Change the behavior of OptimizeForSmallDb(): use a 16MB block cache, put index and filter blocks into it, and cost the memtable size to it. DBOptions.OptimizeForSmallDb() and ColumnFamilyOptions.OptimizeForSmallDb() start to take an optional cache object. -* Added BottommostLevelCompaction::kForceOptimized to avoid double compacting newly compacted files in the bottommost level compaction of manual compaction. Note this option may prohibit the manual compaction to produce a single file in the bottommost level. - -### Bug Fixes -* Adjust WriteBufferManager's dummy entry size to block cache from 1MB to 256KB. -* Fix a race condition between WritePrepared::Get and ::Put with duplicate keys. -* Fix crash when memtable prefix bloom is enabled and read/write a key out of domain of prefix extractor. -* Close a WAL file before another thread deletes it. -* Fix an assertion failure `IsFlushPending() == true` caused by one bg thread releasing the db mutex in ~ColumnFamilyData and another thread clearing `flush_requested_` flag. - -## 6.1.1 (2019-04-09) -### New Features -* When reading from option file/string/map, customized comparators and/or merge operators can be filled according to object registry. - -### Public API Change - -### Bug Fixes -* Fix a bug in 2PC where a sequence of txn prepare, memtable flush, and crash could result in losing the prepared transaction. -* Fix a bug in Encryption Env which could cause encrypted files to be read beyond file boundaries. - -## 6.1.0 (2019-03-27) -### New Features -* Introduce two more stats levels, kExceptHistogramOrTimers and kExceptTimers. -* Added a feature to perform data-block sampling for compressibility, and report stats to user. -* Add support for trace filtering. -* Add DBOptions.avoid_unnecessary_blocking_io. If true, we avoid file deletion when destroying ColumnFamilyHandle and Iterator. Instead, a job is scheduled to delete the files in background. - -### Public API Change -* Remove bundled fbson library. -* statistics.stats_level_ becomes atomic. It is preferred to use statistics.set_stats_level() and statistics.get_stats_level() to access it. -* Introduce a new IOError subcode, PathNotFound, to indicate trying to open a nonexistent file or directory for read. -* Add initial support for multiple db instances sharing the same data in single-writer, multi-reader mode. -* Removed some "using std::xxx" from public headers. - -### Bug Fixes -* Fix JEMALLOC_CXX_THROW macro missing from older Jemalloc versions, causing build failures on some platforms. -* Fix SstFileReader not able to open file ingested with write_glbal_seqno=true. - -## 6.0.0 (2019-02-19) -### New Features -* Enabled checkpoint on readonly db (DBImplReadOnly). -* Make DB ignore dropped column families while committing results of atomic flush. -* RocksDB may choose to preopen some files even if options.max_open_files != -1. This may make DB open slightly longer. -* For users of dictionary compression with ZSTD v0.7.0+, we now reuse the same digested dictionary when compressing each of an SST file's data blocks for faster compression speeds. -* For all users of dictionary compression who set `cache_index_and_filter_blocks == true`, we now store dictionary data used for decompression in the block cache for better control over memory usage. For users of ZSTD v1.1.4+ who compile with -DZSTD_STATIC_LINKING_ONLY, this includes a digested dictionary, which is used to increase decompression speed. -* Add support for block checksums verification for external SST files before ingestion. -* Introduce stats history which periodically saves Statistics snapshots and added `GetStatsHistory` API to retrieve these snapshots. -* Add a place holder in manifest which indicate a record from future that can be safely ignored. -* Add support for trace sampling. -* Enable properties block checksum verification for block-based tables. -* For all users of dictionary compression, we now generate a separate dictionary for compressing each bottom-level SST file. Previously we reused a single dictionary for a whole compaction to bottom level. The new approach achieves better compression ratios; however, it uses more memory and CPU for buffering/sampling data blocks and training dictionaries. -* Add whole key bloom filter support in memtable. -* Files written by `SstFileWriter` will now use dictionary compression if it is configured in the file writer's `CompressionOptions`. - -### Public API Change -* Disallow CompactionFilter::IgnoreSnapshots() = false, because it is not very useful and the behavior is confusing. The filter will filter everything if there is no snapshot declared by the time the compaction starts. However, users can define a snapshot after the compaction starts and before it finishes and this new snapshot won't be repeatable, because after the compaction finishes, some keys may be dropped. -* CompactionPri = kMinOverlappingRatio also uses compensated file size, which boosts file with lots of tombstones to be compacted first. -* Transaction::GetForUpdate is extended with a do_validate parameter with default value of true. If false it skips validating the snapshot before doing the read. Similarly ::Merge, ::Put, ::Delete, and ::SingleDelete are extended with assume_tracked with default value of false. If true it indicates that call is assumed to be after a ::GetForUpdate. -* `TableProperties::num_entries` and `TableProperties::num_deletions` now also account for number of range tombstones. -* Remove geodb, spatial_db, document_db, json_document, date_tiered_db, and redis_lists. -* With "ldb ----try_load_options", when wal_dir specified by the option file doesn't exist, ignore it. -* Change time resolution in FileOperationInfo. -* Deleting Blob files also go through SStFileManager. -* Remove CuckooHash memtable. -* The counter stat `number.block.not_compressed` now also counts blocks not compressed due to poor compression ratio. -* Remove ttl option from `CompactionOptionsFIFO`. The option has been deprecated and ttl in `ColumnFamilyOptions` is used instead. -* Support SST file ingestion across multiple column families via DB::IngestExternalFiles. See the function's comment about atomicity. -* Remove Lua compaction filter. - -### Bug Fixes -* Fix a deadlock caused by compaction and file ingestion waiting for each other in the event of write stalls. -* Fix a memory leak when files with range tombstones are read in mmap mode and block cache is enabled -* Fix handling of corrupt range tombstone blocks such that corruptions cannot cause deleted keys to reappear -* Lock free MultiGet -* Fix incorrect `NotFound` point lookup result when querying the endpoint of a file that has been extended by a range tombstone. -* Fix with pipelined write, write leaders's callback failure lead to the whole write group fail. - -### Change Default Options -* Change options.compaction_pri's default to kMinOverlappingRatio - -## 5.18.0 (2018-11-30) -### New Features -* Introduced `JemallocNodumpAllocator` memory allocator. When being use, block cache will be excluded from core dump. -* Introduced `PerfContextByLevel` as part of `PerfContext` which allows storing perf context at each level. Also replaced `__thread` with `thread_local` keyword for perf_context. Added per-level perf context for bloom filter and `Get` query. -* With level_compaction_dynamic_level_bytes = true, level multiplier may be adjusted automatically when Level 0 to 1 compaction is lagged behind. -* Introduced DB option `atomic_flush`. If true, RocksDB supports flushing multiple column families and atomically committing the result to MANIFEST. Useful when WAL is disabled. -* Added `num_deletions` and `num_merge_operands` members to `TableProperties`. -* Added "rocksdb.min-obsolete-sst-number-to-keep" DB property that reports the lower bound on SST file numbers that are being kept from deletion, even if the SSTs are obsolete. -* Add xxhash64 checksum support -* Introduced `MemoryAllocator`, which lets the user specify custom memory allocator for block based table. -* Improved `DeleteRange` to prevent read performance degradation. The feature is no longer marked as experimental. - -### Public API Change -* `DBOptions::use_direct_reads` now affects reads issued by `BackupEngine` on the database's SSTs. -* `NO_ITERATORS` is divided into two counters `NO_ITERATOR_CREATED` and `NO_ITERATOR_DELETE`. Both of them are only increasing now, just as other counters. - -### Bug Fixes -* Fix corner case where a write group leader blocked due to write stall blocks other writers in queue with WriteOptions::no_slowdown set. -* Fix in-memory range tombstone truncation to avoid erroneously covering newer keys at a lower level, and include range tombstones in compacted files whose largest key is the range tombstone's start key. -* Properly set the stop key for a truncated manual CompactRange -* Fix slow flush/compaction when DB contains many snapshots. The problem became noticeable to us in DBs with 100,000+ snapshots, though it will affect others at different thresholds. -* Fix the bug that WriteBatchWithIndex's SeekForPrev() doesn't see the entries with the same key. -* Fix the bug where user comparator was sometimes fed with InternalKey instead of the user key. The bug manifests when during GenerateBottommostFiles. -* Fix a bug in WritePrepared txns where if the number of old snapshots goes beyond the snapshot cache size (128 default) the rest will not be checked when evicting a commit entry from the commit cache. -* Fixed Get correctness bug in the presence of range tombstones where merge operands covered by a range tombstone always result in NotFound. -* Start populating `NO_FILE_CLOSES` ticker statistic, which was always zero previously. -* The default value of NewBloomFilterPolicy()'s argument use_block_based_builder is changed to false. Note that this new default may cause large temp memory usage when building very large SST files. - -## 5.17.0 (2018-10-05) -### Public API Change -* `OnTableFileCreated` will now be called for empty files generated during compaction. In that case, `TableFileCreationInfo::file_path` will be "(nil)" and `TableFileCreationInfo::file_size` will be zero. -* Add `FlushOptions::allow_write_stall`, which controls whether Flush calls start working immediately, even if it causes user writes to stall, or will wait until flush can be performed without causing write stall (similar to `CompactRangeOptions::allow_write_stall`). Note that the default value is false, meaning we add delay to Flush calls until stalling can be avoided when possible. This is behavior change compared to previous RocksDB versions, where Flush calls didn't check if they might cause stall or not. -* Application using PessimisticTransactionDB is expected to rollback/commit recovered transactions before starting new ones. This assumption is used to skip concurrency control during recovery. -* Expose column family id to `OnCompactionCompleted`. - -### New Features -* TransactionOptions::skip_concurrency_control allows pessimistic transactions to skip the overhead of concurrency control. Could be used for optimizing certain transactions or during recovery. - -### Bug Fixes -* Avoid creating empty SSTs and subsequently deleting them in certain cases during compaction. -* Sync CURRENT file contents during checkpoint. - -## 5.16.3 (2018-10-01) -### Bug Fixes -* Fix crash caused when `CompactFiles` run with `CompactionOptions::compression == CompressionType::kDisableCompressionOption`. Now that setting causes the compression type to be chosen according to the column family-wide compression options. - -## 5.16.2 (2018-09-21) -### Bug Fixes -* Fix bug in partition filters with format_version=4. - -## 5.16.1 (2018-09-17) -### Bug Fixes -* Remove trace_analyzer_tool from rocksdb_lib target in TARGETS file. -* Fix RocksDB Java build and tests. -* Remove sync point in Block destructor. - -## 5.16.0 (2018-08-21) -### Public API Change -* The merge operands are passed to `MergeOperator::ShouldMerge` in the reversed order relative to how they were merged (passed to FullMerge or FullMergeV2) for performance reasons -* GetAllKeyVersions() to take an extra argument of `max_num_ikeys`. -* Using ZSTD dictionary trainer (i.e., setting `CompressionOptions::zstd_max_train_bytes` to a nonzero value) now requires ZSTD version 1.1.3 or later. - -### New Features -* Changes the format of index blocks by delta encoding the index values, which are the block handles. This saves the encoding of BlockHandle::offset of the non-head index entries in each restart interval. The feature is backward compatible but not forward compatible. It is disabled by default unless format_version 4 or above is used. -* Add a new tool: trace_analyzer. Trace_analyzer analyzes the trace file generated by using trace_replay API. It can convert the binary format trace file to a human readable txt file, output the statistics of the analyzed query types such as access statistics and size statistics, combining the dumped whole key space file to analyze, support query correlation analyzing, and etc. Current supported query types are: Get, Put, Delete, SingleDelete, DeleteRange, Merge, Iterator (Seek, SeekForPrev only). -* Add hash index support to data blocks, which helps reducing the cpu utilization of point-lookup operations. This feature is backward compatible with the data block created without the hash index. It is disabled by default unless BlockBasedTableOptions::data_block_index_type is set to data_block_index_type = kDataBlockBinaryAndHash. - -### Bug Fixes -* Fix a bug in misreporting the estimated partition index size in properties block. - -## 5.15.0 (2018-07-17) -### Public API Change -* Remove managed iterator. ReadOptions.managed is not effective anymore. -* For bottommost_compression, a compatible CompressionOptions is added via `bottommost_compression_opts`. To keep backward compatible, a new boolean `enabled` is added to CompressionOptions. For compression_opts, it will be always used no matter what value of `enabled` is. For bottommost_compression_opts, it will only be used when user set `enabled=true`, otherwise, compression_opts will be used for bottommost_compression as default. -* With LRUCache, when high_pri_pool_ratio > 0, midpoint insertion strategy will be enabled to put low-pri items to the tail of low-pri list (the midpoint) when they first inserted into the cache. This is to make cache entries never get hit age out faster, improving cache efficiency when large background scan presents. -* For users of `Statistics` objects created via `CreateDBStatistics()`, the format of the string returned by its `ToString()` method has changed. -* The "rocksdb.num.entries" table property no longer counts range deletion tombstones as entries. - -### New Features -* Changes the format of index blocks by storing the key in their raw form rather than converting them to InternalKey. This saves 8 bytes per index key. The feature is backward compatible but not forward compatible. It is disabled by default unless format_version 3 or above is used. -* Avoid memcpy when reading mmap files with OpenReadOnly and max_open_files==-1. -* Support dynamically changing `ColumnFamilyOptions::ttl` via `SetOptions()`. -* Add a new table property, "rocksdb.num.range-deletions", which counts the number of range deletion tombstones in the table. -* Improve the performance of iterators doing long range scans by using readahead, when using direct IO. -* pin_top_level_index_and_filter (default true) in BlockBasedTableOptions can be used in combination with cache_index_and_filter_blocks to prefetch and pin the top-level index of partitioned index and filter blocks in cache. It has no impact when cache_index_and_filter_blocks is false. -* Write properties meta-block at the end of block-based table to save read-ahead IO. - -### Bug Fixes -* Fix deadlock with enable_pipelined_write=true and max_successive_merges > 0 -* Check conflict at output level in CompactFiles. -* Fix corruption in non-iterator reads when mmap is used for file reads -* Fix bug with prefix search in partition filters where a shared prefix would be ignored from the later partitions. The bug could report an eixstent key as missing. The bug could be triggered if prefix_extractor is set and partition filters is enabled. -* Change default value of `bytes_max_delete_chunk` to 0 in NewSstFileManager() as it doesn't work well with checkpoints. -* Fix a bug caused by not copying the block trailer with compressed SST file, direct IO, prefetcher and no compressed block cache. -* Fix write can stuck indefinitely if enable_pipelined_write=true. The issue exists since pipelined write was introduced in 5.5.0. - -## 5.14.0 (2018-05-16) -### Public API Change -* Add a BlockBasedTableOption to align uncompressed data blocks on the smaller of block size or page size boundary, to reduce flash reads by avoiding reads spanning 4K pages. -* The background thread naming convention changed (on supporting platforms) to "rocksdb:", e.g., "rocksdb:low0". -* Add a new ticker stat rocksdb.number.multiget.keys.found to count number of keys successfully read in MultiGet calls -* Touch-up to write-related counters in PerfContext. New counters added: write_scheduling_flushes_compactions_time, write_thread_wait_nanos. Counters whose behavior was fixed or modified: write_memtable_time, write_pre_and_post_process_time, write_delay_time. -* Posix Env's NewRandomRWFile() will fail if the file doesn't exist. -* Now, `DBOptions::use_direct_io_for_flush_and_compaction` only applies to background writes, and `DBOptions::use_direct_reads` applies to both user reads and background reads. This conforms with Linux's `open(2)` manpage, which advises against simultaneously reading a file in buffered and direct modes, due to possibly undefined behavior and degraded performance. -* Iterator::Valid() always returns false if !status().ok(). So, now when doing a Seek() followed by some Next()s, there's no need to check status() after every operation. -* Iterator::Seek()/SeekForPrev()/SeekToFirst()/SeekToLast() always resets status(). -* Introduced `CompressionOptions::kDefaultCompressionLevel`, which is a generic way to tell RocksDB to use the compression library's default level. It is now the default value for `CompressionOptions::level`. Previously the level defaulted to -1, which gave poor compression ratios in ZSTD. - -### New Features -* Introduce TTL for level compaction so that all files older than ttl go through the compaction process to get rid of old data. -* TransactionDBOptions::write_policy can be configured to enable WritePrepared 2PC transactions. Read more about them in the wiki. -* Add DB properties "rocksdb.block-cache-capacity", "rocksdb.block-cache-usage", "rocksdb.block-cache-pinned-usage" to show block cache usage. -* Add `Env::LowerThreadPoolCPUPriority(Priority)` method, which lowers the CPU priority of background (esp. compaction) threads to minimize interference with foreground tasks. -* Fsync parent directory after deleting a file in delete scheduler. -* In level-based compaction, if bottom-pri thread pool was setup via `Env::SetBackgroundThreads()`, compactions to the bottom level will be delegated to that thread pool. -* `prefix_extractor` has been moved from ImmutableCFOptions to MutableCFOptions, meaning it can be dynamically changed without a DB restart. - -### Bug Fixes -* Fsync after writing global seq number to the ingestion file in ExternalSstFileIngestionJob. -* Fix WAL corruption caused by race condition between user write thread and FlushWAL when two_write_queue is not set. -* Fix `BackupableDBOptions::max_valid_backups_to_open` to not delete backup files when refcount cannot be accurately determined. -* Fix memory leak when pin_l0_filter_and_index_blocks_in_cache is used with partitioned filters -* Disable rollback of merge operands in WritePrepared transactions to work around an issue in MyRocks. It can be enabled back by setting TransactionDBOptions::rollback_merge_operands to true. -* Fix wrong results by ReverseBytewiseComparator::FindShortSuccessor() - -### Java API Changes -* Add `BlockBasedTableConfig.setBlockCache` to allow sharing a block cache across DB instances. -* Added SstFileManager to the Java API to allow managing SST files across DB instances. - -## 5.13.0 (2018-03-20) -### Public API Change -* RocksDBOptionsParser::Parse()'s `ignore_unknown_options` argument will only be effective if the option file shows it is generated using a higher version of RocksDB than the current version. -* Remove CompactionEventListener. - -### New Features -* SstFileManager now can cancel compactions if they will result in max space errors. SstFileManager users can also use SetCompactionBufferSize to specify how much space must be leftover during a compaction for auxiliary file functions such as logging and flushing. -* Avoid unnecessarily flushing in `CompactRange()` when the range specified by the user does not overlap unflushed memtables. -* If `ColumnFamilyOptions::max_subcompactions` is set greater than one, we now parallelize large manual level-based compactions. -* Add "rocksdb.live-sst-files-size" DB property to return total bytes of all SST files belong to the latest LSM tree. -* NewSstFileManager to add an argument bytes_max_delete_chunk with default 64MB. With this argument, a file larger than 64MB will be ftruncated multiple times based on this size. - -### Bug Fixes -* Fix a leak in prepared_section_completed_ where the zeroed entries would not removed from the map. -* Fix WAL corruption caused by race condition between user write thread and backup/checkpoint thread. - -## 5.12.0 (2018-02-14) -### Public API Change -* Iterator::SeekForPrev is now a pure virtual method. This is to prevent user who implement the Iterator interface fail to implement SeekForPrev by mistake. -* Add `include_end` option to make the range end exclusive when `include_end == false` in `DeleteFilesInRange()`. -* Add `CompactRangeOptions::allow_write_stall`, which makes `CompactRange` start working immediately, even if it causes user writes to stall. The default value is false, meaning we add delay to `CompactRange` calls until stalling can be avoided when possible. Note this delay is not present in previous RocksDB versions. -* Creating checkpoint with empty directory now returns `Status::InvalidArgument`; previously, it returned `Status::IOError`. -* Adds a BlockBasedTableOption to turn off index block compression. -* Close() method now returns a status when closing a db. - -### New Features -* Improve the performance of iterators doing long range scans by using readahead. -* Add new function `DeleteFilesInRanges()` to delete files in multiple ranges at once for better performance. -* FreeBSD build support for RocksDB and RocksJava. -* Improved performance of long range scans with readahead. -* Updated to and now continuously tested in Visual Studio 2017. - -### Bug Fixes -* Fix `DisableFileDeletions()` followed by `GetSortedWalFiles()` to not return obsolete WAL files that `PurgeObsoleteFiles()` is going to delete. -* Fix Handle error return from WriteBuffer() during WAL file close and DB close. -* Fix advance reservation of arena block addresses. -* Fix handling of empty string as checkpoint directory. - -## 5.11.0 (2018-01-08) -### Public API Change -* Add `autoTune` and `getBytesPerSecond()` to RocksJava RateLimiter - -### New Features -* Add a new histogram stat called rocksdb.db.flush.micros for memtable flush. -* Add "--use_txn" option to use transactional API in db_stress. -* Disable onboard cache for compaction output in Windows platform. -* Improve the performance of iterators doing long range scans by using readahead. - -### Bug Fixes -* Fix a stack-use-after-scope bug in ForwardIterator. -* Fix builds on platforms including Linux, Windows, and PowerPC. -* Fix buffer overrun in backup engine for DBs with huge number of files. -* Fix a mislabel bug for bottom-pri compaction threads. -* Fix DB::Flush() keep waiting after flush finish under certain condition. - -## 5.10.0 (2017-12-11) -### Public API Change -* When running `make` with environment variable `USE_SSE` set and `PORTABLE` unset, will use all machine features available locally. Previously this combination only compiled SSE-related features. - -### New Features -* Provide lifetime hints when writing files on Linux. This reduces hardware write-amp on storage devices supporting multiple streams. -* Add a DB stat, `NUMBER_ITER_SKIP`, which returns how many internal keys were skipped during iterations (e.g., due to being tombstones or duplicate versions of a key). -* Add PerfContext counters, `key_lock_wait_count` and `key_lock_wait_time`, which measure the number of times transactions wait on key locks and total amount of time waiting. - -### Bug Fixes -* Fix IOError on WAL write doesn't propagate to write group follower -* Make iterator invalid on merge error. -* Fix performance issue in `IngestExternalFile()` affecting databases with large number of SST files. -* Fix possible corruption to LSM structure when `DeleteFilesInRange()` deletes a subset of files spanned by a `DeleteRange()` marker. - -## 5.9.0 (2017-11-01) -### Public API Change -* `BackupableDBOptions::max_valid_backups_to_open == 0` now means no backups will be opened during BackupEngine initialization. Previously this condition disabled limiting backups opened. -* `DBOptions::preserve_deletes` is a new option that allows one to specify that DB should not drop tombstones for regular deletes if they have sequence number larger than what was set by the new API call `DB::SetPreserveDeletesSequenceNumber(SequenceNumber seqnum)`. Disabled by default. -* API call `DB::SetPreserveDeletesSequenceNumber(SequenceNumber seqnum)` was added, users who wish to preserve deletes are expected to periodically call this function to advance the cutoff seqnum (all deletes made before this seqnum can be dropped by DB). It's user responsibility to figure out how to advance the seqnum in the way so the tombstones are kept for the desired period of time, yet are eventually processed in time and don't eat up too much space. -* `ReadOptions::iter_start_seqnum` was added; -if set to something > 0 user will see 2 changes in iterators behavior 1) only keys written with sequence larger than this parameter would be returned and 2) the `Slice` returned by iter->key() now points to the memory that keep User-oriented representation of the internal key, rather than user key. New struct `FullKey` was added to represent internal keys, along with a new helper function `ParseFullKey(const Slice& internal_key, FullKey* result);`. -* Deprecate trash_dir param in NewSstFileManager, right now we will rename deleted files to .trash instead of moving them to trash directory -* Allow setting a custom trash/DB size ratio limit in the SstFileManager, after which files that are to be scheduled for deletion are deleted immediately, regardless of any delete ratelimit. -* Return an error on write if write_options.sync = true and write_options.disableWAL = true to warn user of inconsistent options. Previously we will not write to WAL and not respecting the sync options in this case. - -### New Features -* CRC32C is now using the 3-way pipelined SSE algorithm `crc32c_3way` on supported platforms to improve performance. The system will choose to use this algorithm on supported platforms automatically whenever possible. If PCLMULQDQ is not supported it will fall back to the old Fast_CRC32 algorithm. -* `DBOptions::writable_file_max_buffer_size` can now be changed dynamically. -* `DBOptions::bytes_per_sync`, `DBOptions::compaction_readahead_size`, and `DBOptions::wal_bytes_per_sync` can now be changed dynamically, `DBOptions::wal_bytes_per_sync` will flush all memtables and switch to a new WAL file. -* Support dynamic adjustment of rate limit according to demand for background I/O. It can be enabled by passing `true` to the `auto_tuned` parameter in `NewGenericRateLimiter()`. The value passed as `rate_bytes_per_sec` will still be respected as an upper-bound. -* Support dynamically changing `ColumnFamilyOptions::compaction_options_fifo`. -* Introduce `EventListener::OnStallConditionsChanged()` callback. Users can implement it to be notified when user writes are stalled, stopped, or resumed. -* Add a new db property "rocksdb.estimate-oldest-key-time" to return oldest data timestamp. The property is available only for FIFO compaction with compaction_options_fifo.allow_compaction = false. -* Upon snapshot release, recompact bottommost files containing deleted/overwritten keys that previously could not be dropped due to the snapshot. This alleviates space-amp caused by long-held snapshots. -* Support lower bound on iterators specified via `ReadOptions::iterate_lower_bound`. -* Support for differential snapshots (via iterator emitting the sequence of key-values representing the difference between DB state at two different sequence numbers). Supports preserving and emitting puts and regular deletes, doesn't support SingleDeletes, MergeOperator, Blobs and Range Deletes. - -### Bug Fixes -* Fix a potential data inconsistency issue during point-in-time recovery. `DB:Open()` will abort if column family inconsistency is found during PIT recovery. -* Fix possible metadata corruption in databases using `DeleteRange()`. - -## 5.8.0 (2017-08-30) -### Public API Change -* Users of `Statistics::getHistogramString()` will see fewer histogram buckets and different bucket endpoints. -* `Slice::compare` and BytewiseComparator `Compare` no longer accept `Slice`s containing nullptr. -* `Transaction::Get` and `Transaction::GetForUpdate` variants with `PinnableSlice` added. - -### New Features -* Add Iterator::Refresh(), which allows users to update the iterator state so that they can avoid some initialization costs of recreating iterators. -* Replace dynamic_cast<> (except unit test) so people can choose to build with RTTI off. With make, release mode is by default built with -fno-rtti and debug mode is built without it. Users can override it by setting USE_RTTI=0 or 1. -* Universal compactions including the bottom level can be executed in a dedicated thread pool. This alleviates head-of-line blocking in the compaction queue, which cause write stalling, particularly in multi-instance use cases. Users can enable this feature via `Env::SetBackgroundThreads(N, Env::Priority::BOTTOM)`, where `N > 0`. -* Allow merge operator to be called even with a single merge operand during compactions, by appropriately overriding `MergeOperator::AllowSingleOperand`. -* Add `DB::VerifyChecksum()`, which verifies the checksums in all SST files in a running DB. -* Block-based table support for disabling checksums by setting `BlockBasedTableOptions::checksum = kNoChecksum`. - -### Bug Fixes -* Fix wrong latencies in `rocksdb.db.get.micros`, `rocksdb.db.write.micros`, and `rocksdb.sst.read.micros`. -* Fix incorrect dropping of deletions during intra-L0 compaction. -* Fix transient reappearance of keys covered by range deletions when memtable prefix bloom filter is enabled. -* Fix potentially wrong file smallest key when range deletions separated by snapshot are written together. - -## 5.7.0 (2017-07-13) -### Public API Change -* DB property "rocksdb.sstables" now prints keys in hex form. - -### New Features -* Measure estimated number of reads per file. The information can be accessed through DB::GetColumnFamilyMetaData or "rocksdb.sstables" DB property. -* RateLimiter support for throttling background reads, or throttling the sum of background reads and writes. This can give more predictable I/O usage when compaction reads more data than it writes, e.g., due to lots of deletions. -* [Experimental] FIFO compaction with TTL support. It can be enabled by setting CompactionOptionsFIFO.ttl > 0. -* Introduce `EventListener::OnBackgroundError()` callback. Users can implement it to be notified of errors causing the DB to enter read-only mode, and optionally override them. -* Partitioned Index/Filters exiting the experimental mode. To enable partitioned indexes set index_type to kTwoLevelIndexSearch and to further enable partitioned filters set partition_filters to true. To configure the partition size set metadata_block_size. - - -### Bug Fixes -* Fix discarding empty compaction output files when `DeleteRange()` is used together with subcompactions. - -## 5.6.0 (2017-06-06) -### Public API Change -* Scheduling flushes and compactions in the same thread pool is no longer supported by setting `max_background_flushes=0`. Instead, users can achieve this by configuring their high-pri thread pool to have zero threads. -* Replace `Options::max_background_flushes`, `Options::max_background_compactions`, and `Options::base_background_compactions` all with `Options::max_background_jobs`, which automatically decides how many threads to allocate towards flush/compaction. -* options.delayed_write_rate by default take the value of options.rate_limiter rate. -* Replace global variable `IOStatsContext iostats_context` with `IOStatsContext* get_iostats_context()`; replace global variable `PerfContext perf_context` with `PerfContext* get_perf_context()`. - -### New Features -* Change ticker/histogram statistics implementations to use core-local storage. This improves aggregation speed compared to our previous thread-local approach, particularly for applications with many threads. -* Users can pass a cache object to write buffer manager, so that they can cap memory usage for memtable and block cache using one single limit. -* Flush will be triggered when 7/8 of the limit introduced by write_buffer_manager or db_write_buffer_size is triggered, so that the hard threshold is hard to hit. -* Introduce WriteOptions.low_pri. If it is true, low priority writes will be throttled if the compaction is behind. -* `DB::IngestExternalFile()` now supports ingesting files into a database containing range deletions. - -### Bug Fixes -* Shouldn't ignore return value of fsync() in flush. - -## 5.5.0 (2017-05-17) -### New Features -* FIFO compaction to support Intra L0 compaction too with CompactionOptionsFIFO.allow_compaction=true. -* DB::ResetStats() to reset internal stats. -* Statistics::Reset() to reset user stats. -* ldb add option --try_load_options, which will open DB with its own option file. -* Introduce WriteBatch::PopSavePoint to pop the most recent save point explicitly. -* Support dynamically change `max_open_files` option via SetDBOptions() -* Added DB::CreateColumnFamilie() and DB::DropColumnFamilies() to bulk create/drop column families. -* Add debugging function `GetAllKeyVersions` to see internal versions of a range of keys. -* Support file ingestion with universal compaction style -* Support file ingestion behind with option `allow_ingest_behind` -* New option enable_pipelined_write which may improve write throughput in case writing from multiple threads and WAL enabled. - -### Bug Fixes -* Fix the bug that Direct I/O uses direct reads for non-SST file - -## 5.4.0 (2017-04-11) -### Public API Change -* random_access_max_buffer_size no longer has any effect -* Removed Env::EnableReadAhead(), Env::ShouldForwardRawRequest() -* Support dynamically change `stats_dump_period_sec` option via SetDBOptions(). -* Added ReadOptions::max_skippable_internal_keys to set a threshold to fail a request as incomplete when too many keys are being skipped when using iterators. -* DB::Get in place of std::string accepts PinnableSlice, which avoids the extra memcpy of value to std::string in most of cases. - * PinnableSlice releases the pinned resources that contain the value when it is destructed or when ::Reset() is called on it. - * The old API that accepts std::string, although discouraged, is still supported. -* Replace Options::use_direct_writes with Options::use_direct_io_for_flush_and_compaction. Read Direct IO wiki for details. -* Added CompactionEventListener and EventListener::OnFlushBegin interfaces. - -### New Features -* Memtable flush can be avoided during checkpoint creation if total log file size is smaller than a threshold specified by the user. -* Introduce level-based L0->L0 compactions to reduce file count, so write delays are incurred less often. -* (Experimental) Partitioning filters which creates an index on the partitions. The feature can be enabled by setting partition_filters when using kFullFilter. Currently the feature also requires two-level indexing to be enabled. Number of partitions is the same as the number of partitions for indexes, which is controlled by metadata_block_size. - -## 5.3.0 (2017-03-08) -### Public API Change -* Remove disableDataSync option. -* Remove timeout_hint_us option from WriteOptions. The option has been deprecated and has no effect since 3.13.0. -* Remove option min_partial_merge_operands. Partial merge operands will always be merged in flush or compaction if there are more than one. -* Remove option verify_checksums_in_compaction. Compaction will always verify checksum. - -### Bug Fixes -* Fix the bug that iterator may skip keys - -## 5.2.0 (2017-02-08) -### Public API Change -* NewLRUCache() will determine number of shard bits automatically based on capacity, if the user doesn't pass one. This also impacts the default block cache when the user doesn't explicit provide one. -* Change the default of delayed slowdown value to 16MB/s and further increase the L0 stop condition to 36 files. -* Options::use_direct_writes and Options::use_direct_reads are now ready to use. -* (Experimental) Two-level indexing that partition the index and creates a 2nd level index on the partitions. The feature can be enabled by setting kTwoLevelIndexSearch as IndexType and configuring index_per_partition. - -### New Features -* Added new overloaded function GetApproximateSizes that allows to specify if memtable stats should be computed only without computing SST files' stats approximations. -* Added new function GetApproximateMemTableStats that approximates both number of records and size of memtables. -* Add Direct I/O mode for SST file I/O - -### Bug Fixes -* RangeSync() should work if ROCKSDB_FALLOCATE_PRESENT is not set -* Fix wrong results in a data race case in Get() -* Some fixes related to 2PC. -* Fix bugs of data corruption in direct I/O - -## 5.1.0 (2017-01-13) -* Support dynamically change `delete_obsolete_files_period_micros` option via SetDBOptions(). -* Added EventListener::OnExternalFileIngested which will be called when IngestExternalFile() add a file successfully. -* BackupEngine::Open and BackupEngineReadOnly::Open now always return error statuses matching those of the backup Env. - -### Bug Fixes -* Fix the bug that if 2PC is enabled, checkpoints may loss some recent transactions. -* When file copying is needed when creating checkpoints or bulk loading files, fsync the file after the file copying. - -## 5.0.0 (2016-11-17) -### Public API Change -* Options::max_bytes_for_level_multiplier is now a double along with all getters and setters. -* Support dynamically change `delayed_write_rate` and `max_total_wal_size` options via SetDBOptions(). -* Introduce DB::DeleteRange for optimized deletion of large ranges of contiguous keys. -* Support dynamically change `delayed_write_rate` option via SetDBOptions(). -* Options::allow_concurrent_memtable_write and Options::enable_write_thread_adaptive_yield are now true by default. -* Remove Tickers::SEQUENCE_NUMBER to avoid confusion if statistics object is shared among RocksDB instance. Alternatively DB::GetLatestSequenceNumber() can be used to get the same value. -* Options.level0_stop_writes_trigger default value changes from 24 to 32. -* New compaction filter API: CompactionFilter::FilterV2(). Allows to drop ranges of keys. -* Removed flashcache support. -* DB::AddFile() is deprecated and is replaced with DB::IngestExternalFile(). DB::IngestExternalFile() remove all the restrictions that existed for DB::AddFile. - -### New Features -* Add avoid_flush_during_shutdown option, which speeds up DB shutdown by not flushing unpersisted data (i.e. with disableWAL = true). Unpersisted data will be lost. The options is dynamically changeable via SetDBOptions(). -* Add memtable_insert_with_hint_prefix_extractor option. The option is mean to reduce CPU usage for inserting keys into memtable, if keys can be group by prefix and insert for each prefix are sequential or almost sequential. See include/rocksdb/options.h for more details. -* Add LuaCompactionFilter in utilities. This allows developers to write compaction filters in Lua. To use this feature, LUA_PATH needs to be set to the root directory of Lua. -* No longer populate "LATEST_BACKUP" file in backup directory, which formerly contained the number of the latest backup. The latest backup can be determined by finding the highest numbered file in the "meta/" subdirectory. - -## 4.13.0 (2016-10-18) -### Public API Change -* DB::GetOptions() reflect dynamic changed options (i.e. through DB::SetOptions()) and return copy of options instead of reference. -* Added Statistics::getAndResetTickerCount(). - -### New Features -* Add DB::SetDBOptions() to dynamic change base_background_compactions and max_background_compactions. -* Added Iterator::SeekForPrev(). This new API will seek to the last key that less than or equal to the target key. - -## 4.12.0 (2016-09-12) -### Public API Change -* CancelAllBackgroundWork() flushes all memtables for databases containing writes that have bypassed the WAL (writes issued with WriteOptions::disableWAL=true) before shutting down background threads. -* Merge options source_compaction_factor, max_grandparent_overlap_bytes and expanded_compaction_factor into max_compaction_bytes. -* Remove ImmutableCFOptions. -* Add a compression type ZSTD, which can work with ZSTD 0.8.0 or up. Still keep ZSTDNotFinal for compatibility reasons. - -### New Features -* Introduce NewClockCache, which is based on CLOCK algorithm with better concurrent performance in some cases. It can be used to replace the default LRU-based block cache and table cache. To use it, RocksDB need to be linked with TBB lib. -* Change ticker/histogram statistics implementations to accumulate data in thread-local storage, which improves CPU performance by reducing cache coherency costs. Callers of CreateDBStatistics do not need to change anything to use this feature. -* Block cache mid-point insertion, where index and filter block are inserted into LRU block cache with higher priority. The feature can be enabled by setting BlockBasedTableOptions::cache_index_and_filter_blocks_with_high_priority to true and high_pri_pool_ratio > 0 when creating NewLRUCache. - -## 4.11.0 (2016-08-01) -### Public API Change -* options.memtable_prefix_bloom_huge_page_tlb_size => memtable_huge_page_size. When it is set, RocksDB will try to allocate memory from huge page for memtable too, rather than just memtable bloom filter. - -### New Features -* A tool to migrate DB after options change. See include/rocksdb/utilities/option_change_migration.h. -* Add ReadOptions.background_purge_on_iterator_cleanup. If true, we avoid file deletion when destroying iterators. - -## 4.10.0 (2016-07-05) -### Public API Change -* options.memtable_prefix_bloom_bits changes to options.memtable_prefix_bloom_bits_ratio and deprecate options.memtable_prefix_bloom_probes -* enum type CompressionType and PerfLevel changes from char to unsigned char. Value of all PerfLevel shift by one. -* Deprecate options.filter_deletes. - -### New Features -* Add avoid_flush_during_recovery option. -* Add a read option background_purge_on_iterator_cleanup to avoid deleting files in foreground when destroying iterators. Instead, a job is scheduled in high priority queue and would be executed in a separate background thread. -* RepairDB support for column families. RepairDB now associates data with non-default column families using information embedded in the SST/WAL files (4.7 or later). For data written by 4.6 or earlier, RepairDB associates it with the default column family. -* Add options.write_buffer_manager which allows users to control total memtable sizes across multiple DB instances. - -## 4.9.0 (2016-06-09) -### Public API changes -* Add bottommost_compression option, This option can be used to set a specific compression algorithm for the bottommost level (Last level containing files in the DB). -* Introduce CompactionJobInfo::compression, This field state the compression algorithm used to generate the output files of the compaction. -* Deprecate BlockBaseTableOptions.hash_index_allow_collision=false -* Deprecate options builder (GetOptions()). - -### New Features -* Introduce NewSimCache() in rocksdb/utilities/sim_cache.h. This function creates a block cache that is able to give simulation results (mainly hit rate) of simulating block behavior with a configurable cache size. - -## 4.8.0 (2016-05-02) -### Public API Change -* Allow preset compression dictionary for improved compression of block-based tables. This is supported for zlib, zstd, and lz4. The compression dictionary's size is configurable via CompressionOptions::max_dict_bytes. -* Delete deprecated classes for creating backups (BackupableDB) and restoring from backups (RestoreBackupableDB). Now, BackupEngine should be used for creating backups, and BackupEngineReadOnly should be used for restorations. For more details, see https://github.com/facebook/rocksdb/wiki/How-to-backup-RocksDB%3F -* Expose estimate of per-level compression ratio via DB property: "rocksdb.compression-ratio-at-levelN". -* Added EventListener::OnTableFileCreationStarted. EventListener::OnTableFileCreated will be called on failure case. User can check creation status via TableFileCreationInfo::status. - -### New Features -* Add ReadOptions::readahead_size. If non-zero, NewIterator will create a new table reader which performs reads of the given size. - -## 4.7.0 (2016-04-08) -### Public API Change -* rename options compaction_measure_io_stats to report_bg_io_stats and include flush too. -* Change some default options. Now default options will optimize for server-workloads. Also enable slowdown and full stop triggers for pending compaction bytes. These changes may cause sub-optimal performance or significant increase of resource usage. To avoid these risks, users can open existing RocksDB with options extracted from RocksDB option files. See https://github.com/facebook/rocksdb/wiki/RocksDB-Options-File for how to use RocksDB option files. Or you can call Options.OldDefaults() to recover old defaults. DEFAULT_OPTIONS_HISTORY.md will track change history of default options. - -## 4.6.0 (2016-03-10) -### Public API Changes -* Change default of BlockBasedTableOptions.format_version to 2. It means default DB created by 4.6 or up cannot be opened by RocksDB version 3.9 or earlier. -* Added strict_capacity_limit option to NewLRUCache. If the flag is set to true, insert to cache will fail if no enough capacity can be free. Signature of Cache::Insert() is updated accordingly. -* Tickers [NUMBER_DB_NEXT, NUMBER_DB_PREV, NUMBER_DB_NEXT_FOUND, NUMBER_DB_PREV_FOUND, ITER_BYTES_READ] are not updated immediately. The are updated when the Iterator is deleted. -* Add monotonically increasing counter (DB property "rocksdb.current-super-version-number") that increments upon any change to the LSM tree. - -### New Features -* Add CompactionPri::kMinOverlappingRatio, a compaction picking mode friendly to write amplification. -* Deprecate Iterator::IsKeyPinned() and replace it with Iterator::GetProperty() with prop_name="rocksdb.iterator.is.key.pinned" - -## 4.5.0 (2016-02-05) -### Public API Changes -* Add a new perf context level between kEnableCount and kEnableTime. Level 2 now does not include timers for mutexes. -* Statistics of mutex operation durations will not be measured by default. If you want to have them enabled, you need to set Statistics::stats_level_ to kAll. -* DBOptions::delete_scheduler and NewDeleteScheduler() are removed, please use DBOptions::sst_file_manager and NewSstFileManager() instead - -### New Features -* ldb tool now supports operations to non-default column families. -* Add kPersistedTier to ReadTier. This option allows Get and MultiGet to read only the persited data and skip mem-tables if writes were done with disableWAL = true. -* Add DBOptions::sst_file_manager. Use NewSstFileManager() in include/rocksdb/sst_file_manager.h to create a SstFileManager that can be used to track the total size of SST files and control the SST files deletion rate. - -## 4.4.0 (2016-01-14) -### Public API Changes -* Change names in CompactionPri and add a new one. -* Deprecate options.soft_rate_limit and add options.soft_pending_compaction_bytes_limit. -* If options.max_write_buffer_number > 3, writes will be slowed down when writing to the last write buffer to delay a full stop. -* Introduce CompactionJobInfo::compaction_reason, this field include the reason to trigger the compaction. -* After slow down is triggered, if estimated pending compaction bytes keep increasing, slowdown more. -* Increase default options.delayed_write_rate to 2MB/s. -* Added a new parameter --path to ldb tool. --path accepts the name of either MANIFEST, SST or a WAL file. Either --db or --path can be used when calling ldb. - -## 4.3.0 (2015-12-08) -### New Features -* CompactionFilter has new member function called IgnoreSnapshots which allows CompactionFilter to be called even if there are snapshots later than the key. -* RocksDB will now persist options under the same directory as the RocksDB database on successful DB::Open, CreateColumnFamily, DropColumnFamily, and SetOptions. -* Introduce LoadLatestOptions() in rocksdb/utilities/options_util.h. This function can construct the latest DBOptions / ColumnFamilyOptions used by the specified RocksDB intance. -* Introduce CheckOptionsCompatibility() in rocksdb/utilities/options_util.h. This function checks whether the input set of options is able to open the specified DB successfully. - -### Public API Changes -* When options.db_write_buffer_size triggers, only the column family with the largest column family size will be flushed, not all the column families. - -## 4.2.0 (2015-11-09) -### New Features -* Introduce CreateLoggerFromOptions(), this function create a Logger for provided DBOptions. -* Add GetAggregatedIntProperty(), which returns the sum of the GetIntProperty of all the column families. -* Add MemoryUtil in rocksdb/utilities/memory.h. It currently offers a way to get the memory usage by type from a list rocksdb instances. - -### Public API Changes -* CompactionFilter::Context includes information of Column Family ID -* The need-compaction hint given by TablePropertiesCollector::NeedCompact() will be persistent and recoverable after DB recovery. This introduces a breaking format change. If you use this experimental feature, including NewCompactOnDeletionCollectorFactory() in the new version, you may not be able to directly downgrade the DB back to version 4.0 or lower. -* TablePropertiesCollectorFactory::CreateTablePropertiesCollector() now takes an option Context, containing the information of column family ID for the file being written. -* Remove DefaultCompactionFilterFactory. - - -## 4.1.0 (2015-10-08) -### New Features -* Added single delete operation as a more efficient way to delete keys that have not been overwritten. -* Added experimental AddFile() to DB interface that allow users to add files created by SstFileWriter into an empty Database, see include/rocksdb/sst_file_writer.h and DB::AddFile() for more info. -* Added support for opening SST files with .ldb suffix which enables opening LevelDB databases. -* CompactionFilter now supports filtering of merge operands and merge results. - -### Public API Changes -* Added SingleDelete() to the DB interface. -* Added AddFile() to DB interface. -* Added SstFileWriter class. -* CompactionFilter has a new method FilterMergeOperand() that RocksDB applies to every merge operand during compaction to decide whether to filter the operand. -* We removed CompactionFilterV2 interfaces from include/rocksdb/compaction_filter.h. The functionality was deprecated already in version 3.13. - -## 4.0.0 (2015-09-09) -### New Features -* Added support for transactions. See include/rocksdb/utilities/transaction.h for more info. -* DB::GetProperty() now accepts "rocksdb.aggregated-table-properties" and "rocksdb.aggregated-table-properties-at-levelN", in which case it returns aggregated table properties of the target column family, or the aggregated table properties of the specified level N if the "at-level" version is used. -* Add compression option kZSTDNotFinalCompression for people to experiment ZSTD although its format is not finalized. -* We removed the need for LATEST_BACKUP file in BackupEngine. We still keep writing it when we create new backups (because of backward compatibility), but we don't read it anymore. - -### Public API Changes -* Removed class Env::RandomRWFile and Env::NewRandomRWFile(). -* Renamed DBOptions.num_subcompactions to DBOptions.max_subcompactions to make the name better match the actual functionality of the option. -* Added Equal() method to the Comparator interface that can optionally be overwritten in cases where equality comparisons can be done more efficiently than three-way comparisons. -* Previous 'experimental' OptimisticTransaction class has been replaced by Transaction class. - -## 3.13.0 (2015-08-06) -### New Features -* RollbackToSavePoint() in WriteBatch/WriteBatchWithIndex -* Add NewCompactOnDeletionCollectorFactory() in utilities/table_properties_collectors, which allows rocksdb to mark a SST file as need-compaction when it observes at least D deletion entries in any N consecutive entries in that SST file. Note that this feature depends on an experimental NeedCompact() API --- the result of this API will not persist after DB restart. -* Add DBOptions::delete_scheduler. Use NewDeleteScheduler() in include/rocksdb/delete_scheduler.h to create a DeleteScheduler that can be shared among multiple RocksDB instances to control the file deletion rate of SST files that exist in the first db_path. - -### Public API Changes -* Deprecated WriteOptions::timeout_hint_us. We no longer support write timeout. If you really need this option, talk to us and we might consider returning it. -* Deprecated purge_redundant_kvs_while_flush option. -* Removed BackupEngine::NewBackupEngine() and NewReadOnlyBackupEngine() that were deprecated in RocksDB 3.8. Please use BackupEngine::Open() instead. -* Deprecated Compaction Filter V2. We are not aware of any existing use-cases. If you use this filter, your compile will break with RocksDB 3.13. Please let us know if you use it and we'll put it back in RocksDB 3.14. -* Env::FileExists now returns a Status instead of a boolean -* Add statistics::getHistogramString() to print detailed distribution of a histogram metric. -* Add DBOptions::skip_stats_update_on_db_open. When it is on, DB::Open() will run faster as it skips the random reads required for loading necessary stats from SST files to optimize compaction. - -## 3.12.0 (2015-07-02) -### New Features -* Added experimental support for optimistic transactions. See include/rocksdb/utilities/optimistic_transaction.h for more info. -* Added a new way to report QPS from db_bench (check out --report_file and --report_interval_seconds) -* Added a cache for individual rows. See DBOptions::row_cache for more info. -* Several new features on EventListener (see include/rocksdb/listener.h): - - OnCompactionCompleted() now returns per-compaction job statistics, defined in include/rocksdb/compaction_job_stats.h. - - Added OnTableFileCreated() and OnTableFileDeleted(). -* Add compaction_options_universal.enable_trivial_move to true, to allow trivial move while performing universal compaction. Trivial move will happen only when all the input files are non overlapping. - -### Public API changes -* EventListener::OnFlushCompleted() now passes FlushJobInfo instead of a list of parameters. -* DB::GetDbIdentity() is now a const function. If this function is overridden in your application, be sure to also make GetDbIdentity() const to avoid compile error. -* Move listeners from ColumnFamilyOptions to DBOptions. -* Add max_write_buffer_number_to_maintain option -* DB::CompactRange()'s parameter reduce_level is changed to change_level, to allow users to move levels to lower levels if allowed. It can be used to migrate a DB from options.level_compaction_dynamic_level_bytes=false to options.level_compaction_dynamic_level_bytes.true. -* Change default value for options.compaction_filter_factory and options.compaction_filter_factory_v2 to nullptr instead of DefaultCompactionFilterFactory and DefaultCompactionFilterFactoryV2. -* If CancelAllBackgroundWork is called without doing a flush after doing loads with WAL disabled, the changes which haven't been flushed before the call to CancelAllBackgroundWork will be lost. -* WBWIIterator::Entry() now returns WriteEntry instead of `const WriteEntry&` -* options.hard_rate_limit is deprecated. -* When options.soft_rate_limit or options.level0_slowdown_writes_trigger is triggered, the way to slow down writes is changed to: write rate to DB is limited to to options.delayed_write_rate. -* DB::GetApproximateSizes() adds a parameter to allow the estimation to include data in mem table, with default to be not to include. It is now only supported in skip list mem table. -* DB::CompactRange() now accept CompactRangeOptions instead of multiple parameters. CompactRangeOptions is defined in include/rocksdb/options.h. -* CompactRange() will now skip bottommost level compaction for level based compaction if there is no compaction filter, bottommost_level_compaction is introduced in CompactRangeOptions to control when it's possible to skip bottommost level compaction. This mean that if you want the compaction to produce a single file you need to set bottommost_level_compaction to BottommostLevelCompaction::kForce. -* Add Cache.GetPinnedUsage() to get the size of memory occupied by entries that are in use by the system. -* DB:Open() will fail if the compression specified in Options is not linked with the binary. If you see this failure, recompile RocksDB with compression libraries present on your system. Also, previously our default compression was snappy. This behavior is now changed. Now, the default compression is snappy only if it's available on the system. If it isn't we change the default to kNoCompression. -* We changed how we account for memory used in block cache. Previously, we only counted the sum of block sizes currently present in block cache. Now, we count the actual memory usage of the blocks. For example, a block of size 4.5KB will use 8KB memory with jemalloc. This might decrease your memory usage and possibly decrease performance. Increase block cache size if you see this happening after an upgrade. -* Add BackupEngineImpl.options_.max_background_operations to specify the maximum number of operations that may be performed in parallel. Add support for parallelized backup and restore. -* Add DB::SyncWAL() that does a WAL sync without blocking writers. - -## 3.11.0 (2015-05-19) -### New Features -* Added a new API Cache::SetCapacity(size_t capacity) to dynamically change the maximum configured capacity of the cache. If the new capacity is less than the existing cache usage, the implementation will try to lower the usage by evicting the necessary number of elements following a strict LRU policy. -* Added an experimental API for handling flashcache devices (blacklists background threads from caching their reads) -- NewFlashcacheAwareEnv -* If universal compaction is used and options.num_levels > 1, compact files are tried to be stored in none-L0 with smaller files based on options.target_file_size_base. The limitation of DB size when using universal compaction is greatly mitigated by using more levels. You can set num_levels = 1 to make universal compaction behave as before. If you set num_levels > 1 and want to roll back to a previous version, you need to compact all files to a big file in level 0 (by setting target_file_size_base to be large and CompactRange(, nullptr, nullptr, true, 0) and reopen the DB with the same version to rewrite the manifest, and then you can open it using previous releases. -* More information about rocksdb background threads are available in Env::GetThreadList(), including the number of bytes read / written by a compaction job, mem-table size and current number of bytes written by a flush job and many more. Check include/rocksdb/thread_status.h for more detail. - -### Public API changes -* TablePropertiesCollector::AddUserKey() is added to replace TablePropertiesCollector::Add(). AddUserKey() exposes key type, sequence number and file size up to now to users. -* DBOptions::bytes_per_sync used to apply to both WAL and table files. As of 3.11 it applies only to table files. If you want to use this option to sync WAL in the background, please use wal_bytes_per_sync - -## 3.10.0 (2015-03-24) -### New Features -* GetThreadStatus() is now able to report detailed thread status, including: - - Thread Operation including flush and compaction. - - The stage of the current thread operation. - - The elapsed time in micros since the current thread operation started. - More information can be found in include/rocksdb/thread_status.h. In addition, when running db_bench with --thread_status_per_interval, db_bench will also report thread status periodically. -* Changed the LRU caching algorithm so that referenced blocks (by iterators) are never evicted. This change made parameter removeScanCountLimit obsolete. Because of that NewLRUCache doesn't take three arguments anymore. table_cache_remove_scan_limit option is also removed -* By default we now optimize the compilation for the compilation platform (using -march=native). If you want to build portable binary, use 'PORTABLE=1' before the make command. -* We now allow level-compaction to place files in different paths by - specifying them in db_paths along with the target_size. - Lower numbered levels will be placed earlier in the db_paths and higher - numbered levels will be placed later in the db_paths vector. -* Potentially big performance improvements if you're using RocksDB with lots of column families (100-1000) -* Added BlockBasedTableOptions.format_version option, which allows user to specify which version of block based table he wants. As a general guideline, newer versions have more features, but might not be readable by older versions of RocksDB. -* Added new block based table format (version 2), which you can enable by setting BlockBasedTableOptions.format_version = 2. This format changes how we encode size information in compressed blocks and should help with memory allocations if you're using Zlib or BZip2 compressions. -* MemEnv (env that stores data in memory) is now available in default library build. You can create it by calling NewMemEnv(). -* Add SliceTransform.SameResultWhenAppended() to help users determine it is safe to apply prefix bloom/hash. -* Block based table now makes use of prefix bloom filter if it is a full fulter. -* Block based table remembers whether a whole key or prefix based bloom filter is supported in SST files. Do a sanity check when reading the file with users' configuration. -* Fixed a bug in ReadOnlyBackupEngine that deleted corrupted backups in some cases, even though the engine was ReadOnly -* options.level_compaction_dynamic_level_bytes, a feature to allow RocksDB to pick dynamic base of bytes for levels. With this feature turned on, we will automatically adjust max bytes for each level. The goal of this feature is to have lower bound on size amplification. For more details, see comments in options.h. -* Added an abstract base class WriteBatchBase for write batches -* Fixed a bug where we start deleting files of a dropped column families even if there are still live references to it - -### Public API changes -* Deprecated skip_log_error_on_recovery and table_cache_remove_scan_count_limit options. -* Logger method logv with log level parameter is now virtual - -### RocksJava -* Added compression per level API. -* MemEnv is now available in RocksJava via RocksMemEnv class. -* lz4 compression is now included in rocksjava static library when running `make rocksdbjavastatic`. -* Overflowing a size_t when setting rocksdb options now throws an IllegalArgumentException, which removes the necessity for a developer to catch these Exceptions explicitly. - -## 3.9.0 (2014-12-08) - -### New Features -* Add rocksdb::GetThreadList(), which in the future will return the current status of all - rocksdb-related threads. We will have more code instruments in the following RocksDB - releases. -* Change convert function in rocksdb/utilities/convenience.h to return Status instead of boolean. - Also add support for nested options in convert function - -### Public API changes -* New API to create a checkpoint added. Given a directory name, creates a new - database which is an image of the existing database. -* New API LinkFile added to Env. If you implement your own Env class, an - implementation of the API LinkFile will have to be provided. -* MemTableRep takes MemTableAllocator instead of Arena - -### Improvements -* RocksDBLite library now becomes smaller and will be compiled with -fno-exceptions flag. - -## 3.8.0 (2014-11-14) - -### Public API changes -* BackupEngine::NewBackupEngine() was deprecated; please use BackupEngine::Open() from now on. -* BackupableDB/RestoreBackupableDB have new GarbageCollect() methods, which will clean up files from corrupt and obsolete backups. -* BackupableDB/RestoreBackupableDB have new GetCorruptedBackups() methods which list corrupt backups. - -### Cleanup -* Bunch of code cleanup, some extra warnings turned on (-Wshadow, -Wshorten-64-to-32, -Wnon-virtual-dtor) - -### New features -* CompactFiles and EventListener, although they are still in experimental state -* Full ColumnFamily support in RocksJava. - -## 3.7.0 (2014-11-06) -### Public API changes -* Introduce SetOptions() API to allow adjusting a subset of options dynamically online -* Introduce 4 new convenient functions for converting Options from string: GetColumnFamilyOptionsFromMap(), GetColumnFamilyOptionsFromString(), GetDBOptionsFromMap(), GetDBOptionsFromString() -* Remove WriteBatchWithIndex.Delete() overloads using SliceParts -* When opening a DB, if options.max_background_compactions is larger than the existing low pri pool of options.env, it will enlarge it. Similarly, options.max_background_flushes is larger than the existing high pri pool of options.env, it will enlarge it. - -## 3.6.0 (2014-10-07) -### Disk format changes -* If you're using RocksDB on ARM platforms and you're using default bloom filter, there is a disk format change you need to be aware of. There are three steps you need to do when you convert to new release: 1. turn off filter policy, 2. compact the whole database, 3. turn on filter policy - -### Behavior changes -* We have refactored our system of stalling writes. Any stall-related statistics' meanings are changed. Instead of per-write stall counts, we now count stalls per-epoch, where epochs are periods between flushes and compactions. You'll find more information in our Tuning Perf Guide once we release RocksDB 3.6. -* When disableDataSync=true, we no longer sync the MANIFEST file. -* Add identity_as_first_hash property to CuckooTable. SST file needs to be rebuilt to be opened by reader properly. - -### Public API changes -* Change target_file_size_base type to uint64_t from int. -* Remove allow_thread_local. This feature was proved to be stable, so we are turning it always-on. - -## 3.5.0 (2014-09-03) -### New Features -* Add include/utilities/write_batch_with_index.h, providing a utility class to query data out of WriteBatch when building it. -* Move BlockBasedTable related options to BlockBasedTableOptions from Options. Change corresponding JNI interface. Options affected include: - no_block_cache, block_cache, block_cache_compressed, block_size, block_size_deviation, block_restart_interval, filter_policy, whole_key_filtering. filter_policy is changed to shared_ptr from a raw pointer. -* Remove deprecated options: disable_seek_compaction and db_stats_log_interval -* OptimizeForPointLookup() takes one parameter for block cache size. It now builds hash index, bloom filter, and block cache. - -### Public API changes -* The Prefix Extractor used with V2 compaction filters is now passed user key to SliceTransform::Transform instead of unparsed RocksDB key. - -## 3.4.0 (2014-08-18) -### New Features -* Support Multiple DB paths in universal style compactions -* Add feature of storing plain table index and bloom filter in SST file. -* CompactRange() will never output compacted files to level 0. This used to be the case when all the compaction input files were at level 0. -* Added iterate_upper_bound to define the extent upto which the forward iterator will return entries. This will prevent iterating over delete markers and overwritten entries for edge cases where you want to break out the iterator anyways. This may improve performance in case there are a large number of delete markers or overwritten entries. - -### Public API changes -* DBOptions.db_paths now is a vector of a DBPath structure which indicates both of path and target size -* NewPlainTableFactory instead of bunch of parameters now accepts PlainTableOptions, which is defined in include/rocksdb/table.h -* Moved include/utilities/*.h to include/rocksdb/utilities/*.h -* Statistics APIs now take uint32_t as type instead of Tickers. Also make two access functions getTickerCount and histogramData const -* Add DB property rocksdb.estimate-num-keys, estimated number of live keys in DB. -* Add DB::GetIntProperty(), which returns DB properties that are integer as uint64_t. -* The Prefix Extractor used with V2 compaction filters is now passed user key to SliceTransform::Transform instead of unparsed RocksDB key. - -## 3.3.0 (2014-07-10) -### New Features -* Added JSON API prototype. -* HashLinklist reduces performance outlier caused by skewed bucket by switching data in the bucket from linked list to skip list. Add parameter threshold_use_skiplist in NewHashLinkListRepFactory(). -* RocksDB is now able to reclaim storage space more effectively during the compaction process. This is done by compensating the size of each deletion entry by the 2X average value size, which makes compaction to be triggered by deletion entries more easily. -* Add TimeOut API to write. Now WriteOptions have a variable called timeout_hint_us. With timeout_hint_us set to non-zero, any write associated with this timeout_hint_us may be aborted when it runs longer than the specified timeout_hint_us, and it is guaranteed that any write completes earlier than the specified time-out will not be aborted due to the time-out condition. -* Add a rate_limiter option, which controls total throughput of flush and compaction. The throughput is specified in bytes/sec. Flush always has precedence over compaction when available bandwidth is constrained. - -### Public API changes -* Removed NewTotalOrderPlainTableFactory because it is not used and implemented semantically incorrect. - -## 3.2.0 (2014-06-20) - -### Public API changes -* We removed seek compaction as a concept from RocksDB because: -1) It makes more sense for spinning disk workloads, while RocksDB is primarily designed for flash and memory, -2) It added some complexity to the important code-paths, -3) None of our internal customers were really using it. -Because of that, Options::disable_seek_compaction is now obsolete. It is still a parameter in Options, so it does not break the build, but it does not have any effect. We plan to completely remove it at some point, so we ask users to please remove this option from your code base. -* Add two parameters to NewHashLinkListRepFactory() for logging on too many entries in a hash bucket when flushing. -* Added new option BlockBasedTableOptions::hash_index_allow_collision. When enabled, prefix hash index for block-based table will not store prefix and allow hash collision, reducing memory consumption. - -### New Features -* PlainTable now supports a new key encoding: for keys of the same prefix, the prefix is only written once. It can be enabled through encoding_type parameter of NewPlainTableFactory() -* Add AdaptiveTableFactory, which is used to convert from a DB of PlainTable to BlockBasedTabe, or vise versa. It can be created using NewAdaptiveTableFactory() - -### Performance Improvements -* Tailing Iterator re-implemeted with ForwardIterator + Cascading Search Hint , see ~20% throughput improvement. - -## 3.1.0 (2014-05-21) - -### Public API changes -* Replaced ColumnFamilyOptions::table_properties_collectors with ColumnFamilyOptions::table_properties_collector_factories - -### New Features -* Hash index for block-based table will be materialized and reconstructed more efficiently. Previously hash index is constructed by scanning the whole table during every table open. -* FIFO compaction style - -## 3.0.0 (2014-05-05) - -### Public API changes -* Added _LEVEL to all InfoLogLevel enums -* Deprecated ReadOptions.prefix and ReadOptions.prefix_seek. Seek() defaults to prefix-based seek when Options.prefix_extractor is supplied. More detail is documented in https://github.com/facebook/rocksdb/wiki/Prefix-Seek-API-Changes -* MemTableRepFactory::CreateMemTableRep() takes info logger as an extra parameter. - -### New Features -* Column family support -* Added an option to use different checksum functions in BlockBasedTableOptions -* Added ApplyToAllCacheEntries() function to Cache - -## 2.8.0 (2014-04-04) - -* Removed arena.h from public header files. -* By default, checksums are verified on every read from database -* Change default value of several options, including: paranoid_checks=true, max_open_files=5000, level0_slowdown_writes_trigger=20, level0_stop_writes_trigger=24, disable_seek_compaction=true, max_background_flushes=1 and allow_mmap_writes=false -* Added is_manual_compaction to CompactionFilter::Context -* Added "virtual void WaitForJoin()" in class Env. Default operation is no-op. -* Removed BackupEngine::DeleteBackupsNewerThan() function -* Added new option -- verify_checksums_in_compaction -* Changed Options.prefix_extractor from raw pointer to shared_ptr (take ownership) - Changed HashSkipListRepFactory and HashLinkListRepFactory constructor to not take SliceTransform object (use Options.prefix_extractor implicitly) -* Added Env::GetThreadPoolQueueLen(), which returns the waiting queue length of thread pools -* Added a command "checkconsistency" in ldb tool, which checks - if file system state matches DB state (file existence and file sizes) -* Separate options related to block based table to a new struct BlockBasedTableOptions. -* WriteBatch has a new function Count() to return total size in the batch, and Data() now returns a reference instead of a copy -* Add more counters to perf context. -* Supports several more DB properties: compaction-pending, background-errors and cur-size-active-mem-table. - -### New Features -* If we find one truncated record at the end of the MANIFEST or WAL files, - we will ignore it. We assume that writers of these records were interrupted - and that we can safely ignore it. -* A new SST format "PlainTable" is added, which is optimized for memory-only workloads. It can be created through NewPlainTableFactory() or NewTotalOrderPlainTableFactory(). -* A new mem table implementation hash linked list optimizing for the case that there are only few keys for each prefix, which can be created through NewHashLinkListRepFactory(). -* Merge operator supports a new function PartialMergeMulti() to allow users to do partial merges against multiple operands. -* Now compaction filter has a V2 interface. It buffers the kv-pairs sharing the same key prefix, process them in batches, and return the batched results back to DB. The new interface uses a new structure CompactionFilterContext for the same purpose as CompactionFilter::Context in V1. -* Geo-spatial support for locations and radial-search. - -## 2.7.0 (2014-01-28) - -### Public API changes - -* Renamed `StackableDB::GetRawDB()` to `StackableDB::GetBaseDB()`. -* Renamed `WriteBatch::Data()` `const std::string& Data() const`. -* Renamed class `TableStats` to `TableProperties`. -* Deleted class `PrefixHashRepFactory`. Please use `NewHashSkipListRepFactory()` instead. -* Supported multi-threaded `EnableFileDeletions()` and `DisableFileDeletions()`. -* Added `DB::GetOptions()`. -* Added `DB::GetDbIdentity()`. - -### New Features - -* Added [BackupableDB](https://github.com/facebook/rocksdb/wiki/How-to-backup-RocksDB%3F) -* Implemented [TailingIterator](https://github.com/facebook/rocksdb/wiki/Tailing-Iterator), a special type of iterator that - doesn't create a snapshot (can be used to read newly inserted data) - and is optimized for doing sequential reads. -* Added property block for table, which allows (1) a table to store - its metadata and (2) end user to collect and store properties they - are interested in. -* Enabled caching index and filter block in block cache (turned off by default). -* Supported error report when doing manual compaction. -* Supported additional Linux platform flavors and Mac OS. -* Put with `SliceParts` - Variant of `Put()` that gathers output like `writev(2)` -* Bug fixes and code refactor for compatibility with upcoming Column - Family feature. - -### Performance Improvements - -* Huge benchmark performance improvements by multiple efforts. For example, increase in readonly QPS from about 530k in 2.6 release to 1.1 million in 2.7 [1] -* Speeding up a way RocksDB deleted obsolete files - no longer listing the whole directory under a lock -- decrease in p99 -* Use raw pointer instead of shared pointer for statistics: [5b825d](https://github.com/facebook/rocksdb/commit/5b825d6964e26ec3b4bb6faa708ebb1787f1d7bd) -- huge increase in performance -- shared pointers are slow -* Optimized locking for `Get()` -- [1fdb3f](https://github.com/facebook/rocksdb/commit/1fdb3f7dc60e96394e3e5b69a46ede5d67fb976c) -- 1.5x QPS increase for some workloads -* Cache speedup - [e8d40c3](https://github.com/facebook/rocksdb/commit/e8d40c31b3cca0c3e1ae9abe9b9003b1288026a9) -* Implemented autovector, which allocates first N elements on stack. Most of vectors in RocksDB are small. Also, we never want to allocate heap objects while holding a mutex. -- [c01676e4](https://github.com/facebook/rocksdb/commit/c01676e46d3be08c3c140361ef1f5884f47d3b3c) -* Lots of efforts to move malloc, memcpy and IO outside of locks diff --git a/LICENSE.Apache b/LICENSE similarity index 100% rename from LICENSE.Apache rename to LICENSE diff --git a/README.md b/README.md index 8fcc4abc2..6ad228706 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,7 @@ -## RocksDB: A Persistent Key-Value Store for Flash and RAM Storage +## ForSt: A Persistent Key-Value Store designed for Streaming processing -[![CircleCI Status](https://circleci.com/gh/facebook/rocksdb.svg?style=svg)](https://circleci.com/gh/facebook/rocksdb) - -RocksDB is developed and maintained by Facebook Database Engineering Team. -It is built on earlier work on [LevelDB](https://github.com/google/leveldb) by Sanjay Ghemawat (sanjay@google.com) -and Jeff Dean (jeff@google.com) +ForSt is developed and maintained by Flink community and hosted by ververica. +It is built on top of [RocksDB](https://github.com/facebook/rocksdb) by facebook. This code is a library that forms the core building block for a fast key-value server, especially suited for storing data on flash drives. @@ -14,16 +11,14 @@ and Space-Amplification-Factor (SAF). It has multi-threaded compactions, making it especially suitable for storing multiple terabytes of data in a single database. -Start with example usage here: https://github.com/facebook/rocksdb/tree/main/examples - See the [github wiki](https://github.com/facebook/rocksdb/wiki) for more explanation. The public interface is in `include/`. Callers should not include or rely on the details of any other header files in this package. Those internal APIs may be changed without warning. -Questions and discussions are welcome on the [RocksDB Developers Public](https://www.facebook.com/groups/rocksdb.dev/) Facebook group and [email list](https://groups.google.com/g/rocksdb) on Google Groups. +Questions and discussions are welcome on the [Discussion](https://github.com/ververica/ForSt/discussions). ## License -RocksDB is dual-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). You may select, at your option, one of the above-listed licenses. +ForSt is licensed under Apache 2.0 License. From 0f4667b128d80a3268923939fc691e4f1f79050a Mon Sep 17 00:00:00 2001 From: Yanfei Lei Date: Tue, 12 Mar 2024 17:41:58 +0800 Subject: [PATCH 21/61] Revert "[FLINK-19710] Revert implementation of PerfContext back to __thread to avoid performance regression" (#11) --- db/perf_context_test.cc | 83 +++++++++++++++++++++++++++++++++++ monitoring/perf_context_imp.h | 2 +- 2 files changed, 84 insertions(+), 1 deletion(-) diff --git a/db/perf_context_test.cc b/db/perf_context_test.cc index fca9523cd..bb8691b96 100644 --- a/db/perf_context_test.cc +++ b/db/perf_context_test.cc @@ -706,6 +706,89 @@ TEST_F(PerfContextTest, MergeOperatorTime) { delete db; } +TEST_F(PerfContextTest, CopyAndMove) { + // Assignment operator + { + get_perf_context()->Reset(); + get_perf_context()->EnablePerLevelPerfContext(); + PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5); + ASSERT_EQ( + 1, + (*(get_perf_context()->level_to_perf_context))[5].bloom_filter_useful); + PerfContext perf_context_assign; + perf_context_assign = *get_perf_context(); + ASSERT_EQ( + 1, + (*(perf_context_assign.level_to_perf_context))[5].bloom_filter_useful); + get_perf_context()->ClearPerLevelPerfContext(); + get_perf_context()->Reset(); + ASSERT_EQ( + 1, + (*(perf_context_assign.level_to_perf_context))[5].bloom_filter_useful); + perf_context_assign.ClearPerLevelPerfContext(); + perf_context_assign.Reset(); + } + // Copy constructor + { + get_perf_context()->Reset(); + get_perf_context()->EnablePerLevelPerfContext(); + PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5); + ASSERT_EQ( + 1, + (*(get_perf_context()->level_to_perf_context))[5].bloom_filter_useful); + PerfContext perf_context_copy(*get_perf_context()); + ASSERT_EQ( + 1, (*(perf_context_copy.level_to_perf_context))[5].bloom_filter_useful); + get_perf_context()->ClearPerLevelPerfContext(); + get_perf_context()->Reset(); + ASSERT_EQ( + 1, (*(perf_context_copy.level_to_perf_context))[5].bloom_filter_useful); + perf_context_copy.ClearPerLevelPerfContext(); + perf_context_copy.Reset(); + } + // Move constructor + { + get_perf_context()->Reset(); + get_perf_context()->EnablePerLevelPerfContext(); + PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5); + ASSERT_EQ( + 1, + (*(get_perf_context()->level_to_perf_context))[5].bloom_filter_useful); + PerfContext perf_context_move = std::move(*get_perf_context()); + ASSERT_EQ( + 1, (*(perf_context_move.level_to_perf_context))[5].bloom_filter_useful); + get_perf_context()->ClearPerLevelPerfContext(); + get_perf_context()->Reset(); + ASSERT_EQ( + 1, (*(perf_context_move.level_to_perf_context))[5].bloom_filter_useful); + perf_context_move.ClearPerLevelPerfContext(); + perf_context_move.Reset(); + } +} + +TEST_F(PerfContextTest, PerfContextDisableEnable) { + get_perf_context()->Reset(); + get_perf_context()->EnablePerLevelPerfContext(); + PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_positive, 1, 0); + get_perf_context()->DisablePerLevelPerfContext(); + PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5); + get_perf_context()->EnablePerLevelPerfContext(); + PERF_COUNTER_BY_LEVEL_ADD(block_cache_hit_count, 1, 0); + get_perf_context()->DisablePerLevelPerfContext(); + PerfContext perf_context_copy(*get_perf_context()); + ASSERT_EQ(1, (*(perf_context_copy.level_to_perf_context))[0] + .bloom_filter_full_positive); + // this was set when per level perf context is disabled, should not be copied + ASSERT_NE( + 1, (*(perf_context_copy.level_to_perf_context))[5].bloom_filter_useful); + ASSERT_EQ( + 1, (*(perf_context_copy.level_to_perf_context))[0].block_cache_hit_count); + perf_context_copy.ClearPerLevelPerfContext(); + perf_context_copy.Reset(); + get_perf_context()->ClearPerLevelPerfContext(); + get_perf_context()->Reset(); +} + TEST_F(PerfContextTest, PerfContextByLevelGetSet) { get_perf_context()->Reset(); get_perf_context()->EnablePerLevelPerfContext(); diff --git a/monitoring/perf_context_imp.h b/monitoring/perf_context_imp.h index 439a1e28c..5b66ff2ff 100644 --- a/monitoring/perf_context_imp.h +++ b/monitoring/perf_context_imp.h @@ -16,7 +16,7 @@ extern PerfContext perf_context; extern thread_local PerfContext perf_context_; #define perf_context (*get_perf_context()) #else -extern __thread PerfContext perf_context; +extern thread_local PerfContext perf_context; #endif #endif From 0d7fea8c7e47d2bfd137c4b096b8e55f7cd3a63d Mon Sep 17 00:00:00 2001 From: Yanfei Lei Date: Wed, 13 Mar 2024 13:06:29 +0800 Subject: [PATCH 22/61] [build] Add pr-jobs check (#10) --- .github/actions/build-folly/action.yml | 7 + .../action.yml | 10 + .../install-gflags-on-macos/action.yml | 7 + .github/actions/install-gflags/action.yml | 7 + .../actions/install-jdk8-on-macos/action.yml | 9 + .github/actions/post-steps/action.yml | 38 ++++ .github/actions/pre-steps-macos/action.yml | 5 + .github/actions/pre-steps/action.yml | 18 ++ .github/actions/setup-folly/action.yml | 7 + .github/actions/setup-upstream/action.yml | 20 ++ .github/workflows/pr-jobs.yml | 173 ++++++++++++++++++ Makefile | 6 + java/Makefile | 2 - 13 files changed, 307 insertions(+), 2 deletions(-) create mode 100644 .github/actions/build-folly/action.yml create mode 100644 .github/actions/increase-max-open-files-on-macos/action.yml create mode 100644 .github/actions/install-gflags-on-macos/action.yml create mode 100644 .github/actions/install-gflags/action.yml create mode 100644 .github/actions/install-jdk8-on-macos/action.yml create mode 100644 .github/actions/post-steps/action.yml create mode 100644 .github/actions/pre-steps-macos/action.yml create mode 100644 .github/actions/pre-steps/action.yml create mode 100644 .github/actions/setup-folly/action.yml create mode 100644 .github/actions/setup-upstream/action.yml create mode 100644 .github/workflows/pr-jobs.yml diff --git a/.github/actions/build-folly/action.yml b/.github/actions/build-folly/action.yml new file mode 100644 index 000000000..cd6cdfc06 --- /dev/null +++ b/.github/actions/build-folly/action.yml @@ -0,0 +1,7 @@ +name: build-folly +runs: + using: composite + steps: + - name: Build folly and dependencies + run: make build_folly + shell: bash \ No newline at end of file diff --git a/.github/actions/increase-max-open-files-on-macos/action.yml b/.github/actions/increase-max-open-files-on-macos/action.yml new file mode 100644 index 000000000..869cd14ed --- /dev/null +++ b/.github/actions/increase-max-open-files-on-macos/action.yml @@ -0,0 +1,10 @@ +name: increase-max-open-files-on-macos +runs: + using: composite + steps: + - name: Increase max open files + run: |- + sudo sysctl -w kern.maxfiles=1048576 + sudo sysctl -w kern.maxfilesperproc=1048576 + sudo launchctl limit maxfiles 1048576 + shell: bash \ No newline at end of file diff --git a/.github/actions/install-gflags-on-macos/action.yml b/.github/actions/install-gflags-on-macos/action.yml new file mode 100644 index 000000000..3de06f614 --- /dev/null +++ b/.github/actions/install-gflags-on-macos/action.yml @@ -0,0 +1,7 @@ +name: install-gflags-on-macos +runs: + using: composite + steps: + - name: Install gflags on macos + run: HOMEBREW_NO_AUTO_UPDATE=1 brew install gflags + shell: bash \ No newline at end of file diff --git a/.github/actions/install-gflags/action.yml b/.github/actions/install-gflags/action.yml new file mode 100644 index 000000000..d47619722 --- /dev/null +++ b/.github/actions/install-gflags/action.yml @@ -0,0 +1,7 @@ +name: install-gflags +runs: + using: composite + steps: + - name: Install gflags + run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev + shell: bash \ No newline at end of file diff --git a/.github/actions/install-jdk8-on-macos/action.yml b/.github/actions/install-jdk8-on-macos/action.yml new file mode 100644 index 000000000..80c56da09 --- /dev/null +++ b/.github/actions/install-jdk8-on-macos/action.yml @@ -0,0 +1,9 @@ +name: install-jdk8-on-macos +runs: + using: composite + steps: + - name: Install JDK 8 on macos + run: |- + HOMEBREW_NO_AUTO_UPDATE=1 brew tap bell-sw/liberica + HOMEBREW_NO_AUTO_UPDATE=1 brew install --cask liberica-jdk8 + shell: bash \ No newline at end of file diff --git a/.github/actions/post-steps/action.yml b/.github/actions/post-steps/action.yml new file mode 100644 index 000000000..5bb7502ec --- /dev/null +++ b/.github/actions/post-steps/action.yml @@ -0,0 +1,38 @@ +name: post-steps +description: Steps that are taken after a RocksDB job +inputs: + artifact-prefix: + description: Prefix to append to the name of artifacts that are uploaded + required: true + default: "${{ github.job }}" +runs: + using: composite + steps: + - name: Upload Test Results artifact + uses: actions/upload-artifact@v4.0.0 + with: + name: "${{ inputs.artifact-prefix }}-test-results" + path: "${{ runner.temp }}/test-results/**" + - name: Upload DB LOG file artifact + uses: actions/upload-artifact@v4.0.0 + with: + name: "${{ inputs.artifact-prefix }}-db-log-file" + path: LOG + - name: Copy Test Logs (on Failure) + if: ${{ failure() }} + run: | + mkdir -p ${{ runner.temp }}/failure-test-logs + cp -r t/* ${{ runner.temp }}/failure-test-logs + shell: bash + - name: Upload Test Logs (on Failure) artifact + uses: actions/upload-artifact@v4.0.0 + with: + name: "${{ inputs.artifact-prefix }}-failure-test-logs" + path: ${{ runner.temp }}/failure-test-logs/** + if-no-files-found: ignore + - name: Upload Core Dumps artifact + uses: actions/upload-artifact@v4.0.0 + with: + name: "${{ inputs.artifact-prefix }}-core-dumps" + path: "core.*" + if-no-files-found: ignore \ No newline at end of file diff --git a/.github/actions/pre-steps-macos/action.yml b/.github/actions/pre-steps-macos/action.yml new file mode 100644 index 000000000..86c83b3b4 --- /dev/null +++ b/.github/actions/pre-steps-macos/action.yml @@ -0,0 +1,5 @@ +name: pre-steps-macos +runs: + using: composite + steps: + - uses: "./.github/actions/pre-steps" \ No newline at end of file diff --git a/.github/actions/pre-steps/action.yml b/.github/actions/pre-steps/action.yml new file mode 100644 index 000000000..d40254610 --- /dev/null +++ b/.github/actions/pre-steps/action.yml @@ -0,0 +1,18 @@ +name: pre-steps +runs: + using: composite + steps: + - name: Setup Environment Variables + run: |- + echo "GTEST_THROW_ON_FAILURE=0" >> "$GITHUB_ENV" + echo "GTEST_OUTPUT=\"xml:${{ runner.temp }}/test-results/\"" >> "$GITHUB_ENV" + echo "SKIP_FORMAT_BUCK_CHECKS=1" >> "$GITHUB_ENV" + echo "GTEST_COLOR=1" >> "$GITHUB_ENV" + echo "CTEST_OUTPUT_ON_FAILURE=1" >> "$GITHUB_ENV" + echo "CTEST_TEST_TIMEOUT=300" >> "$GITHUB_ENV" + echo "ZLIB_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/zlib" >> "$GITHUB_ENV" + echo "BZIP2_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/bzip2" >> "$GITHUB_ENV" + echo "SNAPPY_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/snappy" >> "$GITHUB_ENV" + echo "LZ4_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/lz4" >> "$GITHUB_ENV" + echo "ZSTD_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/zstd" >> "$GITHUB_ENV" + shell: bash \ No newline at end of file diff --git a/.github/actions/setup-folly/action.yml b/.github/actions/setup-folly/action.yml new file mode 100644 index 000000000..cf2b2900b --- /dev/null +++ b/.github/actions/setup-folly/action.yml @@ -0,0 +1,7 @@ +name: setup-folly +runs: + using: composite + steps: + - name: Checkout folly sources + run: make checkout_folly + shell: bash \ No newline at end of file diff --git a/.github/actions/setup-upstream/action.yml b/.github/actions/setup-upstream/action.yml new file mode 100644 index 000000000..6cbe22771 --- /dev/null +++ b/.github/actions/setup-upstream/action.yml @@ -0,0 +1,20 @@ +name: build-folly +runs: + using: composite + steps: + - name: Fix repo ownership + # Needed in some cases, as safe.directory setting doesn't take effect + # under env -i + run: chown `whoami` . || true + shell: bash + - name: Set upstream + run: git remote add upstream https://github.com/facebook/rocksdb.git + shell: bash + - name: Fetch upstream + run: git fetch upstream + shell: bash + - name: Git status + # NOTE: some old branch builds under check_format_compatible.sh invoke + # git under env -i + run: git status && git remote -v && env -i git branch + shell: bash \ No newline at end of file diff --git a/.github/workflows/pr-jobs.yml b/.github/workflows/pr-jobs.yml new file mode 100644 index 000000000..385bd2dde --- /dev/null +++ b/.github/workflows/pr-jobs.yml @@ -0,0 +1,173 @@ +name: ververica/forst/pr-jobs +on: [push, pull_request] +jobs: + # ======================== Fast Initial Checks ====================== # + check-format-and-targets: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4.1.0 + with: + fetch-depth: 0 # Need full checkout to determine merge base + fetch-tags: true + - uses: "./.github/actions/setup-upstream" + - name: Setup Python + uses: actions/setup-python@v5 + - name: Install Dependencies + run: python -m pip install --upgrade pip + - name: Install argparse + run: pip install argparse + - name: Download clang-format-diff.py + run: wget https://raw.githubusercontent.com/llvm/llvm-project/release/12.x/clang/tools/clang-format/clang-format-diff.py + - name: Check format + run: VERBOSE_CHECK=1 make check-format + - name: Simple source code checks + run: make check-sources + # ========================= Linux With Tests ======================== # + build-linux: + runs-on: ubuntu-latest + timeout-minutes: 120 + steps: + - uses: actions/checkout@v4.1.0 + - uses: "./.github/actions/pre-steps" + - uses: "./.github/actions/install-gflags" + - run: echo "JAVA_HOME=${JAVA_HOME}" + - run: DISABLE_WARNING_AS_ERROR=1 make V=1 J=8 -j8 check + - uses: "./.github/actions/post-steps" + # ======================== Linux No Test Runs ======================= # + build-linux-release: + runs-on: ubuntu-latest + timeout-minutes: 120 + steps: + - uses: actions/checkout@v4.1.0 + - uses: "./.github/actions/install-gflags" + - run: echo "JAVA_HOME=${JAVA_HOME}" + - run: echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $GITHUB_PATH + - run: DISABLE_WARNING_AS_ERROR=1 make V=1 -j32 LIB_MODE=shared release + - run: ls librocksdb.so + - run: "./db_stress --version" + - run: DISABLE_WARNING_AS_ERROR=1 make clean + - run: DISABLE_WARNING_AS_ERROR=1 make V=1 -j32 release + - run: ls librocksdb.a + - run: "./db_stress --version" + - run: DISABLE_WARNING_AS_ERROR=1 make clean + - run: sudo apt-get remove -y libgflags-dev + - run: DISABLE_WARNING_AS_ERROR=1 make V=1 -j32 LIB_MODE=shared release + - run: ls librocksdb.so + - run: if ./db_stress --version; then false; else true; fi + - run: DISABLE_WARNING_AS_ERROR=1 make clean + - run: DISABLE_WARNING_AS_ERROR=1 make V=1 -j32 release + - run: ls librocksdb.a + - run: if ./db_stress --version; then false; else true; fi + - uses: "./.github/actions/post-steps" + # ============================ Java Jobs ============================ # + build-linux-java: + runs-on: ubuntu-latest + container: evolvedbinary/rocksjava:centos6_x64-be + steps: + # The docker image is intentionally based on an OS that has an older GLIBC version. + # That GLIBC is incompatibile with GitHub's actions/checkout. Thus we implement a manual checkout step. + - name: Checkout + env: + GH_TOKEN: ${{ github.token }} + run: | + chown `whoami` . || true + git clone --no-checkout https://oath2:$GH_TOKEN@github.com/${{ github.repository }}.git . + git -c protocol.version=2 fetch --update-head-ok --no-tags --prune --no-recurse-submodules --depth=1 origin +${{ github.sha }}:${{ github.ref }} + git checkout --progress --force ${{ github.ref }} + git log -1 --format='%H' + - uses: "./.github/actions/pre-steps" + - name: Set Java Environment + run: |- + echo "JAVA_HOME=${JAVA_HOME}" + echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $GITHUB_PATH + which java && java -version + which javac && javac -version + - name: Test RocksDBJava + run: scl enable devtoolset-7 'DISABLE_WARNING_AS_ERROR=1 make V=1 J=8 -j8 jtest' + # NOTE: post-steps skipped because of compatibility issues with docker image + build-linux-java-static: + runs-on: ubuntu-latest + container: evolvedbinary/rocksjava:centos6_x64-be + steps: + # The docker image is intentionally based on an OS that has an older GLIBC version. + # That GLIBC is incompatibile with GitHub's actions/checkout. Thus we implement a manual checkout step. + - name: Checkout + env: + GH_TOKEN: ${{ github.token }} + run: | + chown `whoami` . || true + git clone --no-checkout https://oath2:$GH_TOKEN@github.com/${{ github.repository }}.git . + git -c protocol.version=2 fetch --update-head-ok --no-tags --prune --no-recurse-submodules --depth=1 origin +${{ github.sha }}:${{ github.ref }} + git checkout --progress --force ${{ github.ref }} + git log -1 --format='%H' + - uses: "./.github/actions/pre-steps" + - name: Set Java Environment + run: |- + echo "JAVA_HOME=${JAVA_HOME}" + which java && java -version + which javac && javac -version + - name: Build RocksDBJava Static Library + run: scl enable devtoolset-7 'DISABLE_WARNING_AS_ERROR=1 make V=1 J=8 -j8 rocksdbjavastatic' + # NOTE: post-steps skipped because of compatibility issues with docker image + + # ========================= MacOS build only ======================== # + build-macos: + runs-on: macos-13 + timeout-minutes: 120 + env: + ROCKSDB_DISABLE_JEMALLOC: 1 + steps: + - uses: actions/checkout@v4.1.0 + - uses: maxim-lobanov/setup-xcode@v1.6.0 + with: + xcode-version: 14.3.1 + - uses: "./.github/actions/increase-max-open-files-on-macos" + - uses: "./.github/actions/install-gflags-on-macos" + - uses: "./.github/actions/pre-steps-macos" + - name: Build + run: ulimit -S -n `ulimit -H -n` && DISABLE_WARNING_AS_ERROR=1 make V=1 J=16 -j16 all + - uses: "./.github/actions/post-steps" + # ========================= MacOS with java ======================== # + build-macos-java: + runs-on: macos-13 + env: + JAVA_HOME: "/Library/Java/JavaVirtualMachines/liberica-jdk-8.jdk/Contents/Home" + ROCKSDB_DISABLE_JEMALLOC: 1 + steps: + - uses: actions/checkout@v4.1.0 + - uses: maxim-lobanov/setup-xcode@v1.6.0 + with: + xcode-version: 14.3.1 + - uses: "./.github/actions/increase-max-open-files-on-macos" + - uses: "./.github/actions/install-gflags-on-macos" + - uses: "./.github/actions/install-jdk8-on-macos" + - uses: "./.github/actions/pre-steps-macos" + - name: Set Java Environment + run: |- + echo "JAVA_HOME=${JAVA_HOME}" + which java && java -version + which javac && javac -version + - name: Test RocksDBJava + run: DISABLE_WARNING_AS_ERROR=1 make V=1 J=16 -j16 jtest + - uses: "./.github/actions/post-steps" + build-macos-java-static: + runs-on: macos-13 + env: + JAVA_HOME: "/Library/Java/JavaVirtualMachines/liberica-jdk-8.jdk/Contents/Home" + steps: + - uses: actions/checkout@v4.1.0 + - uses: maxim-lobanov/setup-xcode@v1.6.0 + with: + xcode-version: 14.3.1 + - uses: "./.github/actions/increase-max-open-files-on-macos" + - uses: "./.github/actions/install-gflags-on-macos" + - uses: "./.github/actions/install-jdk8-on-macos" + - uses: "./.github/actions/pre-steps-macos" + - name: Set Java Environment + run: |- + echo "JAVA_HOME=${JAVA_HOME}" + which java && java -version + which javac && javac -version + - name: Build RocksDBJava x86 and ARM Static Libraries + run: DISABLE_WARNING_AS_ERROR=1 make V=1 J=16 -j16 rocksdbjavastaticosx + - uses: "./.github/actions/post-steps" \ No newline at end of file diff --git a/Makefile b/Makefile index 0c111485c..1658f24c1 100644 --- a/Makefile +++ b/Makefile @@ -10,9 +10,15 @@ BASH_EXISTS := $(shell which bash) SHELL := $(shell which bash) include common.mk +MY_JAVA_INCLUDE = -I$(JAVA_HOME)/include/ -I$(JAVA_HOME)/include/linux +ifneq ("$(wildcard $(JAVA_HOME)/include/darwin)","") + MY_JAVA_INCLUDE = -I$(JAVA_HOME)/include -I $(JAVA_HOME)/include/darwin +endif + CLEAN_FILES = # deliberately empty, so we can append below. CFLAGS += ${EXTRA_CFLAGS} CXXFLAGS += ${EXTRA_CXXFLAGS} +CXXFLAGS += ${MY_JAVA_INCLUDE} LDFLAGS += $(EXTRA_LDFLAGS) MACHINE ?= $(shell uname -m) ARFLAGS = ${EXTRA_ARFLAGS} rs diff --git a/java/Makefile b/java/Makefile index 5f32dc7e5..ea8ca7eb6 100644 --- a/java/Makefile +++ b/java/Makefile @@ -338,8 +338,6 @@ javalib: java java_test javadocs java: java-version $(AM_V_GEN)mkdir -p $(MAIN_CLASSES) $(AM_V_at) $(JAVAC_CMD) $(JAVAC_ARGS) -h $(NATIVE_INCLUDE) -d $(MAIN_CLASSES) $(SOURCES) - $(AM_V_at)@cp ../HISTORY.md ./HISTORY-CPP.md - $(AM_V_at)@rm -f ./HISTORY-CPP.md sample: java $(AM_V_GEN)mkdir -p $(SAMPLES_MAIN_CLASSES) From d4e8ef1b41d3042bca39d6e0da96d483f2f5a91e Mon Sep 17 00:00:00 2001 From: Jinzhong Li Date: Mon, 18 Mar 2024 15:01:42 +0800 Subject: [PATCH 23/61] [env] Fix jvm_util unused parameter error (#14) --- env/flink/jvm_util.cc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/env/flink/jvm_util.cc b/env/flink/jvm_util.cc index 8e2c6f07a..ecd6f9677 100644 --- a/env/flink/jvm_util.cc +++ b/env/flink/jvm_util.cc @@ -18,11 +18,14 @@ #include "env/flink/jvm_util.h" +#define UNUSED(x) (void)(x) + namespace ROCKSDB_NAMESPACE { std::atomic jvm_ = std::atomic(nullptr); JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { + UNUSED(reserved); JNIEnv* env = nullptr; if (vm->GetEnv((void**)&env, JNI_VERSION_1_8) != JNI_OK) { return -1; @@ -33,6 +36,8 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { } JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) { + UNUSED(vm); + UNUSED(reserved); jvm_.store(nullptr); } From 3ded35eb665d21f2948719240ba03573bf873e90 Mon Sep 17 00:00:00 2001 From: Adam Retter Date: Fri, 16 Feb 2024 10:26:32 -0800 Subject: [PATCH 24/61] Update ZLib to 1.3.1 (#12358) Summary: pdillinger This fixes the RocksJava build, is also needed in the 8.10.fb and 8.11.fb branches please? Pull Request resolved: https://github.com/facebook/rocksdb/pull/12358 Reviewed By: jaykorean Differential Revision: D53859743 Pulled By: pdillinger fbshipit-source-id: b8417fccfee931591805f9aecdfae7c086fee708 --- Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index 1658f24c1..2be194499 100644 --- a/Makefile +++ b/Makefile @@ -2097,8 +2097,8 @@ ROCKSDB_JAVADOCS_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-javadoc.jar ROCKSDB_SOURCES_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-sources.jar SHA256_CMD = sha256sum -ZLIB_VER ?= 1.2.13 -ZLIB_SHA256 ?= b3a24de97a8fdbc835b9833169501030b8977031bcb54b3b3ac13740f846ab30 +ZLIB_VER ?= 1.3.1 +ZLIB_SHA256 ?= 9a93b2b7dfdac77ceba5a558a580e74667dd6fede4585b91eefb60f03b72df23 ZLIB_DOWNLOAD_BASE ?= http://zlib.net BZIP2_VER ?= 1.0.8 BZIP2_SHA256 ?= ab5a03176ee106d3f0fa90e381da478ddae405918153cca248e682cd0c4a2269 From 7c0c8da59ae8d27b7db68752ac84ec3004efba87 Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Fri, 15 Mar 2024 09:38:58 +0800 Subject: [PATCH 25/61] [env] Implement all methods of env_flink (#13) --- env/flink/env_flink.cc | 843 +++++++++++++++++++++++++++++++++++++++- env/flink/env_flink.h | 37 +- env/flink/jni_helper.cc | 325 ++++++++++++++-- env/flink/jni_helper.h | 103 ++++- 4 files changed, 1243 insertions(+), 65 deletions(-) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index 87183f131..8987084d0 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -3,8 +3,843 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -// TODO: -// 1. Register flink env to ObjectLibrary -// 2. Implement all methods of env_flink.h +#include "env_flink.h" -#include "env_flink.h" \ No newline at end of file +#include "jvm_util.h" + +// +// This file defines a Flink environment for ForSt. It uses the JNI call +// to access Flink FileSystem. All files created by one instance of ForSt +// will reside on the actual Flink FileSystem. +// +namespace ROCKSDB_NAMESPACE { + +// Appends to an existing file in Flink FileSystem. +class FlinkWritableFile : public FSWritableFile { + private: + const std::string file_path_; + const jobject file_system_instance_; + jobject fs_data_output_stream_instance_; + JavaClassCache* class_cache_; + + public: + FlinkWritableFile(jobject file_system_instance, + JavaClassCache* java_class_cache, + const std::string& file_path, const FileOptions& options) + : FSWritableFile(options), + file_path_(file_path), + file_system_instance_(file_system_instance), + class_cache_(java_class_cache) {} + + ~FlinkWritableFile() override { + JNIEnv* jniEnv = getJNIEnv(); + if (fs_data_output_stream_instance_ != nullptr) { + jniEnv->DeleteGlobalRef(fs_data_output_stream_instance_); + } + } + + IOStatus Init() { + JNIEnv* jniEnv = getJNIEnv(); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(file_path_, &pathInstance); + if (!status.ok()) { + return status; + } + + JavaClassCache::JavaMethodContext fileSystemCreateMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_CREATE); + jobject fsDataOutputStream = jniEnv->CallObjectMethod( + file_system_instance_, fileSystemCreateMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + if (fsDataOutputStream == nullptr) { + return CheckThenError( + std::string( + "CallObjectMethod Exception when Init FlinkWritableFile, ") + .append(fileSystemCreateMethod.ToString()) + .append(", args: Path(") + .append(file_path_) + .append(")")); + } + fs_data_output_stream_instance_ = jniEnv->NewGlobalRef(fsDataOutputStream); + jniEnv->DeleteLocalRef(fsDataOutputStream); + return IOStatus::OK(); + } + + IOStatus Append(const Slice& data, const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override { + JNIEnv* jniEnv = getJNIEnv(); + if (data.size() > static_cast(LONG_MAX)) { + return IOStatus::IOError( + std::string("Append too big data to file, data: ") + .append(data.ToString())); + } + jobject directByteBuffer = jniEnv->NewDirectByteBuffer( + (void*)data.data(), static_cast(data.size())); + + JavaClassCache::JavaMethodContext writeMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_OUTPUT_STREAM_WRITE); + jniEnv->CallVoidMethod(fs_data_output_stream_instance_, + writeMethod.javaMethod, directByteBuffer); + jniEnv->DeleteLocalRef(directByteBuffer); + + std::string filePath = file_path_; + return CurrentStatus([filePath]() { + return std::string("Exception when Appending file, path: ") + .append(filePath); + }); + } + + IOStatus Append(const Slice& data, const IOOptions& options, + const DataVerificationInfo& /* verification_info */, + IODebugContext* dbg) override { + return Append(data, options, dbg); + } + + IOStatus Flush(const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override { + JavaClassCache::JavaMethodContext flushMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_OUTPUT_STREAM_FLUSH); + JNIEnv* jniEnv = getJNIEnv(); + jniEnv->CallVoidMethod(fs_data_output_stream_instance_, + flushMethod.javaMethod); + + std::string filePath = file_path_; + return CurrentStatus([filePath]() { + return std::string("Exception when Flush file, path: ").append(filePath); + }); + } + + IOStatus Sync(const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override { + JavaClassCache::JavaMethodContext flushMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_OUTPUT_STREAM_SYNC); + JNIEnv* jniEnv = getJNIEnv(); + jniEnv->CallVoidMethod(fs_data_output_stream_instance_, + flushMethod.javaMethod); + + std::string filePath = file_path_; + return CurrentStatus([filePath]() { + return std::string("Exception when Sync file, path: ").append(filePath); + }); + } + + IOStatus Close(const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override { + JavaClassCache::JavaMethodContext closeMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_OUTPUT_STREAM_CLOSE); + JNIEnv* jniEnv = getJNIEnv(); + jniEnv->CallVoidMethod(fs_data_output_stream_instance_, + closeMethod.javaMethod); + + std::string filePath = file_path_; + return CurrentStatus([filePath]() { + return std::string("Exception when Close file, path: ").append(filePath); + }); + } +}; + +// Used for reading a file from Flink FileSystem. It implements both +// sequential-read access methods and random read access methods. +class FlinkReadableFile : virtual public FSSequentialFile, + virtual public FSRandomAccessFile { + private: + const std::string file_path_; + const jobject file_system_instance_; + jobject fs_data_input_stream_instance_; + JavaClassCache* class_cache_; + + public: + FlinkReadableFile(jobject file_system_instance, + JavaClassCache* java_class_cache, + const std::string& file_path) + : file_path_(file_path), + file_system_instance_(file_system_instance), + class_cache_(java_class_cache) {} + + ~FlinkReadableFile() override { + JNIEnv* jniEnv = getJNIEnv(); + if (fs_data_input_stream_instance_ != nullptr) { + jniEnv->DeleteGlobalRef(fs_data_input_stream_instance_); + } + } + + IOStatus Init() { + JNIEnv* jniEnv = getJNIEnv(); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(file_path_, &pathInstance); + if (!status.ok()) { + return status; + } + + JavaClassCache::JavaMethodContext openMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_OPEN); + jobject fsDataInputStream = jniEnv->CallObjectMethod( + file_system_instance_, openMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + if (fsDataInputStream == nullptr) { + return CheckThenError( + std::string( + "CallObjectMethod Exception when Init FlinkReadableFile, ") + .append(openMethod.ToString()) + .append(", args: Path(") + .append(file_path_) + .append(")")); + } + + fs_data_input_stream_instance_ = jniEnv->NewGlobalRef(fsDataInputStream); + jniEnv->DeleteLocalRef(fsDataInputStream); + return IOStatus::OK(); + } + + // sequential access, read data at current offset in file + IOStatus Read(size_t n, const IOOptions& /*options*/, Slice* result, + char* scratch, IODebugContext* /*dbg*/) override { + JNIEnv* jniEnv = getJNIEnv(); + if (n > static_cast(LONG_MAX)) { + return IOStatus::IOError( + std::string("Read too big data to file, data size: ") + .append(std::to_string(n))); + } + jobject directByteBuffer = + jniEnv->NewDirectByteBuffer((void*)scratch, static_cast(n)); + + JavaClassCache::JavaMethodContext readMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_INPUT_STREAM_SEQ_READ); + jint totalBytesRead = + jniEnv->CallIntMethod(fs_data_input_stream_instance_, + readMethod.javaMethod, directByteBuffer); + + jniEnv->DeleteLocalRef(directByteBuffer); + + std::string filePath = file_path_; + IOStatus status = CurrentStatus([filePath]() { + return std::string("Exception when Reading file, path: ") + .append(filePath); + }); + if (!status.ok()) { + return status; + } + + *result = Slice(scratch, totalBytesRead == -1 ? 0 : totalBytesRead); + return IOStatus::OK(); + } + + // random access, read data from specified offset in file + IOStatus Read(uint64_t offset, size_t n, const IOOptions& /*options*/, + Slice* result, char* scratch, + IODebugContext* /*dbg*/) const override { + JNIEnv* jniEnv = getJNIEnv(); + if (n > static_cast(LONG_MAX)) { + return IOStatus::IOError( + std::string("Read too big data to file, data size: ") + .append(std::to_string(n))); + } + jobject directByteBuffer = + jniEnv->NewDirectByteBuffer((void*)scratch, static_cast(n)); + + JavaClassCache::JavaMethodContext readMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_INPUT_STREAM_RANDOM_READ); + jint totalBytesRead = + jniEnv->CallIntMethod(fs_data_input_stream_instance_, + readMethod.javaMethod, offset, directByteBuffer); + + jniEnv->DeleteLocalRef(directByteBuffer); + + std::string filePath = file_path_; + IOStatus status = CurrentStatus([filePath]() { + return std::string("Exception when Reading file, path: ") + .append(filePath); + }); + if (!status.ok()) { + return status; + } + + *result = Slice(scratch, totalBytesRead == -1 ? 0 : totalBytesRead); + return IOStatus::OK(); + } + + IOStatus Skip(uint64_t n) override { + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaMethodContext skipMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FS_INPUT_STREAM_SKIP); + jniEnv->CallVoidMethod(fs_data_input_stream_instance_, + skipMethod.javaMethod, n); + + std::string filePath = file_path_; + return CurrentStatus([filePath]() { + return std::string("Exception when skipping file, path: ") + .append(filePath); + }); + } +}; + +// Simple implementation of FSDirectory, Shouldn't influence the normal usage +class FlinkDirectory : public FSDirectory { + public: + explicit FlinkDirectory() = default; + ~FlinkDirectory() override = default; + + IOStatus Fsync(const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override { + // TODO: Syncing directory is managed by specific flink file system + // currently, consider to implement in the future + return IOStatus::OK(); + } +}; + +FlinkFileSystem::FlinkFileSystem(const std::shared_ptr& base_fs, + const std::string& base_path) + : FileSystemWrapper(base_fs), base_path_(base_path) {} + +FlinkFileSystem::~FlinkFileSystem() { + if (file_system_instance_ != nullptr) { + JNIEnv* env = getJNIEnv(); + env->DeleteGlobalRef(file_system_instance_); + } + delete class_cache_; +} + +Status FlinkFileSystem::Init() { + JNIEnv* jniEnv = getJNIEnv(); + std::unique_ptr javaClassCache; + Status status = JavaClassCache::Create(jniEnv, &javaClassCache); + if (!status.ok()) { + return status; + } + class_cache_ = javaClassCache.release(); + + // Delegate Flink to load real FileSystem (e.g. + // S3FileSystem/OSSFileSystem/...) + JavaClassCache::JavaClassContext fileSystemClass = + class_cache_->GetJClass(JavaClassCache::JC_FLINK_FILE_SYSTEM); + JavaClassCache::JavaMethodContext fileSystemGetMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_GET); + + JavaClassCache::JavaClassContext uriClass = + class_cache_->GetJClass(JavaClassCache::JC_URI); + JavaClassCache::JavaMethodContext uriConstructor = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_URI_CONSTRUCTOR); + + // Construct URI + jstring uriStringArg = jniEnv->NewStringUTF(base_path_.c_str()); + jobject uriInstance = jniEnv->NewObject( + uriClass.javaClass, uriConstructor.javaMethod, uriStringArg); + jniEnv->DeleteLocalRef(uriStringArg); + if (uriInstance == nullptr) { + return CheckThenError( + std::string("NewObject Exception when Init FlinkFileSystem, ") + .append(uriClass.ToString()) + .append(uriConstructor.ToString()) + .append(", args: ") + .append(base_path_)); + } + + // Construct FileSystem + jobject fileSystemInstance = jniEnv->CallStaticObjectMethod( + fileSystemClass.javaClass, fileSystemGetMethod.javaMethod, uriInstance); + jniEnv->DeleteLocalRef(uriInstance); + if (fileSystemInstance == nullptr) { + return CheckThenError( + std::string( + "CallStaticObjectMethod Exception when Init FlinkFileSystem, ") + .append(fileSystemClass.ToString()) + .append(fileSystemGetMethod.ToString()) + .append(", args: URI(") + .append(base_path_) + .append(")")); + } + file_system_instance_ = jniEnv->NewGlobalRef(fileSystemInstance); + jniEnv->DeleteLocalRef(fileSystemInstance); + return Status::OK(); +} + +std::string FlinkFileSystem::ConstructPath(const std::string& fname) { + return fname.at(0) == '/' ? base_path_ + fname : base_path_ + "/" + fname; +} + +// open a file for sequential reading +IOStatus FlinkFileSystem::NewSequentialFile( + const std::string& fname, const FileOptions& options, + std::unique_ptr* result, IODebugContext* dbg) { + result->reset(); + IOStatus status = FileExists(fname, IOOptions(), dbg); + if (!status.ok()) { + return status; + } + + auto f = new FlinkReadableFile(file_system_instance_, class_cache_, + ConstructPath(fname)); + IOStatus valid = f->Init(); + if (!valid.ok()) { + delete f; + return valid; + } + result->reset(f); + return IOStatus::OK(); +} + +// open a file for random reading +IOStatus FlinkFileSystem::NewRandomAccessFile( + const std::string& fname, const FileOptions& options, + std::unique_ptr* result, IODebugContext* dbg) { + result->reset(); + IOStatus status = FileExists(fname, IOOptions(), dbg); + if (!status.ok()) { + return status; + } + + auto f = new FlinkReadableFile(file_system_instance_, class_cache_, + ConstructPath(fname)); + IOStatus valid = f->Init(); + if (!valid.ok()) { + delete f; + return valid; + } + result->reset(f); + return IOStatus::OK(); +} + +// create a new file for writing +IOStatus FlinkFileSystem::NewWritableFile( + const std::string& fname, const FileOptions& options, + std::unique_ptr* result, IODebugContext* /*dbg*/) { + result->reset(); + auto f = new FlinkWritableFile(file_system_instance_, class_cache_, + ConstructPath(fname), options); + IOStatus valid = f->Init(); + if (!valid.ok()) { + delete f; + return valid; + } + result->reset(f); + return IOStatus::OK(); +} + +IOStatus FlinkFileSystem::NewDirectory(const std::string& name, + const IOOptions& options, + std::unique_ptr* result, + IODebugContext* dbg) { + result->reset(); + IOStatus s = FileExists(name, options, dbg); + if (s.ok()) { + result->reset(new FlinkDirectory()); + } + return s; +} + +IOStatus FlinkFileSystem::FileExists(const std::string& file_name, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) { + std::string filePath = ConstructPath(file_name); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(filePath, &pathInstance); + if (!status.ok()) { + return status; + } + + // Call exist method + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaMethodContext existsMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_EXISTS); + jboolean exists = jniEnv->CallBooleanMethod( + file_system_instance_, existsMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + + status = CurrentStatus([filePath]() { + return std::string("Exception when FileExists, path: ").append(filePath); + }); + if (!status.ok()) { + return status; + } + + return exists == JNI_TRUE ? IOStatus::OK() : IOStatus::NotFound(); +} + +// TODO: Not Efficient! Consider adding usable methods in FLink FileSystem +IOStatus FlinkFileSystem::GetChildren(const std::string& file_name, + const IOOptions& options, + std::vector* result, + IODebugContext* dbg) { + IOStatus fileExistsStatus = FileExists(file_name, options, dbg); + if (!fileExistsStatus.ok()) { + return fileExistsStatus.IsNotFound() + ? IOStatus::PathNotFound( + std::string("Could not find path when GetChildren, path: ") + .append(ConstructPath(file_name))) + : fileExistsStatus; + } + + std::string filePath = ConstructPath(file_name); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(filePath, &pathInstance); + if (!status.ok()) { + return status; + } + + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaMethodContext listStatusMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FILE_SYSTEM_LIST_STATUS); + + auto fileStatusArray = (jobjectArray)jniEnv->CallObjectMethod( + file_system_instance_, listStatusMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + if (fileStatusArray == nullptr) { + return CheckThenError( + std::string("Exception when CallObjectMethod in GetChildren, ") + .append(listStatusMethod.ToString()) + .append(", args: Path(") + .append(filePath) + .append(")")); + } + + jsize fileStatusArrayLen = jniEnv->GetArrayLength(fileStatusArray); + for (jsize i = 0; i < fileStatusArrayLen; i++) { + jobject fileStatusObj = jniEnv->GetObjectArrayElement(fileStatusArray, i); + if (fileStatusObj == nullptr) { + jniEnv->DeleteLocalRef(fileStatusArray); + return CheckThenError( + "Exception when GetObjectArrayElement in GetChildren"); + } + + JavaClassCache::JavaMethodContext getPathMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_STATUS_GET_PATH); + jobject subPath = + jniEnv->CallObjectMethod(fileStatusObj, getPathMethod.javaMethod); + jniEnv->DeleteLocalRef(fileStatusObj); + if (subPath == nullptr) { + jniEnv->DeleteLocalRef(fileStatusArray); + return CheckThenError( + std::string("Exception when CallObjectMethod in GetChildren, ") + .append(getPathMethod.ToString())); + } + + JavaClassCache::JavaMethodContext pathToStringMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_PATH_TO_STRING); + auto subPathStr = (jstring)jniEnv->CallObjectMethod( + subPath, pathToStringMethod.javaMethod); + jniEnv->DeleteLocalRef(subPath); + const char* str = jniEnv->GetStringUTFChars(subPathStr, nullptr); + result->emplace_back(str); + jniEnv->ReleaseStringUTFChars(subPathStr, str); + jniEnv->DeleteLocalRef(subPathStr); + } + + jniEnv->DeleteLocalRef(fileStatusArray); + return IOStatus::OK(); +} + +IOStatus FlinkFileSystem::DeleteDir(const std::string& file_name, + const IOOptions& options, + IODebugContext* dbg) { + return Delete(file_name, options, dbg, true); +}; + +IOStatus FlinkFileSystem::DeleteFile(const std::string& file_name, + const IOOptions& options, + IODebugContext* dbg) { + return Delete(file_name, options, dbg, false); +} + +IOStatus FlinkFileSystem::Delete(const std::string& file_name, + const IOOptions& options, IODebugContext* dbg, + bool recursive) { + IOStatus fileExistsStatus = FileExists(file_name, options, dbg); + if (!fileExistsStatus.ok()) { + return fileExistsStatus.IsNotFound() + ? IOStatus::PathNotFound( + std::string("Could not find path when Delete, path: ") + .append(ConstructPath(file_name))) + : fileExistsStatus; + } + + std::string filePath = ConstructPath(file_name); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(filePath, &pathInstance); + if (!status.ok()) { + return status; + } + + // Call delete method + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaMethodContext deleteMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_DELETE); + jboolean deleted = jniEnv->CallBooleanMethod( + file_system_instance_, deleteMethod.javaMethod, pathInstance, recursive); + jniEnv->DeleteLocalRef(pathInstance); + + status = CurrentStatus([filePath]() { + return std::string("Exception when Delete, path: ").append(filePath); + }); + if (!status.ok()) { + return status; + } + + return deleted + ? IOStatus::OK() + : IOStatus::IOError(std::string("Exception when Delete, path: ") + .append(filePath)); +} + +IOStatus FlinkFileSystem::CreateDir(const std::string& file_name, + const IOOptions& options, + IODebugContext* dbg) { + IOStatus s = FileExists(file_name, options, dbg); + if (!s.ok()) { + return CreateDirIfMissing(file_name, options, dbg); + } + return IOStatus::IOError(std::string("Exception when CreateDir because Dir (") + .append(file_name) + .append(") exists")); +} + +IOStatus FlinkFileSystem::CreateDirIfMissing(const std::string& file_name, + const IOOptions& options, + IODebugContext* dbg) { + JNIEnv* jniEnv = getJNIEnv(); + + std::string filePath = ConstructPath(file_name); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(filePath, &pathInstance); + if (!status.ok()) { + return status; + } + + // Call mkdirs method + JavaClassCache::JavaMethodContext mkdirMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_MKDIR); + jboolean created = jniEnv->CallBooleanMethod( + file_system_instance_, mkdirMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + status = CurrentStatus([filePath]() { + return std::string("Exception when CreateDirIfMissing, path: ") + .append(filePath); + }); + if (!status.ok()) { + return status; + } + + return created ? IOStatus::OK() + : IOStatus::IOError( + std::string("Exception when CreateDirIfMissing, path: ") + .append(filePath)); +} + +IOStatus FlinkFileSystem::GetFileSize(const std::string& file_name, + const IOOptions& options, uint64_t* size, + IODebugContext* dbg) { + JNIEnv* jniEnv = getJNIEnv(); + jobject fileStatus; + IOStatus status = GetFileStatus(file_name, options, dbg, &fileStatus); + if (!status.ok()) { + return status; + } + + JavaClassCache::JavaMethodContext getLenMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_STATUS_GET_LEN); + jlong fileSize = jniEnv->CallLongMethod(fileStatus, getLenMethod.javaMethod); + jniEnv->DeleteLocalRef(fileStatus); + + status = CurrentStatus([file_name]() { + return std::string("Exception when GetFileSize, file name: ") + .append(file_name); + }); + if (!status.ok()) { + return status; + } + + *size = fileSize; + return IOStatus::OK(); +} + +// The life cycle of fileStatus is maintained by caller. +IOStatus FlinkFileSystem::GetFileStatus(const std::string& file_name, + const IOOptions& options, + IODebugContext* dbg, + jobject* fileStatus) { + IOStatus status = FileExists(file_name, options, dbg); + if (!status.ok()) { + return status.IsNotFound() + ? IOStatus::PathNotFound( + std::string( + "Could not find path when GetFileStatus, path: ") + .append(ConstructPath(file_name))) + : status; + } + + std::string filePath = ConstructPath(file_name); + // Construct Path Instance + jobject pathInstance; + status = class_cache_->ConstructPathInstance(filePath, &pathInstance); + if (!status.ok()) { + return status; + } + + // Call getFileStatus method + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaMethodContext getFileStatusMethod = + class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FILE_SYSTEM_GET_FILE_STATUS); + *fileStatus = jniEnv->CallObjectMethod( + file_system_instance_, getFileStatusMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + + return CurrentStatus([filePath]() { + return std::string("Exception when GetFileStatus, path: ").append(filePath); + }); +} + +IOStatus FlinkFileSystem::GetFileModificationTime(const std::string& file_name, + const IOOptions& options, + uint64_t* time, + IODebugContext* dbg) { + JNIEnv* jniEnv = getJNIEnv(); + jobject fileStatus; + IOStatus status = GetFileStatus(file_name, options, dbg, &fileStatus); + if (!status.ok()) { + return status; + } + + JavaClassCache::JavaMethodContext getModificationTimeMethod = + class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FILE_STATUS_GET_MODIFICATION_TIME); + jlong fileModificationTime = + jniEnv->CallLongMethod(fileStatus, getModificationTimeMethod.javaMethod); + jniEnv->DeleteLocalRef(fileStatus); + + status = CurrentStatus([file_name]() { + return std::string("Exception when GetFileModificationTime, file name: ") + .append(file_name); + }); + if (!status.ok()) { + return status; + } + + *time = fileModificationTime; + return IOStatus::OK(); +} + +IOStatus FlinkFileSystem::IsDirectory(const std::string& path, + const IOOptions& options, bool* is_dir, + IODebugContext* dbg) { + JNIEnv* jniEnv = getJNIEnv(); + jobject fileStatus; + IOStatus status = GetFileStatus(path, options, dbg, &fileStatus); + if (!status.ok()) { + return status; + } + + JavaClassCache::JavaMethodContext isDirMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_STATUS_IS_DIR); + jboolean isDir = + jniEnv->CallBooleanMethod(fileStatus, isDirMethod.javaMethod); + jniEnv->DeleteLocalRef(fileStatus); + + status = CurrentStatus([path]() { + return std::string("Exception when IsDirectory, file name: ").append(path); + }); + if (!status.ok()) { + return status; + } + + *is_dir = isDir; + return IOStatus::OK(); +} + +IOStatus FlinkFileSystem::RenameFile(const std::string& src, + const std::string& target, + const IOOptions& options, + IODebugContext* dbg) { + IOStatus status = FileExists(src, options, dbg); + if (!status.ok()) { + return status.IsNotFound() + ? IOStatus::PathNotFound( + std::string( + "Could not find src path when RenameFile, path: ") + .append(ConstructPath(src))) + : status; + } + + JNIEnv* jniEnv = getJNIEnv(); + + std::string srcFilePath = ConstructPath(src); + // Construct src Path Instance + jobject srcPathInstance; + status = class_cache_->ConstructPathInstance(srcFilePath, &srcPathInstance); + if (!status.ok()) { + return status; + } + + std::string targetFilePath = ConstructPath(target); + // Construct target Path Instance + jobject targetPathInstance; + status = + class_cache_->ConstructPathInstance(targetFilePath, &targetPathInstance); + if (!status.ok()) { + jniEnv->DeleteLocalRef(srcPathInstance); + return status; + } + + JavaClassCache::JavaMethodContext renameMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FILE_SYSTEM_RENAME_FILE); + jboolean renamed = + jniEnv->CallBooleanMethod(file_system_instance_, renameMethod.javaMethod, + srcPathInstance, targetPathInstance); + jniEnv->DeleteLocalRef(srcPathInstance); + jniEnv->DeleteLocalRef(targetPathInstance); + + status = CurrentStatus([srcFilePath, targetFilePath]() { + return std::string("Exception when RenameFile, src: ") + .append(srcFilePath) + .append(", target: ") + .append(targetFilePath); + }); + if (!status.ok()) { + return status; + } + + return renamed + ? IOStatus::OK() + : IOStatus::IOError(std::string("Exception when RenameFile, src: ") + .append(srcFilePath) + .append(", target: ") + .append(targetFilePath)); +} + +IOStatus FlinkFileSystem::LockFile(const std::string& /*file_name*/, + const IOOptions& /*options*/, + FileLock** lock, IODebugContext* /*dbg*/) { + // There isn't a very good way to atomically check and create a file, + // Since it will not influence the usage of Flink, just leave it OK() now; + *lock = nullptr; + return IOStatus::OK(); +} + +IOStatus FlinkFileSystem::UnlockFile(FileLock* /*lock*/, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) { + // There isn't a very good way to atomically check and create a file, + // Since it will not influence the usage of Flink, just leave it OK() now; + return IOStatus::OK(); +} + +Status FlinkFileSystem::Create(const std::shared_ptr& base, + const std::string& uri, + std::unique_ptr* result) { + auto* fileSystem = new FlinkFileSystem(base, uri); + Status status = fileSystem->Init(); + result->reset(fileSystem); + return status; +} +} // namespace ROCKSDB_NAMESPACE diff --git a/env/flink/env_flink.h b/env/flink/env_flink.h index d1912a3de..a4d1892b4 100644 --- a/env/flink/env_flink.h +++ b/env/flink/env_flink.h @@ -5,6 +5,7 @@ #pragma once +#include "jni_helper.h" #include "rocksdb/env.h" #include "rocksdb/file_system.h" #include "rocksdb/status.h" @@ -28,16 +29,9 @@ class FlinkFileSystem : public FileSystemWrapper { static const char* kNickName() { return "flink"; } const char* NickName() const override { return kNickName(); } - // Constructor and Destructor - explicit FlinkFileSystem(const std::shared_ptr& base, - const std::string& fsname); ~FlinkFileSystem() override; // Several methods current FileSystem must implement - - std::string GetId() const override; - Status ValidateOptions(const DBOptions& /*db_opts*/, - const ColumnFamilyOptions& /*cf_opts*/) const override; IOStatus NewSequentialFile(const std::string& /*fname*/, const FileOptions& /*options*/, std::unique_ptr* /*result*/, @@ -54,14 +48,14 @@ class FlinkFileSystem : public FileSystemWrapper { const IOOptions& /*options*/, std::unique_ptr* /*result*/, IODebugContext* /*dbg*/) override; - IOStatus FileExists(const std::string& /*fname*/, + IOStatus FileExists(const std::string& /*file_name*/, const IOOptions& /*options*/, IODebugContext* /*dbg*/) override; - IOStatus GetChildren(const std::string& /*path*/, + IOStatus GetChildren(const std::string& /*file_name*/, const IOOptions& /*options*/, std::vector* /*result*/, IODebugContext* /*dbg*/) override; - IOStatus DeleteFile(const std::string& /*fname*/, + IOStatus DeleteFile(const std::string& /*file_name*/, const IOOptions& /*options*/, IODebugContext* /*dbg*/) override; IOStatus CreateDir(const std::string& /*name*/, const IOOptions& /*options*/, @@ -69,9 +63,10 @@ class FlinkFileSystem : public FileSystemWrapper { IOStatus CreateDirIfMissing(const std::string& /*name*/, const IOOptions& /*options*/, IODebugContext* /*dbg*/) override; - IOStatus DeleteDir(const std::string& /*name*/, const IOOptions& /*options*/, + IOStatus DeleteDir(const std::string& /*file_name*/, + const IOOptions& /*options*/, IODebugContext* /*dbg*/) override; - IOStatus GetFileSize(const std::string& /*fname*/, + IOStatus GetFileSize(const std::string& /*file_name*/, const IOOptions& /*options*/, uint64_t* /*size*/, IODebugContext* /*dbg*/) override; IOStatus GetFileModificationTime(const std::string& /*fname*/, @@ -90,7 +85,23 @@ class FlinkFileSystem : public FileSystemWrapper { IODebugContext* /*dbg*/) override; private: - std::string base_path_; + const std::string base_path_; + JavaClassCache* class_cache_; + jobject file_system_instance_; + + explicit FlinkFileSystem(const std::shared_ptr& base, + const std::string& fsname); + + // Init FileSystem + Status Init(); + + IOStatus Delete(const std::string& /*file_name*/, + const IOOptions& /*options*/, IODebugContext* /*dbg*/, + bool /*recursive*/); + IOStatus GetFileStatus(const std::string& /*file_name*/, + const IOOptions& /*options*/, IODebugContext* /*dbg*/, + jobject* /*fileStatus*/); + std::string ConstructPath(const std::string& /*file_name*/); }; // Returns a `FlinkEnv` with base_path diff --git a/env/flink/jni_helper.cc b/env/flink/jni_helper.cc index 8d1ac5acf..6d18219cb 100644 --- a/env/flink/jni_helper.cc +++ b/env/flink/jni_helper.cc @@ -5,72 +5,325 @@ #include "jni_helper.h" +#include "jvm_util.h" + namespace ROCKSDB_NAMESPACE { -JavaClassCache::JavaClassCache(JNIEnv *env) : jni_env_(env) { +JavaClassCache::JavaClassCache(JNIEnv* env) : jni_env_(env) {} + +JavaClassCache::~JavaClassCache() { + // Release all global ref of cached jclasses + for (const auto& item : cached_java_classes_) { + if (item.javaClass) { + jni_env_->DeleteGlobalRef(item.javaClass); + } + } +} + +IOStatus JavaClassCache::Create(JNIEnv* env, + std::unique_ptr* result) { + auto classCache = new JavaClassCache(env); + IOStatus status = classCache->Init(); + if (!status.ok()) { + delete classCache; + result->reset(); + return status; + } + result->reset(classCache); + return status; +} + +IOStatus JavaClassCache::Init() { // Set all class names - cached_java_classes_[JavaClassCache::JC_URI].className = "java/net/URI"; - cached_java_classes_[JavaClassCache::JC_BYTE_BUFFER].className = + cached_java_classes_[CachedJavaClass::JC_URI].className = "java/net/URI"; + cached_java_classes_[CachedJavaClass::JC_BYTE_BUFFER].className = "java/nio/ByteBuffer"; - cached_java_classes_[JavaClassCache::JC_THROWABLE].className = + cached_java_classes_[CachedJavaClass::JC_THROWABLE].className = "java/lang/Throwable"; - cached_java_classes_[JavaClassCache::JC_FLINK_PATH].className = + cached_java_classes_[CachedJavaClass::JC_FLINK_PATH].className = "org/apache/flink/core/fs/Path"; - cached_java_classes_[JavaClassCache::JC_FLINK_FILE_SYSTEM].className = + cached_java_classes_[CachedJavaClass::JC_FLINK_FILE_SYSTEM].className = "org/apache/flink/state/forst/fs/ForStFlinkFileSystem"; - cached_java_classes_[JavaClassCache::JC_FLINK_FILE_STATUS].className = + cached_java_classes_[CachedJavaClass::JC_FLINK_FILE_STATUS].className = "org/apache/flink/core/fs/FileStatus"; - cached_java_classes_[JavaClassCache::JC_FLINK_FS_INPUT_STREAM].className = + cached_java_classes_[CachedJavaClass::JC_FLINK_FS_INPUT_STREAM].className = "org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream"; - cached_java_classes_[JavaClassCache::JC_FLINK_FS_OUTPUT_STREAM].className = + cached_java_classes_[CachedJavaClass::JC_FLINK_FS_OUTPUT_STREAM].className = "org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream"; - // Try best to create and set the jclass objects based on the class names set - // above + // Create and set the jclass objects based on the class names set above int numCachedClasses = - sizeof(cached_java_classes_) / sizeof(javaClassAndName); + sizeof(cached_java_classes_) / sizeof(JavaClassContext); for (int i = 0; i < numCachedClasses; i++) { - initCachedClass(cached_java_classes_[i].className, - &cached_java_classes_[i].javaClass); + IOStatus status = initCachedClass(cached_java_classes_[i].className, + &cached_java_classes_[i].javaClass); + if (!status.ok()) { + return status; + } } -} -JavaClassCache::~JavaClassCache() { - // Release all global ref of cached jclasses - for (const auto &item : cached_java_classes_) { - if (item.javaClass) { - jni_env_->DeleteGlobalRef(item.javaClass); + // Set all method names, signatures and class infos + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_CONSTRUCTOR] + .javaClassAndName = cached_java_classes_[JC_FLINK_PATH]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_CONSTRUCTOR].methodName = + ""; + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_CONSTRUCTOR].signature = + "(Lorg/apache/flink/core/fs/Path;)Z"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_TO_STRING] + .javaClassAndName = cached_java_classes_[JC_FLINK_PATH]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_TO_STRING].methodName = + "toString"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_TO_STRING].signature = + "()Ljava/lang/String;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_URI_CONSTRUCTOR] + .javaClassAndName = cached_java_classes_[JC_URI]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_URI_CONSTRUCTOR].methodName = + ""; + cached_java_methods_[CachedJavaMethod::JM_FLINK_URI_CONSTRUCTOR].signature = + "(Ljava/lang/String;)V"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET].methodName = + "get"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET].signature = + "(Ljava/net/URI;)Lorg/apache/flink/core/fs/FileSystem;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_EXISTS] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_EXISTS] + .methodName = "exists"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_EXISTS] + .signature = "(Lorg/apache/flink/core/fs/Path;)Z"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_LIST_STATUS] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_LIST_STATUS] + .methodName = "listStatus"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_LIST_STATUS] + .signature = + "(Lorg/apache/flink/core/fs/Path;)[Lorg/apache/flink/core/fs/FileStatus;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET_FILE_STATUS] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET_FILE_STATUS] + .methodName = "getFileStatus"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET_FILE_STATUS] + .signature = + "(Lorg/apache/flink/core/fs/Path;)Lorg/apache/flink/core/fs/FileStatus;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_DELETE] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_DELETE] + .methodName = "delete"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_DELETE] + .signature = "(Lorg/apache/flink/core/fs/Path;Z)Z"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_MKDIR] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_MKDIR] + .methodName = "mkdirs"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_MKDIR].signature = + "(Lorg/apache/flink/core/fs/Path;)Z"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_RENAME_FILE] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_RENAME_FILE] + .methodName = "rename"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_RENAME_FILE] + .signature = + "(Lorg/apache/flink/core/fs/Path;Lorg/apache/flink/core/fs/Path;)Z"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_OPEN] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_OPEN].methodName = + "open"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_OPEN].signature = + "(Lorg/apache/flink/core/fs/Path;)Lorg/apache/flink/state/forst/fs/" + "ByteBufferReadableFSDataInputStream;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SEQ_READ] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_INPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SEQ_READ] + .methodName = "readFully"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SEQ_READ] + .signature = "(Ljava/nio/ByteBuffer;)I"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_RANDOM_READ] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_INPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_RANDOM_READ] + .methodName = "readFully"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_RANDOM_READ] + .signature = "(JLjava/nio/ByteBuffer;)I"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SKIP] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_INPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SKIP] + .methodName = "skip"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SKIP] + .signature = "(J)J"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_WRITE] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_OUTPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_WRITE] + .methodName = "write"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_WRITE] + .signature = "(Ljava/nio/ByteBuffer;)V"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_FLUSH] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_OUTPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_FLUSH] + .methodName = "flush"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_FLUSH] + .signature = "()V"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_SYNC] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_OUTPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_SYNC] + .methodName = "sync"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_SYNC] + .signature = "()V"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_CLOSE] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_OUTPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_CLOSE] + .methodName = "close"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_CLOSE] + .signature = "()V"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_CREATE] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_CREATE] + .methodName = "create"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_CREATE] + .signature = + "(Lorg/apache/flink/core/fs/Path;)Lorg/apache/flink/state/forst/fs/" + "ByteBufferWritableFSDataOutputStream;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_PATH] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_STATUS]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_PATH] + .methodName = "getPath"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_PATH] + .signature = "()Lorg/apache/flink/core/fs/Path;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_LEN] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_STATUS]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_LEN] + .methodName = "getLen"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_LEN] + .signature = "()J"; + + cached_java_methods_ + [CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_MODIFICATION_TIME] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_STATUS]; + cached_java_methods_ + [CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_MODIFICATION_TIME] + .methodName = "getModificationTime"; + cached_java_methods_ + [CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_MODIFICATION_TIME] + .signature = "()J"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_IS_DIR] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_STATUS]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_IS_DIR] + .methodName = "isDir"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_IS_DIR] + .signature = "()Z"; + + // Create and set the jmethod based on the method names and signatures set + // above + int numCachedMethods = + sizeof(cached_java_methods_) / sizeof(JavaMethodContext); + for (int i = 0; i < numCachedMethods; i++) { + cached_java_methods_[i].javaMethod = jni_env_->GetMethodID( + cached_java_methods_[i].javaClassAndName.javaClass, + cached_java_methods_[i].methodName, cached_java_methods_[i].signature); + + if (!cached_java_methods_[i].javaMethod) { + return IOStatus::IOError(std::string("Exception when GetMethodID, ") + .append(cached_java_methods_[i].ToString())); } } + return IOStatus::OK(); } -Status JavaClassCache::initCachedClass(const char *className, - jclass *cachedJclass) { +IOStatus JavaClassCache::initCachedClass(const char* className, + jclass* cachedJclass) { jclass tempLocalClassRef = jni_env_->FindClass(className); if (!tempLocalClassRef) { - return Status::IOError("Exception when FindClass, class name: " + - std::string(className)); + return IOStatus::IOError("Exception when FindClass, class name: " + + std::string(className)); } *cachedJclass = (jclass)jni_env_->NewGlobalRef(tempLocalClassRef); if (!*cachedJclass) { - return Status::IOError("Exception when NewGlobalRef, class name " + - std::string(className)); + return IOStatus::IOError("Exception when NewGlobalRef, class name " + + std::string(className)); } jni_env_->DeleteLocalRef(tempLocalClassRef); - return Status::OK(); + return IOStatus::OK(); +} + +JavaClassCache::JavaClassContext JavaClassCache::GetJClass( + CachedJavaClass cachedJavaClass) { + return cached_java_classes_[cachedJavaClass]; +} + +JavaClassCache::JavaMethodContext JavaClassCache::GetJMethod( + CachedJavaMethod cachedJavaMethod) { + return cached_java_methods_[cachedJavaMethod]; } -Status JavaClassCache::GetJClass(CachedJavaClass cachedJavaClass, - jclass *javaClass) { - jclass targetClass = cached_java_classes_[cachedJavaClass].javaClass; - Status status = Status::OK(); - if (!targetClass) { - status = initCachedClass(cached_java_classes_[cachedJavaClass].className, - &targetClass); +IOStatus JavaClassCache::ConstructPathInstance(const std::string& file_path, + jobject* pathInstance) { + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaClassContext pathClass = + GetJClass(JavaClassCache::JC_FLINK_PATH); + JavaClassCache::JavaMethodContext pathConstructor = + GetJMethod(JavaClassCache::JM_FLINK_PATH_CONSTRUCTOR); + jstring pathString = jniEnv->NewStringUTF(file_path.c_str()); + jobject tempPathInstance = jniEnv->NewObject( + pathClass.javaClass, pathConstructor.javaMethod, pathString); + jniEnv->DeleteLocalRef(pathString); + if (tempPathInstance == nullptr) { + return CheckThenError(std::string("Exception when ConstructPathInstance, ") + .append(pathClass.ToString()) + .append(pathConstructor.ToString()) + .append(", args: Path(") + .append(file_path) + .append(")")); } - *javaClass = targetClass; - return status; + *pathInstance = tempPathInstance; + return IOStatus::OK(); +} + +IOStatus CurrentStatus( + const std::function& exceptionMessageIfError) { + JNIEnv* jniEnv = getJNIEnv(); + if (jniEnv->ExceptionCheck()) { + // Throw Exception to Java side, stop any call from Java. + jthrowable throwable = jniEnv->ExceptionOccurred(); + jniEnv->ExceptionDescribe(); + jniEnv->ExceptionClear(); + jniEnv->Throw(throwable); + return IOStatus::IOError(exceptionMessageIfError()); + } + return IOStatus::OK(); +} + +IOStatus CheckThenError(const std::string& exceptionMessageIfError) { + JNIEnv* jniEnv = getJNIEnv(); + if (jniEnv->ExceptionCheck()) { + // Throw Exception to Java side, stop any call from Java. + jthrowable throwable = jniEnv->ExceptionOccurred(); + jniEnv->ExceptionDescribe(); + jniEnv->ExceptionClear(); + jniEnv->Throw(throwable); + } + return IOStatus::IOError(exceptionMessageIfError); } } // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/jni_helper.h b/env/flink/jni_helper.h index 39d9e9f9a..fefaea8fb 100644 --- a/env/flink/jni_helper.h +++ b/env/flink/jni_helper.h @@ -3,8 +3,11 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). +#include +#include + #include "jni.h" -#include "rocksdb/status.h" +#include "rocksdb/io_status.h" namespace ROCKSDB_NAMESPACE { @@ -24,22 +27,98 @@ class JavaClassCache { NUM_CACHED_CLASSES } CachedJavaClass; - // Constructor and Destructor - explicit JavaClassCache(JNIEnv* env); - ~JavaClassCache(); - - // Get jclass by specific CachedJavaClass - Status GetJClass(CachedJavaClass cachedJavaClass, jclass* javaClass); + // Frequently-used method type representing jmethods which will be cached. + typedef enum { + JM_FLINK_PATH_CONSTRUCTOR, + JM_FLINK_PATH_TO_STRING, + JM_FLINK_URI_CONSTRUCTOR, + JM_FLINK_FILE_SYSTEM_GET, + JM_FLINK_FILE_SYSTEM_EXISTS, + JM_FLINK_FILE_SYSTEM_LIST_STATUS, + JM_FLINK_FILE_SYSTEM_GET_FILE_STATUS, + JM_FLINK_FILE_SYSTEM_DELETE, + JM_FLINK_FILE_SYSTEM_MKDIR, + JM_FLINK_FILE_SYSTEM_RENAME_FILE, + JM_FLINK_FILE_SYSTEM_OPEN, + JM_FLINK_FS_INPUT_STREAM_SEQ_READ, + JM_FLINK_FS_INPUT_STREAM_RANDOM_READ, + JM_FLINK_FS_INPUT_STREAM_SKIP, + JM_FLINK_FS_OUTPUT_STREAM_WRITE, + JM_FLINK_FS_OUTPUT_STREAM_FLUSH, + JM_FLINK_FS_OUTPUT_STREAM_SYNC, + JM_FLINK_FS_OUTPUT_STREAM_CLOSE, + JM_FLINK_FILE_SYSTEM_CREATE, + JM_FLINK_FILE_STATUS_GET_PATH, + JM_FLINK_FILE_STATUS_GET_LEN, + JM_FLINK_FILE_STATUS_GET_MODIFICATION_TIME, + JM_FLINK_FILE_STATUS_IS_DIR, + NUM_CACHED_METHODS + } CachedJavaMethod; - private: - typedef struct { + // jclass with its context description + struct JavaClassContext { jclass javaClass; const char* className; - } javaClassAndName; + std::string ToString() const { + return std::string("className: ").append(className); + } + }; + + // jmethod with its context description + struct JavaMethodContext { + JavaClassContext javaClassAndName; + jmethodID javaMethod; + const char* methodName; + const char* signature; + + std::string ToString() const { + return javaClassAndName.ToString() + .append(", methodName: ") + .append(methodName) + .append(", signature: ") + .append(signature); + } + }; + + ~JavaClassCache(); + + // Create a unique instance which inits necessary cached classes and methods. + // Return Status representing whether these classes and methods are inited + // correctly or not. + static IOStatus Create(JNIEnv* env, + std::unique_ptr* javaClassCache); + + // Get JavaClassContext by specific CachedJavaClass. + JavaClassContext GetJClass(CachedJavaClass cachedJavaClass); + + // Get JavaMethodContext by specific CachedJavaMethod. + JavaMethodContext GetJMethod(CachedJavaMethod cachedJavaMethod); + + // Construct Java Path Instance based on cached classes and method related to + // Path. + IOStatus ConstructPathInstance(const std::string& /*file_path*/, + jobject* /*pathInstance*/); + + private: JNIEnv* jni_env_; - javaClassAndName cached_java_classes_[JavaClassCache::NUM_CACHED_CLASSES]; + JavaClassContext cached_java_classes_[CachedJavaClass::NUM_CACHED_CLASSES]; + JavaMethodContext cached_java_methods_[CachedJavaMethod::NUM_CACHED_METHODS]; - Status initCachedClass(const char* className, jclass* cachedClass); + explicit JavaClassCache(JNIEnv* env); + + // Init all classes and methods. + IOStatus Init(); + + // Init cached class. + IOStatus initCachedClass(const char* className, jclass* cachedClass); }; + +// Return current status of JNIEnv. +IOStatus CurrentStatus( + const std::function& /*exceptionMessageIfError*/); + +// Wrap error status of JNIEnv. +IOStatus CheckThenError(const std::string& /*exceptionMessageIfError*/); + } // namespace ROCKSDB_NAMESPACE \ No newline at end of file From a5c920d35dcf7a5a9a09bdd00b06cffdbff8a919 Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Mon, 18 Mar 2024 16:40:03 +0800 Subject: [PATCH 26/61] [env] Modify the license (#13) --- env/flink/env_flink.cc | 21 +++++++++++++++++---- env/flink/env_flink.h | 21 +++++++++++++++++---- env/flink/jni_helper.cc | 21 +++++++++++++++++---- env/flink/jni_helper.h | 21 +++++++++++++++++---- 4 files changed, 68 insertions(+), 16 deletions(-) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index 8987084d0..290aa215b 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -1,7 +1,20 @@ -// Copyright (c) 2021-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). +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ #include "env_flink.h" diff --git a/env/flink/env_flink.h b/env/flink/env_flink.h index a4d1892b4..2b937b050 100644 --- a/env/flink/env_flink.h +++ b/env/flink/env_flink.h @@ -1,7 +1,20 @@ -// Copyright (c) 2021-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). +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ #pragma once diff --git a/env/flink/jni_helper.cc b/env/flink/jni_helper.cc index 6d18219cb..de82978e3 100644 --- a/env/flink/jni_helper.cc +++ b/env/flink/jni_helper.cc @@ -1,7 +1,20 @@ -// Copyright (c) 2019-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). +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ #include "jni_helper.h" diff --git a/env/flink/jni_helper.h b/env/flink/jni_helper.h index fefaea8fb..1927a2c07 100644 --- a/env/flink/jni_helper.h +++ b/env/flink/jni_helper.h @@ -1,7 +1,20 @@ -// Copyright (c) 2019-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). +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ #include #include From ec88681c32e5f9d80b0bf331070bd05d740d685c Mon Sep 17 00:00:00 2001 From: Jinzhong Li Date: Thu, 21 Mar 2024 16:35:09 +0800 Subject: [PATCH 27/61] [env] Support JNI of FlinkEnv (#12) * [env] Support JNI of FlinkEnv --- env/flink/env_flink.cc | 21 +++++++ java/CMakeLists.txt | 3 + java/rocksjni/env_flink.cc | 63 ++++++++++++++++++++ java/src/main/java/org/rocksdb/FlinkEnv.java | 41 +++++++++++++ src.mk | 1 + 5 files changed, 129 insertions(+) create mode 100644 java/rocksjni/env_flink.cc create mode 100644 java/src/main/java/org/rocksdb/FlinkEnv.java diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index 290aa215b..9ff8f5b6d 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -855,4 +855,25 @@ Status FlinkFileSystem::Create(const std::shared_ptr& base, result->reset(fileSystem); return status; } + +Status NewFlinkEnv(const std::string& uri, + std::unique_ptr* flinkFileSystem) { + std::shared_ptr fs; + Status s = NewFlinkFileSystem(uri, &fs); + if (s.ok()) { + *flinkFileSystem = NewCompositeEnv(fs); + } + return s; +} + +Status NewFlinkFileSystem(const std::string& uri, + std::shared_ptr* fs) { + std::unique_ptr flinkFileSystem; + Status s = + FlinkFileSystem::Create(FileSystem::Default(), uri, &flinkFileSystem); + if (s.ok()) { + fs->reset(flinkFileSystem.release()); + } + return s; +} } // namespace ROCKSDB_NAMESPACE diff --git a/java/CMakeLists.txt b/java/CMakeLists.txt index 9c4e9d308..759f9967a 100644 --- a/java/CMakeLists.txt +++ b/java/CMakeLists.txt @@ -30,6 +30,7 @@ set(JNI_NATIVE_SOURCES rocksjni/concurrent_task_limiter.cc rocksjni/config_options.cc rocksjni/env.cc + rocksjni/env_flink.cc rocksjni/env_options.cc rocksjni/event_listener.cc rocksjni/event_listener_jnicallback.cc @@ -157,6 +158,7 @@ set(JAVA_MAIN_CLASSES src/main/java/org/rocksdb/Filter.java src/main/java/org/rocksdb/FileOperationInfo.java src/main/java/org/rocksdb/FlinkCompactionFilter.java + src/main/java/org/rocksdb/FlinkEnv.java src/main/java/org/rocksdb/FlushJobInfo.java src/main/java/org/rocksdb/FlushReason.java src/main/java/org/rocksdb/FlushOptions.java @@ -459,6 +461,7 @@ if(${CMAKE_VERSION} VERSION_LESS "3.11.4") org.rocksdb.EnvOptions org.rocksdb.Filter org.rocksdb.FlinkCompactionFilter + org.rocksdb.FlinkEnv org.rocksdb.FlushOptions org.rocksdb.HashLinkedListMemTableConfig org.rocksdb.HashSkipListMemTableConfig diff --git a/java/rocksjni/env_flink.cc b/java/rocksjni/env_flink.cc new file mode 100644 index 000000000..f6d4b44ca --- /dev/null +++ b/java/rocksjni/env_flink.cc @@ -0,0 +1,63 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "env/flink/env_flink.h" + +#include + +#include + +#include "java/rocksjni/portal.h" +#include "rocksdb/env.h" + +/* + * Class: org_rocksdb_FlinkEnv + * Method: createFlinkEnv + * Signature: (Ljava/lang/String;)J + */ +jlong Java_org_rocksdb_FlinkEnv_createFlinkEnv(JNIEnv* env, jclass, + jstring base_path) { + jboolean has_exception = JNI_FALSE; + auto path = + ROCKSDB_NAMESPACE::JniUtil::copyStdString(env, base_path, &has_exception); + if (has_exception == JNI_TRUE) { + ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew( + env, "Could not copy jstring to std::string"); + return 0; + } + std::unique_ptr flink_env; + auto status = ROCKSDB_NAMESPACE::NewFlinkEnv(path, &flink_env); + if (!status.ok()) { + ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, status); + return 0; + } + auto ptr_as_handle = flink_env.release(); + return reinterpret_cast(ptr_as_handle); +} + +/* + * Class: org_rocksdb_FlinkEnv + * Method: disposeInternal + * Signature: (J)V + */ +void Java_org_rocksdb_FlinkEnv_disposeInternal(JNIEnv*, jobject, + jlong jhandle) { + auto* handle = reinterpret_cast(jhandle); + assert(handle != nullptr); + delete handle; +} diff --git a/java/src/main/java/org/rocksdb/FlinkEnv.java b/java/src/main/java/org/rocksdb/FlinkEnv.java new file mode 100644 index 000000000..91e6d46b6 --- /dev/null +++ b/java/src/main/java/org/rocksdb/FlinkEnv.java @@ -0,0 +1,41 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.rocksdb; + +/** + * Flink Env which proxy all filesystem access to Flink FileSystem. + */ +public class FlinkEnv extends Env { + /** +

Creates a new environment that is used for Flink environment.

+ * + *

The caller must delete the result when it is + * no longer needed.

+ * + * @param basePath the base path string for the given Flink file system, + * formatted as "{fs-schema-supported-by-flink}://xxx" + */ + public FlinkEnv(final String basePath) { + super(createFlinkEnv(basePath)); + } + + private static native long createFlinkEnv(final String basePath); + + @Override protected final native void disposeInternal(final long handle); +} \ No newline at end of file diff --git a/src.mk b/src.mk index 9629e7ec8..41f4c0076 100644 --- a/src.mk +++ b/src.mk @@ -663,6 +663,7 @@ JNI_NATIVE_SOURCES = \ java/rocksjni/config_options.cc \ java/rocksjni/export_import_files_metadatajni.cc \ java/rocksjni/env.cc \ + java/rocksjni/env_flink.cc \ java/rocksjni/env_options.cc \ java/rocksjni/event_listener.cc \ java/rocksjni/event_listener_jnicallback.cc \ From de9582bb42d8451ec36c15521507f6a9e1c951e8 Mon Sep 17 00:00:00 2001 From: Jinzhong Li Date: Fri, 29 Mar 2024 11:41:31 +0800 Subject: [PATCH 28/61] [env]Introduce flink-env test suite (#17) * [env]Introduce flink-env test suite --- CMakeLists.txt | 3 +- env/flink/env_flink.cc | 2 +- env/flink/env_flink.h | 8 + env/flink/env_flink_test_suite.cc | 66 +++ env/flink/env_flink_test_suite.h | 34 ++ env/flink/jni_helper.cc | 18 +- env/flink/jni_helper.h | 5 +- java/CMakeLists.txt | 3 + java/Makefile | 20 +- .../org/apache/flink/core/fs/FileStatus.java | 79 +++ .../org/apache/flink/core/fs/FileSystem.java | 257 ++++++++++ .../flink/core/fs/LocalDataInputStream.java | 83 ++++ .../flink/core/fs/LocalDataOutputStream.java | 92 ++++ .../apache/flink/core/fs/LocalFileStatus.java | 93 ++++ .../apache/flink/core/fs/LocalFileSystem.java | 296 +++++++++++ .../java/org/apache/flink/core/fs/Path.java | 469 ++++++++++++++++++ .../ByteBufferReadableFSDataInputStream.java | 133 +++++ .../ByteBufferWritableFSDataOutputStream.java | 83 ++++ .../state/forst/fs/ForStFlinkFileSystem.java | 126 +++++ java/rocksjni/env_flink_test_suite.cc | 73 +++ .../java/org/rocksdb/EnvFlinkTestSuite.java | 50 ++ .../java/org/rocksdb/flink/FlinkEnvTest.java | 45 ++ src.mk | 2 + 23 files changed, 2030 insertions(+), 10 deletions(-) create mode 100644 env/flink/env_flink_test_suite.cc create mode 100644 env/flink/env_flink_test_suite.h create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileStatus.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileSystem.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataInputStream.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataOutputStream.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileStatus.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileSystem.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/Path.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ForStFlinkFileSystem.java create mode 100644 java/rocksjni/env_flink_test_suite.cc create mode 100644 java/src/main/java/org/rocksdb/EnvFlinkTestSuite.java create mode 100644 java/src/test/java/org/rocksdb/flink/FlinkEnvTest.java diff --git a/CMakeLists.txt b/CMakeLists.txt index 9ad7a5cb0..e8866f2af 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1019,7 +1019,8 @@ else() env/io_posix.cc env/flink/env_flink.cc env/flink/jvm_util.cc - env/flink/jni_helper.cc) + env/flink/jni_helper.cc + env/flink/env_flink_test_suite.cc) endif() if(USE_FOLLY_LITE) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index 9ff8f5b6d..b963fe508 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -306,7 +306,7 @@ class FlinkDirectory : public FSDirectory { FlinkFileSystem::FlinkFileSystem(const std::shared_ptr& base_fs, const std::string& base_path) - : FileSystemWrapper(base_fs), base_path_(base_path) {} + : FileSystemWrapper(base_fs), base_path_(TrimTrailingSlash(base_path)) {} FlinkFileSystem::~FlinkFileSystem() { if (file_system_instance_ != nullptr) { diff --git a/env/flink/env_flink.h b/env/flink/env_flink.h index 2b937b050..04295815f 100644 --- a/env/flink/env_flink.h +++ b/env/flink/env_flink.h @@ -115,6 +115,14 @@ class FlinkFileSystem : public FileSystemWrapper { const IOOptions& /*options*/, IODebugContext* /*dbg*/, jobject* /*fileStatus*/); std::string ConstructPath(const std::string& /*file_name*/); + + static std::string TrimTrailingSlash(const std::string& base_path) { + if (!base_path.empty() && base_path.back() == '/') { + return base_path.substr(0, base_path.size() - 1); + } else { + return base_path; + } + } }; // Returns a `FlinkEnv` with base_path diff --git a/env/flink/env_flink_test_suite.cc b/env/flink/env_flink_test_suite.cc new file mode 100644 index 000000000..2b1a312ab --- /dev/null +++ b/env/flink/env_flink_test_suite.cc @@ -0,0 +1,66 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "env/flink/env_flink_test_suite.h" + +#include +#include + +#define ASSERT_TRUE(expression) \ + if (!(expression)) { \ + std::cerr << "Assertion failed: " << #expression << ", file " << __FILE__ \ + << ", line " << __LINE__ << "." << std::endl; \ + std::abort(); \ + } + +namespace ROCKSDB_NAMESPACE { + +EnvFlinkTestSuites::EnvFlinkTestSuites(const std::string& basePath) + : base_path_(basePath) {} + +void EnvFlinkTestSuites::runAllTestSuites() { + setUp(); + testFileExist(); +} + +void EnvFlinkTestSuites::setUp() { + auto status = ROCKSDB_NAMESPACE::NewFlinkEnv(base_path_, &flink_env_); + if (!status.ok()) { + throw std::runtime_error("New FlinkEnv failed"); + } +} + +void EnvFlinkTestSuites::testFileExist() { + std::string fileName("test-file"); + Status result = flink_env_->FileExists(fileName); + ASSERT_TRUE(result.IsNotFound()); + + // Generate a file manually + const std::string prefix = "file:"; + std::string writeFileName = base_path_ + fileName; + if (writeFileName.compare(0, prefix.size(), prefix) == 0) { + writeFileName = writeFileName.substr(prefix.size()); + } + std::ofstream writeFile(writeFileName); + writeFile << "testFileExist"; + writeFile.close(); + + result = flink_env_->FileExists(fileName); + ASSERT_TRUE(result.ok()); +} +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/env_flink_test_suite.h b/env/flink/env_flink_test_suite.h new file mode 100644 index 000000000..3826060d5 --- /dev/null +++ b/env/flink/env_flink_test_suite.h @@ -0,0 +1,34 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "env_flink.h" + +namespace ROCKSDB_NAMESPACE { + +class EnvFlinkTestSuites { + public: + EnvFlinkTestSuites(const std::string& basePath); + void runAllTestSuites(); + + private: + std::unique_ptr flink_env_; + const std::string base_path_; + void setUp(); + void testFileExist(); +}; +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/jni_helper.cc b/env/flink/jni_helper.cc index de82978e3..9be816c39 100644 --- a/env/flink/jni_helper.cc +++ b/env/flink/jni_helper.cc @@ -81,7 +81,7 @@ IOStatus JavaClassCache::Init() { cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_CONSTRUCTOR].methodName = ""; cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_CONSTRUCTOR].signature = - "(Lorg/apache/flink/core/fs/Path;)Z"; + "(Ljava/lang/String;)V"; cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_TO_STRING] .javaClassAndName = cached_java_classes_[JC_FLINK_PATH]; @@ -103,6 +103,8 @@ IOStatus JavaClassCache::Init() { "get"; cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET].signature = "(Ljava/net/URI;)Lorg/apache/flink/core/fs/FileSystem;"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET].isStatic = + true; cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_EXISTS] .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; @@ -251,9 +253,17 @@ IOStatus JavaClassCache::Init() { int numCachedMethods = sizeof(cached_java_methods_) / sizeof(JavaMethodContext); for (int i = 0; i < numCachedMethods; i++) { - cached_java_methods_[i].javaMethod = jni_env_->GetMethodID( - cached_java_methods_[i].javaClassAndName.javaClass, - cached_java_methods_[i].methodName, cached_java_methods_[i].signature); + if (cached_java_methods_[i].isStatic) { + cached_java_methods_[i].javaMethod = jni_env_->GetStaticMethodID( + cached_java_methods_[i].javaClassAndName.javaClass, + cached_java_methods_[i].methodName, + cached_java_methods_[i].signature); + } else { + cached_java_methods_[i].javaMethod = jni_env_->GetMethodID( + cached_java_methods_[i].javaClassAndName.javaClass, + cached_java_methods_[i].methodName, + cached_java_methods_[i].signature); + } if (!cached_java_methods_[i].javaMethod) { return IOStatus::IOError(std::string("Exception when GetMethodID, ") diff --git a/env/flink/jni_helper.h b/env/flink/jni_helper.h index 1927a2c07..54a6da85b 100644 --- a/env/flink/jni_helper.h +++ b/env/flink/jni_helper.h @@ -84,13 +84,16 @@ class JavaClassCache { jmethodID javaMethod; const char* methodName; const char* signature; + bool isStatic = false; std::string ToString() const { return javaClassAndName.ToString() .append(", methodName: ") .append(methodName) .append(", signature: ") - .append(signature); + .append(signature) + .append(", isStatic:") + .append(isStatic ? "true" : "false"); } }; diff --git a/java/CMakeLists.txt b/java/CMakeLists.txt index 759f9967a..076800414 100644 --- a/java/CMakeLists.txt +++ b/java/CMakeLists.txt @@ -31,6 +31,7 @@ set(JNI_NATIVE_SOURCES rocksjni/config_options.cc rocksjni/env.cc rocksjni/env_flink.cc + rocksjni/env_flink_test_suite.cc rocksjni/env_options.cc rocksjni/event_listener.cc rocksjni/event_listener_jnicallback.cc @@ -150,6 +151,7 @@ set(JAVA_MAIN_CLASSES src/main/java/org/rocksdb/DirectSlice.java src/main/java/org/rocksdb/EncodingType.java src/main/java/org/rocksdb/Env.java + src/main/java/org/rocksdb/EnvFlinkTestSuite.java src/main/java/org/rocksdb/EnvOptions.java src/main/java/org/rocksdb/EventListener.java src/main/java/org/rocksdb/Experimental.java @@ -458,6 +460,7 @@ if(${CMAKE_VERSION} VERSION_LESS "3.11.4") org.rocksdb.DBOptions org.rocksdb.DirectSlice org.rocksdb.Env + org.rocksdb.EnvFlinkTestSuite org.rocksdb.EnvOptions org.rocksdb.Filter org.rocksdb.FlinkCompactionFilter diff --git a/java/Makefile b/java/Makefile index ea8ca7eb6..0eb1cb36b 100644 --- a/java/Makefile +++ b/java/Makefile @@ -200,6 +200,9 @@ JAVA_TESTS = \ org.rocksdb.WriteOptionsTest\ org.rocksdb.WriteBatchWithIndexTest +FLINK_TESTS = \ + org.rocksdb.flink.FlinkEnvTest + MAIN_SRC = src/main/java TEST_SRC = src/test/java OUTPUT = target @@ -292,14 +295,15 @@ PLUGIN_SOURCES = $(foreach root, $(ROCKSDB_PLUGIN_JAVA_ROOTS), $(foreach pkg, or CORE_SOURCES = $(foreach pkg, org/rocksdb/util org/rocksdb, $(MAIN_SRC)/$(pkg)/*.java) SOURCES = $(wildcard $(CORE_SOURCES) $(PLUGIN_SOURCES)) PLUGIN_TEST_SOURCES = $(foreach root, $(ROCKSDB_PLUGIN_JAVA_ROOTS), $(foreach pkg, org/rocksdb/test org/rocksdb/util org/rocksdb, $(root)/$(TEST_SRC)/$(pkg)/*.java)) -CORE_TEST_SOURCES = $(foreach pkg, org/rocksdb/test org/rocksdb/util org/rocksdb, $(TEST_SRC)/$(pkg)/*.java) +CORE_TEST_SOURCES = $(foreach pkg, org/rocksdb/test org/rocksdb/util org/rocksdb/flink org/rocksdb, $(TEST_SRC)/$(pkg)/*.java) TEST_SOURCES = $(wildcard $(CORE_TEST_SOURCES) $(PLUGIN_TEST_SOURCES)) +MOCK_FLINK_TEST_SOURCES = $(foreach pkg, org/apache/flink/core/fs org/apache/flink/state/forst/fs, flinktestmock/src/main/java/$(pkg)/*.java) # Configure the plugin tests and java classes ROCKSDB_PLUGIN_NATIVE_JAVA_CLASSES = $(foreach plugin, $(ROCKSDB_PLUGINS), $(foreach class, $($(plugin)_NATIVE_JAVA_CLASSES), $(class))) NATIVE_JAVA_CLASSES = $(NATIVE_JAVA_CLASSES) $(ROCKSDB_PLUGIN_NATIVE_JAVA_CLASSES) ROCKSDB_PLUGIN_JAVA_TESTS = $(foreach plugin, $(ROCKSDB_PLUGINS), $(foreach testclass, $($(plugin)_JAVA_TESTS), $(testclass))) -ALL_JAVA_TESTS = $(JAVA_TESTS) $(ROCKSDB_PLUGIN_JAVA_TESTS) +ALL_JAVA_TESTS = $(FLINK_TESTS) $(JAVA_TESTS) $(ROCKSDB_PLUGIN_JAVA_TESTS) # When debugging add -Xcheck:jni to the java args ifneq ($(DEBUG_LEVEL),0) @@ -439,7 +443,7 @@ java_test: java resolve_test_deps $(AM_V_at) $(JAVAC_CMD) $(JAVAC_ARGS) -cp $(MAIN_CLASSES):$(JAVA_TESTCLASSPATH) -h $(NATIVE_INCLUDE) -d $(TEST_CLASSES)\ $(TEST_SOURCES) -test: java java_test +test: java mock_flink_fs java_test $(MAKE) run_test run_test: @@ -451,3 +455,13 @@ run_plugin_test: db_bench: java $(AM_V_GEN)mkdir -p $(BENCHMARK_MAIN_CLASSES) $(AM_V_at)$(JAVAC_CMD) $(JAVAC_ARGS) -cp $(MAIN_CLASSES) -d $(BENCHMARK_MAIN_CLASSES) $(BENCHMARK_MAIN_SRC)/org/rocksdb/benchmark/*.java + +mock_flink_fs: + $(AM_V_at) $(JAVAC_CMD) $(JAVAC_ARGS) -cp $(MAIN_CLASSES):$(JAVA_TESTCLASSPATH) -h $(NATIVE_INCLUDE) -d $(TEST_CLASSES) \ + $(MOCK_FLINK_TEST_SOURCES) + +flink_test: java java_test mock_flink_fs + $(MAKE) run_flink_test + +run_flink_test: + $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp "$(MAIN_CLASSES):$(TEST_CLASSES):$(JAVA_TESTCLASSPATH):target/*" org.rocksdb.test.RocksJunitRunner $(FLINK_TESTS) diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileStatus.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileStatus.java new file mode 100644 index 000000000..52d3360b7 --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileStatus.java @@ -0,0 +1,79 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This file is based on source code from the Hadoop Project (http://hadoop.apache.org/), licensed + * by the Apache Software Foundation (ASF) under the Apache License, Version 2.0. See the NOTICE + * file distributed with this work for additional information regarding copyright ownership. + */ + +package org.apache.flink.core.fs; + +/** + * Interface that represents the client side information for a file independent of the file system. + */ +public interface FileStatus { + /** + * Return the length of this file. + * + * @return the length of this file + */ + long getLen(); + + /** + * Get the block size of the file. + * + * @return the number of bytes + */ + long getBlockSize(); + + /** + * Get the replication factor of a file. + * + * @return the replication factor of a file. + */ + short getReplication(); + + /** + * Get the modification time of the file. + * + * @return the modification time of file in milliseconds since January 1, 1970 UTC. + */ + long getModificationTime(); + + /** + * Get the access time of the file. + * + * @return the access time of file in milliseconds since January 1, 1970 UTC. + */ + long getAccessTime(); + + /** + * Checks if this object represents a directory. + * + * @return true if this is a directory, false otherwise + */ + boolean isDir(); + + /** + * Returns the corresponding Path to the FileStatus. + * + * @return the corresponding Path to the FileStatus + */ + Path getPath(); +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileSystem.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileSystem.java new file mode 100644 index 000000000..5fef72b42 --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileSystem.java @@ -0,0 +1,257 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This file is based on source code from the Hadoop Project (http://hadoop.apache.org/), licensed + * by the Apache Software Foundation (ASF) under the Apache License, Version 2.0. See the NOTICE + * file distributed with this work for additional information regarding copyright ownership. + */ + +package org.apache.flink.core.fs; + +import static org.apache.flink.core.fs.LocalFileSystem.LOCAL_URI; + +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.URI; +import java.util.Objects; + +/** + * Abstract base class of all file systems used by Flink. This class may be extended to implement + * distributed file systems, or local file systems. The abstraction by this file system is very + * simple, and the set of available operations quite limited, to support the common denominator of a + * wide range of file systems. For example, appending to or mutating existing files is not + * supported. + */ +public abstract class FileSystem { + /** + * The possible write modes. The write mode decides what happens if a file should be created, + * but already exists. + */ + public enum WriteMode { + + /** + * Creates the target file only if no file exists at that path already. Does not overwrite + * existing files and directories. + */ + NO_OVERWRITE, + + /** + * Creates a new target file regardless of any existing files or directories. Existing files + * and directories will be deleted (recursively) automatically before creating the new file. + */ + OVERWRITE + } + + /** + * Returns a reference to the {@link FileSystem} instance for accessing the local file system. + * + * @return a reference to the {@link FileSystem} instance for accessing the local file system. + */ + public static FileSystem getLocalFileSystem() { + return LocalFileSystem.getSharedInstance(); + } + + /** + * Returns a reference to the {@link FileSystem} instance for accessing the file system + * identified by the given {@link URI}. + * + * @param uri the {@link URI} identifying the file system + * @return a reference to the {@link FileSystem} instance for accessing the file system + * identified by the given {@link URI}. + * @throws IOException thrown if a reference to the file system instance could not be obtained + */ + public static FileSystem get(URI uri) throws IOException { + if (Objects.equals(LOCAL_URI.getScheme(), uri.getScheme()) + && Objects.equals(LOCAL_URI.getAuthority(), LOCAL_URI.getAuthority())) { + return getLocalFileSystem(); + } + throw new UnsupportedOperationException("Unsupported URI pattern:" + uri); + } + + // ------------------------------------------------------------------------ + // File System Methods + // ------------------------------------------------------------------------ + + /** + * Returns the path of the file system's current working directory. + * + * @return the path of the file system's current working directory + */ + public abstract Path getWorkingDirectory(); + + /** + * Returns the path of the user's home directory in this file system. + * + * @return the path of the user's home directory in this file system. + */ + public abstract Path getHomeDirectory(); + + /** + * Returns a URI whose scheme and authority identify this file system. + * + * @return a URI whose scheme and authority identify this file system + */ + public abstract URI getUri(); + + /** + * Return a file status object that represents the path. + * + * @param f The path we want information from + * @return a FileStatus object + * @throws FileNotFoundException when the path does not exist; IOException see specific + * implementation + */ + public abstract FileStatus getFileStatus(Path f) throws IOException; + + /** + * Opens an FSDataInputStream at the indicated Path. + * + * @param f the file name to open + * @param bufferSize the size of the buffer to be used. + */ + public abstract InputStream open(Path f, int bufferSize) throws IOException; + + /** + * Opens an FSDataInputStream at the indicated Path. + * + * @param f the file to open + */ + public abstract InputStream open(Path f) throws IOException; + + /** + * List the statuses of the files/directories in the given path if the path is a directory. + * + * @param f given path + * @return the statuses of the files/directories in the given path + * @throws IOException + */ + public abstract FileStatus[] listStatus(Path f) throws IOException; + + /** + * Check if exists. + * + * @param f source file + */ + public boolean exists(final Path f) throws IOException { + try { + return (getFileStatus(f) != null); + } catch (FileNotFoundException e) { + return false; + } + } + + /** + * Delete a file. + * + * @param f the path to delete + * @param recursive if path is a directory and set to true, the directory is + * deleted else throws an exception. In case of a file the recursive can be set to either + * true or false + * @return true if delete is successful, false otherwise + * @throws IOException + */ + public abstract boolean delete(Path f, boolean recursive) throws IOException; + + /** + * Make the given file and all non-existent parents into directories. Has the semantics of Unix + * 'mkdir -p'. Existence of the directory hierarchy is not an error. + * + * @param f the directory/directories to be created + * @return true if at least one new directory has been created, false + * otherwise + * @throws IOException thrown if an I/O error occurs while creating the directory + */ + public abstract boolean mkdirs(Path f) throws IOException; + + /** + * Opens an FSDataOutputStream at the indicated Path. + * + *

This method is deprecated, because most of its parameters are ignored by most file + * systems. To control for example the replication factor and block size in the Hadoop + * Distributed File system, make sure that the respective Hadoop configuration file is either + * linked from the Flink configuration, or in the classpath of either Flink or the user code. + * + * @param f the file name to open + * @param overwrite if a file with this name already exists, then if true, the file will be + * overwritten, and if false an error will be thrown. + * @param bufferSize the size of the buffer to be used. + * @param replication required block replication for the file. + * @param blockSize the size of the file blocks + * @throws IOException Thrown, if the stream could not be opened because of an I/O, or because a + * file already exists at that path and the write mode indicates to not overwrite the file. + * @deprecated Deprecated because not well supported across types of file systems. Control the + * behavior of specific file systems via configurations instead. + */ + @Deprecated + public OutputStream create(Path f, boolean overwrite, int bufferSize, short replication, + long blockSize) throws IOException { + return create(f, overwrite ? WriteMode.OVERWRITE : WriteMode.NO_OVERWRITE); + } + + /** + * Opens an FSDataOutputStream at the indicated Path. + * + * @param f the file name to open + * @param overwrite if a file with this name already exists, then if true, the file will be + * overwritten, and if false an error will be thrown. + * @throws IOException Thrown, if the stream could not be opened because of an I/O, or because a + * file already exists at that path and the write mode indicates to not overwrite the file. + * @deprecated Use {@link #create(Path, WriteMode)} instead. + */ + @Deprecated + public OutputStream create(Path f, boolean overwrite) throws IOException { + return create(f, overwrite ? WriteMode.OVERWRITE : WriteMode.NO_OVERWRITE); + } + + /** + * Opens an FSDataOutputStream to a new file at the given path. + * + *

If the file already exists, the behavior depends on the given {@code WriteMode}. If the + * mode is set to {@link WriteMode#NO_OVERWRITE}, then this method fails with an exception. + * + * @param f The file path to write to + * @param overwriteMode The action to take if a file or directory already exists at the given + * path. + * @return The stream to the new file at the target path. + * @throws IOException Thrown, if the stream could not be opened because of an I/O, or because a + * file already exists at that path and the write mode indicates to not overwrite the file. + */ + public abstract OutputStream create(Path f, WriteMode overwriteMode) throws IOException; + + /** + * Renames the file/directory src to dst. + * + * @param src the file/directory to rename + * @param dst the new name of the file/directory + * @return true if the renaming was successful, false otherwise + * @throws IOException + */ + public abstract boolean rename(Path src, Path dst) throws IOException; + + /** + * Returns true if this is a distributed file system. A distributed file system here means that + * the file system is shared among all Flink processes that participate in a cluster or job and + * that all these processes can see the same files. + * + * @return True, if this is a distributed file system, false otherwise. + */ + public abstract boolean isDistributedFS(); +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataInputStream.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataInputStream.java new file mode 100644 index 000000000..64706ba8d --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataInputStream.java @@ -0,0 +1,83 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.core.fs; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.channels.FileChannel; + +/** + * The LocalDataInputStream class is a wrapper class for a data input stream to the + * local file system. + */ +public class LocalDataInputStream extends InputStream { + /** The file input stream used to read data from. */ + private final FileInputStream fis; + + private final FileChannel fileChannel; + + /** + * Constructs a new LocalDataInputStream object from a given {@link File} object. + * + * @param file The File the data stream is read from + * @throws IOException Thrown if the data input stream cannot be created. + */ + public LocalDataInputStream(File file) throws IOException { + this.fis = new FileInputStream(file); + this.fileChannel = fis.getChannel(); + } + + public void seek(long desired) throws IOException { + if (desired != getPos()) { + this.fileChannel.position(desired); + } + } + + public long getPos() throws IOException { + return this.fileChannel.position(); + } + + @Override + public int read() throws IOException { + return this.fis.read(); + } + + @Override + public int read(byte[] buffer, int offset, int length) throws IOException { + return this.fis.read(buffer, offset, length); + } + + @Override + public void close() throws IOException { + // According to javadoc, this also closes the channel + this.fis.close(); + } + + @Override + public int available() throws IOException { + return this.fis.available(); + } + + @Override + public long skip(final long n) throws IOException { + return this.fis.skip(n); + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataOutputStream.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataOutputStream.java new file mode 100644 index 000000000..aabfcaa98 --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataOutputStream.java @@ -0,0 +1,92 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.core.fs; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.nio.channels.ClosedChannelException; + +/** + * The LocalDataOutputStream class is a wrapper class for a data output stream to the + * local file system. + */ +public class LocalDataOutputStream extends OutputStream { + /** The file output stream used to write data. */ + private final FileOutputStream fos; + + private boolean closed = false; + + /** + * Constructs a new LocalDataOutputStream object from a given {@link File} object. + * + * @param file the {@link File} object the data stream is read from + * @throws IOException thrown if the data output stream cannot be created + */ + public LocalDataOutputStream(final File file) throws IOException { + this.fos = new FileOutputStream(file); + } + + @Override + public void write(final int b) throws IOException { + checkOpen(); + fos.write(b); + } + + @Override + public void write(final byte[] b) throws IOException { + checkOpen(); + fos.write(b); + } + + @Override + public void write(final byte[] b, final int off, final int len) throws IOException { + checkOpen(); + fos.write(b, off, len); + } + + @Override + public void close() throws IOException { + closed = true; + fos.close(); + } + + @Override + public void flush() throws IOException { + checkOpen(); + fos.flush(); + } + + public void sync() throws IOException { + checkOpen(); + fos.getFD().sync(); + } + + public long getPos() throws IOException { + checkOpen(); + return fos.getChannel().position(); + } + + private void checkOpen() throws IOException { + if (closed) { + throw new ClosedChannelException(); + } + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileStatus.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileStatus.java new file mode 100644 index 000000000..b79f112ce --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileStatus.java @@ -0,0 +1,93 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.core.fs; + +import java.io.File; + +/** + * The class LocalFileStatus provides an implementation of the {@link FileStatus} + * interface for the local file system. + */ +public class LocalFileStatus implements FileStatus { + /** The file this file status belongs to. */ + private final File file; + + /** The path of this file this file status belongs to. */ + private final Path path; + + /** Cached length field, to avoid repeated native/syscalls. */ + private final long len; + + /** + * Creates a LocalFileStatus object from a given {@link File} object. + * + * @param f the {@link File} object this LocalFileStatus refers to + * @param fs the file system the corresponding file has been read from + */ + public LocalFileStatus(final File f, final FileSystem fs) { + this.file = f; + this.path = new Path(fs.getUri().getScheme() + ":" + f.toURI().getPath()); + this.len = f.length(); + } + + @Override + public long getAccessTime() { + return 0; // We don't have access files for local files + } + + @Override + public long getBlockSize() { + return this.len; + } + + @Override + public long getLen() { + return this.len; + } + + @Override + public long getModificationTime() { + return this.file.lastModified(); + } + + @Override + public short getReplication() { + return 1; // For local files replication is always 1 + } + + @Override + public boolean isDir() { + return this.file.isDirectory(); + } + + @Override + public Path getPath() { + return this.path; + } + + public File getFile() { + return this.file; + } + + @Override + public String toString() { + return "LocalFileStatus{" + + "file=" + file + ", path=" + path + '}'; + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileSystem.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileSystem.java new file mode 100644 index 000000000..863d689f3 --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileSystem.java @@ -0,0 +1,296 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Parts of earlier versions of this file were based on source code from the + * Hadoop Project (http://hadoop.apache.org/), licensed by the Apache Software Foundation (ASF) + * under the Apache License, Version 2.0. See the NOTICE file distributed with this work for + * additional information regarding copyright ownership. + */ + +package org.apache.flink.core.fs; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.URI; +import java.nio.file.AccessDeniedException; +import java.nio.file.DirectoryNotEmptyException; +import java.nio.file.FileAlreadyExistsException; +import java.nio.file.Files; +import java.nio.file.NoSuchFileException; +import java.nio.file.StandardCopyOption; + +/** + * The class {@code LocalFileSystem} is an implementation of the {@link FileSystem} interface for + * the local file system of the machine where the JVM runs. + */ +public class LocalFileSystem extends FileSystem { + /** The URI representing the local file system. */ + public static final URI LOCAL_URI = URI.create("file:///"); + + /** The shared instance of the local file system. */ + private static final LocalFileSystem INSTANCE = new LocalFileSystem(); + + /** + * Path pointing to the current working directory. Because Paths are not immutable, we cannot + * cache the proper path here + */ + private final URI workingDir; + + /** + * Path pointing to the current user home directory. Because Paths are not immutable, we cannot + * cache the proper path here. + */ + private final URI homeDir; + + /** Constructs a new LocalFileSystem object. */ + public LocalFileSystem() { + this.workingDir = new File(System.getProperty("user.dir")).toURI(); + this.homeDir = new File(System.getProperty("user.home")).toURI(); + } + + // ------------------------------------------------------------------------ + + @Override + public FileStatus getFileStatus(Path f) throws IOException { + final File path = pathToFile(f); + if (path.exists()) { + return new LocalFileStatus(path, this); + } else { + throw new FileNotFoundException("File " + f + " does not exist or the user running " + + "Flink ('" + System.getProperty("user.name") + + "') has insufficient permissions to access it."); + } + } + + @Override + public URI getUri() { + return LOCAL_URI; + } + + @Override + public Path getWorkingDirectory() { + return new Path(workingDir); + } + + @Override + public Path getHomeDirectory() { + return new Path(homeDir); + } + + @Override + public InputStream open(final Path f, final int bufferSize) throws IOException { + return open(f); + } + + @Override + public InputStream open(final Path f) throws IOException { + final File file = pathToFile(f); + return new LocalDataInputStream(file); + } + + @Override + public boolean exists(Path f) throws IOException { + final File path = pathToFile(f); + return path.exists(); + } + + @Override + public FileStatus[] listStatus(final Path f) throws IOException { + final File localf = pathToFile(f); + FileStatus[] results; + + if (!localf.exists()) { + return null; + } + if (localf.isFile()) { + return new FileStatus[] {new LocalFileStatus(localf, this)}; + } + + final String[] names = localf.list(); + if (names == null) { + return null; + } + results = new FileStatus[names.length]; + for (int i = 0; i < names.length; i++) { + results[i] = getFileStatus(new Path(f, names[i])); + } + + return results; + } + + @Override + public boolean delete(final Path f, final boolean recursive) throws IOException { + final File file = pathToFile(f); + if (file.isFile()) { + return file.delete(); + } else if ((!recursive) && file.isDirectory()) { + File[] containedFiles = file.listFiles(); + if (containedFiles == null) { + throw new IOException( + "Directory " + file.toString() + " does not exist or an I/O error occurred"); + } else if (containedFiles.length != 0) { + throw new IOException("Directory " + file.toString() + " is not empty"); + } + } + + return delete(file); + } + + /** + * Deletes the given file or directory. + * + * @param f the file to be deleted + * @return true if all files were deleted successfully, false + * otherwise + * @throws IOException thrown if an error occurred while deleting the files/directories + */ + private boolean delete(final File f) throws IOException { + if (f.isDirectory()) { + final File[] files = f.listFiles(); + if (files != null) { + for (File file : files) { + final boolean del = delete(file); + if (!del) { + return false; + } + } + } + } else { + return f.delete(); + } + + // Now directory is empty + return f.delete(); + } + + /** + * Recursively creates the directory specified by the provided path. + * + * @return trueif the directories either already existed or have been created + * successfully, false otherwise + * @throws IOException thrown if an error occurred while creating the directory/directories + */ + @Override + public boolean mkdirs(final Path f) throws IOException { + assert f != null; + return mkdirsInternal(pathToFile(f)); + } + + private boolean mkdirsInternal(File file) throws IOException { + if (file.isDirectory()) { + return true; + } else if (file.exists() && !file.isDirectory()) { + // Important: The 'exists()' check above must come before the 'isDirectory()' check to + // be safe when multiple parallel instances try to create the directory + + // exists and is not a directory -> is a regular file + throw new FileAlreadyExistsException(file.getAbsolutePath()); + } else { + File parent = file.getParentFile(); + return (parent == null || mkdirsInternal(parent)) && (file.mkdir() || file.isDirectory()); + } + } + + @Override + public OutputStream create(final Path filePath, final WriteMode overwrite) throws IOException { + // checkNotNull(filePath, "filePath"); + + if (exists(filePath) && overwrite == WriteMode.NO_OVERWRITE) { + throw new FileAlreadyExistsException("File already exists: " + filePath); + } + + final Path parent = filePath.getParent(); + if (parent != null && !mkdirs(parent)) { + throw new IOException("Mkdirs failed to create " + parent); + } + + final File file = pathToFile(filePath); + return new LocalDataOutputStream(file); + } + + @Override + public boolean rename(final Path src, final Path dst) throws IOException { + final File srcFile = pathToFile(src); + final File dstFile = pathToFile(dst); + + final File dstParent = dstFile.getParentFile(); + + // Files.move fails if the destination directory doesn't exist + // noinspection ResultOfMethodCallIgnored -- we don't care if the directory existed or was + // created + dstParent.mkdirs(); + + try { + Files.move(srcFile.toPath(), dstFile.toPath(), StandardCopyOption.REPLACE_EXISTING); + return true; + } catch (NoSuchFileException | AccessDeniedException | DirectoryNotEmptyException + | SecurityException ex) { + // catch the errors that are regular "move failed" exceptions and return false + return false; + } + } + + @Override + public boolean isDistributedFS() { + return false; + } + + // ------------------------------------------------------------------------ + + /** + * Converts the given Path to a File for this file system. If the path is empty, we will return + * new File(".") instead of new File(""), since the latter returns + * false for isDirectory judgement (See issue + * https://issues.apache.org/jira/browse/FLINK-18612). + */ + public File pathToFile(Path path) { + String localPath = path.getPath(); + // checkState(localPath != null, "Cannot convert a null path to File"); + + if (localPath.length() == 0) { + return new File("."); + } + + return new File(localPath); + } + + // ------------------------------------------------------------------------ + + /** + * Gets the URI that represents the local file system. That URI is {@code "file:/"} on Windows + * platforms and {@code "file:///"} on other UNIX family platforms. + * + * @return The URI that represents the local file system. + */ + public static URI getLocalFsURI() { + return LOCAL_URI; + } + + /** + * Gets the shared instance of this file system. + * + * @return The shared instance of this file system. + */ + public static LocalFileSystem getSharedInstance() { + return INSTANCE; + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/Path.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/Path.java new file mode 100644 index 000000000..1d06ae4be --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/Path.java @@ -0,0 +1,469 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* This file is based on source code from the Hadoop Project (http://hadoop.apache.org/), licensed + * by the Apache Software Foundation (ASF) under the Apache License, Version 2.0. See the NOTICE + * file distributed with this work for additional information regarding copyright ownership. */ + +package org.apache.flink.core.fs; + +import java.io.File; +import java.io.IOException; +import java.io.Serializable; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.regex.Pattern; + +/** + * Names a file or directory in a {@link FileSystem}. Path strings use slash as the directory + * separator. A path string is absolute if it begins with a slash. + * + *

Tailing slashes are removed from the path. + * + *

Note: Path will no longer implement {@link IOReadableWritable} in future versions. Please use + * {@code serializeToDataOutputView} and {@code deserializeFromDataInputView} instead. + */ +public class Path implements Serializable { + private static final long serialVersionUID = 1L; + + /** The directory separator, a slash. */ + public static final String SEPARATOR = "/"; + + /** The directory separator, a slash (character). */ + public static final char SEPARATOR_CHAR = '/'; + + /** Character denoting the current directory. */ + public static final String CUR_DIR = "."; + + /** A pre-compiled regex/state-machine to match the windows drive pattern. */ + private static final Pattern WINDOWS_ROOT_DIR_REGEX = Pattern.compile("/\\p{Alpha}+:/"); + + /** The internal representation of the path, a hierarchical URI. */ + private URI uri; + + /** Constructs a new (empty) path object (used to reconstruct path object after RPC call). */ + public Path() {} + + /** + * Constructs a path object from a given URI. + * + * @param uri the URI to construct the path object from + */ + public Path(URI uri) { + this.uri = uri; + } + + /** + * Resolve a child path against a parent path. + * + * @param parent the parent path + * @param child the child path + */ + public Path(String parent, String child) { + this(new Path(parent), new Path(child)); + } + + /** + * Resolve a child path against a parent path. + * + * @param parent the parent path + * @param child the child path + */ + public Path(Path parent, String child) { + this(parent, new Path(child)); + } + + /** + * Resolve a child path against a parent path. + * + * @param parent the parent path + * @param child the child path + */ + public Path(String parent, Path child) { + this(new Path(parent), child); + } + + /** + * Resolve a child path against a parent path. + * + * @param parent the parent path + * @param child the child path + */ + public Path(Path parent, Path child) { + // Add a slash to parent's path so resolution is compatible with URI's + URI parentUri = parent.uri; + final String parentPath = parentUri.getPath(); + if (!(parentPath.equals("/") || parentPath.equals(""))) { + try { + parentUri = new URI( + parentUri.getScheme(), parentUri.getAuthority(), parentUri.getPath() + "/", null, null); + } catch (URISyntaxException e) { + throw new IllegalArgumentException(e); + } + } + + if (child.uri.getPath().startsWith(Path.SEPARATOR)) { + child = new Path( + child.uri.getScheme(), child.uri.getAuthority(), child.uri.getPath().substring(1)); + } + + final URI resolved = parentUri.resolve(child.uri); + initialize(resolved.getScheme(), resolved.getAuthority(), resolved.getPath()); + } + + /** + * Checks if the provided path string is either null or has zero length and throws a {@link + * IllegalArgumentException} if any of the two conditions apply. + * + * @param path the path string to be checked + * @return The checked path. + */ + private String checkPathArg(String path) { + // disallow construction of a Path from an empty string + if (path == null) { + throw new IllegalArgumentException("Can not create a Path from a null string"); + } + if (path.length() == 0) { + throw new IllegalArgumentException("Can not create a Path from an empty string"); + } + return path; + } + + /** + * Construct a path from a String. Path strings are URIs, but with unescaped elements and some + * additional normalization. + * + * @param pathString the string to construct a path from + */ + public Path(String pathString) { + pathString = checkPathArg(pathString); + + // We can't use 'new URI(String)' directly, since it assumes things are + // escaped, which we don't require of Paths. + + // add a slash in front of paths with Windows drive letters + if (hasWindowsDrive(pathString, false)) { + pathString = "/" + pathString; + } + + // parse uri components + String scheme = null; + String authority = null; + + int start = 0; + + // parse uri scheme, if any + final int colon = pathString.indexOf(':'); + final int slash = pathString.indexOf('/'); + if ((colon != -1) && ((slash == -1) || (colon < slash))) { // has a + // scheme + scheme = pathString.substring(0, colon); + start = colon + 1; + } + + // parse uri authority, if any + if (pathString.startsWith("//", start) && (pathString.length() - start > 2)) { // has authority + final int nextSlash = pathString.indexOf('/', start + 2); + final int authEnd = nextSlash > 0 ? nextSlash : pathString.length(); + authority = pathString.substring(start + 2, authEnd); + start = authEnd; + } + + // uri path is the rest of the string -- query & fragment not supported + final String path = pathString.substring(start, pathString.length()); + + initialize(scheme, authority, path); + } + + /** + * Construct a Path from a scheme, an authority and a path string. + * + * @param scheme the scheme string + * @param authority the authority string + * @param path the path string + */ + public Path(String scheme, String authority, String path) { + path = checkPathArg(path); + initialize(scheme, authority, path); + } + + /** + * Initializes a path object given the scheme, authority and path string. + * + * @param scheme the scheme string. + * @param authority the authority string. + * @param path the path string. + */ + private void initialize(String scheme, String authority, String path) { + try { + this.uri = new URI(scheme, authority, normalizePath(path), null, null).normalize(); + } catch (URISyntaxException e) { + throw new IllegalArgumentException(e); + } + } + + /** + * Normalizes a path string. + * + * @param path the path string to normalize + * @return the normalized path string + */ + private String normalizePath(String path) { + // remove consecutive slashes & backslashes + path = path.replace("\\", "/"); + path = path.replaceAll("/+", "/"); + + // remove tailing separator + if (path.endsWith(SEPARATOR) && !path.equals(SEPARATOR) && // UNIX root path + !WINDOWS_ROOT_DIR_REGEX.matcher(path).matches()) { // Windows root path) + + // remove tailing slash + path = path.substring(0, path.length() - SEPARATOR.length()); + } + + return path; + } + + /** + * Converts the path object to a {@link URI}. + * + * @return the {@link URI} object converted from the path object + */ + public URI toUri() { + return uri; + } + + /** + * Returns the FileSystem that owns this Path. + * + * @return the FileSystem that owns this Path + * @throws IOException thrown if the file system could not be retrieved + */ + public FileSystem getFileSystem() throws IOException { + return FileSystem.get(this.toUri()); + } + + /** + * Checks if the directory of this path is absolute. + * + * @return true if the directory of this path is absolute, false + * otherwise + */ + public boolean isAbsolute() { + final int start = hasWindowsDrive(uri.getPath(), true) ? 3 : 0; + return uri.getPath().startsWith(SEPARATOR, start); + } + + /** + * Returns the final component of this path, i.e., everything that follows the last separator. + * + * @return the final component of the path + */ + public String getName() { + final String path = uri.getPath(); + final int slash = path.lastIndexOf(SEPARATOR); + return path.substring(slash + 1); + } + + /** + * Return full path. + * + * @return full path + */ + public String getPath() { + return uri.getPath(); + } + + /** + * Returns the parent of a path, i.e., everything that precedes the last separator or null + * if at root. + * + * @return the parent of a path or null if at root. + */ + public Path getParent() { + final String path = uri.getPath(); + final int lastSlash = path.lastIndexOf('/'); + final int start = hasWindowsDrive(path, true) ? 3 : 0; + if ((path.length() == start) || // empty path + (lastSlash == start && path.length() == start + 1)) { // at root + return null; + } + String parent; + if (lastSlash == -1) { + parent = CUR_DIR; + } else { + final int end = hasWindowsDrive(path, true) ? 3 : 0; + parent = path.substring(0, lastSlash == end ? end + 1 : lastSlash); + } + return new Path(uri.getScheme(), uri.getAuthority(), parent); + } + + /** + * Adds a suffix to the final name in the path. + * + * @param suffix The suffix to be added + * @return the new path including the suffix + */ + public Path suffix(String suffix) { + return new Path(getParent(), getName() + suffix); + } + + @Override + public String toString() { + // we can't use uri.toString(), which escapes everything, because we want + // illegal characters unescaped in the string, for glob processing, etc. + final StringBuilder buffer = new StringBuilder(); + if (uri.getScheme() != null) { + buffer.append(uri.getScheme()); + buffer.append(":"); + } + if (uri.getAuthority() != null) { + buffer.append("//"); + buffer.append(uri.getAuthority()); + } + if (uri.getPath() != null) { + String path = uri.getPath(); + if (path.indexOf('/') == 0 && hasWindowsDrive(path, true) && // has windows drive + uri.getScheme() == null && // but no scheme + uri.getAuthority() == null) { // or authority + path = path.substring(1); // remove slash before drive + } + buffer.append(path); + } + return buffer.toString(); + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof Path)) { + return false; + } + Path that = (Path) o; + return this.uri.equals(that.uri); + } + + @Override + public int hashCode() { + return uri.hashCode(); + } + + public int compareTo(Object o) { + Path that = (Path) o; + return this.uri.compareTo(that.uri); + } + + /** + * Returns the number of elements in this path. + * + * @return the number of elements in this path + */ + public int depth() { + String path = uri.getPath(); + int depth = 0; + int slash = path.length() == 1 && path.charAt(0) == '/' ? -1 : 0; + while (slash != -1) { + depth++; + slash = path.indexOf(SEPARATOR, slash + 1); + } + return depth; + } + + /** + * Returns a qualified path object. + * + * @param fs the FileSystem that should be used to obtain the current working directory + * @return the qualified path object + */ + public Path makeQualified(FileSystem fs) { + Path path = this; + if (!isAbsolute()) { + path = new Path(fs.getWorkingDirectory(), this); + } + + final URI pathUri = path.toUri(); + final URI fsUri = fs.getUri(); + + String scheme = pathUri.getScheme(); + String authority = pathUri.getAuthority(); + + if (scheme != null && (authority != null || fsUri.getAuthority() == null)) { + return path; + } + + if (scheme == null) { + scheme = fsUri.getScheme(); + } + + if (authority == null) { + authority = fsUri.getAuthority(); + if (authority == null) { + authority = ""; + } + } + + return new Path(scheme + ":" + + "//" + authority + pathUri.getPath()); + } + + // ------------------------------------------------------------------------ + // Utilities + // ------------------------------------------------------------------------ + + /** + * Checks if the provided path string contains a windows drive letter. + * + * @return True, if the path string contains a windows drive letter, false otherwise. + */ + public boolean hasWindowsDrive() { + return hasWindowsDrive(uri.getPath(), true); + } + + /** + * Checks if the provided path string contains a windows drive letter. + * + * @param path the path to check + * @param slashed true to indicate the first character of the string is a slash, false otherwise + * @return true if the path string contains a windows drive letter, false otherwise + */ + private boolean hasWindowsDrive(String path, boolean slashed) { + final int start = slashed ? 1 : 0; + return path.length() >= start + 2 && (!slashed || path.charAt(0) == '/') + && path.charAt(start + 1) == ':' + && ((path.charAt(start) >= 'A' && path.charAt(start) <= 'Z') + || (path.charAt(start) >= 'a' && path.charAt(start) <= 'z')); + } + + // ------------------------------------------------------------------------ + // Utilities + // ------------------------------------------------------------------------ + + /** + * Creates a path for the given local file. + * + *

This method is useful to make sure the path creation for local files works seamlessly + * across different operating systems. Especially Windows has slightly different rules for + * slashes between schema and a local file path, making it sometimes tricky to produce + * cross-platform URIs for local files. + * + * @param file The file that the path should represent. + * @return A path representing the local file URI of the given file. + */ + public static Path fromLocalFile(File file) { + return new Path(file.toURI()); + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream.java b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream.java new file mode 100644 index 000000000..b38a518bc --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream.java @@ -0,0 +1,133 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.state.forst.fs; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import org.apache.flink.core.fs.LocalDataInputStream; +import org.apache.flink.core.fs.Path; + +/** + * ByteBufferReadableFSDataInputStream. + */ +public class ByteBufferReadableFSDataInputStream extends InputStream { + private final LocalDataInputStream localDataInputStream; + private final Path path; + private final long totalFileSize; + + public ByteBufferReadableFSDataInputStream( + Path path, InputStream inputStream, long totalFileSize) { + if (!(inputStream instanceof LocalDataInputStream)) { + throw new UnsupportedOperationException("Unsupported input stream type"); + } + this.localDataInputStream = (LocalDataInputStream) inputStream; + this.path = path; + this.totalFileSize = totalFileSize; + } + + public void seek(long desired) throws IOException { + localDataInputStream.seek(desired); + } + + public long getPos() throws IOException { + return localDataInputStream.getPos(); + } + + @Override + public int read() throws IOException { + return localDataInputStream.read(); + } + + @Override + public int read(byte[] b) throws IOException { + return localDataInputStream.read(b); + } + + @Override + public int read(byte[] b, int off, int len) throws IOException { + return localDataInputStream.read(b, off, len); + } + + /** + * Return the total number of bytes read into the buffer. + * REQUIRES: External synchronization + */ + public int readFully(ByteBuffer bb) throws IOException { + return readFullyFromFSDataInputStream(localDataInputStream, bb); + } + + private int readFullyFromFSDataInputStream(LocalDataInputStream fsdis, ByteBuffer bb) + throws IOException { + byte[] tmp = new byte[bb.remaining()]; + int n = 0; + long pos = fsdis.getPos(); + while (n < tmp.length) { + int read = fsdis.read(tmp, n, tmp.length - n); + if (read == -1) { + break; + } + n += read; + } + if (n > 0) { + bb.put(tmp, 0, n); + } + return n; + } + + /** + * Return the total number of bytes read into the buffer. + * Safe for concurrent use by multiple threads. + */ + public int readFully(long position, ByteBuffer bb) throws IOException { + localDataInputStream.seek(position); + return readFullyFromFSDataInputStream(localDataInputStream, bb); + } + + @Override + public long skip(long n) throws IOException { + seek(getPos() + n); + return getPos(); + } + + @Override + public int available() throws IOException { + return localDataInputStream.available(); + } + + @Override + public void close() throws IOException { + localDataInputStream.close(); + } + + @Override + public synchronized void mark(int readlimit) { + localDataInputStream.mark(readlimit); + } + + @Override + public synchronized void reset() throws IOException { + localDataInputStream.reset(); + } + + @Override + public boolean markSupported() { + return localDataInputStream.markSupported(); + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream.java b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream.java new file mode 100644 index 000000000..9c59fda3b --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream.java @@ -0,0 +1,83 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.state.forst.fs; + +import java.io.IOException; +import java.io.OutputStream; +import java.nio.ByteBuffer; +import org.apache.flink.core.fs.LocalDataOutputStream; +import org.apache.flink.core.fs.Path; + +/** + * ByteBufferWritableFSDataOutputStream. + */ +public class ByteBufferWritableFSDataOutputStream extends OutputStream { + private final Path path; + private final LocalDataOutputStream localDataOutputStream; + + public ByteBufferWritableFSDataOutputStream(Path path, OutputStream fsdos) { + if (!(fsdos instanceof LocalDataOutputStream)) { + throw new UnsupportedOperationException("Unsupported output stream type"); + } + this.path = path; + this.localDataOutputStream = (LocalDataOutputStream) fsdos; + } + + public long getPos() throws IOException { + return localDataOutputStream.getPos(); + } + + @Override + public void write(int b) throws IOException { + localDataOutputStream.write(b); + } + + public void write(byte[] b) throws IOException { + localDataOutputStream.write(b); + } + + @Override + public void write(byte[] b, int off, int len) throws IOException { + localDataOutputStream.write(b, off, len); + } + + public void write(ByteBuffer bb) throws IOException { + if (bb.hasArray()) { + write(bb.array(), bb.arrayOffset() + bb.position(), bb.remaining()); + } else { + byte[] tmp = new byte[bb.remaining()]; + bb.get(tmp); + write(tmp, 0, tmp.length); + } + } + + @Override + public void flush() throws IOException { + localDataOutputStream.flush(); + } + + public void sync() throws IOException { + localDataOutputStream.sync(); + } + + @Override + public void close() throws IOException { + localDataOutputStream.close(); + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ForStFlinkFileSystem.java b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ForStFlinkFileSystem.java new file mode 100644 index 000000000..afb32d754 --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ForStFlinkFileSystem.java @@ -0,0 +1,126 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.state.forst.fs; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.URI; +import org.apache.flink.core.fs.FileStatus; +import org.apache.flink.core.fs.FileSystem; +import org.apache.flink.core.fs.Path; + +/** + * RemoteRocksdbFlinkFileSystem, used to expose flink fileSystem interface to frocksdb. + */ +public class ForStFlinkFileSystem extends FileSystem { + private final FileSystem flinkFS; + + public ForStFlinkFileSystem(FileSystem flinkFS) { + this.flinkFS = flinkFS; + } + + public static FileSystem get(URI uri) throws IOException { + return new ForStFlinkFileSystem(FileSystem.get(uri)); + } + + @Override + public Path getWorkingDirectory() { + return flinkFS.getWorkingDirectory(); + } + + @Override + public Path getHomeDirectory() { + return flinkFS.getHomeDirectory(); + } + + @Override + public URI getUri() { + return flinkFS.getUri(); + } + + @Override + public FileStatus getFileStatus(Path f) throws IOException { + return flinkFS.getFileStatus(f); + } + + @Override + public ByteBufferReadableFSDataInputStream open(Path f, int bufferSize) throws IOException { + InputStream original = flinkFS.open(f, bufferSize); + long fileSize = flinkFS.getFileStatus(f).getLen(); + return new ByteBufferReadableFSDataInputStream(f, original, fileSize); + } + + @Override + public ByteBufferReadableFSDataInputStream open(Path f) throws IOException { + InputStream original = flinkFS.open(f); + long fileSize = flinkFS.getFileStatus(f).getLen(); + return new ByteBufferReadableFSDataInputStream(f, original, fileSize); + } + + @Override + public FileStatus[] listStatus(Path f) throws IOException { + return flinkFS.listStatus(f); + } + + @Override + public boolean exists(final Path f) throws IOException { + return flinkFS.exists(f); + } + + @Override + public boolean delete(Path f, boolean recursive) throws IOException { + return flinkFS.delete(f, recursive); + } + + @Override + public boolean mkdirs(Path f) throws IOException { + return flinkFS.mkdirs(f); + } + + public ByteBufferWritableFSDataOutputStream create(Path f) throws IOException { + return create(f, WriteMode.OVERWRITE); + } + + @Override + public ByteBufferWritableFSDataOutputStream create(Path f, WriteMode overwriteMode) + throws IOException { + OutputStream original = flinkFS.create(f, overwriteMode); + return new ByteBufferWritableFSDataOutputStream(f, original); + } + + @Override + public boolean rename(Path src, Path dst) throws IOException { + // The rename is not atomic for RocksDB. Some FileSystems e.g. HDFS, OSS does not allow a + // renaming if the target already exists. So, we delete the target before attempting the + // rename. + if (flinkFS.exists(dst)) { + boolean deleted = flinkFS.delete(dst, false); + if (!deleted) { + throw new IOException("Fail to delete dst path: " + dst); + } + } + return flinkFS.rename(src, dst); + } + + @Override + public boolean isDistributedFS() { + return flinkFS.isDistributedFS(); + } +} diff --git a/java/rocksjni/env_flink_test_suite.cc b/java/rocksjni/env_flink_test_suite.cc new file mode 100644 index 000000000..5e66ca746 --- /dev/null +++ b/java/rocksjni/env_flink_test_suite.cc @@ -0,0 +1,73 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "env/flink/env_flink_test_suite.h" + +#include + +#include "include/org_rocksdb_EnvFlinkTestSuite.h" +#include "java/rocksjni/portal.h" + +/* + * Class: org_rocksdb_EnvFlinkTestSuite + * Method: buildNativeObject + * Signature: (Ljava/lang/String;)J + */ +jlong Java_org_rocksdb_EnvFlinkTestSuite_buildNativeObject(JNIEnv* env, jobject, + jstring basePath) { + jboolean has_exception = JNI_FALSE; + auto path = + ROCKSDB_NAMESPACE::JniUtil::copyStdString(env, basePath, &has_exception); + if (has_exception == JNI_TRUE) { + ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew( + env, "Could not copy jstring to std::string"); + return 0; + } + auto env_flink_test_suites = new ROCKSDB_NAMESPACE::EnvFlinkTestSuites(path); + return reinterpret_cast(env_flink_test_suites); +} + +/* + * Class: org_rocksdb_EnvFlinkTestSuite + * Method: runAllTestSuites + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_rocksdb_EnvFlinkTestSuite_runAllTestSuites( + JNIEnv* jniEnv, jobject, jlong objectHandle) { + auto env_flink_test_suites = + reinterpret_cast(objectHandle); + env_flink_test_suites->runAllTestSuites(); + if (jniEnv->ExceptionCheck()) { + jthrowable throwable = jniEnv->ExceptionOccurred(); + jniEnv->ExceptionDescribe(); + jniEnv->ExceptionClear(); + jniEnv->Throw(throwable); + } +} + +/* + * Class: org_rocksdb_EnvFlinkTestSuite + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_rocksdb_EnvFlinkTestSuite_disposeInternal( + JNIEnv*, jobject, jlong objectHandle) { + auto test_suites = + reinterpret_cast(objectHandle); + delete test_suites; +} \ No newline at end of file diff --git a/java/src/main/java/org/rocksdb/EnvFlinkTestSuite.java b/java/src/main/java/org/rocksdb/EnvFlinkTestSuite.java new file mode 100644 index 000000000..92e503509 --- /dev/null +++ b/java/src/main/java/org/rocksdb/EnvFlinkTestSuite.java @@ -0,0 +1,50 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.rocksdb; + +/** + * The test suite used for flink-env interfaces testing. You could define and implement test + * procedures in the "env/flink/env_flink_test_suite.h" and "env/flink/env_flink_test_suite.cc", and + * these tests will be executed by EnvFlinkTestSuite#runAllTestSuites. + */ +public class EnvFlinkTestSuite implements AutoCloseable { + private final String basePath; + + private final long nativeObjectHandle; + + public EnvFlinkTestSuite(String basePath) { + this.basePath = basePath; + this.nativeObjectHandle = buildNativeObject(basePath); + } + + private native long buildNativeObject(String basePath); + + private native void runAllTestSuites(long nativeObjectHandle); + + private native void disposeInternal(long nativeObjectHandle); + + public void runAllTestSuites() { + runAllTestSuites(nativeObjectHandle); + } + + @Override + public void close() throws Exception { + disposeInternal(nativeObjectHandle); + } +} \ No newline at end of file diff --git a/java/src/test/java/org/rocksdb/flink/FlinkEnvTest.java b/java/src/test/java/org/rocksdb/flink/FlinkEnvTest.java new file mode 100644 index 000000000..5c7166557 --- /dev/null +++ b/java/src/test/java/org/rocksdb/flink/FlinkEnvTest.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.rocksdb.flink; + +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; +import org.rocksdb.EnvFlinkTestSuite; +import org.rocksdb.RocksNativeLibraryResource; + +/** + * Unit test for env/flink/env_flink.cc. + */ +public class FlinkEnvTest { + @ClassRule + public static final RocksNativeLibraryResource ROCKS_NATIVE_LIBRARY_RESOURCE = + new RocksNativeLibraryResource(); + + @Rule public TemporaryFolder parentFolder = new TemporaryFolder(); + + @Test + public void runEnvFlinkTestSuites() throws Exception { + String basePath = parentFolder.newFolder().toURI().toString(); + try (EnvFlinkTestSuite testSuite = new EnvFlinkTestSuite(basePath)) { + testSuite.runAllTestSuites(); + } + } +} \ No newline at end of file diff --git a/src.mk b/src.mk index 41f4c0076..1aaa0a949 100644 --- a/src.mk +++ b/src.mk @@ -114,6 +114,7 @@ LIB_SOURCES = \ env/flink/env_flink.cc \ env/flink/jvm_util.cc \ env/flink/jni_helper.cc \ + env/flink/env_flink_test_suite.cc \ file/delete_scheduler.cc \ file/file_prefetch_buffer.cc \ file/file_util.cc \ @@ -664,6 +665,7 @@ JNI_NATIVE_SOURCES = \ java/rocksjni/export_import_files_metadatajni.cc \ java/rocksjni/env.cc \ java/rocksjni/env_flink.cc \ + java/rocksjni/env_flink_test_suite.cc \ java/rocksjni/env_options.cc \ java/rocksjni/event_listener.cc \ java/rocksjni/event_listener_jnicallback.cc \ From 729cf5c764c5c40a3990912c2860f9319f8c354a Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Mon, 1 Apr 2024 16:27:27 +0800 Subject: [PATCH 29/61] [env] Add test cases in flink-env test suite --- env/flink/env_flink.cc | 19 +++-- env/flink/env_flink_test_suite.cc | 127 +++++++++++++++++++++++++++--- env/flink/env_flink_test_suite.h | 7 +- 3 files changed, 137 insertions(+), 16 deletions(-) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index b963fe508..26deba9e7 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -66,7 +66,7 @@ class FlinkWritableFile : public FSWritableFile { jobject fsDataOutputStream = jniEnv->CallObjectMethod( file_system_instance_, fileSystemCreateMethod.javaMethod, pathInstance); jniEnv->DeleteLocalRef(pathInstance); - if (fsDataOutputStream == nullptr) { + if (fsDataOutputStream == nullptr || jniEnv->ExceptionCheck()) { return CheckThenError( std::string( "CallObjectMethod Exception when Init FlinkWritableFile, ") @@ -193,7 +193,7 @@ class FlinkReadableFile : virtual public FSSequentialFile, jobject fsDataInputStream = jniEnv->CallObjectMethod( file_system_instance_, openMethod.javaMethod, pathInstance); jniEnv->DeleteLocalRef(pathInstance); - if (fsDataInputStream == nullptr) { + if (fsDataInputStream == nullptr || jniEnv->ExceptionCheck()) { return CheckThenError( std::string( "CallObjectMethod Exception when Init FlinkReadableFile, ") @@ -355,7 +355,7 @@ Status FlinkFileSystem::Init() { jobject fileSystemInstance = jniEnv->CallStaticObjectMethod( fileSystemClass.javaClass, fileSystemGetMethod.javaMethod, uriInstance); jniEnv->DeleteLocalRef(uriInstance); - if (fileSystemInstance == nullptr) { + if (fileSystemInstance == nullptr || jniEnv->ExceptionCheck()) { return CheckThenError( std::string( "CallStaticObjectMethod Exception when Init FlinkFileSystem, ") @@ -504,7 +504,7 @@ IOStatus FlinkFileSystem::GetChildren(const std::string& file_name, auto fileStatusArray = (jobjectArray)jniEnv->CallObjectMethod( file_system_instance_, listStatusMethod.javaMethod, pathInstance); jniEnv->DeleteLocalRef(pathInstance); - if (fileStatusArray == nullptr) { + if (fileStatusArray == nullptr || jniEnv->ExceptionCheck()) { return CheckThenError( std::string("Exception when CallObjectMethod in GetChildren, ") .append(listStatusMethod.ToString()) @@ -516,7 +516,7 @@ IOStatus FlinkFileSystem::GetChildren(const std::string& file_name, jsize fileStatusArrayLen = jniEnv->GetArrayLength(fileStatusArray); for (jsize i = 0; i < fileStatusArrayLen; i++) { jobject fileStatusObj = jniEnv->GetObjectArrayElement(fileStatusArray, i); - if (fileStatusObj == nullptr) { + if (fileStatusObj == nullptr || jniEnv->ExceptionCheck()) { jniEnv->DeleteLocalRef(fileStatusArray); return CheckThenError( "Exception when GetObjectArrayElement in GetChildren"); @@ -527,7 +527,7 @@ IOStatus FlinkFileSystem::GetChildren(const std::string& file_name, jobject subPath = jniEnv->CallObjectMethod(fileStatusObj, getPathMethod.javaMethod); jniEnv->DeleteLocalRef(fileStatusObj); - if (subPath == nullptr) { + if (subPath == nullptr || jniEnv->ExceptionCheck()) { jniEnv->DeleteLocalRef(fileStatusArray); return CheckThenError( std::string("Exception when CallObjectMethod in GetChildren, ") @@ -539,6 +539,13 @@ IOStatus FlinkFileSystem::GetChildren(const std::string& file_name, auto subPathStr = (jstring)jniEnv->CallObjectMethod( subPath, pathToStringMethod.javaMethod); jniEnv->DeleteLocalRef(subPath); + if (subPathStr == nullptr || jniEnv->ExceptionCheck()) { + jniEnv->DeleteLocalRef(fileStatusArray); + return CheckThenError( + std::string("Exception when CallObjectMethod in GetChildren, ") + .append(pathToStringMethod.ToString())); + } + const char* str = jniEnv->GetStringUTFChars(subPathStr, nullptr); result->emplace_back(str); jniEnv->ReleaseStringUTFChars(subPathStr, str); diff --git a/env/flink/env_flink_test_suite.cc b/env/flink/env_flink_test_suite.cc index 2b1a312ab..4db7f6968 100644 --- a/env/flink/env_flink_test_suite.cc +++ b/env/flink/env_flink_test_suite.cc @@ -18,6 +18,7 @@ #include "env/flink/env_flink_test_suite.h" +#include #include #include @@ -28,6 +29,10 @@ std::abort(); \ } +#define ASSERT_FALSE(condition) ASSERT_TRUE(!(condition)) + +#define LOG(message) (std::cout << (message) << std::endl) + namespace ROCKSDB_NAMESPACE { EnvFlinkTestSuites::EnvFlinkTestSuites(const std::string& basePath) @@ -35,7 +40,15 @@ EnvFlinkTestSuites::EnvFlinkTestSuites(const std::string& basePath) void EnvFlinkTestSuites::runAllTestSuites() { setUp(); - testFileExist(); + LOG("Stage 1: setUp OK"); + testDirOperation(); + LOG("Stage 2: testDirOperation OK"); + testFileOperation(); + LOG("Stage 3: testFileOperation OK"); + testGetChildren(); + LOG("Stage 4: testGetChildren OK"); + testFileReadAndWrite(); + LOG("Stage 5: testFileReadAndWrite OK"); } void EnvFlinkTestSuites::setUp() { @@ -45,11 +58,110 @@ void EnvFlinkTestSuites::setUp() { } } -void EnvFlinkTestSuites::testFileExist() { - std::string fileName("test-file"); - Status result = flink_env_->FileExists(fileName); - ASSERT_TRUE(result.IsNotFound()); +void EnvFlinkTestSuites::testDirOperation() { + const std::string dir_name = "test-dir"; + ASSERT_TRUE(flink_env_->FileExists(dir_name).IsNotFound()); + ASSERT_TRUE(flink_env_->CreateDir(dir_name).ok()); + ASSERT_TRUE(flink_env_->CreateDirIfMissing(dir_name).ok()); + ASSERT_FALSE(flink_env_->CreateDir(dir_name).ok()); + + bool is_dir; + ASSERT_TRUE(flink_env_->IsDirectory(dir_name, &is_dir).ok() && is_dir); + ASSERT_TRUE(flink_env_->FileExists(dir_name).ok()); + ASSERT_TRUE(flink_env_->DeleteDir(dir_name).ok()); + ASSERT_TRUE(flink_env_->FileExists(dir_name).IsNotFound()); +} + +void EnvFlinkTestSuites::testFileOperation() { + const std::string file_name = "test-file"; + const std::string not_exist_file_name = "not-exist-file"; + + // test file exists + ASSERT_TRUE(flink_env_->FileExists(file_name).IsNotFound()); + generateFile(file_name); + ASSERT_TRUE(flink_env_->FileExists(file_name).ok()); + + // test file status + uint64_t file_size, file_mtime; + ASSERT_TRUE(flink_env_->GetFileSize(file_name, &file_size).ok()); + ASSERT_FALSE(flink_env_->GetFileSize(not_exist_file_name, &file_size).ok()); + ASSERT_TRUE(file_size > 0); + ASSERT_TRUE(flink_env_->GetFileModificationTime(file_name, &file_mtime).ok()); + ASSERT_FALSE( + flink_env_->GetFileModificationTime(not_exist_file_name, &file_mtime) + .ok()); + ASSERT_TRUE(file_mtime > 0); + + // test renaming file + const std::string file_name_2 = "test-file-2"; + flink_env_->RenameFile(file_name, file_name_2); + ASSERT_TRUE(flink_env_->FileExists(file_name).IsNotFound()); + ASSERT_TRUE(flink_env_->FileExists(file_name_2).ok()); + ASSERT_TRUE(flink_env_->DeleteFile(file_name_2).ok()); + ASSERT_TRUE(flink_env_->FileExists(file_name_2).IsNotFound()); +} + +void EnvFlinkTestSuites::testGetChildren() { + const std::string dir_name = "test-dir"; + const std::string sub_dir_name = dir_name + "/test-sub-dir"; + const std::string file_name_1 = dir_name + "/test-file-1"; + const std::string file_name_2 = dir_name + "/test-file-2"; + ASSERT_TRUE(flink_env_->CreateDirIfMissing(dir_name).ok()); + ASSERT_TRUE(flink_env_->CreateDirIfMissing(sub_dir_name).ok()); + generateFile(file_name_1); + generateFile(file_name_2); + std::vector result, + expected{base_path_ + sub_dir_name, base_path_ + file_name_1, + base_path_ + file_name_2}; + ASSERT_TRUE(flink_env_->GetChildren(dir_name, &result).ok()); + ASSERT_TRUE(result.size() == 3); + std::sort(result.begin(), result.end()); + std::sort(expected.begin(), expected.end()); + ASSERT_TRUE(expected == result); +} + +void EnvFlinkTestSuites::testFileReadAndWrite() { + const std::string file_name = "test-file"; + const std::string content1 = "Hello World", content2 = ", Hello ForSt", + content = content1 + content2; + + std::unique_ptr write_result; + ASSERT_TRUE( + flink_env_->NewWritableFile(file_name, &write_result, EnvOptions()).ok()); + write_result->Append(content1); + write_result->Append(content2); + write_result->Sync(); + write_result->Flush(); + write_result->Close(); + + std::unique_ptr sequential_result; + ASSERT_TRUE( + flink_env_->NewSequentialFile(file_name, &sequential_result, EnvOptions()) + .ok()); + + Slice sequential_data; + char* sequential_scratch = new char[content2.size()]; + sequential_result->Skip(content1.size()); + sequential_result->Read(content2.size(), &sequential_data, + sequential_scratch); + ASSERT_TRUE(sequential_data.data() == content2); + delete[] sequential_scratch; + + std::unique_ptr random_access_result; + ASSERT_TRUE( + flink_env_ + ->NewRandomAccessFile(file_name, &random_access_result, EnvOptions()) + .ok()); + Slice random_access_data; + char* random_access_scratch = new char[content2.size()]; + random_access_result->Read(content1.size(), content.size() - content1.size(), + &random_access_data, (char*)random_access_scratch); + ASSERT_TRUE(random_access_data.data() == content2); + delete[] random_access_scratch; +} + +void EnvFlinkTestSuites::generateFile(const std::string& fileName) { // Generate a file manually const std::string prefix = "file:"; std::string writeFileName = base_path_ + fileName; @@ -57,10 +169,7 @@ void EnvFlinkTestSuites::testFileExist() { writeFileName = writeFileName.substr(prefix.size()); } std::ofstream writeFile(writeFileName); - writeFile << "testFileExist"; + writeFile << "Hello World"; writeFile.close(); - - result = flink_env_->FileExists(fileName); - ASSERT_TRUE(result.ok()); } } // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/env_flink_test_suite.h b/env/flink/env_flink_test_suite.h index 3826060d5..c7512b031 100644 --- a/env/flink/env_flink_test_suite.h +++ b/env/flink/env_flink_test_suite.h @@ -29,6 +29,11 @@ class EnvFlinkTestSuites { std::unique_ptr flink_env_; const std::string base_path_; void setUp(); - void testFileExist(); + void testDirOperation(); + void testFileOperation(); + void testGetChildren(); + void testFileReadAndWrite(); + + void generateFile(const std::string& fileName); }; } // namespace ROCKSDB_NAMESPACE \ No newline at end of file From 9c23507040c0efed8324ffc4dfbf0763d3884ae4 Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Mon, 1 Apr 2024 18:54:46 +0800 Subject: [PATCH 30/61] [build] Fix warning about unused parameters --- env/flink/env_flink.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index 26deba9e7..eae1773cf 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -379,7 +379,7 @@ IOStatus FlinkFileSystem::NewSequentialFile( const std::string& fname, const FileOptions& options, std::unique_ptr* result, IODebugContext* dbg) { result->reset(); - IOStatus status = FileExists(fname, IOOptions(), dbg); + IOStatus status = FileExists(fname, options.io_options, dbg); if (!status.ok()) { return status; } @@ -400,7 +400,7 @@ IOStatus FlinkFileSystem::NewRandomAccessFile( const std::string& fname, const FileOptions& options, std::unique_ptr* result, IODebugContext* dbg) { result->reset(); - IOStatus status = FileExists(fname, IOOptions(), dbg); + IOStatus status = FileExists(fname, options.io_options, dbg); if (!status.ok()) { return status; } @@ -623,8 +623,8 @@ IOStatus FlinkFileSystem::CreateDir(const std::string& file_name, } IOStatus FlinkFileSystem::CreateDirIfMissing(const std::string& file_name, - const IOOptions& options, - IODebugContext* dbg) { + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) { JNIEnv* jniEnv = getJNIEnv(); std::string filePath = ConstructPath(file_name); From 5d70ad0574987a530453cdd619ddd8aa6c476c45 Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Sat, 6 Apr 2024 12:32:05 +0800 Subject: [PATCH 31/61] [build] Support releasing forst --- CMakeLists.txt | 1 + FORST-RELEASE.md | 248 ++++++++++++++++++ Makefile | 35 ++- java/crossbuild/build-win.bat | 16 ++ java/deploysettings.xml | 12 + java/pom.xml.template | 46 +--- ...ish-frocksdbjni.sh => publish-forstjni.sh} | 4 +- 7 files changed, 322 insertions(+), 40 deletions(-) create mode 100644 FORST-RELEASE.md create mode 100644 java/crossbuild/build-win.bat create mode 100644 java/deploysettings.xml rename java/{publish-frocksdbjni.sh => publish-forstjni.sh} (93%) diff --git a/CMakeLists.txt b/CMakeLists.txt index e8866f2af..0a864e1c9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1154,6 +1154,7 @@ endif() if(WITH_JNI OR JNI) message(STATUS "JNI library is enabled") add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/java) + find_package(JNI) include_directories(${JNI_INCLUDE_DIRS}) if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux") include_directories(${JNI_INCLUDE_DIRS}/linux) diff --git a/FORST-RELEASE.md b/FORST-RELEASE.md new file mode 100644 index 000000000..f9f48fb20 --- /dev/null +++ b/FORST-RELEASE.md @@ -0,0 +1,248 @@ +# ForSt Release Process + +## Summary + +ForSt releases are a fat jar file that contain the following binaries: +* .so files for linux32 (glibc and musl-libc) +* .so files for linux64 (glibc and musl-libc) +* .so files for linux [aarch64](https://en.wikipedia.org/wiki/AArch64) (glibc and musl-libc) +* .so files for linux [ppc64le](https://en.wikipedia.org/wiki/Ppc64le) (glibc and musl-libc) +* .jnilib file for Mac OSX +* .dll for Windows x64 + +To build the binaries for a ForSt release, building on native architectures is advised. Building the binaries for ppc64le and aarch64 *can* be done using QEMU, but you may run into emulation bugs and the build times will be dramatically slower (up to x20). + +We recommend building the binaries on environments with at least 4 cores, 16GB RAM and 40GB of storage. The following environments are recommended for use in the build process: +* Windows x64 +* Linux aarch64 +* Linux ppc64le +* Mac OSX + +## Build for Windows + +For the Windows binary build, we recommend using a base [AWS Windows EC2 instance](https://aws.amazon.com/windows/products/ec2/) with 4 cores, 16GB RAM, 40GB storage for the build. + +Firstly, install [chocolatey](https://chocolatey.org/install). Once installed, the following required components can be installed using Powershell: + + choco install git.install jdk8 maven visualstudio2017community visualstudio2017-workload-nativedesktop + +Open the "Developer Command Prompt for VS 2017" and run the following commands: + + git clone git@github.com:ververica/ForSt.git + cd ForSt + java\crossbuild\build-win.bat + +The resulting native binary will be built and available at `build\java\Release\rocksdbjni-shared.dll`. You can also find it under project folder with name `librocksdbjni-win64.dll`. +The result windows jar is `build\java\rocksdbjni_classes.jar`. + +There is also a how-to in CMakeLists.txt. + +**Once finished, extract the `librocksdbjni-win64.dll` from the build environment. You will need this .dll in the final crossbuild.** + +## Build for aarch64 + +For the Linux aarch64 binary build, we recommend using a base [AWS Ubuntu Server 20.04 LTS EC2](https://aws.amazon.com/windows/products/ec2/) with a 4 core Arm processor, 16GB RAM, 40GB storage for the build. You can also attempt to build with QEMU on a non-aarch64 processor, but you may run into emulation bugs and very long build times. + +### Building in aarch64 environment + +First, install the required packages such as Java 8 and make: + + sudo apt-get update + sudo apt-get install build-essential openjdk-8-jdk + +then, install and setup [Docker](https://docs.docker.com/engine/install/ubuntu/): + + sudo apt-get install apt-transport-https ca-certificates curl gnupg lsb-release + + curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg + echo "deb [arch=arm64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null + + sudo apt-get update + sudo apt-get install docker-ce docker-ce-cli containerd.io + + sudo groupadd docker + sudo usermod -aG docker $USER + newgrp docker + +Then, clone the ForSt repo: + + git clone https://github.com/ververica/ForSt.git + cd ForSt + +First, build the glibc binary: + + make jclean clean rocksdbjavastaticdockerarm64v8 + +**Once finished, extract the `java/target/librocksdbjni-linux-aarch64.so` from the build environment. You will need this .so in the final crossbuild.** + +Next, build the musl-libc binary: + + make jclean clean rocksdbjavastaticdockerarm64v8musl + +**Once finished, extract the `java/target/librocksdbjni-linux-aarch64-musl.so` from the build environment. You will need this .so in the final crossbuild.** + +### Building via QEMU + +You can use QEMU on, for example, an `x86_64` system to build the aarch64 binaries. To set this up on an Ubuntu environment: + + sudo apt-get install qemu binfmt-support qemu-user-static + docker run --rm --privileged multiarch/qemu-user-static --reset -p yes + +To verify that you can now run aarch64 docker images: + + docker run --rm -t arm64v8/ubuntu uname -m + > aarch64 + +You can now attempt to build the aarch64 binaries as in the previous section. + +## Build in PPC64LE + +For the ppc64le binaries, we recommend building on a PowerPC machine if possible, as it can be tricky to spin up a ppc64le cloud environment. However, if a PowerPC machine is not available, [Travis-CI](https://www.travis-ci.com/) offers ppc64le build environments that work perfectly for building these binaries. If neither a machine or Travis are an option, you can use QEMU but the build may take a very long time and be prone to emulation errors. + +### Building in ppc64le environment + +As with the aarch64 environment, the ppc64le environment will require Java 8, Docker and build-essentials installed. Once installed, you can build the 2 binaries: + + make jclean clean rocksdbjavastaticdockerppc64le + +**Once finished, extract the `java/target/librocksdbjni-linux-ppc64le.so` from the build environment. You will need this .so in the final crossbuild.** + + make jclean clean rocksdbjavastaticdockerppc64lemusl + +**Once finished, extract the `java/target/librocksdbjni-linux-ppc64le-musl.so` from the build environment. You will need this .so in the final crossbuild.** + +### Building via Travis + +Travis-CI supports ppc64le build environments, and this can be a convenient way of building in the absence of a PowerPC machine. Assuming that you have an S3 bucket called **my-forst-release-artifacts**, the following Travis configuration will build the release artifacts and push them to the S3 bucket: + +``` +dist: xenial +language: cpp +os: + - linux +arch: + - ppc64le + +services: + - docker +addons: + artifacts: + paths: + - $TRAVIS_BUILD_DIR/java/target/librocksdbjni-linux-ppc64le-musl.so + - $TRAVIS_BUILD_DIR/java/target/librocksdbjni-linux-ppc64le.so + +env: + global: + - ARTIFACTS_BUCKET=my-forst-release-artifacts + jobs: + - CMD=rocksdbjavastaticdockerppc64le + - CMD=rocksdbjavastaticdockerppc64lemusl + +install: + - sudo apt-get install -y openjdk-8-jdk || exit $? + - export PATH=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture)/bin:$PATH + - export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture) + - echo "JAVA_HOME=${JAVA_HOME}" + - which java && java -version + - which javac && javac -version + +script: + - make jclean clean $CMD +``` + +**Make sure to set the `ARTIFACTS_KEY` and `ARTIFACTS_SECRET` environment variables in the Travis Job with valid AWS credentials to access the S3 bucket you defined.** + +**Make sure to avoid signatureV4-only S3 regions to store the uploaded artifacts (due to unresolved https://github.com/travis-ci/artifacts/issues/57). You can just choose the S3 bucket of `us-east-1` region for 100% compatibility.** + +**Once finished, the`librocksdbjni-linux-ppce64le.so` and `librocksdbjni-linux-ppce64le-musl.so` binaries will be in the S3 bucket. You will need these .so binaries in the final crossbuild.** + + +### Building via QEMU + +You can use QEMU on, for example, an `x86_64` system to build the ppc64le binaries. To set this up on an Ubuntu environment: + + sudo apt-get install qemu binfmt-support qemu-user-static + docker run --rm --privileged multiarch/qemu-user-static --reset -p yes + +To verify that you can now run ppc64le docker images: + + docker run --rm -t ppc64le/ubuntu uname -m + > ppc64le + +You can now attempt to build the ppc64le binaries as in the previous section. + +## Final crossbuild in Mac OSX + +Documentation for the final crossbuild for Mac OSX and Linux is described in [java/RELEASE.md](java/RELEASE.md) as has information on dependencies that should be installed. As above, this tends to be Java 8, build-essentials and Docker. + +Before you run this step, you should have 5 binaries from the previous build steps: + +1. `librocksdbjni-win64.dll` from the Windows build step. +2. `librocksdbjni-linux-aarch64.so` from the aarch64 build step. +3. `librocksdbjni-linux-aarch64-musl.so` from the aarch64 build step. +4. `librocksdbjni-linux-ppc64le.so` from the ppc64le build step. +5. `librocksdbjni-linux-ppc64le-musl.so` from the ppc64le build step. + +To start the crossbuild within a Mac OSX environment: + + make jclean clean + mkdir -p java/target + cp /librocksdbjni-win64.dll java/target/librocksdbjni-win64.dll + cp /librocksdbjni-linux-ppc64le.so java/target/librocksdbjni-linux-ppc64le.so + cp /librocksdbjni-linux-ppc64le-musl.so java/target/librocksdbjni-linux-ppc64le-musl.so + cp /librocksdbjni-linux-aarch64.so java/target/librocksdbjni-linux-aarch64.so + cp /librocksdbjni-linux-aarch64-musl.so java/target/librocksdbjni-linux-aarch64-musl.so + FORST_VERSION=0.1.0-SNAPSHOT PORTABLE=1 ROCKSDB_DISABLE_JEMALLOC=true DEBUG_LEVEL=0 make forstjavastaticreleasedocker + +*Note, we disable jemalloc on mac due to https://github.com/facebook/rocksdb/issues/5787*. + +Once finished, there should be a directory at `java/target/forst-release` with the ForSt jar, javadoc jar, sources jar and pom in it. You can inspect the jar file and ensure that contains the binaries, history file, etc: + +``` +$ jar tf forstjni-$(FORST_VERSION).jar +META-INF/ +META-INF/MANIFEST.MF +HISTORY-JAVA.md +HISTORY.md +librocksdbjni-linux-aarch64-musl.so +librocksdbjni-linux-aarch64.so +librocksdbjni-linux-ppc64le-musl.so +librocksdbjni-linux-ppc64le.so +librocksdbjni-linux32-musl.so +librocksdbjni-linux32.so +librocksdbjni-linux64-musl.so +librocksdbjni-linux64.so +librocksdbjni-osx.jnilib +librocksdbjni-win64.dl +... +``` + +*Note that it contains linux32/64.so binaries as well as librocksdbjni-osx.jnilib*. + +## Push to Maven Central + +For this step, you will need the following: + +- The OSX Crossbuild artifacts built in `java/target/forst-release` as above. +- A Sonatype account with access to the staging repository. If you do not have permission, open a ticket with Sonatype, [such as this one](https://issues.sonatype.org/browse/OSSRH-72185). +- A GPG key to sign the release, with your public key available for verification (for example, by uploading it to https://keys.openpgp.org/) + +To upload the release to the Sonatype staging repository: +```bash +VERSION= \ +USER= \ +PASSWORD= \ +KEYNAME= \ +PASSPHRASE= \ +java/publish-forstjni.sh +``` + +Go to the staging repositories on Sonatype: + +https://oss.sonatype.org/#stagingRepositories + +Select the open staging repository and click on "Close". + +The staging repository will look something like `https://oss.sonatype.org/content/repositories/xxxx-1020`. You can use this staged release to test the artifacts and ensure they are correct. + +Once you have verified the artifacts are correct, press the "Release" button. **WARNING: this can not be undone**. Within 24-48 hours, the artifact will be available on Maven Central for use. \ No newline at end of file diff --git a/Makefile b/Makefile index 2be194499..644a4b4df 100644 --- a/Makefile +++ b/Makefile @@ -6,6 +6,8 @@ #----------------------------------------------- +FORST_VERSION ?= 0.1.0 + BASH_EXISTS := $(shell which bash) SHELL := $(shell which bash) include common.mk @@ -2325,10 +2327,41 @@ rocksdbjavastaticrelease: rocksdbjavastaticosx rocksdbjava_javadocs_jar rocksdbj rocksdbjavastaticreleasedocker: rocksdbjavastaticosx rocksdbjavastaticdockerx86 rocksdbjavastaticdockerx86_64 rocksdbjavastaticdockerx86musl rocksdbjavastaticdockerx86_64musl rocksdbjava_javadocs_jar rocksdbjava_sources_jar cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR_ALL) HISTORY*.md - cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) librocksdbjni-*.so librocksdbjni-*.jnilib + cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) librocksdbjni-*.so librocksdbjni-*.jnilib librocksdbjni-win64.dll cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR_ALL) org/rocksdb/*.class org/rocksdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR_ALL) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR_ALL).sha1 +forstjavastaticreleasedocker: rocksdbjavastaticreleasedocker + # update apache license + mkdir -p java/target/META-INF + cp LICENSE java/target/META-INF/LICENSE + cd java/target;jar -uf $(ROCKSDB_JAR_ALL) META-INF/LICENSE + + # jars to be released + $(eval JAR_PREF=forstjni-$(FORST_VERSION)) + $(eval JAR_DOCS=$(JAR_PREF)-javadoc.jar) + $(eval JAR_SOURCES=$(JAR_PREF)-sources.jar) + + # update docs and sources jars + cd java/target;jar -uf $(JAR_DOCS) META-INF/LICENSE + cd java/target;jar -uf $(JAR_SOURCES) META-INF/LICENSE + + # prepare forst release + cd java/target;mkdir -p forst-release + + $(eval FORST_JAVA_VERSION=$(FORST_VERSION)) + $(eval FJAR_PREF=forstjni-$(FORST_JAVA_VERSION)) + $(eval FJAR=$(FJAR_PREF).jar) + $(eval FJAR_DOCS=$(FJAR_PREF)-javadoc.jar) + $(eval FJAR_SOURCES=$(FJAR_PREF)-sources.jar) + + cd java/target;cp $(ROCKSDB_JAR_ALL) forst-release/$(FJAR) + cd java/target;cp $(JAR_DOCS) forst-release/$(FJAR_DOCS) + cd java/target;cp $(JAR_SOURCES) forst-release/$(FJAR_SOURCES) + openssl sha1 java/target/$(ROCKSDB_JAR_ALL) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR_ALL).sha1 + cd java;cat pom.xml.template | sed 's/\$${FORST_JAVA_VERSION}/$(FORST_JAVA_VERSION)/' > pom.xml + cd java;cp pom.xml target/forst-release/$(FJAR_PREF).pom + rocksdbjavastaticdockerx86: mkdir -p java/target docker run --rm --name rocksdb_linux_x86-be --platform linux/386 --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) evolvedbinary/rocksjava:centos6_x86-be /rocksdb-host/java/crossbuild/docker-build-linux-centos.sh diff --git a/java/crossbuild/build-win.bat b/java/crossbuild/build-win.bat new file mode 100644 index 000000000..2925ec19a --- /dev/null +++ b/java/crossbuild/build-win.bat @@ -0,0 +1,16 @@ +:: install git, java 8, maven, visual studio community 15 (2017) + +set MSBUILD=C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\MSBuild\15.0\Bin\MSBuild.exe + +if exist build rd /s /q build +if exist librocksdbjni-win64.dll del librocksdbjni-win64.dll +mkdir build && cd build + +cmake -G "Visual Studio 15 Win64" -DWITH_JNI=1 .. + +"%MSBUILD%" rocksdb.sln /p:Configuration=Release /m + +cd .. + +copy build\java\Release\rocksdbjni-shared.dll librocksdbjni-win64.dll +echo Result is in librocksdbjni-win64.dll \ No newline at end of file diff --git a/java/deploysettings.xml b/java/deploysettings.xml new file mode 100644 index 000000000..acd06d518 --- /dev/null +++ b/java/deploysettings.xml @@ -0,0 +1,12 @@ + + + + sonatype-nexus-staging + ${sonatype_user} + ${sonatype_pw} + + + \ No newline at end of file diff --git a/java/pom.xml.template b/java/pom.xml.template index 8a1981c66..0090ff142 100644 --- a/java/pom.xml.template +++ b/java/pom.xml.template @@ -2,12 +2,12 @@ 4.0.0 - org.rocksdb - rocksdbjni - ${ROCKSDB_JAVA_VERSION} + com.ververica + forstjni + ${FORST_JAVA_VERSION} - RocksDB JNI - RocksDB fat jar that contains .so files for linux32 and linux64 (glibc and musl-libc), jnilib files + ForSt JNI + ForSt fat jar that contains .so files for linux32 and linux64 (glibc and musl-libc), jnilib files for Mac OSX, and a .dll for Windows x64. https://rocksdb.org @@ -19,45 +19,19 @@ http://www.apache.org/licenses/LICENSE-2.0.html repo - - GNU General Public License, version 2 - http://www.gnu.org/licenses/gpl-2.0.html - repo - - scm:git:https://github.com/facebook/rocksdb.git - scm:git:https://github.com/facebook/rocksdb.git - scm:git:https://github.com/facebook/rocksdb.git + scm:git:https://github.com/ververica/ForSt.git + scm:git:https://github.com/ververica/ForSt.git + scm:git:https://github.com/ververica/ForSt.git - Facebook - https://www.facebook.com + Ververica + https://www.ververica.com - - - Facebook - help@facebook.com - America/New_York - - architect - - - - - - - rocksdb - Google Groups - rocksdb-subscribe@googlegroups.com - rocksdb-unsubscribe@googlegroups.com - rocksdb@googlegroups.com - https://groups.google.com/forum/#!forum/rocksdb - - - 1.8 1.8 diff --git a/java/publish-frocksdbjni.sh b/java/publish-forstjni.sh similarity index 93% rename from java/publish-frocksdbjni.sh rename to java/publish-forstjni.sh index 2a6bd2865..6518206fa 100644 --- a/java/publish-frocksdbjni.sh +++ b/java/publish-forstjni.sh @@ -20,7 +20,7 @@ # fail on errors set -e -PREFIX=java/target/frocksdb-release/frocksdbjni-${VERSION} +PREFIX=java/target/forst-release/forstjni-${VERSION} function deploy() { FILE=$1 @@ -37,8 +37,6 @@ function deploy() { -Dgpg.passphrase="${PASSPHRASE}" } -PREFIX=java/target/frocksdb-release/frocksdbjni-${VERSION} - deploy ${PREFIX}-sources.jar sources deploy ${PREFIX}-javadoc.jar javadoc deploy ${PREFIX}.jar From a9f4b16d482569481247947a0ab6c9e31533f04b Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Sun, 7 Apr 2024 12:05:25 +0800 Subject: [PATCH 32/61] [build] Fix platform-related codes --- CMakeLists.txt | 10 +++++----- env/flink/jvm_util.cc | 8 ++++---- java/rocksjni/env_flink.cc | 3 +-- 3 files changed, 10 insertions(+), 11 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0a864e1c9..fa630f327 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -728,6 +728,10 @@ set(SOURCES env/fs_remap.cc env/mock_env.cc env/unique_id_gen.cc + env/flink/env_flink.cc + env/flink/jvm_util.cc + env/flink/jni_helper.cc + env/flink/env_flink_test_suite.cc file/delete_scheduler.cc file/file_prefetch_buffer.cc file/file_util.cc @@ -1016,11 +1020,7 @@ else() port/port_posix.cc env/env_posix.cc env/fs_posix.cc - env/io_posix.cc - env/flink/env_flink.cc - env/flink/jvm_util.cc - env/flink/jni_helper.cc - env/flink/env_flink_test_suite.cc) + env/io_posix.cc) endif() if(USE_FOLLY_LITE) diff --git a/env/flink/jvm_util.cc b/env/flink/jvm_util.cc index ecd6f9677..ab5cc9663 100644 --- a/env/flink/jvm_util.cc +++ b/env/flink/jvm_util.cc @@ -18,14 +18,14 @@ #include "env/flink/jvm_util.h" -#define UNUSED(x) (void)(x) +#define UNUSED_JNI_PARAMETER(x) (void)(x) namespace ROCKSDB_NAMESPACE { std::atomic jvm_ = std::atomic(nullptr); JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { - UNUSED(reserved); + UNUSED_JNI_PARAMETER(reserved); JNIEnv* env = nullptr; if (vm->GetEnv((void**)&env, JNI_VERSION_1_8) != JNI_OK) { return -1; @@ -36,8 +36,8 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { } JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) { - UNUSED(vm); - UNUSED(reserved); + UNUSED_JNI_PARAMETER(vm); + UNUSED_JNI_PARAMETER(reserved); jvm_.store(nullptr); } diff --git a/java/rocksjni/env_flink.cc b/java/rocksjni/env_flink.cc index f6d4b44ca..55d2edca5 100644 --- a/java/rocksjni/env_flink.cc +++ b/java/rocksjni/env_flink.cc @@ -20,8 +20,7 @@ #include -#include - +#include "include/org_rocksdb_FlinkEnv.h" #include "java/rocksjni/portal.h" #include "rocksdb/env.h" From 1d531dab3f2d2dd98a509d6b2cb5cab72c1373a6 Mon Sep 17 00:00:00 2001 From: Zakelly Date: Wed, 6 Mar 2024 14:17:12 +0800 Subject: [PATCH 33/61] [build] Setting up templates for issues and PRs (#1) (cherry picked from commit e7b6d68b6eca99f0f8780d30889e45e80df07ab0) --- .github/ISSUE_TEMPLATE/bug_report.md | 29 ++++++++++++++++++ .github/ISSUE_TEMPLATE/config.yml | 8 +++++ .github/ISSUE_TEMPLATE/work_item.md | 20 +++++++++++++ .github/pull_request_template.md | 44 ++++++++++++++++++++++++++++ issue_template.md | 7 ----- 5 files changed, 101 insertions(+), 7 deletions(-) create mode 100644 .github/ISSUE_TEMPLATE/bug_report.md create mode 100644 .github/ISSUE_TEMPLATE/config.yml create mode 100644 .github/ISSUE_TEMPLATE/work_item.md create mode 100644 .github/pull_request_template.md delete mode 100644 issue_template.md diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 000000000..044c642ce --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,29 @@ +--- +name: Bug report +about: Create a report to help us improve +title: '' +labels: bug +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Steps to reproduce the behavior: +1. Compile '...' +2. Run '....' +3. See error + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Desktop (please complete the following information):** + - OS: [e.g. CentOS 7.8] + +**Additional context** +Add any other context about the problem here. diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 000000000..e3e7745a4 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,8 @@ +blank_issues_enabled: false +contact_links: + - name: Have questions + url: https://github.com/ververica/ForSt/discussions/categories/q-a + about: Please ask and answer questions here. + - name: New Ideas + url: https://github.com/ververica/ForSt/discussions/categories/ideas + about: Please suggest your new ideas here. \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/work_item.md b/.github/ISSUE_TEMPLATE/work_item.md new file mode 100644 index 000000000..d3dea472d --- /dev/null +++ b/.github/ISSUE_TEMPLATE/work_item.md @@ -0,0 +1,20 @@ +--- +name: Work Item +about: Suggest/Log a work item (For big ideas and proposals, please go to New Ideas) +title: '' +labels: '' +assignees: '' + +--- + +**What is this for** +A clear and concise description of what the item is. + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 000000000..9429374eb --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,44 @@ + + +## What is the purpose of the change + +*(For example: This pull request enables caching all the java classes that will be frequently used.)* + + +## Brief change log + +*(for example:)* + - *A global cache container* + - *Cache entries for each objects* + + +## Verifying this change + +*(Please pick either of the following options)* + +This change is a trivial rework / code cleanup without any test coverage. + +*(or)* + +This change is already covered by existing tests, such as *(please describe tests)*. + +*(or)* + +This change added tests and can be verified as follows: + +*(example:)* + - *first step* + - *second step* + - *third step, and xxx behaves as expected* \ No newline at end of file diff --git a/issue_template.md b/issue_template.md deleted file mode 100644 index ca52f5ead..000000000 --- a/issue_template.md +++ /dev/null @@ -1,7 +0,0 @@ -> Note: Please use Issues only for bug reports. For questions, discussions, feature requests, etc. post to dev group: https://groups.google.com/forum/#!forum/rocksdb or https://www.facebook.com/groups/rocksdb.dev - -### Expected behavior - -### Actual behavior - -### Steps to reproduce the behavior From eaa8588741441820b860b0ab00b090668ec20b29 Mon Sep 17 00:00:00 2001 From: Zakelly Date: Thu, 7 Mar 2024 12:05:10 +0800 Subject: [PATCH 34/61] [build] Remove buckify output in sanity check (#3) This fixes #2 (cherry picked from commit 6f910e2772e770bbeab87bd417dd5e88a6b91019) --- .github/workflows/sanity_check.yml | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/.github/workflows/sanity_check.yml b/.github/workflows/sanity_check.yml index efc9d99cf..093b2e230 100644 --- a/.github/workflows/sanity_check.yml +++ b/.github/workflows/sanity_check.yml @@ -38,8 +38,5 @@ jobs: - name: Check format run: VERBOSE_CHECK=1 make check-format - - name: Compare buckify output - run: make check-buck-targets - - name: Simple source code checks - run: make check-sources + run: make check-sources \ No newline at end of file From f10be993a3d7aeadd2750a7f278e7f3f2286c580 Mon Sep 17 00:00:00 2001 From: yhx <38719192+masteryhx@users.noreply.github.com> Date: Tue, 12 Mar 2024 11:25:14 +0800 Subject: [PATCH 35/61] [env] Introduce interface of env_flink (#5) (cherry picked from commit 61f9574773fbfdae7b2f71bd8f861605afead3ec) --- CMakeLists.txt | 3 +- env/flink/env_flink.cc | 10 ++++ env/flink/env_flink.h | 101 +++++++++++++++++++++++++++++++++++++++++ src.mk | 1 + 4 files changed, 114 insertions(+), 1 deletion(-) create mode 100644 env/flink/env_flink.cc create mode 100644 env/flink/env_flink.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 5fcd9b7cd..61f96005b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1019,7 +1019,8 @@ else() port/port_posix.cc env/env_posix.cc env/fs_posix.cc - env/io_posix.cc) + env/io_posix.cc + env/flink/env_flink.cc) endif() if(USE_FOLLY_LITE) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc new file mode 100644 index 000000000..87183f131 --- /dev/null +++ b/env/flink/env_flink.cc @@ -0,0 +1,10 @@ +// Copyright (c) 2021-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). + +// TODO: +// 1. Register flink env to ObjectLibrary +// 2. Implement all methods of env_flink.h + +#include "env_flink.h" \ No newline at end of file diff --git a/env/flink/env_flink.h b/env/flink/env_flink.h new file mode 100644 index 000000000..d1912a3de --- /dev/null +++ b/env/flink/env_flink.h @@ -0,0 +1,101 @@ +// Copyright (c) 2021-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). + +#pragma once + +#include "rocksdb/env.h" +#include "rocksdb/file_system.h" +#include "rocksdb/status.h" + +namespace ROCKSDB_NAMESPACE { + +// FlinkFileSystem extended from FileSystemWrapper which delegate necessary +// methods to Flink FileSystem based on JNI. For other methods, base FileSystem +// will proxy its methods. +class FlinkFileSystem : public FileSystemWrapper { + public: + // Create FlinkFileSystem with base_fs proxying all other methods and + // base_path + static Status Create(const std::shared_ptr& /*base_fs*/, + const std::string& /*base_path*/, + std::unique_ptr* /*fs*/); + + // Define some names + static const char* kClassName() { return "FlinkFileSystem"; } + const char* Name() const override { return kClassName(); } + static const char* kNickName() { return "flink"; } + const char* NickName() const override { return kNickName(); } + + // Constructor and Destructor + explicit FlinkFileSystem(const std::shared_ptr& base, + const std::string& fsname); + ~FlinkFileSystem() override; + + // Several methods current FileSystem must implement + + std::string GetId() const override; + Status ValidateOptions(const DBOptions& /*db_opts*/, + const ColumnFamilyOptions& /*cf_opts*/) const override; + IOStatus NewSequentialFile(const std::string& /*fname*/, + const FileOptions& /*options*/, + std::unique_ptr* /*result*/, + IODebugContext* /*dbg*/) override; + IOStatus NewRandomAccessFile(const std::string& /*fname*/, + const FileOptions& /*options*/, + std::unique_ptr* /*result*/, + IODebugContext* /*dbg*/) override; + IOStatus NewWritableFile(const std::string& /*fname*/, + const FileOptions& /*options*/, + std::unique_ptr* /*result*/, + IODebugContext* /*dbg*/) override; + IOStatus NewDirectory(const std::string& /*name*/, + const IOOptions& /*options*/, + std::unique_ptr* /*result*/, + IODebugContext* /*dbg*/) override; + IOStatus FileExists(const std::string& /*fname*/, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus GetChildren(const std::string& /*path*/, + const IOOptions& /*options*/, + std::vector* /*result*/, + IODebugContext* /*dbg*/) override; + IOStatus DeleteFile(const std::string& /*fname*/, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus CreateDir(const std::string& /*name*/, const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus CreateDirIfMissing(const std::string& /*name*/, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus DeleteDir(const std::string& /*name*/, const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus GetFileSize(const std::string& /*fname*/, + const IOOptions& /*options*/, uint64_t* /*size*/, + IODebugContext* /*dbg*/) override; + IOStatus GetFileModificationTime(const std::string& /*fname*/, + const IOOptions& /*options*/, + uint64_t* /*time*/, + IODebugContext* /*dbg*/) override; + IOStatus RenameFile(const std::string& /*src*/, const std::string& /*target*/, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus LockFile(const std::string& /*fname*/, const IOOptions& /*options*/, + FileLock** /*lock*/, IODebugContext* /*dbg*/) override; + IOStatus UnlockFile(FileLock* /*lock*/, const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override; + IOStatus IsDirectory(const std::string& /*path*/, + const IOOptions& /*options*/, bool* /*is_dir*/, + IODebugContext* /*dbg*/) override; + + private: + std::string base_path_; +}; + +// Returns a `FlinkEnv` with base_path +Status NewFlinkEnv(const std::string& base_path, std::unique_ptr* env); +// Returns a `FlinkFileSystem` with base_path +Status NewFlinkFileSystem(const std::string& base_path, + std::shared_ptr* fs); +} // namespace ROCKSDB_NAMESPACE diff --git a/src.mk b/src.mk index dc3289b00..caad7ee8f 100644 --- a/src.mk +++ b/src.mk @@ -113,6 +113,7 @@ LIB_SOURCES = \ env/io_posix.cc \ env/mock_env.cc \ env/unique_id_gen.cc \ + env/flink/env_flink.cc \ file/delete_scheduler.cc \ file/file_prefetch_buffer.cc \ file/file_util.cc \ From b8cb45ea8ef3a201bb85a45207a4cc480dbc63c2 Mon Sep 17 00:00:00 2001 From: "jinse.ljz" Date: Tue, 12 Mar 2024 12:56:06 +0800 Subject: [PATCH 36/61] [env] Introduce JvmUtils to support global JNIEnv (cherry picked from commit 44debe7a9de2c1a50405bd7501830670b9542451) --- CMakeLists.txt | 7 +++- env/flink/jvm_util.cc | 59 ++++++++++++++++++++++++++++++++++ env/flink/jvm_util.h | 74 +++++++++++++++++++++++++++++++++++++++++++ src.mk | 1 + 4 files changed, 140 insertions(+), 1 deletion(-) create mode 100644 env/flink/jvm_util.cc create mode 100644 env/flink/jvm_util.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 61f96005b..a5cc1e39d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1020,7 +1020,8 @@ else() env/env_posix.cc env/fs_posix.cc env/io_posix.cc - env/flink/env_flink.cc) + env/flink/env_flink.cc + env/flink/jvm_util.cc) endif() if(USE_FOLLY_LITE) @@ -1165,6 +1166,10 @@ endif() if(WITH_JNI OR JNI) message(STATUS "JNI library is enabled") add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/java) + include_directories(${JNI_INCLUDE_DIRS}) + if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux") + include_directories(${JNI_INCLUDE_DIRS}/linux) + endif () else() message(STATUS "JNI library is disabled") endif() diff --git a/env/flink/jvm_util.cc b/env/flink/jvm_util.cc new file mode 100644 index 000000000..8e2c6f07a --- /dev/null +++ b/env/flink/jvm_util.cc @@ -0,0 +1,59 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "env/flink/jvm_util.h" + +namespace ROCKSDB_NAMESPACE { + +std::atomic jvm_ = std::atomic(nullptr); + +JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { + JNIEnv* env = nullptr; + if (vm->GetEnv((void**)&env, JNI_VERSION_1_8) != JNI_OK) { + return -1; + } + + jvm_.store(vm); + return JNI_VERSION_1_8; +} + +JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) { + jvm_.store(nullptr); +} + +void setJVM(JavaVM* jvm) { jvm_.store(jvm); } + +JNIEnv* getJNIEnv(bool attach) { + JavaVM* jvm = jvm_.load(); + if (jvm == nullptr) { + return nullptr; + } + + thread_local JavaEnv env; + if (env.getEnv() == nullptr) { + auto status = jvm->GetEnv((void**)&(env.getEnv()), JNI_VERSION_1_8); + if (attach && (status == JNI_EDETACHED || env.getEnv() == nullptr)) { + if (jvm->AttachCurrentThread((void**)&(env.getEnv()), nullptr) == + JNI_OK) { + env.setNeedDetach(); + } + } + } + return env.getEnv(); +} +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/jvm_util.h b/env/flink/jvm_util.h new file mode 100644 index 000000000..5c5b5fc83 --- /dev/null +++ b/env/flink/jvm_util.h @@ -0,0 +1,74 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include +#include + +#include "jni.h" +#include "rocksdb/env.h" + +namespace ROCKSDB_NAMESPACE { + +extern std::atomic jvm_; + +#ifdef __cplusplus +extern "C" { +#endif + +JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved); +JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved); + +#ifdef __cplusplus +} +#endif + +void setJVM(JavaVM* jvm); + +JNIEnv* getJNIEnv(bool attach = true); + +static inline std::string parseJavaString(JNIEnv* jni_env, + jstring java_string) { + const char* chars = jni_env->GetStringUTFChars(java_string, nullptr); + auto length = jni_env->GetStringUTFLength(java_string); + std::string native_string = std::string(chars, length); + jni_env->ReleaseStringUTFChars(java_string, chars); + return native_string; +} + +class JavaEnv { + public: + ~JavaEnv() { + if (env_ != nullptr && need_detach_) { + jvm_.load()->DetachCurrentThread(); + need_detach_ = false; + } + } + + JNIEnv*& getEnv() { return env_; } + + void setNeedDetach() { need_detach_ = true; } + + private: + JNIEnv* env_ = nullptr; + bool need_detach_ = false; +}; +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/src.mk b/src.mk index caad7ee8f..30b70195a 100644 --- a/src.mk +++ b/src.mk @@ -114,6 +114,7 @@ LIB_SOURCES = \ env/mock_env.cc \ env/unique_id_gen.cc \ env/flink/env_flink.cc \ + env/flink/jvm_util.cc \ file/delete_scheduler.cc \ file/file_prefetch_buffer.cc \ file/file_util.cc \ From 0a7f5f1eb5d6aba1ae258fa4460be7e63ddd097a Mon Sep 17 00:00:00 2001 From: yhx Date: Tue, 12 Mar 2024 16:11:25 +0800 Subject: [PATCH 37/61] [env] Introduce interface of env_flink (#7) (cherry picked from commit 4a511b33d33ff41d1231fd8d3361b1916e94dbac) --- CMakeLists.txt | 3 +- env/flink/jni_helper.cc | 76 +++++++++++++++++++++++++++++++++++++++++ env/flink/jni_helper.h | 45 ++++++++++++++++++++++++ src.mk | 1 + 4 files changed, 124 insertions(+), 1 deletion(-) create mode 100644 env/flink/jni_helper.cc create mode 100644 env/flink/jni_helper.h diff --git a/CMakeLists.txt b/CMakeLists.txt index a5cc1e39d..1efcde659 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1021,7 +1021,8 @@ else() env/fs_posix.cc env/io_posix.cc env/flink/env_flink.cc - env/flink/jvm_util.cc) + env/flink/jvm_util.cc + env/flink/jni_helper.cc) endif() if(USE_FOLLY_LITE) diff --git a/env/flink/jni_helper.cc b/env/flink/jni_helper.cc new file mode 100644 index 000000000..8d1ac5acf --- /dev/null +++ b/env/flink/jni_helper.cc @@ -0,0 +1,76 @@ +// Copyright (c) 2019-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). + +#include "jni_helper.h" + +namespace ROCKSDB_NAMESPACE { + +JavaClassCache::JavaClassCache(JNIEnv *env) : jni_env_(env) { + // Set all class names + cached_java_classes_[JavaClassCache::JC_URI].className = "java/net/URI"; + cached_java_classes_[JavaClassCache::JC_BYTE_BUFFER].className = + "java/nio/ByteBuffer"; + cached_java_classes_[JavaClassCache::JC_THROWABLE].className = + "java/lang/Throwable"; + cached_java_classes_[JavaClassCache::JC_FLINK_PATH].className = + "org/apache/flink/core/fs/Path"; + cached_java_classes_[JavaClassCache::JC_FLINK_FILE_SYSTEM].className = + "org/apache/flink/state/forst/fs/ForStFlinkFileSystem"; + cached_java_classes_[JavaClassCache::JC_FLINK_FILE_STATUS].className = + "org/apache/flink/core/fs/FileStatus"; + cached_java_classes_[JavaClassCache::JC_FLINK_FS_INPUT_STREAM].className = + "org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream"; + cached_java_classes_[JavaClassCache::JC_FLINK_FS_OUTPUT_STREAM].className = + "org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream"; + + // Try best to create and set the jclass objects based on the class names set + // above + int numCachedClasses = + sizeof(cached_java_classes_) / sizeof(javaClassAndName); + for (int i = 0; i < numCachedClasses; i++) { + initCachedClass(cached_java_classes_[i].className, + &cached_java_classes_[i].javaClass); + } +} + +JavaClassCache::~JavaClassCache() { + // Release all global ref of cached jclasses + for (const auto &item : cached_java_classes_) { + if (item.javaClass) { + jni_env_->DeleteGlobalRef(item.javaClass); + } + } +} + +Status JavaClassCache::initCachedClass(const char *className, + jclass *cachedJclass) { + jclass tempLocalClassRef = jni_env_->FindClass(className); + if (!tempLocalClassRef) { + return Status::IOError("Exception when FindClass, class name: " + + std::string(className)); + } + *cachedJclass = (jclass)jni_env_->NewGlobalRef(tempLocalClassRef); + if (!*cachedJclass) { + return Status::IOError("Exception when NewGlobalRef, class name " + + std::string(className)); + } + + jni_env_->DeleteLocalRef(tempLocalClassRef); + return Status::OK(); +} + +Status JavaClassCache::GetJClass(CachedJavaClass cachedJavaClass, + jclass *javaClass) { + jclass targetClass = cached_java_classes_[cachedJavaClass].javaClass; + Status status = Status::OK(); + if (!targetClass) { + status = initCachedClass(cached_java_classes_[cachedJavaClass].className, + &targetClass); + } + *javaClass = targetClass; + return status; +} + +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/jni_helper.h b/env/flink/jni_helper.h new file mode 100644 index 000000000..39d9e9f9a --- /dev/null +++ b/env/flink/jni_helper.h @@ -0,0 +1,45 @@ +// Copyright (c) 2019-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). + +#include "jni.h" +#include "rocksdb/status.h" + +namespace ROCKSDB_NAMESPACE { + +// A cache for java classes to avoid calling FindClass frequently +class JavaClassCache { + public: + // Frequently-used class type representing jclasses which will be cached. + typedef enum { + JC_URI, + JC_BYTE_BUFFER, + JC_THROWABLE, + JC_FLINK_PATH, + JC_FLINK_FILE_SYSTEM, + JC_FLINK_FILE_STATUS, + JC_FLINK_FS_INPUT_STREAM, + JC_FLINK_FS_OUTPUT_STREAM, + NUM_CACHED_CLASSES + } CachedJavaClass; + + // Constructor and Destructor + explicit JavaClassCache(JNIEnv* env); + ~JavaClassCache(); + + // Get jclass by specific CachedJavaClass + Status GetJClass(CachedJavaClass cachedJavaClass, jclass* javaClass); + + private: + typedef struct { + jclass javaClass; + const char* className; + } javaClassAndName; + + JNIEnv* jni_env_; + javaClassAndName cached_java_classes_[JavaClassCache::NUM_CACHED_CLASSES]; + + Status initCachedClass(const char* className, jclass* cachedClass); +}; +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/src.mk b/src.mk index 30b70195a..4beae92a3 100644 --- a/src.mk +++ b/src.mk @@ -115,6 +115,7 @@ LIB_SOURCES = \ env/unique_id_gen.cc \ env/flink/env_flink.cc \ env/flink/jvm_util.cc \ + env/flink/jni_helper.cc \ file/delete_scheduler.cc \ file/file_prefetch_buffer.cc \ file/file_util.cc \ From 5ad02f7cc91e6ef72c90ff911481ad9ba75caac1 Mon Sep 17 00:00:00 2001 From: Zakelly Date: Tue, 12 Mar 2024 17:23:59 +0800 Subject: [PATCH 38/61] [build] license and READMEs (#9) (cherry picked from commit 09ba94fc277a872445f29a4d95e94b656b852fd2) --- CONTRIBUTING.md | 48 +- COPYING | 339 ----- DEFAULT_OPTIONS_HISTORY.md | 24 - DUMP_FORMAT.md | 16 - FROCKSDB-RELEASE.md | 251 ---- HISTORY.md | 2602 ------------------------------------ LICENSE.Apache => LICENSE | 0 README.md | 15 +- 8 files changed, 43 insertions(+), 3252 deletions(-) delete mode 100644 COPYING delete mode 100644 DEFAULT_OPTIONS_HISTORY.md delete mode 100644 DUMP_FORMAT.md delete mode 100644 FROCKSDB-RELEASE.md delete mode 100644 HISTORY.md rename LICENSE.Apache => LICENSE (100%) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 190100b42..d7ca7890d 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,17 +1,45 @@ -# Contributing to RocksDB +# Contributing to ForSt ## Code of Conduct The code of conduct is described in [`CODE_OF_CONDUCT.md`](CODE_OF_CONDUCT.md) -## Contributor License Agreement ("CLA") +## Basic Development Workflow +As most open-source projects in github, ForSt contributors work on their forks, and send pull requests to ForSt’s repo. After a reviewer approves the pull request and all the CI check are passed, a ForSt team member will merge it. -In order to accept your pull request, we need you to submit a CLA. You -only need to do this once, so if you've done this for another Facebook -open source project, you're good to go. If you are submitting a pull -request for the first time, just let us know that you have completed -the CLA and we can cross-check with your GitHub username. +## Code style +ForSt follows the RocksDB's code format. +RocksDB follows Google C++ Style: https://google.github.io/styleguide/cppguide.html +Note: a common pattern in existing RocksDB code is using non-nullable Type* for output parameters, in the old Google C++ Style, but this guideline has changed. The new guideline prefers (non-const) references for output parameters. +For formatting, we limit each line to 80 characters. Most formatting can be done automatically by running +``` +build_tools/format-diff.sh +``` +or simply ```make format``` if you use GNU make. If you lack of dependencies to run it, the script will print out instructions for you to install them. -Complete your CLA here: -If you prefer to sign a paper copy, we can send you a PDF. Send us an -e-mail or create a new github issue to request the CLA in PDF format. +## License Claim +ForSt is licensed under Apache 2.0 License. But since the RocksDB has its own license, we keep the license claim on top of each existing files, and use/add Apache 2.0 License on top of each new created files. +``` +/* Copyright 2024-present, the ForSt authors. All Rights Reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +``` + +## Submit patches +Before you submit a patch, we strongly recommend that you share your ideas with others +in the community via [Issues](https://github.com/ververica/ForSt/issues) or +[Discussions](https://github.com/ververica/ForSt/discussions). Of course, you do not +need to do this if you are submitting a patch that can already be associated with an +issue, or a minor patch like a typo fix. You can then submit your patch via +[Pull Requests](https://github.com/ververica/ForSt/pulls), which requires a GitHub account. diff --git a/COPYING b/COPYING deleted file mode 100644 index d159169d1..000000000 --- a/COPYING +++ /dev/null @@ -1,339 +0,0 @@ - GNU GENERAL PUBLIC LICENSE - Version 2, June 1991 - - Copyright (C) 1989, 1991 Free Software Foundation, Inc., - 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -License is intended to guarantee your freedom to share and change free -software--to make sure the software is free for all its users. This -General Public License applies to most of the Free Software -Foundation's software and to any other program whose authors commit to -using it. (Some other Free Software Foundation software is covered by -the GNU Lesser General Public License instead.) You can apply it to -your programs, too. - - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -this service if you wish), that you receive source code or can get it -if you want it, that you can change the software or use pieces of it -in new free programs; and that you know you can do these things. - - To protect your rights, we need to make restrictions that forbid -anyone to deny you these rights or to ask you to surrender the rights. -These restrictions translate to certain responsibilities for you if you -distribute copies of the software, or if you modify it. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must give the recipients all the rights that -you have. You must make sure that they, too, receive or can get the -source code. And you must show them these terms so they know their -rights. - - We protect your rights with two steps: (1) copyright the software, and -(2) offer you this license which gives you legal permission to copy, -distribute and/or modify the software. - - Also, for each author's protection and ours, we want to make certain -that everyone understands that there is no warranty for this free -software. If the software is modified by someone else and passed on, we -want its recipients to know that what they have is not the original, so -that any problems introduced by others will not reflect on the original -authors' reputations. - - Finally, any free program is threatened constantly by software -patents. We wish to avoid the danger that redistributors of a free -program will individually obtain patent licenses, in effect making the -program proprietary. To prevent this, we have made it clear that any -patent must be licensed for everyone's free use or not licensed at all. - - The precise terms and conditions for copying, distribution and -modification follow. - - GNU GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License applies to any program or other work which contains -a notice placed by the copyright holder saying it may be distributed -under the terms of this General Public License. The "Program", below, -refers to any such program or work, and a "work based on the Program" -means either the Program or any derivative work under copyright law: -that is to say, a work containing the Program or a portion of it, -either verbatim or with modifications and/or translated into another -language. (Hereinafter, translation is included without limitation in -the term "modification".) Each licensee is addressed as "you". - -Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running the Program is not restricted, and the output from the Program -is covered only if its contents constitute a work based on the -Program (independent of having been made by running the Program). -Whether that is true depends on what the Program does. - - 1. You may copy and distribute verbatim copies of the Program's -source code as you receive it, in any medium, provided that you -conspicuously and appropriately publish on each copy an appropriate -copyright notice and disclaimer of warranty; keep intact all the -notices that refer to this License and to the absence of any warranty; -and give any other recipients of the Program a copy of this License -along with the Program. - -You may charge a fee for the physical act of transferring a copy, and -you may at your option offer warranty protection in exchange for a fee. - - 2. You may modify your copy or copies of the Program or any portion -of it, thus forming a work based on the Program, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) You must cause the modified files to carry prominent notices - stating that you changed the files and the date of any change. - - b) You must cause any work that you distribute or publish, that in - whole or in part contains or is derived from the Program or any - part thereof, to be licensed as a whole at no charge to all third - parties under the terms of this License. - - c) If the modified program normally reads commands interactively - when run, you must cause it, when started running for such - interactive use in the most ordinary way, to print or display an - announcement including an appropriate copyright notice and a - notice that there is no warranty (or else, saying that you provide - a warranty) and that users may redistribute the program under - these conditions, and telling the user how to view a copy of this - License. (Exception: if the Program itself is interactive but - does not normally print such an announcement, your work based on - the Program is not required to print an announcement.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Program, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Program, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Program. - -In addition, mere aggregation of another work not based on the Program -with the Program (or with a work based on the Program) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may copy and distribute the Program (or a work based on it, -under Section 2) in object code or executable form under the terms of -Sections 1 and 2 above provided that you also do one of the following: - - a) Accompany it with the complete corresponding machine-readable - source code, which must be distributed under the terms of Sections - 1 and 2 above on a medium customarily used for software interchange; or, - - b) Accompany it with a written offer, valid for at least three - years, to give any third party, for a charge no more than your - cost of physically performing source distribution, a complete - machine-readable copy of the corresponding source code, to be - distributed under the terms of Sections 1 and 2 above on a medium - customarily used for software interchange; or, - - c) Accompany it with the information you received as to the offer - to distribute corresponding source code. (This alternative is - allowed only for noncommercial distribution and only if you - received the program in object code or executable form with such - an offer, in accord with Subsection b above.) - -The source code for a work means the preferred form of the work for -making modifications to it. For an executable work, complete source -code means all the source code for all modules it contains, plus any -associated interface definition files, plus the scripts used to -control compilation and installation of the executable. However, as a -special exception, the source code distributed need not include -anything that is normally distributed (in either source or binary -form) with the major components (compiler, kernel, and so on) of the -operating system on which the executable runs, unless that component -itself accompanies the executable. - -If distribution of executable or object code is made by offering -access to copy from a designated place, then offering equivalent -access to copy the source code from the same place counts as -distribution of the source code, even though third parties are not -compelled to copy the source along with the object code. - - 4. You may not copy, modify, sublicense, or distribute the Program -except as expressly provided under this License. Any attempt -otherwise to copy, modify, sublicense or distribute the Program is -void, and will automatically terminate your rights under this License. -However, parties who have received copies, or rights, from you under -this License will not have their licenses terminated so long as such -parties remain in full compliance. - - 5. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Program or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Program (or any work based on the -Program), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Program or works based on it. - - 6. Each time you redistribute the Program (or any work based on the -Program), the recipient automatically receives a license from the -original licensor to copy, distribute or modify the Program subject to -these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties to -this License. - - 7. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Program at all. For example, if a patent -license would not permit royalty-free redistribution of the Program by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Program. - -If any portion of this section is held invalid or unenforceable under -any particular circumstance, the balance of the section is intended to -apply and the section as a whole is intended to apply in other -circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system, which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 8. If the distribution and/or use of the Program is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Program under this License -may add an explicit geographical distribution limitation excluding -those countries, so that distribution is permitted only in or among -countries not thus excluded. In such case, this License incorporates -the limitation as if written in the body of this License. - - 9. The Free Software Foundation may publish revised and/or new versions -of the General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - -Each version is given a distinguishing version number. If the Program -specifies a version number of this License which applies to it and "any -later version", you have the option of following the terms and conditions -either of that version or of any later version published by the Free -Software Foundation. If the Program does not specify a version number of -this License, you may choose any version ever published by the Free Software -Foundation. - - 10. If you wish to incorporate parts of the Program into other free -programs whose distribution conditions are different, write to the author -to ask for permission. For software which is copyrighted by the Free -Software Foundation, write to the Free Software Foundation; we sometimes -make exceptions for this. Our decision will be guided by the two goals -of preserving the free status of all derivatives of our free software and -of promoting the sharing and reuse of software generally. - - NO WARRANTY - - 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY -FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN -OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES -PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED -OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS -TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE -PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, -REPAIR OR CORRECTION. - - 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR -REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, -INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING -OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED -TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY -YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER -PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE -POSSIBILITY OF SUCH DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -convey the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License along - with this program; if not, write to the Free Software Foundation, Inc., - 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. - -Also add information on how to contact you by electronic and paper mail. - -If the program is interactive, make it output a short notice like this -when it starts in an interactive mode: - - Gnomovision version 69, Copyright (C) year name of author - Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, the commands you use may -be called something other than `show w' and `show c'; they could even be -mouse-clicks or menu items--whatever suits your program. - -You should also get your employer (if you work as a programmer) or your -school, if any, to sign a "copyright disclaimer" for the program, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the program - `Gnomovision' (which makes passes at compilers) written by James Hacker. - - , 1 April 1989 - Ty Coon, President of Vice - -This General Public License does not permit incorporating your program into -proprietary programs. If your program is a subroutine library, you may -consider it more useful to permit linking proprietary applications with the -library. If this is what you want to do, use the GNU Lesser General -Public License instead of this License. diff --git a/DEFAULT_OPTIONS_HISTORY.md b/DEFAULT_OPTIONS_HISTORY.md deleted file mode 100644 index 82c64d523..000000000 --- a/DEFAULT_OPTIONS_HISTORY.md +++ /dev/null @@ -1,24 +0,0 @@ -# RocksDB default options change log (NO LONGER MAINTAINED) -## Unreleased -* delayed_write_rate takes the rate given by rate_limiter if not specified. - -## 5.2 -* Change the default of delayed slowdown value to 16MB/s and further increase the L0 stop condition to 36 files. - -## 5.0 (11/17/2016) -* Options::allow_concurrent_memtable_write and Options::enable_write_thread_adaptive_yield are now true by default -* Options.level0_stop_writes_trigger default value changes from 24 to 32. - -## 4.8.0 (5/2/2016) -* options.max_open_files changes from 5000 to -1. It improves performance, but users need to set file descriptor limit to be large enough and watch memory usage for index and bloom filters. -* options.base_background_compactions changes from max_background_compactions to 1. When users set higher max_background_compactions but the write throughput is not high, the writes are less spiky to disks. -* options.wal_recovery_mode changes from kTolerateCorruptedTailRecords to kPointInTimeRecovery. Avoid some false positive when file system or hardware reorder the writes for file data and metadata. - -## 4.7.0 (4/8/2016) -* options.write_buffer_size changes from 4MB to 64MB. -* options.target_file_size_base changes from 2MB to 64MB. -* options.max_bytes_for_level_base changes from 10MB to 256MB. -* options.soft_pending_compaction_bytes_limit changes from 0 (disabled) to 64GB. -* options.hard_pending_compaction_bytes_limit changes from 0 (disabled) to 256GB. -* table_cache_numshardbits changes from 4 to 6. -* max_file_opening_threads changes from 1 to 16. diff --git a/DUMP_FORMAT.md b/DUMP_FORMAT.md deleted file mode 100644 index 009dabad5..000000000 --- a/DUMP_FORMAT.md +++ /dev/null @@ -1,16 +0,0 @@ -## RocksDB dump format - -The version 1 RocksDB dump format is fairly simple: - -1) The dump starts with the magic 8 byte identifier "ROCKDUMP" - -2) The magic is followed by an 8 byte big-endian version which is 0x00000001. - -3) Next are arbitrarily sized chunks of bytes prepended by 4 byte little endian number indicating how large each chunk is. - -4) The first chunk is special and is a json string indicating some things about the creation of this dump. It contains the following keys: -* database-path: The path of the database this dump was created from. -* hostname: The hostname of the machine where the dump was created. -* creation-time: Unix seconds since epoc when this dump was created. - -5) Following the info dump the slices paired into are key/value pairs. diff --git a/FROCKSDB-RELEASE.md b/FROCKSDB-RELEASE.md deleted file mode 100644 index 2cd092d88..000000000 --- a/FROCKSDB-RELEASE.md +++ /dev/null @@ -1,251 +0,0 @@ -# FRocksDB Release Process - -## Summary - -FrocksDB-6.x releases are a fat jar file that contain the following binaries: -* .so files for linux32 (glibc and musl-libc) -* .so files for linux64 (glibc and musl-libc) -* .so files for linux [aarch64](https://en.wikipedia.org/wiki/AArch64) (glibc and musl-libc) -* .so files for linux [ppc64le](https://en.wikipedia.org/wiki/Ppc64le) (glibc and musl-libc) -* .jnilib file for Mac OSX -* .dll for Windows x64 - -To build the binaries for a FrocksDB release, building on native architectures is advised. Building the binaries for ppc64le and aarch64 *can* be done using QEMU, but you may run into emulation bugs and the build times will be dramatically slower (up to x20). - -We recommend building the binaries on environments with at least 4 cores, 16GB RAM and 40GB of storage. The following environments are recommended for use in the build process: -* Windows x64 -* Linux aarch64 -* Linux ppc64le -* Mac OSX - -## Build for Windows - -For the Windows binary build, we recommend using a base [AWS Windows EC2 instance](https://aws.amazon.com/windows/products/ec2/) with 4 cores, 16GB RAM, 40GB storage for the build. - -Firstly, install [chocolatey](https://chocolatey.org/install). Once installed, the following required components can be installed using Powershell: - - choco install git.install jdk8 maven visualstudio2017community visualstudio2017-workload-nativedesktop - -Open the "Developer Command Prompt for VS 2017" and run the following commands: - - git clone git@github.com:ververica/frocksdb.git - cd frocksdb - git checkout FRocksDB-6.20.3 # release branch - java\crossbuild\build-win.bat - -The resulting native binary will be built and available at `build\java\Release\rocksdbjni-shared.dll`. You can also find it under project folder with name `librocksdbjni-win64.dll`. -The result windows jar is `build\java\rocksdbjni_classes.jar`. - -There is also a how-to in CMakeLists.txt. - -**Once finished, extract the `librocksdbjni-win64.dll` from the build environment. You will need this .dll in the final crossbuild.** - -## Build for aarch64 - -For the Linux aarch64 binary build, we recommend using a base [AWS Ubuntu Server 20.04 LTS EC2](https://aws.amazon.com/windows/products/ec2/) with a 4 core Arm processor, 16GB RAM, 40GB storage for the build. You can also attempt to build with QEMU on a non-aarch64 processor, but you may run into emulation bugs and very long build times. - -### Building in aarch64 environment - -First, install the required packages such as Java 8 and make: - - sudo apt-get update - sudo apt-get install build-essential openjdk-8-jdk - -then, install and setup [Docker](https://docs.docker.com/engine/install/ubuntu/): - - sudo apt-get install apt-transport-https ca-certificates curl gnupg lsb-release - - curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg - echo "deb [arch=arm64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null - - sudo apt-get update - sudo apt-get install docker-ce docker-ce-cli containerd.io - - sudo groupadd docker - sudo usermod -aG docker $USER - newgrp docker - -Then, clone the FrocksDB repo: - - git clone https://github.com/ververica/frocksdb.git - cd frocksdb - git checkout FRocksDB-6.20.3 # release branch - - -First, build the glibc binary: - - make jclean clean rocksdbjavastaticdockerarm64v8 - -**Once finished, extract the `java/target/librocksdbjni-linux-aarch64.so` from the build environment. You will need this .so in the final crossbuild.** - -Next, build the musl-libc binary: - - make jclean clean rocksdbjavastaticdockerarm64v8musl - -**Once finished, extract the `java/target/librocksdbjni-linux-aarch64-musl.so` from the build environment. You will need this .so in the final crossbuild.** - -### Building via QEMU - -You can use QEMU on, for example, an `x86_64` system to build the aarch64 binaries. To set this up on an Ubuntu envirnment: - - sudo apt-get install qemu binfmt-support qemu-user-static - docker run --rm --privileged multiarch/qemu-user-static --reset -p yes - -To verify that you can now run aarch64 docker images: - - docker run --rm -t arm64v8/ubuntu uname -m - > aarch64 - -You can now attempt to build the aarch64 binaries as in the previous section. - -## Build in PPC64LE - -For the ppc64le binaries, we recommend building on a PowerPC machine if possible, as it can be tricky to spin up a ppc64le cloud environment. However, if a PowerPC machine is not available, [Travis-CI](https://www.travis-ci.com/) offers ppc64le build environments that work perfectly for building these binaries. If neither a machine or Travis are an option, you can use QEMU but the build may take a very long time and be prone to emulation errors. - -### Building in ppc64le environment - -As with the aarch64 environment, the ppc64le environment will require Java 8, Docker and build-essentials installed. Once installed, you can build the 2 binaries: - - make jclean clean rocksdbjavastaticdockerppc64le - -**Once finished, extract the `java/target/librocksdbjni-linux-ppc64le.so` from the build environment. You will need this .so in the final crossbuild.** - - make jclean clean rocksdbjavastaticdockerppc64lemusl - -**Once finished, extract the `java/target/librocksdbjni-linux-ppc64le-musl.so` from the build environment. You will need this .so in the final crossbuild.** - -### Building via Travis - -Travis-CI supports ppc64le build environments, and this can be a convienient way of building in the absence of a PowerPC machine. Assuming that you have an S3 bucket called **my-frocksdb-release-artifacts**, the following Travis configuration will build the release artifacts and push them to the S3 bucket: - -``` -dist: xenial -language: cpp -os: - - linux -arch: - - ppc64le - -services: - - docker -addons: - artifacts: - paths: - - $TRAVIS_BUILD_DIR/java/target/librocksdbjni-linux-ppc64le-musl.so - - $TRAVIS_BUILD_DIR/java/target/librocksdbjni-linux-ppc64le.so - -env: - global: - - ARTIFACTS_BUCKET=my-rocksdb-release-artifacts - jobs: - - CMD=rocksdbjavastaticdockerppc64le - - CMD=rocksdbjavastaticdockerppc64lemusl - -install: - - sudo apt-get install -y openjdk-8-jdk || exit $? - - export PATH=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture)/bin:$PATH - - export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture) - - echo "JAVA_HOME=${JAVA_HOME}" - - which java && java -version - - which javac && javac -version - -script: - - make jclean clean $CMD -``` - -**Make sure to set the `ARTIFACTS_KEY` and `ARTIFACTS_SECRET` environment variables in the Travis Job with valid AWS credentials to access the S3 bucket you defined.** - -**Make sure to avoid signatureV4-only S3 regions to store the uploaded artifacts (due to unresolved https://github.com/travis-ci/artifacts/issues/57). You can just choose the S3 bucket of `us-east-1` region for 100% compatibility.** - -**Once finished, the`librocksdbjni-linux-ppce64le.so` and `librocksdbjni-linux-ppce64le-musl.so` binaries will be in the S3 bucket. You will need these .so binaries in the final crossbuild.** - - -### Building via QEMU - -You can use QEMU on, for example, an `x86_64` system to build the ppc64le binaries. To set this up on an Ubuntu envirnment: - - sudo apt-get install qemu binfmt-support qemu-user-static - docker run --rm --privileged multiarch/qemu-user-static --reset -p yes - -To verify that you can now run ppc64le docker images: - - docker run --rm -t ppc64le/ubuntu uname -m - > ppc64le - -You can now attempt to build the ppc64le binaries as in the previous section. - -## Final crossbuild in Mac OSX - -Documentation for the final crossbuild for Mac OSX and Linux is described in [java/RELEASE.md](java/RELEASE.md) as has information on dependencies that should be installed. As above, this tends to be Java 8, build-essentials and Docker. - -Before you run this step, you should have 5 binaries from the previous build steps: - - 1. `librocksdbjni-win64.dll` from the Windows build step. - 2. `librocksdbjni-linux-aarch64.so` from the aarch64 build step. - 3. `librocksdbjni-linux-aarch64-musl.so` from the aarch64 build step. - 3. `librocksdbjni-linux-ppc64le.so` from the ppc64le build step. - 4. `librocksdbjni-linux-ppc64le-musl.so` from the ppc64le build step. - -To start the crossbuild within a Mac OSX environment: - - make jclean clean - mkdir -p java/target - cp /librocksdbjni-win64.dll java/target/librocksdbjni-win64.dll - cp /librocksdbjni-linux-ppc64le.so java/target/librocksdbjni-linux-ppc64le.so - cp /librocksdbjni-linux-ppc64le-musl.so java/target/librocksdbjni-linux-ppc64le-musl.so - cp /librocksdbjni-linux-aarch64.so java/target/librocksdbjni-linux-aarch64.so - cp /librocksdbjni-linux-aarch64-musl.so java/target/librocksdbjni-linux-aarch64-musl.so - FROCKSDB_VERSION=1.0 PORTABLE=1 ROCKSDB_DISABLE_JEMALLOC=true DEBUG_LEVEL=0 make frocksdbjavastaticreleasedocker - -*Note, we disable jemalloc on mac due to https://github.com/facebook/rocksdb/issues/5787*. - -Once finished, there should be a directory at `java/target/frocksdb-release` with the FRocksDB jar, javadoc jar, sources jar and pom in it. You can inspect the jar file and ensure that contains the binaries, history file, etc: - -``` -$ jar tf frocksdbjni-6.20.3-ververica-1.0.jar -META-INF/ -META-INF/MANIFEST.MF -HISTORY-JAVA.md -HISTORY.md -librocksdbjni-linux-aarch64-musl.so -librocksdbjni-linux-aarch64.so -librocksdbjni-linux-ppc64le-musl.so -librocksdbjni-linux-ppc64le.so -librocksdbjni-linux32-musl.so -librocksdbjni-linux32.so -librocksdbjni-linux64-musl.so -librocksdbjni-linux64.so -librocksdbjni-osx.jnilib -librocksdbjni-win64.dl -... -``` - -*Note that it contains linux32/64.so binaries as well as librocksdbjni-osx.jnilib*. - -## Push to Maven Central - -For this step, you will need the following: - -- The OSX Crossbuild artifacts built in `java/target/frocksdb-release` as above. -- A Sonatype account with access to the staging repository. If you do not have permission, open a ticket with Sonatype, [such as this one](https://issues.sonatype.org/browse/OSSRH-72185). -- A GPG key to sign the release, with your public key available for verification (for example, by uploading it to https://keys.openpgp.org/) - -To upload the release to the Sonatype staging repository: -```bash -VERSION= \ -USER= \ -PASSWORD= \ -KEYNAME= \ -PASSPHRASE= \ -java/publish-frocksdbjni.sh -``` - -Go to the staging repositories on Sonatype: - -https://oss.sonatype.org/#stagingRepositories - -Select the open staging repository and click on "Close". - -The staging repository will look something like `https://oss.sonatype.org/content/repositories/xxxx-1020`. You can use this staged release to test the artifacts and ensure they are correct. - -Once you have verified the artifacts are correct, press the "Release" button. **WARNING: this can not be undone**. Within 24-48 hours, the artifact will be available on Maven Central for use. diff --git a/HISTORY.md b/HISTORY.md deleted file mode 100644 index f4d0ea3f4..000000000 --- a/HISTORY.md +++ /dev/null @@ -1,2602 +0,0 @@ -# FRocksdb Change Log -## 6.20.2-ververica-1.0 (08/09/2021) -### Improvement -* [Flink TTL] compaction filter for background cleanup of state with time-to-live -* [FLINK-19710] Revert implementation of PerfContext back to __thread to avoid performance regression - -# Rocksdb Change Log -> NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt` - -## 8.10.0 (12/15/2023) -### New Features -* Provide support for async_io to trim readahead_size by doing block cache lookup -* Added initial wide-column support in `WriteBatchWithIndex`. This includes the `PutEntity` API and support for wide columns in the existing read APIs (`GetFromBatch`, `GetFromBatchAndDB`, `MultiGetFromBatchAndDB`, and `BaseDeltaIterator`). - -### Public API Changes -* Custom implementations of `TablePropertiesCollectorFactory` may now return a `nullptr` collector to decline processing a file, reducing callback overheads in such cases. - -### Behavior Changes -* Make ReadOptions.auto_readahead_size default true which does prefetching optimizations for forward scans if iterate_upper_bound and block_cache is also specified. -* Compactions can be scheduled in parallel in an additional scenario: high compaction debt relative to the data size -* HyperClockCache now has built-in protection against excessive CPU consumption under the extreme stress condition of no (or very few) evictable cache entries, which can slightly increase memory usage such conditions. New option `HyperClockCacheOptions::eviction_effort_cap` controls the space-time trade-off of the response. The default should be generally well-balanced, with no measurable affect on normal operation. - -### Bug Fixes -* Fix a corner case with auto_readahead_size where Prev Operation returns NOT SUPPORTED error when scans direction is changed from forward to backward. -* Avoid destroying the periodic task scheduler's default timer in order to prevent static destruction order issues. -* Fix double counting of BYTES_WRITTEN ticker when doing writes with transactions. -* Fix a WRITE_STALL counter that was reporting wrong value in few cases. -* A lookup by MultiGet in a TieredCache that goes to the local flash cache and finishes with very low latency, i.e before the subsequent call to WaitAll, is ignored, resulting in a false negative and a memory leak. - -### Performance Improvements -* Java API extensions to improve consistency and completeness of APIs -1 Extended `RocksDB.get([ColumnFamilyHandle columnFamilyHandle,] ReadOptions opt, ByteBuffer key, ByteBuffer value)` which now accepts indirect buffer parameters as well as direct buffer parameters -2 Extended `RocksDB.put( [ColumnFamilyHandle columnFamilyHandle,] WriteOptions writeOpts, final ByteBuffer key, final ByteBuffer value)` which now accepts indirect buffer parameters as well as direct buffer parameters -3 Added `RocksDB.merge([ColumnFamilyHandle columnFamilyHandle,] WriteOptions writeOptions, ByteBuffer key, ByteBuffer value)` methods with the same parameter options as `put(...)` - direct and indirect buffers are supported -4 Added `RocksIterator.key( byte[] key [, int offset, int len])` methods which retrieve the iterator key into the supplied buffer -5 Added `RocksIterator.value( byte[] value [, int offset, int len])` methods which retrieve the iterator value into the supplied buffer -6 Deprecated `get(final ColumnFamilyHandle columnFamilyHandle, final ReadOptions readOptions, byte[])` in favour of `get(final ReadOptions readOptions, final ColumnFamilyHandle columnFamilyHandle, byte[])` which has consistent parameter ordering with other methods in the same class -7 Added `Transaction.get( ReadOptions opt, [ColumnFamilyHandle columnFamilyHandle, ] byte[] key, byte[] value)` methods which retrieve the requested value into the supplied buffer -8 Added `Transaction.get( ReadOptions opt, [ColumnFamilyHandle columnFamilyHandle, ] ByteBuffer key, ByteBuffer value)` methods which retrieve the requested value into the supplied buffer -9 Added `Transaction.getForUpdate( ReadOptions readOptions, [ColumnFamilyHandle columnFamilyHandle, ] byte[] key, byte[] value, boolean exclusive [, boolean doValidate])` methods which retrieve the requested value into the supplied buffer -10 Added `Transaction.getForUpdate( ReadOptions readOptions, [ColumnFamilyHandle columnFamilyHandle, ] ByteBuffer key, ByteBuffer value, boolean exclusive [, boolean doValidate])` methods which retrieve the requested value into the supplied buffer -11 Added `Transaction.getIterator()` method as a convenience which defaults the `ReadOptions` value supplied to existing `Transaction.iterator()` methods. This mirrors the existing `RocksDB.iterator()` method. -12 Added `Transaction.put([ColumnFamilyHandle columnFamilyHandle, ] ByteBuffer key, ByteBuffer value [, boolean assumeTracked])` methods which supply the key, and the value to be written in a `ByteBuffer` parameter -13 Added `Transaction.merge([ColumnFamilyHandle columnFamilyHandle, ] ByteBuffer key, ByteBuffer value [, boolean assumeTracked])` methods which supply the key, and the value to be written/merged in a `ByteBuffer` parameter -14 Added `Transaction.mergeUntracked([ColumnFamilyHandle columnFamilyHandle, ] ByteBuffer key, ByteBuffer value)` methods which supply the key, and the value to be written/merged in a `ByteBuffer` parameter - - -## 8.9.0 (11/17/2023) -### New Features -* Add GetEntity() and PutEntity() API implementation for Attribute Group support. Through the use of Column Families, AttributeGroup enables users to logically group wide-column entities. - -### Public API Changes -* Added rocksdb_ratelimiter_create_auto_tuned API to create an auto-tuned GenericRateLimiter. -* Added clipColumnFamily() to the Java API to clip the entries in the CF according to the range [begin_key, end_key). -* Make the `EnableFileDeletion` API not default to force enabling. For users that rely on this default behavior and still -want to continue to use force enabling, they need to explicitly pass a `true` to `EnableFileDeletion`. -* Add new Cache APIs GetSecondaryCacheCapacity() and GetSecondaryCachePinnedUsage() to return the configured capacity, and cache reservation charged to the secondary cache. - -### Behavior Changes -* During off-peak hours defined by `daily_offpeak_time_utc`, the compaction picker will select a larger number of files for periodic compaction. This selection will include files that are projected to expire by the next off-peak start time, ensuring that these files are not chosen for periodic compaction outside of off-peak hours. -* If an error occurs when writing to a trace file after `DB::StartTrace()`, the subsequent trace writes are skipped to avoid writing to a file that has previously seen error. In this case, `DB::EndTrace()` will also return a non-ok status with info about the error occured previously in its status message. -* Deleting stale files upon recovery are delegated to SstFileManger if available so they can be rate limited. -* Make RocksDB only call `TablePropertiesCollector::Finish()` once. -* When `WAL_ttl_seconds > 0`, we now process archived WALs for deletion at least every `WAL_ttl_seconds / 2` seconds. Previously it could be less frequent in case of small `WAL_ttl_seconds` values when size-based expiration (`WAL_size_limit_MB > 0 `) was simultaneously enabled. - -### Bug Fixes -* Fixed a crash or assertion failure bug in experimental new HyperClockCache variant, especially when running with a SecondaryCache. -* Fix a race between flush error recovery and db destruction that can lead to db crashing. -* Fixed some bugs in the index builder/reader path for user-defined timestamps in Memtable only feature. - -## 8.8.0 (10/23/2023) -### New Features -* Introduce AttributeGroup by adding the first AttributeGroup support API, MultiGetEntity(). Through the use of Column Families, AttributeGroup enables users to logically group wide-column entities. More APIs to support AttributeGroup will come soon, including GetEntity, PutEntity, and others. -* Added new tickers `rocksdb.fifo.{max.size|ttl}.compactions` to count FIFO compactions that drop files for different reasons -* Add an experimental offpeak duration awareness by setting `DBOptions::daily_offpeak_time_utc` in "HH:mm-HH:mm" format. This information will be used for resource optimization in the future -* Users can now change the max bytes granted in a single refill period (i.e, burst) during runtime by `SetSingleBurstBytes()` for RocksDB rate limiter - -### Public API Changes -* The default value of `DBOptions::fail_if_options_file_error` changed from `false` to `true`. Operations that set in-memory options (e.g., `DB::Open*()`, `DB::SetOptions()`, `DB::CreateColumnFamily*()`, and `DB::DropColumnFamily()`) but fail to persist the change will now return a non-OK `Status` by default. - -### Behavior Changes -* For non direct IO, eliminate the file system prefetching attempt for compaction read when `Options::compaction_readahead_size` is 0 -* During a write stop, writes now block on in-progress recovery attempts - -### Bug Fixes -* Fix a bug in auto_readahead_size where first_internal_key of index blocks wasn't copied properly resulting in corruption error when first_internal_key was used for comparison. -* Fixed a bug where compaction read under non direct IO still falls back to RocksDB internal prefetching after file system's prefetching returns non-OK status other than `Status::NotSupported()` -* Add bounds check in WBWIIteratorImpl and make BaseDeltaIterator, WriteUnpreparedTxn and WritePreparedTxn respect the upper bound and lower bound in ReadOption. See 11680. -* Fixed the handling of wide-column base values in the `max_successive_merges` logic. -* Fixed a rare race bug involving a concurrent combination of Create/DropColumnFamily and/or Set(DB)Options that could lead to inconsistency between (a) the DB's reported options state, (b) the DB options in effect, and (c) the latest persisted OPTIONS file. -* Fixed a possible underflow when computing the compressed secondary cache share of memory reservations while updating the compressed secondary to total block cache ratio. - -### Performance Improvements -* Improved the I/O efficiency of DB::Open a new DB with `create_missing_column_families=true` and many column families. - -## 8.7.0 (09/22/2023) -### New Features -* Added an experimental new "automatic" variant of HyperClockCache that does not require a prior estimate of the average size of cache entries. This variant is activated when HyperClockCacheOptions::estimated\_entry\_charge = 0 and has essentially the same concurrency benefits as the existing HyperClockCache. -* Add a new statistic `COMPACTION_CPU_TOTAL_TIME` that records cumulative compaction cpu time. This ticker is updated regularly while a compaction is running. -* Add `GetEntity()` API for ReadOnly DB and Secondary DB. -* Add a new iterator API `Iterator::Refresh(const Snapshot *)` that allows iterator to be refreshed while using the input snapshot to read. -* Added a new read option `merge_operand_count_threshold`. When the number of merge operands applied during a successful point lookup exceeds this threshold, the query will return a special OK status with a new subcode `kMergeOperandThresholdExceeded`. Applications might use this signal to take action to reduce the number of merge operands for the affected key(s), for example by running a compaction. -* For `NewRibbonFilterPolicy()`, made the `bloom_before_level` option mutable through the Configurable interface and the SetOptions API, allowing dynamic switching between all-Bloom and all-Ribbon configurations, and configurations in between. See comments on `NewRibbonFilterPolicy()` -* RocksDB now allows the block cache to be stacked on top of a compressed secondary cache and a non-volatile secondary cache, thus creating a three-tier cache. To set it up, use the `NewTieredCache()` API in rocksdb/cache.h.. -* Added a new wide-column aware full merge API called `FullMergeV3` to `MergeOperator`. `FullMergeV3` supports wide columns both as base value and merge result, which enables the application to perform more general transformations during merges. For backward compatibility, the default implementation implements the earlier logic of applying the merge operation to the default column of any wide-column entities. Specifically, if there is no base value or the base value is a plain key-value, the default implementation falls back to `FullMergeV2`. If the base value is a wide-column entity, the default implementation invokes `FullMergeV2` to perform the merge on the default column, and leaves any other columns unchanged. -* Add wide column support to ldb commands (scan, dump, idump, dump_wal) and sst_dump tool's scan command - -### Public API Changes -* Expose more information about input files used in table creation (if any) in `CompactionFilter::Context`. See `CompactionFilter::Context::input_start_level`,`CompactionFilter::Context::input_table_properties` for more. -* `Options::compaction_readahead_size` 's default value is changed from 0 to 2MB. -* When using LZ4 compression, the `acceleration` parameter is configurable by setting the negated value in `CompressionOptions::level`. For example, `CompressionOptions::level=-10` will set `acceleration=10` -* The `NewTieredCache` API has been changed to take the total cache capacity (inclusive of both the primary and the compressed secondary cache) and the ratio of total capacity to allocate to the compressed cache. These are specified in `TieredCacheOptions`. Any capacity specified in `LRUCacheOptions`, `HyperClockCacheOptions` and `CompressedSecondaryCacheOptions` is ignored. A new API, `UpdateTieredCache` is provided to dynamically update the total capacity, ratio of compressed cache, and admission policy. -* The `NewTieredVolatileCache()` API in rocksdb/cache.h has been renamed to `NewTieredCache()`. - -### Behavior Changes -* Compaction read performance will regress when `Options::compaction_readahead_size` is explicitly set to 0 -* Universal size amp compaction will conditionally exclude some of the newest L0 files when selecting input with a small negative impact to size amp. This is to prevent a large number of L0 files from being locked by a size amp compaction, potentially leading to write stop with a few more flushes. -* Change ldb scan command delimiter from ':' to '==>'. - -### Bug Fixes -* Fix a bug where if there is an error reading from offset 0 of a file from L1+ and that the file is not the first file in the sorted run, data can be lost in compaction and read/scan can return incorrect results. -* Fix a bug where iterator may return incorrect result for DeleteRange() users if there was an error reading from a file. -* Fix a bug with atomic_flush=true that can cause DB to stuck after a flush fails (#11872). -* Fix a bug where RocksDB (with atomic_flush=false) can delete output SST files of pending flushes when a previous concurrent flush fails (#11865). This can result in DB entering read-only state with error message like `IO error: No such file or directory: While open a file for random read: /tmp/rocksdbtest-501/db_flush_test_87732_4230653031040984171/000013.sst`. -* Fix an assertion fault during seek with async_io when readahead trimming is enabled. -* When the compressed secondary cache capacity is reduced to 0, it should be completely disabled. Before this fix, inserts and lookups would still go to the backing `LRUCache` before returning, thus incurring locking overhead. With this fix, inserts and lookups are no-ops and do not add any overhead. -* Updating the tiered cache (cache allocated using NewTieredCache()) by calling SetCapacity() on it was not working properly. The initial creation would set the primary cache capacity to the combined primary and compressed secondary cache capacity. But SetCapacity() would just set the primary cache capacity. With this fix, the user always specifies the total budget and compressed secondary cache ratio on creation. Subsequently, SetCapacity() will distribute the new capacity across the two caches by the same ratio. -* Fixed a bug in `MultiGet` for cleaning up SuperVersion acquired with locking db mutex. -* Fix a bug where row cache can falsely return kNotFound even though row cache entry is hit. -* Fixed a race condition in `GenericRateLimiter` that could cause it to stop granting requests -* Fix a bug (Issue #10257) where DB can hang after write stall since no compaction is scheduled (#11764). -* Add a fix for async_io where during seek, when reading a block for seeking a target key in a file without any readahead, the iterator aligned the read on a page boundary and reading more than necessary. This increased the storage read bandwidth usage. -* Fix an issue in sst dump tool to handle bounds specified for data with user-defined timestamps. -* When auto_readahead_size is enabled, update readahead upper bound during readahead trimming when reseek changes iterate_upper_bound dynamically. -* Fixed a bug where `rocksdb.file.read.verify.file.checksums.micros` is not populated - -### Performance Improvements -* Added additional improvements in tuning readahead_size during Scans when auto_readahead_size is enabled. However it's not supported with Iterator::Prev operation and will return NotSupported error. -* During async_io, the Seek happens in 2 phases. Phase 1 starts an asynchronous read on a block cache miss, and phase 2 waits for it to complete and finishes the seek. In both phases, it tries to lookup the block cache for the data block first before looking in the prefetch buffer. It's optimized by doing the block cache lookup only in the first phase that would save some CPU. - -## 8.6.0 (08/18/2023) -### New Features -* Added enhanced data integrity checking on SST files with new format_version=6. Performance impact is very small or negligible. Previously if SST data was misplaced or re-arranged by the storage layer, it could pass block checksum with higher than 1 in 4 billion probability. With format_version=6, block checksums depend on what file they are in and location within the file. This way, misplaced SST data is no more likely to pass checksum verification than randomly corrupted data. Also in format_version=6, SST footers are checksum-protected. -* Add a new feature to trim readahead_size during scans upto upper_bound when iterate_upper_bound is specified. It's enabled through ReadOptions.auto_readahead_size. Users must also specify ReadOptions.iterate_upper_bound. -* RocksDB will compare the number of input keys to the number of keys processed after each compaction. Compaction will fail and report Corruption status if the verification fails. Option `compaction_verify_record_count` is introduced for this purpose and is enabled by default. -* Add a CF option `bottommost_file_compaction_delay` to allow specifying the delay of bottommost level single-file compactions. -* Add support to allow enabling / disabling user-defined timestamps feature for an existing column family in combination with the in-Memtable only feature. -* Implement a new admission policy for the compressed secondary cache that admits blocks evicted from the primary cache with the hit bit set. This policy can be specified in TieredVolatileCacheOptions by setting the newly added adm_policy option. -* Add a column family option `memtable_max_range_deletions` that limits the number of range deletions in a memtable. RocksDB will try to do an automatic flush after the limit is reached. (#11358) -* Add PutEntity API in sst_file_writer -* Add `timeout` in microsecond option to `WaitForCompactOptions` to allow timely termination of prolonged waiting in scenarios like recurring recoverable errors, such as out-of-space situations and continuous write streams that sustain ongoing flush and compactions -* New statistics `rocksdb.file.read.{get|multiget|db.iterator|verify.checksum|verify.file.checksums}.micros` measure read time of block-based SST tables or blob files during db open, `Get()`, `MultiGet()`, using db iterator, `VerifyFileChecksums()` and `VerifyChecksum()`. They require stats level greater than `StatsLevel::kExceptDetailedTimers`. -* Add close_db option to `WaitForCompactOptions` to call Close() after waiting is done. -* Add a new compression option `CompressionOptions::checksum` for enabling ZSTD's checksum feature to detect corruption during decompression. - -### Public API Changes -* Mark `Options::access_hint_on_compaction_start` related APIs as deprecated. See #11631 for alternative behavior. - -### Behavior Changes -* Statistics `rocksdb.sst.read.micros` now includes time spent on multi read and async read into the file -* For Universal Compaction users, periodic compaction (option `periodic_compaction_seconds`) will be set to 30 days by default if block based table is used. - -### Bug Fixes -* Fix a bug in FileTTLBooster that can cause users with a large number of levels (more than 65) to see errors like "runtime error: shift exponent .. is too large.." (#11673). - -## 8.5.0 (07/21/2023) -### Public API Changes -* Removed recently added APIs `GeneralCache` and `MakeSharedGeneralCache()` as our plan changed to stop exposing a general-purpose cache interface. The old forms of these APIs, `Cache` and `NewLRUCache()`, are still available, although general-purpose caching support will be dropped eventually. - -### Behavior Changes -* Option `periodic_compaction_seconds` no longer supports FIFO compaction: setting it has no effect on FIFO compactions. FIFO compaction users should only set option `ttl` instead. -* Move prefetching responsibility to page cache for compaction read for non directIO use case - -### Performance Improvements -* In case of direct_io, if buffer passed by callee is already aligned, RandomAccessFileRead::Read will avoid realloacting a new buffer, reducing memcpy and use already passed aligned buffer. -* Small efficiency improvement to HyperClockCache by reducing chance of compiler-generated heap allocations - -### Bug Fixes -* Fix use_after_free bug in async_io MultiReads when underlying FS enabled kFSBuffer. kFSBuffer is when underlying FS pass their own buffer instead of using RocksDB scratch in FSReadRequest. Right now it's an experimental feature. - -## 8.4.0 (06/26/2023) -### New Features -* Add FSReadRequest::fs_scratch which is a data buffer allocated and provided by underlying FileSystem to RocksDB during reads, when FS wants to provide its own buffer with data instead of using RocksDB provided FSReadRequest::scratch. This can help in cpu optimization by avoiding copy from file system's buffer to RocksDB buffer. More details on how to use/enable it in file_system.h. Right now its supported only for MultiReads(async + sync) with non direct io. -* Start logging non-zero user-defined timestamp sizes in WAL to signal user key format in subsequent records and use it during recovery. This change will break recovery from WAL files written by early versions that contain user-defined timestamps. The workaround is to ensure there are no WAL files to recover (i.e. by flushing before close) before upgrade. -* Added new property "rocksdb.obsolete-sst-files-size-property" that reports the size of SST files that have become obsolete but have not yet been deleted or scheduled for deletion -* Start to record the value of the flag `AdvancedColumnFamilyOptions.persist_user_defined_timestamps` in the Manifest and table properties for a SST file when it is created. And use the recorded flag when creating a table reader for the SST file. This flag is only explicitly record if it's false. -* Add a new option OptimisticTransactionDBOptions::shared_lock_buckets that enables sharing mutexes for validating transactions between DB instances, for better balancing memory efficiency and validation contention across DB instances. Different column families and DBs also now use different hash seeds in this validation, so that the same set of key names will not contend across DBs or column families. -* Add a new ticker `rocksdb.files.marked.trash.deleted` to track the number of trash files deleted by background thread from the trash queue. -* Add an API NewTieredVolatileCache() in include/rocksdb/cache.h to allocate an instance of a block cache with a primary block cache tier and a compressed secondary cache tier. A cache of this type distributes memory reservations against the block cache, such as WriteBufferManager, table reader memory etc., proportionally across both the primary and compressed secondary cache. -* Add `WaitForCompact()` to wait for all flush and compactions jobs to finish. Jobs to wait include the unscheduled (queued, but not scheduled yet). -* Add `WriteBatch::Release()` that releases the batch's serialized data to the caller. - -### Public API Changes -* Add C API `rocksdb_options_add_compact_on_deletion_collector_factory_del_ratio`. -* change the FileSystem::use_async_io() API to SupportedOps API in order to extend it to various operations supported by underlying FileSystem. Right now it contains FSSupportedOps::kAsyncIO and FSSupportedOps::kFSBuffer. More details about FSSupportedOps in filesystem.h -* Add new tickers: `rocksdb.error.handler.bg.error.count`, `rocksdb.error.handler.bg.io.error.count`, `rocksdb.error.handler.bg.retryable.io.error.count` to replace the misspelled ones: `rocksdb.error.handler.bg.errro.count`, `rocksdb.error.handler.bg.io.errro.count`, `rocksdb.error.handler.bg.retryable.io.errro.count` ('error' instead of 'errro'). Users should switch to use the new tickers before 9.0 release as the misspelled old tickers will be completely removed then. -* Overload the API CreateColumnFamilyWithImport() to support creating ColumnFamily by importing multiple ColumnFamilies It requires that CFs should not overlap in user key range. - -### Behavior Changes -* Change the default value for option `level_compaction_dynamic_level_bytes` to true. This affects users who use leveled compaction and do not set this option explicitly. These users may see additional background compactions following DB open. These compactions help to shape the LSM according to `level_compaction_dynamic_level_bytes` such that the size of each level Ln is approximately size of Ln-1 * `max_bytes_for_level_multiplier`. Turning on this option has other benefits too: see more detail in wiki: https://github.com/facebook/rocksdb/wiki/Leveled-Compaction#option-level_compaction_dynamic_level_bytes-and-levels-target-size and in option comment in advanced_options.h (#11525). -* For Leveled Compaction users, `CompactRange()` will now always try to compact to the last non-empty level. (#11468) -For Leveled Compaction users, `CompactRange()` with `bottommost_level_compaction = BottommostLevelCompaction::kIfHaveCompactionFilter` will behave similar to `kForceOptimized` in that it will skip files created during this manual compaction when compacting files in the bottommost level. (#11468) -* RocksDB will try to drop range tombstones during non-bottommost compaction when it is safe to do so. (#11459) -* When a DB is openend with `allow_ingest_behind=true` (currently only Universal compaction is supported), files in the last level, i.e. the ingested files, will not be included in any compaction. (#11489) -* Statistics `rocksdb.sst.read.micros` scope is expanded to all SST reads except for file ingestion and column family import (some compaction reads were previously excluded). - -### Bug Fixes -* Reduced cases of illegally using Env::Default() during static destruction by never destroying the internal PosixEnv itself (except for builds checking for memory leaks). (#11538) -* Fix extra prefetching during seek in async_io when BlockBasedTableOptions.num_file_reads_for_auto_readahead is 1 leading to extra reads than required. -* Fix a bug where compactions that are qualified to be run as 2 subcompactions were only run as one subcompaction. -* Fix a use-after-move bug in block.cc. - -## 8.3.0 (05/19/2023) -### New Features -* Introduced a new option `block_protection_bytes_per_key`, which can be used to enable per key-value integrity protection for in-memory blocks in block cache (#11287). -* Added `JemallocAllocatorOptions::num_arenas`. Setting `num_arenas > 1` may mitigate mutex contention in the allocator, particularly in scenarios where block allocations commonly bypass jemalloc tcache. -* Improve the operational safety of publishing a DB or SST files to many hosts by using different block cache hash seeds on different hosts. The exact behavior is controlled by new option `ShardedCacheOptions::hash_seed`, which also documents the solved problem in more detail. -* Introduced a new option `CompactionOptionsFIFO::file_temperature_age_thresholds` that allows FIFO compaction to compact files to different temperatures based on key age (#11428). -* Added a new ticker stat to count how many times RocksDB detected a corruption while verifying a block checksum: `BLOCK_CHECKSUM_MISMATCH_COUNT`. -* New statistics `rocksdb.file.read.db.open.micros` that measures read time of block-based SST tables or blob files during db open. -* New statistics tickers for various iterator seek behaviors and relevant filtering, as \*`_LEVEL_SEEK_`\*. (#11460) - -### Public API Changes -* EXPERIMENTAL: Add new API `DB::ClipColumnFamily` to clip the key in CF to a certain range. It will physically deletes all keys outside the range including tombstones. -* Add `MakeSharedCache()` construction functions to various cache Options objects, and deprecated the `NewWhateverCache()` functions with long parameter lists. -* Changed the meaning of various Bloom filter stats (prefix vs. whole key), with iterator-related filtering only being tracked in the new \*`_LEVEL_SEEK_`\*. stats. (#11460) - -### Behavior changes -* For x86, CPU features are no longer detected at runtime nor in build scripts, but in source code using common preprocessor defines. This will likely unlock some small performance improvements on some newer hardware, but could hurt performance of the kCRC32c checksum, which is no longer the default, on some "portable" builds. See PR #11419 for details. - -### Bug Fixes -* Delete an empty WAL file on DB open if the log number is less than the min log number to keep -* Delete temp OPTIONS file on DB open if there is a failure to write it out or rename it - -### Performance Improvements -* Improved the I/O efficiency of prefetching SST metadata by recording more information in the DB manifest. Opening files written with previous versions will still rely on heuristics for how much to prefetch (#11406). - -## 8.2.0 (04/24/2023) -### Public API Changes -* `SstFileWriter::DeleteRange()` now returns `Status::InvalidArgument` if the range's end key comes before its start key according to the user comparator. Previously the behavior was undefined. -* Add `multi_get_for_update` to C API. -* Remove unnecessary constructor for CompressionOptions. - -### Behavior changes -* Changed default block cache size from an 8MB to 32MB LRUCache, which increases the default number of cache shards from 16 to 64. This change is intended to minimize cache mutex contention under stress conditions. See https://github.com/facebook/rocksdb/wiki/Block-Cache for more information. -* For level compaction with `level_compaction_dynamic_level_bytes=true`, RocksDB now trivially moves levels down to fill LSM starting from bottommost level during DB open. See more in comments for option `level_compaction_dynamic_level_bytes` (#11321). -* User-provided `ReadOptions` take effect for more reads of non-`CacheEntryRole::kDataBlock` blocks. -* For level compaction with `level_compaction_dynamic_level_bytes=true`, RocksDB now drains unnecessary levels through background compaction automatically (#11340). This together with #11321 makes it automatic to migrate other compaction settings to level compaction with `level_compaction_dynamic_level_bytes=true`. In addition, a live DB that becomes smaller will now have unnecessary levels drained which can help to reduce read and space amp. -* If `CompactRange()` is called with `CompactRangeOptions::bottommost_level_compaction=kForce*` to compact from L0 to L1, RocksDB now will try to do trivial move from L0 to L1 and then do an intra L1 compaction, instead of a L0 to L1 compaction with trivial move disabled (#11375)). - -### Bug Fixes -* In the DB::VerifyFileChecksums API, ensure that file system reads of SST files are equal to the readahead_size in ReadOptions, if specified. Previously, each read was 2x the readahead_size. -* In block cache tracing, fixed some cases of bad hit/miss information (and more) with MultiGet. - -### New Features -* Add experimental `PerfContext` counters `iter_{next|prev|seek}_count` for db iterator, each counting the times of corresponding API being called. -* Allow runtime changes to whether `WriteBufferManager` allows stall or not by calling `SetAllowStall()` -* Added statistics tickers BYTES_COMPRESSED_FROM, BYTES_COMPRESSED_TO, BYTES_COMPRESSION_BYPASSED, BYTES_COMPRESSION_REJECTED, NUMBER_BLOCK_COMPRESSION_BYPASSED, and NUMBER_BLOCK_COMPRESSION_REJECTED. Disabled/deprecated histograms BYTES_COMPRESSED and BYTES_DECOMPRESSED, and ticker NUMBER_BLOCK_NOT_COMPRESSED. The new tickers offer more inight into compression ratios, rejected vs. disabled compression, etc. (#11388) -* New statistics `rocksdb.file.read.{flush|compaction}.micros` that measure read time of block-based SST tables or blob files during flush or compaction. - -## 8.1.0 (03/18/2023) -### Behavior changes -* Compaction output file cutting logic now considers range tombstone start keys. For example, SST partitioner now may receive ParitionRequest for range tombstone start keys. -* If the async_io ReadOption is specified for MultiGet or NewIterator on a platform that doesn't support IO uring, the option is ignored and synchronous IO is used. - -### Bug Fixes -* Fixed an issue for backward iteration when user defined timestamp is enabled in combination with BlobDB. -* Fixed a couple of cases where a Merge operand encountered during iteration wasn't reflected in the `internal_merge_count` PerfContext counter. -* Fixed a bug in CreateColumnFamilyWithImport()/ExportColumnFamily() which did not support range tombstones (#11252). -* Fixed a bug where an excluded column family from an atomic flush contains unflushed data that should've been included in this atomic flush (i.e, data of seqno less than the max seqno of this atomic flush), leading to potential data loss in this excluded column family when `WriteOptions::disableWAL == true` (#11148). - -### New Features -* Add statistics rocksdb.secondary.cache.filter.hits, rocksdb.secondary.cache.index.hits, and rocksdb.secondary.cache.filter.hits -* Added a new PerfContext counter `internal_merge_point_lookup_count` which tracks the number of Merge operands applied while serving point lookup queries. -* Add new statistics rocksdb.table.open.prefetch.tail.read.bytes, rocksdb.table.open.prefetch.tail.{miss|hit} -* Add support for SecondaryCache with HyperClockCache (`HyperClockCacheOptions` inherits `secondary_cache` option from `ShardedCacheOptions`) -* Add new db properties `rocksdb.cf-write-stall-stats`, `rocksdb.db-write-stall-stats`and APIs to examine them in a structured way. In particular, users of `GetMapProperty()` with property `kCFWriteStallStats`/`kDBWriteStallStats` can now use the functions in `WriteStallStatsMapKeys` to find stats in the map. - -### Public API Changes -* Changed various functions and features in `Cache` that are mostly relevant to custom implementations or wrappers. Especially, asychronous lookup functionality is moved from `Lookup()` to a new `StartAsyncLookup()` function. - -## 8.0.0 (02/19/2023) -### Behavior changes -* `ReadOptions::verify_checksums=false` disables checksum verification for more reads of non-`CacheEntryRole::kDataBlock` blocks. -* In case of scan with async_io enabled, if posix doesn't support IOUring, Status::NotSupported error will be returned to the users. Initially that error was swallowed and reads were switched to synchronous reads. - -### Bug Fixes -* Fixed a data race on `ColumnFamilyData::flush_reason` caused by concurrent flushes. -* Fixed an issue in `Get` and `MultiGet` when user-defined timestamps is enabled in combination with BlobDB. -* Fixed some atypical behaviors for `LockWAL()` such as allowing concurrent/recursive use and not expecting `UnlockWAL()` after non-OK result. See API comments. -* Fixed a feature interaction bug where for blobs `GetEntity` would expose the blob reference instead of the blob value. -* Fixed `DisableManualCompaction()` and `CompactRangeOptions::canceled` to cancel compactions even when they are waiting on conflicting compactions to finish -* Fixed a bug in which a successful `GetMergeOperands()` could transiently return `Status::MergeInProgress()` -* Return the correct error (Status::NotSupported()) to MultiGet caller when ReadOptions::async_io flag is true and IO uring is not enabled. Previously, Status::Corruption() was being returned when the actual failure was lack of async IO support. -* Fixed a bug in DB open/recovery from a compressed WAL that was caused due to incorrect handling of certain record fragments with the same offset within a WAL block. - -### Feature Removal -* Remove RocksDB Lite. -* The feature block_cache_compressed is removed. Statistics related to it are removed too. -* Remove deprecated Env::LoadEnv(). Use Env::CreateFromString() instead. -* Remove deprecated FileSystem::Load(). Use FileSystem::CreateFromString() instead. -* Removed the deprecated version of these utility functions and the corresponding Java bindings: `LoadOptionsFromFile`, `LoadLatestOptions`, `CheckOptionsCompatibility`. -* Remove the FactoryFunc from the LoadObject method from the Customizable helper methods. - -### Public API Changes -* Moved rarely-needed Cache class definition to new advanced_cache.h, and added a CacheWrapper class to advanced_cache.h. Minor changes to SimCache API definitions. -* Completely removed the following deprecated/obsolete statistics: the tickers `BLOCK_CACHE_INDEX_BYTES_EVICT`, `BLOCK_CACHE_FILTER_BYTES_EVICT`, `BLOOM_FILTER_MICROS`, `NO_FILE_CLOSES`, `STALL_L0_SLOWDOWN_MICROS`, `STALL_MEMTABLE_COMPACTION_MICROS`, `STALL_L0_NUM_FILES_MICROS`, `RATE_LIMIT_DELAY_MILLIS`, `NO_ITERATORS`, `NUMBER_FILTERED_DELETES`, `WRITE_TIMEDOUT`, `BLOB_DB_GC_NUM_KEYS_OVERWRITTEN`, `BLOB_DB_GC_NUM_KEYS_EXPIRED`, `BLOB_DB_GC_BYTES_OVERWRITTEN`, `BLOB_DB_GC_BYTES_EXPIRED`, `BLOCK_CACHE_COMPRESSION_DICT_BYTES_EVICT` as well as the histograms `STALL_L0_SLOWDOWN_COUNT`, `STALL_MEMTABLE_COMPACTION_COUNT`, `STALL_L0_NUM_FILES_COUNT`, `HARD_RATE_LIMIT_DELAY_COUNT`, `SOFT_RATE_LIMIT_DELAY_COUNT`, `BLOB_DB_GC_MICROS`, and `NUM_DATA_BLOCKS_READ_PER_LEVEL`. Note that as a result, the C++ enum values of the still supported statistics have changed. Developers are advised to not rely on the actual numeric values. -* Deprecated IngestExternalFileOptions::write_global_seqno and change default to false. This option only needs to be set to true to generate a DB compatible with RocksDB versions before 5.16.0. -* Remove deprecated APIs `GetColumnFamilyOptionsFrom{Map|String}(const ColumnFamilyOptions&, ..)`, `GetDBOptionsFrom{Map|String}(const DBOptions&, ..)`, `GetBlockBasedTableOptionsFrom{Map|String}(const BlockBasedTableOptions& table_options, ..)` and ` GetPlainTableOptionsFrom{Map|String}(const PlainTableOptions& table_options,..)`. -* Added a subcode of `Status::Corruption`, `Status::SubCode::kMergeOperatorFailed`, for users to identify corruption failures originating in the merge operator, as opposed to RocksDB's internally identified data corruptions - -### Build Changes -* The `make` build now builds a shared library by default instead of a static library. Use `LIB_MODE=static` to override. - -### New Features -* Compaction filters are now supported for wide-column entities by means of the `FilterV3` API. See the comment of the API for more details. -* Added `do_not_compress_roles` to `CompressedSecondaryCacheOptions` to disable compression on certain kinds of block. Filter blocks are now not compressed by CompressedSecondaryCache by default. -* Added a new `MultiGetEntity` API that enables batched wide-column point lookups. See the API comments for more details. - -## 7.10.0 (01/23/2023) -### Behavior changes -* Make best-efforts recovery verify SST unique ID before Version construction (#10962) -* Introduce `epoch_number` and sort L0 files by `epoch_number` instead of `largest_seqno`. `epoch_number` represents the order of a file being flushed or ingested/imported. Compaction output file will be assigned with the minimum `epoch_number` among input files'. For L0, larger `epoch_number` indicates newer L0 file. - -### Bug Fixes -* Fixed a regression in iterator where range tombstones after `iterate_upper_bound` is processed. -* Fixed a memory leak in MultiGet with async_io read option, caused by IO errors during table file open -* Fixed a bug that multi-level FIFO compaction deletes one file in non-L0 even when `CompactionOptionsFIFO::max_table_files_size` is no exceeded since #10348 or 7.8.0. -* Fixed a bug caused by `DB::SyncWAL()` affecting `track_and_verify_wals_in_manifest`. Without the fix, application may see "open error: Corruption: Missing WAL with log number" while trying to open the db. The corruption is a false alarm but prevents DB open (#10892). -* Fixed a BackupEngine bug in which RestoreDBFromLatestBackup would fail if the latest backup was deleted and there is another valid backup available. -* Fix L0 file misorder corruption caused by ingesting files of overlapping seqnos with memtable entries' through introducing `epoch_number`. Before the fix, `force_consistency_checks=true` may catch the corruption before it's exposed to readers, in which case writes returning `Status::Corruption` would be expected. Also replace the previous incomplete fix (#5958) to the same corruption with this new and more complete fix. -* Fixed a bug in LockWAL() leading to re-locking mutex (#11020). -* Fixed a heap use after free bug in async scan prefetching when the scan thread and another thread try to read and load the same seek block into cache. -* Fixed a heap use after free in async scan prefetching if dictionary compression is enabled, in which case sync read of the compression dictionary gets mixed with async prefetching -* Fixed a data race bug of `CompactRange()` under `change_level=true` acts on overlapping range with an ongoing file ingestion for level compaction. This will either result in overlapping file ranges corruption at a certain level caught by `force_consistency_checks=true` or protentially two same keys both with seqno 0 in two different levels (i.e, new data ends up in lower/older level). The latter will be caught by assertion in debug build but go silently and result in read returning wrong result in release build. This fix is general so it also replaced previous fixes to a similar problem for `CompactFiles()` (#4665), general `CompactRange()` and auto compaction (commit 5c64fb6 and 87dfc1d). -* Fixed a bug in compaction output cutting where small output files were produced due to TTL file cutting states were not being updated (#11075). - -### New Features -* When an SstPartitionerFactory is configured, CompactRange() now automatically selects for compaction any files overlapping a partition boundary that is in the compaction range, even if no actual entries are in the requested compaction range. With this feature, manual compaction can be used to (re-)establish SST partition points when SstPartitioner changes, without a full compaction. -* Add BackupEngine feature to exclude files from backup that are known to be backed up elsewhere, using `CreateBackupOptions::exclude_files_callback`. To restore the DB, the excluded files must be provided in alternative backup directories using `RestoreOptions::alternate_dirs`. - -### Public API Changes -* Substantial changes have been made to the Cache class to support internal development goals. Direct use of Cache class members is discouraged and further breaking modifications are expected in the future. SecondaryCache has some related changes and implementations will need to be updated. (Unlike Cache, SecondaryCache is still intended to support user implementations, and disruptive changes will be avoided.) (#10975) -* Add `MergeOperationOutput::op_failure_scope` for merge operator users to control the blast radius of merge operator failures. Existing merge operator users do not need to make any change to preserve the old behavior - -### Performance Improvements -* Updated xxHash source code, which should improve kXXH3 checksum speed, at least on ARM (#11098). -* Improved CPU efficiency of DB reads, from block cache access improvements (#10975). - -## 7.9.0 (11/21/2022) -### Performance Improvements -* Fixed an iterator performance regression for delete range users when scanning through a consecutive sequence of range tombstones (#10877). - -### Bug Fixes -* Fix memory corruption error in scans if async_io is enabled. Memory corruption happened if there is IOError while reading the data leading to empty buffer and other buffer already in progress of async read goes again for reading. -* Fix failed memtable flush retry bug that could cause wrongly ordered updates, which would surface to writers as `Status::Corruption` in case of `force_consistency_checks=true` (default). It affects use cases that enable both parallel flush (`max_background_flushes > 1` or `max_background_jobs >= 8`) and non-default memtable count (`max_write_buffer_number > 2`). -* Fixed an issue where the `READ_NUM_MERGE_OPERANDS` ticker was not updated when the base key-value or tombstone was read from an SST file. -* Fixed a memory safety bug when using a SecondaryCache with `block_cache_compressed`. `block_cache_compressed` no longer attempts to use SecondaryCache features. -* Fixed a regression in scan for async_io. During seek, valid buffers were getting cleared causing a regression. -* Tiered Storage: fixed excessive keys written to penultimate level in non-debug builds. - -### New Features -* Add basic support for user-defined timestamp to Merge (#10819). -* Add stats for ReadAsync time spent and async read errors. -* Basic support for the wide-column data model is now available. Wide-column entities can be stored using the `PutEntity` API, and retrieved using `GetEntity` and the new `columns` API of iterator. For compatibility, the classic APIs `Get` and `MultiGet`, as well as iterator's `value` API return the value of the anonymous default column of wide-column entities; also, `GetEntity` and iterator's `columns` return any plain key-values in the form of an entity which only has the anonymous default column. `Merge` (and `GetMergeOperands`) currently also apply to the default column; any other columns of entities are unaffected by `Merge` operations. Note that some features like compaction filters, transactions, user-defined timestamps, and the SST file writer do not yet support wide-column entities; also, there is currently no `MultiGet`-like API to retrieve multiple entities at once. We plan to gradually close the above gaps and also implement new features like column-level operations (e.g. updating or querying only certain columns of an entity). -* Marked HyperClockCache as a production-ready alternative to LRUCache for the block cache. HyperClockCache greatly improves hot-path CPU efficiency under high parallel load or high contention, with some documented caveats and limitations. As much as 4.5x higher ops/sec vs. LRUCache has been seen in db_bench under high parallel load. -* Add periodic diagnostics to info_log (LOG file) for HyperClockCache block cache if performance is degraded by bad `estimated_entry_charge` option. - -### Public API Changes -* Marked `block_cache_compressed` as a deprecated feature. Use SecondaryCache instead. -* Added a `SecondaryCache::InsertSaved()` API, with default implementation depending on `Insert()`. Some implementations might need to add a custom implementation of `InsertSaved()`. (Details in API comments.) - -## 7.8.0 (10/22/2022) -### New Features -* `DeleteRange()` now supports user-defined timestamp. -* Provide support for async_io with tailing iterators when ReadOptions.tailing is enabled during scans. -* Tiered Storage: allow data moving up from the last level to the penultimate level if the input level is penultimate level or above. -* Added `DB::Properties::kFastBlockCacheEntryStats`, which is similar to `DB::Properties::kBlockCacheEntryStats`, except returns cached (stale) values in more cases to reduce overhead. -* FIFO compaction now supports migrating from a multi-level DB via DB::Open(). During the migration phase, FIFO compaction picker will: -* picks the sst file with the smallest starting key in the bottom-most non-empty level. -* Note that during the migration phase, the file purge order will only be an approximation of "FIFO" as files in lower-level might sometime contain newer keys than files in upper-level. -* Added an option `ignore_max_compaction_bytes_for_input` to ignore max_compaction_bytes limit when adding files to be compacted from input level. This should help reduce write amplification. The option is enabled by default. -* Tiered Storage: allow data moving up from the last level even if it's a last level only compaction, as long as the penultimate level is empty. -* Add a new option IOOptions.do_not_recurse that can be used by underlying file systems to skip recursing through sub directories and list only files in GetChildren API. -* Add option `preserve_internal_time_seconds` to preserve the time information for the latest data. Which can be used to determine the age of data when `preclude_last_level_data_seconds` is enabled. The time information is attached with SST in table property `rocksdb.seqno.time.map` which can be parsed by tool ldb or sst_dump. - -### Bug Fixes -* Fix a bug in io_uring_prep_cancel in AbortIO API for posix which expects sqe->addr to match with read request submitted and wrong paramter was being passed. -* Fixed a regression in iterator performance when the entire DB is a single memtable introduced in #10449. The fix is in #10705 and #10716. -* Fixed an optimistic transaction validation bug caused by DBImpl::GetLatestSequenceForKey() returning non-latest seq for merge (#10724). -* Fixed a bug in iterator refresh which could segfault for DeleteRange users (#10739). -* Fixed a bug causing manual flush with `flush_opts.wait=false` to stall when database has stopped all writes (#10001). -* Fixed a bug in iterator refresh that was not freeing up SuperVersion, which could cause excessive resource pinniung (#10770). -* Fixed a bug where RocksDB could be doing compaction endlessly when allow_ingest_behind is true and the bottommost level is not filled (#10767). -* Fixed a memory safety bug in experimental HyperClockCache (#10768) -* Fixed some cases where `ldb update_manifest` and `ldb unsafe_remove_sst_file` are not usable because they were requiring the DB files to match the existing manifest state (before updating the manifest to match a desired state). - -### Performance Improvements -* Try to align the compaction output file boundaries to the next level ones, which can reduce more than 10% compaction load for the default level compaction. The feature is enabled by default, to disable, set `AdvancedColumnFamilyOptions.level_compaction_dynamic_file_size` to false. As a side effect, it can create SSTs larger than the target_file_size (capped at 2x target_file_size) or smaller files. -* Improve RoundRobin TTL compaction, which is going to be the same as normal RoundRobin compaction to move the compaction cursor. -* Fix a small CPU regression caused by a change that UserComparatorWrapper was made Customizable, because Customizable itself has small CPU overhead for initialization. - -### Behavior Changes -* Sanitize min_write_buffer_number_to_merge to 1 if atomic flush is enabled to prevent unexpected data loss when WAL is disabled in a multi-column-family setting (#10773). -* With periodic stat dumper waits up every options.stats_dump_period_sec seconds, it won't dump stats for a CF if it has no change in the period, unless 7 periods have been skipped. -* Only periodic stats dumper triggered by options.stats_dump_period_sec will update stats interval. Ones triggered by DB::GetProperty() will not update stats interval and will report based on an interval since the last time stats dump period. - -### Public API changes -* Make kXXH3 checksum the new default, because it is faster on common hardware, especially with kCRC32c affected by a performance bug in some versions of clang (https://github.com/facebook/rocksdb/issues/9891). DBs written with this new setting can be read by RocksDB 6.27 and newer. -* Refactor the classes, APIs and data structures for block cache tracing to allow a user provided trace writer to be used. Introduced an abstract BlockCacheTraceWriter class that takes a structured BlockCacheTraceRecord. The BlockCacheTraceWriter implementation can then format and log the record in whatever way it sees fit. The default BlockCacheTraceWriterImpl does file tracing using a user provided TraceWriter. More details in rocksdb/includb/block_cache_trace_writer.h. - -## 7.7.0 (09/18/2022) -### Bug Fixes -* Fixed a hang when an operation such as `GetLiveFiles` or `CreateNewBackup` is asked to trigger and wait for memtable flush on a read-only DB. Such indirect requests for memtable flush are now ignored on a read-only DB. -* Fixed bug where `FlushWAL(true /* sync */)` (used by `GetLiveFilesStorageInfo()`, which is used by checkpoint and backup) could cause parallel writes at the tail of a WAL file to never be synced. -* Fix periodic_task unable to re-register the same task type, which may cause `SetOptions()` fail to update periodical_task time like: `stats_dump_period_sec`, `stats_persist_period_sec`. -* Fixed a bug in the rocksdb.prefetched.bytes.discarded stat. It was counting the prefetch buffer size, rather than the actual number of bytes discarded from the buffer. -* Fix bug where the directory containing CURRENT can left unsynced after CURRENT is updated to point to the latest MANIFEST, which leads to risk of unsync data loss of CURRENT. -* Update rocksdb.multiget.io.batch.size stat in non-async MultiGet as well. -* Fix a bug in key range overlap checking with concurrent compactions when user-defined timestamp is enabled. User-defined timestamps should be EXCLUDED when checking if two ranges overlap. -* Fixed a bug where the blob cache prepopulating logic did not consider the secondary cache (see #10603). -* Fixed the rocksdb.num.sst.read.per.level, rocksdb.num.index.and.filter.blocks.read.per.level and rocksdb.num.level.read.per.multiget stats in the MultiGet coroutines - -### Public API changes -* Add `rocksdb_column_family_handle_get_id`, `rocksdb_column_family_handle_get_name` to get name, id of column family in C API -* Add a new stat rocksdb.async.prefetch.abort.micros to measure time spent waiting for async prefetch reads to abort - -### Java API Changes -* Add CompactionPriority.RoundRobin. -* Revert to using the default metadata charge policy when creating an LRU cache via the Java API. - -### Behavior Change -* DBOptions::verify_sst_unique_id_in_manifest is now an on-by-default feature that verifies SST file identity whenever they are opened by a DB, rather than only at DB::Open time. -* Right now, when the option migration tool (OptionChangeMigration()) migrates to FIFO compaction, it compacts all the data into one single SST file and move to L0. This might create a problem for some users: the giant file may be soon deleted to satisfy max_table_files_size, and might cayse the DB to be almost empty. We change the behavior so that the files are cut to be smaller, but these files might not follow the data insertion order. With the change, after the migration, migrated data might not be dropped by insertion order by FIFO compaction. -* When a block is firstly found from `CompressedSecondaryCache`, we just insert a dummy block into the primary cache and don’t erase the block from `CompressedSecondaryCache`. A standalone handle is returned to the caller. Only if the block is found again from `CompressedSecondaryCache` before the dummy block is evicted, we erase the block from `CompressedSecondaryCache` and insert it into the primary cache. -* When a block is firstly evicted from the primary cache to `CompressedSecondaryCache`, we just insert a dummy block in `CompressedSecondaryCache`. Only if it is evicted again before the dummy block is evicted from the cache, it is treated as a hot block and is inserted into `CompressedSecondaryCache`. -* Improved the estimation of memory used by cached blobs by taking into account the size of the object owning the blob value and also the allocator overhead if `malloc_usable_size` is available (see #10583). -* Blob values now have their own category in the cache occupancy statistics, as opposed to being lumped into the "Misc" bucket (see #10601). -* Change the optimize_multiget_for_io experimental ReadOptions flag to default on. - -### New Features -* RocksDB does internal auto prefetching if it notices 2 sequential reads if readahead_size is not specified. New option `num_file_reads_for_auto_readahead` is added in BlockBasedTableOptions which indicates after how many sequential reads internal auto prefetching should be start (default is 2). -* Added new perf context counters `block_cache_standalone_handle_count`, `block_cache_real_handle_count`,`compressed_sec_cache_insert_real_count`, `compressed_sec_cache_insert_dummy_count`, `compressed_sec_cache_uncompressed_bytes`, and `compressed_sec_cache_compressed_bytes`. -* Memory for blobs which are to be inserted into the blob cache is now allocated using the cache's allocator (see #10628 and #10647). -* HyperClockCache is an experimental, lock-free Cache alternative for block cache that offers much improved CPU efficiency under high parallel load or high contention, with some caveats. As much as 4.5x higher ops/sec vs. LRUCache has been seen in db_bench under high parallel load. -* `CompressedSecondaryCacheOptions::enable_custom_split_merge` is added for enabling the custom split and merge feature, which split the compressed value into chunks so that they may better fit jemalloc bins. - -### Performance Improvements -* Iterator performance is improved for `DeleteRange()` users. Internally, iterator will skip to the end of a range tombstone when possible, instead of looping through each key and check individually if a key is range deleted. -* Eliminated some allocations and copies in the blob read path. Also, `PinnableSlice` now only points to the blob value and pins the backing resource (cache entry or buffer) in all cases, instead of containing a copy of the blob value. See #10625 and #10647. -* In case of scans with async_io enabled, few optimizations have been added to issue more asynchronous requests in parallel in order to avoid synchronous prefetching. -* `DeleteRange()` users should see improvement in get/iterator performance from mutable memtable (see #10547). - -## 7.6.0 (08/19/2022) -### New Features -* Added `prepopulate_blob_cache` to ColumnFamilyOptions. If enabled, prepopulate warm/hot blobs which are already in memory into blob cache at the time of flush. On a flush, the blob that is in memory (in memtables) get flushed to the device. If using Direct IO, additional IO is incurred to read this blob back into memory again, which is avoided by enabling this option. This further helps if the workload exhibits high temporal locality, where most of the reads go to recently written data. This also helps in case of the remote file system since it involves network traffic and higher latencies. -* Support using secondary cache with the blob cache. When creating a blob cache, the user can set a secondary blob cache by configuring `secondary_cache` in LRUCacheOptions. -* Charge memory usage of blob cache when the backing cache of the blob cache and the block cache are different. If an operation reserving memory for blob cache exceeds the avaible space left in the block cache at some point (i.e, causing a cache full under `LRUCacheOptions::strict_capacity_limit` = true), creation will fail with `Status::MemoryLimit()`. To opt in this feature, enable charging `CacheEntryRole::kBlobCache` in `BlockBasedTableOptions::cache_usage_options`. -* Improve subcompaction range partition so that it is likely to be more even. More evenly distribution of subcompaction will improve compaction throughput for some workloads. All input files' index blocks to sample some anchor key points from which we pick positions to partition the input range. This would introduce some CPU overhead in compaction preparation phase, if subcompaction is enabled, but it should be a small fraction of the CPU usage of the whole compaction process. This also brings a behavier change: subcompaction number is much more likely to maxed out than before. -* Add CompactionPri::kRoundRobin, a compaction picking mode that cycles through all the files with a compact cursor in a round-robin manner. This feature is available since 7.5. -* Provide support for subcompactions for user_defined_timestamp. -* Added an option `memtable_protection_bytes_per_key` that turns on memtable per key-value checksum protection. Each memtable entry will be suffixed by a checksum that is computed during writes, and verified in reads/compaction. Detected corruption will be logged and with corruption status returned to user. -* Added a blob-specific cache priority level - bottom level. Blobs are typically lower-value targets for caching than data blocks, since 1) with BlobDB, data blocks containing blob references conceptually form an index structure which has to be consulted before we can read the blob value, and 2) cached blobs represent only a single key-value, while cached data blocks generally contain multiple KVs. The user can specify the new option `low_pri_pool_ratio` in `LRUCacheOptions` to configure the ratio of capacity reserved for low priority cache entries (and therefore the remaining ratio is the space reserved for the bottom level), or configuring the new argument `low_pri_pool_ratio` in `NewLRUCache()` to achieve the same effect. - -### Public API changes -* Removed Customizable support for RateLimiter and removed its CreateFromString() and Type() functions. -* `CompactRangeOptions::exclusive_manual_compaction` is now false by default. This ensures RocksDB does not introduce artificial parallelism limitations by default. -* Tiered Storage: change `bottommost_temperture` to `last_level_temperture`. The old option name is kept only for migration, please use the new option. The behavior is changed to apply temperature for the `last_level` SST files only. -* Added a new experimental ReadOption flag called optimize_multiget_for_io, which when set attempts to reduce MultiGet latency by spawning coroutines for keys in multiple levels. - -### Bug Fixes -* Fix a bug starting in 7.4.0 in which some fsync operations might be skipped in a DB after any DropColumnFamily on that DB, until it is re-opened. This can lead to data loss on power loss. (For custom FileSystem implementations, this could lead to `FSDirectory::Fsync` or `FSDirectory::Close` after the first `FSDirectory::Close`; Also, valgrind could report call to `close()` with `fd=-1`.) -* Fix a bug where `GenericRateLimiter` could revert the bandwidth set dynamically using `SetBytesPerSecond()` when a user configures a structure enclosing it, e.g., using `GetOptionsFromString()` to configure an `Options` that references an existing `RateLimiter` object. -* Fix race conditions in `GenericRateLimiter`. -* Fix a bug in `FIFOCompactionPicker::PickTTLCompaction` where total_size calculating might cause underflow -* Fix data race bug in hash linked list memtable. With this bug, read request might temporarily miss an old record in the memtable in a race condition to the hash bucket. -* Fix a bug that `best_efforts_recovery` may fail to open the db with mmap read. -* Fixed a bug where blobs read during compaction would pollute the cache. -* Fixed a data race in LRUCache when used with a secondary_cache. -* Fixed a bug where blobs read by iterators would be inserted into the cache even with the `fill_cache` read option set to false. -* Fixed the segfault caused by `AllocateData()` in `CompressedSecondaryCache::SplitValueIntoChunks()` and `MergeChunksIntoValueTest`. -* Fixed a bug in BlobDB where a mix of inlined and blob values could result in an incorrect value being passed to the compaction filter (see #10391). -* Fixed a memory leak bug in stress tests caused by `FaultInjectionSecondaryCache`. - -### Behavior Change -* Added checksum handshake during the copying of decompressed WAL fragment. This together with #9875, #10037, #10212, #10114 and #10319 provides end-to-end integrity protection for write batch during recovery. -* To minimize the internal fragmentation caused by the variable size of the compressed blocks in `CompressedSecondaryCache`, the original block is split according to the jemalloc bin size in `Insert()` and then merged back in `Lookup()`. -* PosixLogger is removed and by default EnvLogger will be used for info logging. The behavior of the two loggers should be very similar when using the default Posix Env. -* Remove [min|max]_timestamp from VersionEdit for now since they are not tracked in MANIFEST anyway but consume two empty std::string (up to 64 bytes) for each file. Should they be added back in the future, we should store them more compactly. -* Improve universal tiered storage compaction picker to avoid extra major compaction triggered by size amplification. If `preclude_last_level_data_seconds` is enabled, the size amplification is calculated within non last_level data only which skip the last level and use the penultimate level as the size base. -* If an error is hit when writing to a file (append, sync, etc), RocksDB is more strict with not issuing more operations to it, except closing the file, with exceptions of some WAL file operations in error recovery path. -* A `WriteBufferManager` constructed with `allow_stall == false` will no longer trigger write stall implicitly by thrashing until memtable count limit is reached. Instead, a column family can continue accumulating writes while that CF is flushing, which means memory may increase. Users who prefer stalling writes must now explicitly set `allow_stall == true`. -* Add `CompressedSecondaryCache` into the stress tests. -* Block cache keys have changed, which will cause any persistent caches to miss between versions. - -### Performance Improvements -* Instead of constructing `FragmentedRangeTombstoneList` during every read operation, it is now constructed once and stored in immutable memtables. This improves speed of querying range tombstones from immutable memtables. -* When using iterators with the integrated BlobDB implementation, blob cache handles are now released immediately when the iterator's position changes. -* MultiGet can now do more IO in parallel by reading data blocks from SST files in multiple levels, if the optimize_multiget_for_io ReadOption flag is set. - -## 7.5.0 (07/15/2022) -### New Features -* Mempurge option flag `experimental_mempurge_threshold` is now a ColumnFamilyOptions and can now be dynamically configured using `SetOptions()`. -* Support backward iteration when `ReadOptions::iter_start_ts` is set. -* Provide support for ReadOptions.async_io with direct_io to improve Seek latency by using async IO to parallelize child iterator seek and doing asynchronous prefetching on sequential scans. -* Added support for blob caching in order to cache frequently used blobs for BlobDB. - * User can configure the new ColumnFamilyOptions `blob_cache` to enable/disable blob caching. - * Either sharing the backend cache with the block cache or using a completely separate cache is supported. - * A new abstraction interface called `BlobSource` for blob read logic gives all users access to blobs, whether they are in the blob cache, secondary cache, or (remote) storage. Blobs can be potentially read both while handling user reads (`Get`, `MultiGet`, or iterator) and during compaction (while dealing with compaction filters, Merges, or garbage collection) but eventually all blob reads go through `Version::GetBlob` or, for MultiGet, `Version::MultiGetBlob` (and then get dispatched to the interface -- `BlobSource`). -* Add experimental tiered compaction feature `AdvancedColumnFamilyOptions::preclude_last_level_data_seconds`, which makes sure the new data inserted within preclude_last_level_data_seconds won't be placed on cold tier (the feature is not complete). - -### Public API changes -* Add metadata related structs and functions in C API, including - * `rocksdb_get_column_family_metadata()` and `rocksdb_get_column_family_metadata_cf()` to obtain `rocksdb_column_family_metadata_t`. - * `rocksdb_column_family_metadata_t` and its get functions & destroy function. - * `rocksdb_level_metadata_t` and its and its get functions & destroy function. - * `rocksdb_file_metadata_t` and its and get functions & destroy functions. -* Add suggest_compact_range() and suggest_compact_range_cf() to C API. -* When using block cache strict capacity limit (`LRUCache` with `strict_capacity_limit=true`), DB operations now fail with Status code `kAborted` subcode `kMemoryLimit` (`IsMemoryLimit()`) instead of `kIncomplete` (`IsIncomplete()`) when the capacity limit is reached, because Incomplete can mean other specific things for some operations. In more detail, `Cache::Insert()` now returns the updated Status code and this usually propagates through RocksDB to the user on failure. -* NewClockCache calls temporarily return an LRUCache (with similar characteristics as the desired ClockCache). This is because ClockCache is being replaced by a new version (the old one had unknown bugs) but this is still under development. -* Add two functions `int ReserveThreads(int threads_to_be_reserved)` and `int ReleaseThreads(threads_to_be_released)` into `Env` class. In the default implementation, both return 0. Newly added `xxxEnv` class that inherits `Env` should implement these two functions for thread reservation/releasing features. -* Add `rocksdb_options_get_prepopulate_blob_cache` and `rocksdb_options_set_prepopulate_blob_cache` to C API. -* Add `prepopulateBlobCache` and `setPrepopulateBlobCache` to Java API. - -### Bug Fixes -* Fix a bug in which backup/checkpoint can include a WAL deleted by RocksDB. -* Fix a bug where concurrent compactions might cause unnecessary further write stalling. In some cases, this might cause write rate to drop to minimum. -* Fix a bug in Logger where if dbname and db_log_dir are on different filesystems, dbname creation would fail wrt to db_log_dir path returning an error and fails to open the DB. -* Fix a CPU and memory efficiency issue introduce by https://github.com/facebook/rocksdb/pull/8336 which made InternalKeyComparator configurable as an unintended side effect. - -## Behavior Change -* In leveled compaction with dynamic levelling, level multiplier is not anymore adjusted due to oversized L0. Instead, compaction score is adjusted by increasing size level target by adding incoming bytes from upper levels. This would deprioritize compactions from upper levels if more data from L0 is coming. This is to fix some unnecessary full stalling due to drastic change of level targets, while not wasting write bandwidth for compaction while writes are overloaded. -* For track_and_verify_wals_in_manifest, revert to the original behavior before #10087: syncing of live WAL file is not tracked, and we track only the synced sizes of **closed** WALs. (PR #10330). -* WAL compression now computes/verifies checksum during compression/decompression. - -### Performance Improvements -* Rather than doing total sort against all files in a level, SortFileByOverlappingRatio() to only find the top 50 files based on score. This can improve write throughput for the use cases where data is loaded in increasing key order and there are a lot of files in one LSM-tree, where applying compaction results is the bottleneck. -* In leveled compaction, L0->L1 trivial move will allow more than one file to be moved in one compaction. This would allow L0 files to be moved down faster when data is loaded in sequential order, making slowdown or stop condition harder to hit. Also seek L0->L1 trivial move when only some files qualify. -* In leveled compaction, try to trivial move more than one files if possible, up to 4 files or max_compaction_bytes. This is to allow higher write throughput for some use cases where data is loaded in sequential order, where appying compaction results is the bottleneck. - -## 7.4.0 (06/19/2022) -### Bug Fixes -* Fixed a bug in calculating key-value integrity protection for users of in-place memtable updates. In particular, the affected users would be those who configure `protection_bytes_per_key > 0` on `WriteBatch` or `WriteOptions`, and configure `inplace_callback != nullptr`. -* Fixed a bug where a snapshot taken during SST file ingestion would be unstable. -* Fixed a bug for non-TransactionDB with avoid_flush_during_recovery = true and TransactionDB where in case of crash, min_log_number_to_keep may not change on recovery and persisting a new MANIFEST with advanced log_numbers for some column families, results in "column family inconsistency" error on second recovery. As a solution, RocksDB will persist the new MANIFEST after successfully syncing the new WAL. If a future recovery starts from the new MANIFEST, then it means the new WAL is successfully synced. Due to the sentinel empty write batch at the beginning, kPointInTimeRecovery of WAL is guaranteed to go after this point. If future recovery starts from the old MANIFEST, it means the writing the new MANIFEST failed. We won't have the "SST ahead of WAL" error. -* Fixed a bug where RocksDB DB::Open() may creates and writes to two new MANIFEST files even before recovery succeeds. Now writes to MANIFEST are persisted only after recovery is successful. -* Fix a race condition in WAL size tracking which is caused by an unsafe iterator access after container is changed. -* Fix unprotected concurrent accesses to `WritableFileWriter::filesize_` by `DB::SyncWAL()` and `DB::Put()` in two write queue mode. -* Fix a bug in WAL tracking. Before this PR (#10087), calling `SyncWAL()` on the only WAL file of the db will not log the event in MANIFEST, thus allowing a subsequent `DB::Open` even if the WAL file is missing or corrupted. -* Fix a bug that could return wrong results with `index_type=kHashSearch` and using `SetOptions` to change the `prefix_extractor`. -* Fixed a bug in WAL tracking with wal_compression. WAL compression writes a kSetCompressionType record which is not associated with any sequence number. As result, WalManager::GetSortedWalsOfType() will skip these WALs and not return them to caller, e.g. Checkpoint, Backup, causing the operations to fail. -* Avoid a crash if the IDENTITY file is accidentally truncated to empty. A new DB ID will be written and generated on Open. -* Fixed a possible corruption for users of `manual_wal_flush` and/or `FlushWAL(true /* sync */)`, together with `track_and_verify_wals_in_manifest == true`. For those users, losing unsynced data (e.g., due to power loss) could make future DB opens fail with a `Status::Corruption` complaining about missing WAL data. -* Fixed a bug in `WriteBatchInternal::Append()` where WAL termination point in write batch was not considered and the function appends an incorrect number of checksums. -* Fixed a crash bug introduced in 7.3.0 affecting users of MultiGet with `kDataBlockBinaryAndHash`. - -### Public API changes -* Add new API GetUnixTime in Snapshot class which returns the unix time at which Snapshot is taken. -* Add transaction `get_pinned` and `multi_get` to C API. -* Add two-phase commit support to C API. -* Add `rocksdb_transaction_get_writebatch_wi` and `rocksdb_transaction_rebuild_from_writebatch` to C API. -* Add `rocksdb_options_get_blob_file_starting_level` and `rocksdb_options_set_blob_file_starting_level` to C API. -* Add `blobFileStartingLevel` and `setBlobFileStartingLevel` to Java API. -* Add SingleDelete for DB in C API -* Add User Defined Timestamp in C API. - * `rocksdb_comparator_with_ts_create` to create timestamp aware comparator - * Put, Get, Delete, SingleDelete, MultiGet APIs has corresponding timestamp aware APIs with suffix `with_ts` - * And Add C API's for Transaction, SstFileWriter, Compaction as mentioned [here](https://github.com/facebook/rocksdb/wiki/User-defined-Timestamp-(Experimental)) -* The contract for implementations of Comparator::IsSameLengthImmediateSuccessor has been updated to work around a design bug in `auto_prefix_mode`. -* The API documentation for `auto_prefix_mode` now notes some corner cases in which it returns different results than `total_order_seek`, due to design bugs that are not easily fixed. Users using built-in comparators and keys at least the size of a fixed prefix length are not affected. -* Obsoleted the NUM_DATA_BLOCKS_READ_PER_LEVEL stat and introduced the NUM_LEVEL_READ_PER_MULTIGET and MULTIGET_COROUTINE_COUNT stats -* Introduced `WriteOptions::protection_bytes_per_key`, which can be used to enable key-value integrity protection for live updates. - -### New Features -* Add FileSystem::ReadAsync API in io_tracing -* Add blob garbage collection parameters `blob_garbage_collection_policy` and `blob_garbage_collection_age_cutoff` to both force-enable and force-disable GC, as well as selectively override age cutoff when using CompactRange. -* Add an extra sanity check in `GetSortedWalFiles()` (also used by `GetLiveFilesStorageInfo()`, `BackupEngine`, and `Checkpoint`) to reduce risk of successfully created backup or checkpoint failing to open because of missing WAL file. -* Add a new column family option `blob_file_starting_level` to enable writing blob files during flushes and compactions starting from the specified LSM tree level. -* Add support for timestamped snapshots (#9879) -* Provide support for AbortIO in posix to cancel submitted asynchronous requests using io_uring. -* Add support for rate-limiting batched `MultiGet()` APIs -* Added several new tickers, perf context statistics, and DB properties to BlobDB - * Added new DB properties "rocksdb.blob-cache-capacity", "rocksdb.blob-cache-usage", "rocksdb.blob-cache-pinned-usage" to show blob cache usage. - * Added new perf context statistics `blob_cache_hit_count`, `blob_read_count`, `blob_read_byte`, `blob_read_time`, `blob_checksum_time` and `blob_decompress_time`. - * Added new tickers `BLOB_DB_CACHE_MISS`, `BLOB_DB_CACHE_HIT`, `BLOB_DB_CACHE_ADD`, `BLOB_DB_CACHE_ADD_FAILURES`, `BLOB_DB_CACHE_BYTES_READ` and `BLOB_DB_CACHE_BYTES_WRITE`. - -### Behavior changes -* DB::Open(), DB::OpenAsSecondary() will fail if a Logger cannot be created (#9984) -* DB::Write does not hold global `mutex_` if this db instance does not need to switch wal and mem-table (#7516). -* Removed support for reading Bloom filters using obsolete block-based filter format. (Support for writing such filters was dropped in 7.0.) For good read performance on old DBs using these filters, a full compaction is required. -* Per KV checksum in write batch is verified before a write batch is written to WAL to detect any corruption to the write batch (#10114). - -### Performance Improvements -* When compiled with folly (Meta-internal integration; experimental in open source build), improve the locking performance (CPU efficiency) of LRUCache by using folly DistributedMutex in place of standard mutex. - -## 7.3.0 (05/20/2022) -### Bug Fixes -* Fixed a bug where manual flush would block forever even though flush options had wait=false. -* Fixed a bug where RocksDB could corrupt DBs with `avoid_flush_during_recovery == true` by removing valid WALs, leading to `Status::Corruption` with message like "SST file is ahead of WALs" when attempting to reopen. -* Fixed a bug in async_io path where incorrect length of data is read by FilePrefetchBuffer if data is consumed from two populated buffers and request for more data is sent. -* Fixed a CompactionFilter bug. Compaction filter used to use `Delete` to remove keys, even if the keys should be removed with `SingleDelete`. Mixing `Delete` and `SingleDelete` may cause undefined behavior. -* Fixed a bug in `WritableFileWriter::WriteDirect` and `WritableFileWriter::WriteDirectWithChecksum`. The rate_limiter_priority specified in ReadOptions was not passed to the RateLimiter when requesting a token. -* Fixed a bug which might cause process crash when I/O error happens when reading an index block in MultiGet(). - -### New Features -* DB::GetLiveFilesStorageInfo is ready for production use. -* Add new stats PREFETCHED_BYTES_DISCARDED which records number of prefetched bytes discarded by RocksDB FilePrefetchBuffer on destruction and POLL_WAIT_MICROS records wait time for FS::Poll API completion. -* RemoteCompaction supports table_properties_collector_factories override on compaction worker. -* Start tracking SST unique id in MANIFEST, which will be used to verify with SST properties during DB open to make sure the SST file is not overwritten or misplaced. A db option `verify_sst_unique_id_in_manifest` is introduced to enable/disable the verification, if enabled all SST files will be opened during DB-open to verify the unique id (default is false), so it's recommended to use it with `max_open_files = -1` to pre-open the files. -* Added the ability to concurrently read data blocks from multiple files in a level in batched MultiGet. This can be enabled by setting the async_io option in ReadOptions. Using this feature requires a FileSystem that supports ReadAsync (PosixFileSystem is not supported yet for this), and for RocksDB to be compiled with folly and c++20. -* Charge memory usage of file metadata. RocksDB holds one file metadata structure in-memory per on-disk table file. If an operation reserving memory for file metadata exceeds the avaible space left in the block -cache at some point (i.e, causing a cache full under `LRUCacheOptions::strict_capacity_limit` = true), creation will fail with `Status::MemoryLimit()`. To opt in this feature, enable charging `CacheEntryRole::kFileMetadata` in `BlockBasedTableOptions::cache_usage_options`. - -### Public API changes -* Add rollback_deletion_type_callback to TransactionDBOptions so that write-prepared transactions know whether to issue a Delete or SingleDelete to cancel a previous key written during prior prepare phase. The PR aims to prevent mixing SingleDeletes and Deletes for the same key that can lead to undefined behaviors for write-prepared transactions. -* EXPERIMENTAL: Add new API AbortIO in file_system to abort the read requests submitted asynchronously. -* CompactionFilter::Decision has a new value: kRemoveWithSingleDelete. If CompactionFilter returns this decision, then CompactionIterator will use `SingleDelete` to mark a key as removed. -* Renamed CompactionFilter::Decision::kRemoveWithSingleDelete to kPurge since the latter sounds more general and hides the implementation details of how compaction iterator handles keys. -* Added ability to specify functions for Prepare and Validate to OptionsTypeInfo. Added methods to OptionTypeInfo to set the functions via an API. These methods are intended for RocksDB plugin developers for configuration management. -* Added a new immutable db options, enforce_single_del_contracts. If set to false (default is true), compaction will NOT fail due to a single delete followed by a delete for the same key. The purpose of this temporay option is to help existing use cases migrate. -* Introduce `BlockBasedTableOptions::cache_usage_options` and use that to replace `BlockBasedTableOptions::reserve_table_builder_memory` and `BlockBasedTableOptions::reserve_table_reader_memory`. -* Changed `GetUniqueIdFromTableProperties` to return a 128-bit unique identifier, which will be the standard size now. The old functionality (192-bit) is available from `GetExtendedUniqueIdFromTableProperties`. Both functions are no longer "experimental" and are ready for production use. -* In IOOptions, mark `prio` as deprecated for future removal. -* In `file_system.h`, mark `IOPriority` as deprecated for future removal. -* Add an option, `CompressionOptions::use_zstd_dict_trainer`, to indicate whether zstd dictionary trainer should be used for generating zstd compression dictionaries. The default value of this option is true for backward compatibility. When this option is set to false, zstd API `ZDICT_finalizeDictionary` is used to generate compression dictionaries. -* Seek API which positions itself every LevelIterator on the correct data block in the correct SST file which can be parallelized if ReadOptions.async_io option is enabled. -* Add new stat number_async_seek in PerfContext that indicates number of async calls made by seek to prefetch data. -* Add support for user-defined timestamps to read only DB. - -### Bug Fixes -* RocksDB calls FileSystem::Poll API during FilePrefetchBuffer destruction which impacts performance as it waits for read requets completion which is not needed anymore. Calling FileSystem::AbortIO to abort those requests instead fixes that performance issue. -* Fixed unnecessary block cache contention when queries within a MultiGet batch and across parallel batches access the same data block, which previously could cause severely degraded performance in this unusual case. (In more typical MultiGet cases, this fix is expected to yield a small or negligible performance improvement.) - -### Behavior changes -* Enforce the existing contract of SingleDelete so that SingleDelete cannot be mixed with Delete because it leads to undefined behavior. Fix a number of unit tests that violate the contract but happen to pass. -* ldb `--try_load_options` default to true if `--db` is specified and not creating a new DB, the user can still explicitly disable that by `--try_load_options=false` (or explicitly enable that by `--try_load_options`). -* During Flush write or Compaction write/read, the WriteController is used to determine whether DB writes are stalled or slowed down. The priority (Env::IOPriority) can then be determined accordingly and be passed in IOOptions to the file system. - -### Performance Improvements -* Avoid calling malloc_usable_size() in LRU Cache's mutex. -* Reduce DB mutex holding time when finding obsolete files to delete. When a file is trivial moved to another level, the internal files will be referenced twice internally and sometimes opened twice too. If a deletion candidate file is not the last reference, we need to destroy the reference and close the file but not deleting the file. Right now we determine it by building a set of all live files. With the improvement, we check the file against all live LSM-tree versions instead. - -## 7.2.0 (04/15/2022) -### Bug Fixes -* Fixed bug which caused rocksdb failure in the situation when rocksdb was accessible using UNC path -* Fixed a race condition when 2PC is disabled and WAL tracking in the MANIFEST is enabled. The race condition is between two background flush threads trying to install flush results, causing a WAL deletion not tracked in the MANIFEST. A future DB open may fail. -* Fixed a heap use-after-free race with DropColumnFamily. -* Fixed a bug that `rocksdb.read.block.compaction.micros` cannot track compaction stats (#9722). -* Fixed `file_type`, `relative_filename` and `directory` fields returned by `GetLiveFilesMetaData()`, which were added in inheriting from `FileStorageInfo`. -* Fixed a bug affecting `track_and_verify_wals_in_manifest`. Without the fix, application may see "open error: Corruption: Missing WAL with log number" while trying to open the db. The corruption is a false alarm but prevents DB open (#9766). -* Fix segfault in FilePrefetchBuffer with async_io as it doesn't wait for pending jobs to complete on destruction. -* Fix ERROR_HANDLER_AUTORESUME_RETRY_COUNT stat whose value was set wrong in portal.h -* Fixed a bug for non-TransactionDB with avoid_flush_during_recovery = true and TransactionDB where in case of crash, min_log_number_to_keep may not change on recovery and persisting a new MANIFEST with advanced log_numbers for some column families, results in "column family inconsistency" error on second recovery. As a solution the corrupted WALs whose numbers are larger than the corrupted wal and smaller than the new WAL will be moved to archive folder. -* Fixed a bug in RocksDB DB::Open() which may creates and writes to two new MANIFEST files even before recovery succeeds. Now writes to MANIFEST are persisted only after recovery is successful. - -### New Features -* For db_bench when --seed=0 or --seed is not set then it uses the current time as the seed value. Previously it used the value 1000. -* For db_bench when --benchmark lists multiple tests and each test uses a seed for a RNG then the seeds across tests will no longer be repeated. -* Added an option to dynamically charge an updating estimated memory usage of block-based table reader to block cache if block cache available. To enable this feature, set `BlockBasedTableOptions::reserve_table_reader_memory = true`. -* Add new stat ASYNC_READ_BYTES that calculates number of bytes read during async read call and users can check if async code path is being called by RocksDB internal automatic prefetching for sequential reads. -* Enable async prefetching if ReadOptions.readahead_size is set along with ReadOptions.async_io in FilePrefetchBuffer. -* Add event listener support on remote compaction compactor side. -* Added a dedicated integer DB property `rocksdb.live-blob-file-garbage-size` that exposes the total amount of garbage in the blob files in the current version. -* RocksDB does internal auto prefetching if it notices sequential reads. It starts with readahead size `initial_auto_readahead_size` which now can be configured through BlockBasedTableOptions. -* Add a merge operator that allows users to register specific aggregation function so that they can does aggregation using different aggregation types for different keys. See comments in include/rocksdb/utilities/agg_merge.h for actual usage. The feature is experimental and the format is subject to change and we won't provide a migration tool. -* Meta-internal / Experimental: Improve CPU performance by replacing many uses of std::unordered_map with folly::F14FastMap when RocksDB is compiled together with Folly. -* Experimental: Add CompressedSecondaryCache, a concrete implementation of rocksdb::SecondaryCache, that integrates with compression libraries (e.g. LZ4) to hold compressed blocks. - -### Behavior changes -* Disallow usage of commit-time-write-batch for write-prepared/write-unprepared transactions if TransactionOptions::use_only_the_last_commit_time_batch_for_recovery is false to prevent two (or more) uncommitted versions of the same key in the database. Otherwise, bottommost compaction may violate the internal key uniqueness invariant of SSTs if the sequence numbers of both internal keys are zeroed out (#9794). -* Make DB::GetUpdatesSince() return NotSupported early for write-prepared/write-unprepared transactions, as the API contract indicates. - -### Public API changes -* Exposed APIs to examine results of block cache stats collections in a structured way. In particular, users of `GetMapProperty()` with property `kBlockCacheEntryStats` can now use the functions in `BlockCacheEntryStatsMapKeys` to find stats in the map. -* Add `fail_if_not_bottommost_level` to IngestExternalFileOptions so that ingestion will fail if the file(s) cannot be ingested to the bottommost level. -* Add output parameter `is_in_sec_cache` to `SecondaryCache::Lookup()`. It is to indicate whether the handle is possibly erased from the secondary cache after the Lookup. - -## 7.1.0 (03/23/2022) -### New Features -* Allow WriteBatchWithIndex to index a WriteBatch that includes keys with user-defined timestamps. The index itself does not have timestamp. -* Add support for user-defined timestamps to write-committed transaction without API change. The `TransactionDB` layer APIs do not allow timestamps because we require that all user-defined-timestamps-aware operations go through the `Transaction` APIs. -* Added BlobDB options to `ldb` -* `BlockBasedTableOptions::detect_filter_construct_corruption` can now be dynamically configured using `DB::SetOptions`. -* Automatically recover from retryable read IO errors during backgorund flush/compaction. -* Experimental support for preserving file Temperatures through backup and restore, and for updating DB metadata for outside changes to file Temperature (`UpdateManifestForFilesState` or `ldb update_manifest --update_temperatures`). -* Experimental support for async_io in ReadOptions which is used by FilePrefetchBuffer to prefetch some of the data asynchronously, if reads are sequential and auto readahead is enabled by rocksdb internally. - -### Bug Fixes -* Fixed a major performance bug in which Bloom filters generated by pre-7.0 releases are not read by early 7.0.x releases (and vice-versa) due to changes to FilterPolicy::Name() in #9590. This can severely impact read performance and read I/O on upgrade or downgrade with existing DB, but not data correctness. -* Fixed a data race on `versions_` between `DBImpl::ResumeImpl()` and threads waiting for recovery to complete (#9496) -* Fixed a bug caused by race among flush, incoming writes and taking snapshots. Queries to snapshots created with these race condition can return incorrect result, e.g. resurfacing deleted data. -* Fixed a bug that DB flush uses `options.compression` even `options.compression_per_level` is set. -* Fixed a bug that DisableManualCompaction may assert when disable an unscheduled manual compaction. -* Fix a race condition when cancel manual compaction with `DisableManualCompaction`. Also DB close can cancel the manual compaction thread. -* Fixed a potential timer crash when open close DB concurrently. -* Fixed a race condition for `alive_log_files_` in non-two-write-queues mode. The race is between the write_thread_ in WriteToWAL() and another thread executing `FindObsoleteFiles()`. The race condition will be caught if `__glibcxx_requires_nonempty` is enabled. -* Fixed a bug that `Iterator::Refresh()` reads stale keys after DeleteRange() performed. -* Fixed a race condition when disable and re-enable manual compaction. -* Fixed automatic error recovery failure in atomic flush. -* Fixed a race condition when mmaping a WritableFile on POSIX. - -### Public API changes -* Added pure virtual FilterPolicy::CompatibilityName(), which is needed for fixing major performance bug involving FilterPolicy naming in SST metadata without affecting Customizable aspect of FilterPolicy. This change only affects those with their own custom or wrapper FilterPolicy classes. -* `options.compression_per_level` is dynamically changeable with `SetOptions()`. -* Added `WriteOptions::rate_limiter_priority`. When set to something other than `Env::IO_TOTAL`, the internal rate limiter (`DBOptions::rate_limiter`) will be charged at the specified priority for writes associated with the API to which the `WriteOptions` was provided. Currently the support covers automatic WAL flushes, which happen during live updates (`Put()`, `Write()`, `Delete()`, etc.) when `WriteOptions::disableWAL == false` and `DBOptions::manual_wal_flush == false`. -* Add DB::OpenAndTrimHistory API. This API will open DB and trim data to the timestamp specified by trim_ts (The data with timestamp larger than specified trim bound will be removed). This API should only be used at a timestamp-enabled column families recovery. If the column family doesn't have timestamp enabled, this API won't trim any data on that column family. This API is not compatible with avoid_flush_during_recovery option. -* Remove BlockBasedTableOptions.hash_index_allow_collision which already takes no effect. - -## 7.0.0 (02/20/2022) -### Bug Fixes -* Fixed a major bug in which batched MultiGet could return old values for keys deleted by DeleteRange when memtable Bloom filter is enabled (memtable_prefix_bloom_size_ratio > 0). (The fix includes a substantial MultiGet performance improvement in the unusual case of both memtable_whole_key_filtering and prefix_extractor.) -* Fixed more cases of EventListener::OnTableFileCreated called with OK status, file_size==0, and no SST file kept. Now the status is Aborted. -* Fixed a read-after-free bug in `DB::GetMergeOperands()`. -* Fix a data loss bug for 2PC write-committed transaction caused by concurrent transaction commit and memtable switch (#9571). -* Fixed NUM_INDEX_AND_FILTER_BLOCKS_READ_PER_LEVEL, NUM_DATA_BLOCKS_READ_PER_LEVEL, and NUM_SST_READ_PER_LEVEL stats to be reported once per MultiGet batch per level. - -### Performance Improvements -* Mitigated the overhead of building the file location hash table used by the online LSM tree consistency checks, which can improve performance for certain workloads (see #9351). -* Switched to using a sorted `std::vector` instead of `std::map` for storing the metadata objects for blob files, which can improve performance for certain workloads, especially when the number of blob files is high. -* DisableManualCompaction() doesn't have to wait scheduled manual compaction to be executed in thread-pool to cancel the job. - -### Public API changes -* Require C++17 compatible compiler (GCC >= 7, Clang >= 5, Visual Studio >= 2017) for compiling RocksDB and any code using RocksDB headers. See #9388. -* Added `ReadOptions::rate_limiter_priority`. When set to something other than `Env::IO_TOTAL`, the internal rate limiter (`DBOptions::rate_limiter`) will be charged at the specified priority for file reads associated with the API to which the `ReadOptions` was provided. -* Remove HDFS support from main repo. -* Remove librados support from main repo. -* Remove obsolete backupable_db.h and type alias `BackupableDBOptions`. Use backup_engine.h and `BackupEngineOptions`. Similar renamings are in the C and Java APIs. -* Removed obsolete utility_db.h and `UtilityDB::OpenTtlDB`. Use db_ttl.h and `DBWithTTL::Open`. -* Remove deprecated API DB::AddFile from main repo. -* Remove deprecated API ObjectLibrary::Register() and the (now obsolete) Regex public API. Use ObjectLibrary::AddFactory() with PatternEntry instead. -* Remove deprecated option DBOption::table_cache_remove_scan_count_limit. -* Remove deprecated API AdvancedColumnFamilyOptions::soft_rate_limit. -* Remove deprecated API AdvancedColumnFamilyOptions::hard_rate_limit. -* Remove deprecated API DBOption::base_background_compactions. -* Remove deprecated API DBOptions::purge_redundant_kvs_while_flush. -* Remove deprecated overloads of API DB::CompactRange. -* Remove deprecated option DBOptions::skip_log_error_on_recovery. -* Remove ReadOptions::iter_start_seqnum which has been deprecated. -* Remove DBOptions::preserved_deletes and DB::SetPreserveDeletesSequenceNumber(). -* Remove deprecated API AdvancedColumnFamilyOptions::rate_limit_delay_max_milliseconds. -* Removed timestamp from WriteOptions. Accordingly, added to DB APIs Put, Delete, SingleDelete, etc. accepting an additional argument 'timestamp'. Added Put, Delete, SingleDelete, etc to WriteBatch accepting an additional argument 'timestamp'. Removed WriteBatch::AssignTimestamps(vector) API. Renamed WriteBatch::AssignTimestamp() to WriteBatch::UpdateTimestamps() with clarified comments. -* Changed type of cache buffer passed to `Cache::CreateCallback` from `void*` to `const void*`. -* Significant updates to FilterPolicy-related APIs and configuration: - * Remove public API support for deprecated, inefficient block-based filter (use_block_based_builder=true). - * Old code and configuration strings that would enable it now quietly enable full filters instead, though any built-in FilterPolicy can still read block-based filters. This includes changing the longstanding default behavior of the Java API. - * Remove deprecated FilterPolicy::CreateFilter() and FilterPolicy::KeyMayMatch() - * Remove `rocksdb_filterpolicy_create()` from C API, as the only C API support for custom filter policies is now obsolete. - * If temporary memory usage in full filter creation is a problem, consider using partitioned filters, smaller SST files, or setting reserve_table_builder_memory=true. - * Remove support for "filter_policy=experimental_ribbon" configuration - string. Use something like "filter_policy=ribbonfilter:10" instead. - * Allow configuration string like "filter_policy=bloomfilter:10" without - bool, to minimize acknowledgement of obsolete block-based filter. - * Made FilterPolicy Customizable. Configuration of filter_policy is now accurately saved in OPTIONS file and can be loaded with LoadOptionsFromFile. (Loading an OPTIONS file generated by a previous version only enables reading and using existing filters, not generating new filters. Previously, no filter_policy would be configured from a saved OPTIONS file.) - * Change meaning of nullptr return from GetBuilderWithContext() from "use - block-based filter" to "generate no filter in this case." - * Also, when user specifies bits_per_key < 0.5, we now round this down - to "no filter" because we expect a filter with >= 80% FP rate is - unlikely to be worth the CPU cost of accessing it (esp with - cache_index_and_filter_blocks=1 or partition_filters=1). - * bits_per_key >= 0.5 and < 1.0 is still rounded up to 1.0 (for 62% FP - rate) - * Remove class definitions for FilterBitsBuilder and FilterBitsReader from - public API, so these can evolve more easily as implementation details. - Custom FilterPolicy can still decide what kind of built-in filter to use - under what conditions. - * Also removed deprecated functions - * FilterPolicy::GetFilterBitsBuilder() - * NewExperimentalRibbonFilterPolicy() - * Remove default implementations of - * FilterPolicy::GetBuilderWithContext() -* Remove default implementation of Name() from FileSystemWrapper. -* Rename `SizeApproximationOptions.include_memtabtles` to `SizeApproximationOptions.include_memtables`. -* Remove deprecated option DBOptions::max_mem_compaction_level. -* Return Status::InvalidArgument from ObjectRegistry::NewObject if a factory exists but the object ould not be created (returns NotFound if the factory is missing). -* Remove deprecated overloads of API DB::GetApproximateSizes. -* Remove deprecated option DBOptions::new_table_reader_for_compaction_inputs. -* Add Transaction::SetReadTimestampForValidation() and Transaction::SetCommitTimestamp(). Default impl returns NotSupported(). -* Add support for decimal patterns to ObjectLibrary::PatternEntry -* Remove deprecated remote compaction APIs `CompactionService::Start()` and `CompactionService::WaitForComplete()`. Please use `CompactionService::StartV2()`, `CompactionService::WaitForCompleteV2()` instead, which provides the same information plus extra data like priority, db_id, etc. -* `ColumnFamilyOptions::OldDefaults` and `DBOptions::OldDefaults` are marked deprecated, as they are no longer maintained. -* Add subcompaction callback APIs: `OnSubcompactionBegin()` and `OnSubcompactionCompleted()`. -* Add file Temperature information to `FileOperationInfo` in event listener API. -* Change the type of SizeApproximationFlags from enum to enum class. Also update the signature of DB::GetApproximateSizes API from uint8_t to SizeApproximationFlags. -* Add Temperature hints information from RocksDB in API `NewSequentialFile()`. backup and checkpoint operations need to open the source files with `NewSequentialFile()`, which will have the temperature hints. Other operations are not covered. - -### Behavior Changes -* Disallow the combination of DBOptions.use_direct_io_for_flush_and_compaction == true and DBOptions.writable_file_max_buffer_size == 0. This combination can cause WritableFileWriter::Append() to loop forever, and it does not make much sense in direct IO. -* `ReadOptions::total_order_seek` no longer affects `DB::Get()`. The original motivation for this interaction has been obsolete since RocksDB has been able to detect whether the current prefix extractor is compatible with that used to generate table files, probably RocksDB 5.14.0. - -## New Features -* Introduced an option `BlockBasedTableOptions::detect_filter_construct_corruption` for detecting corruption during Bloom Filter (format_version >= 5) and Ribbon Filter construction. -* Improved the SstDumpTool to read the comparator from table properties and use it to read the SST File. -* Extended the column family statistics in the info log so the total amount of garbage in the blob files and the blob file space amplification factor are also logged. Also exposed the blob file space amp via the `rocksdb.blob-stats` DB property. -* Introduced the API rocksdb_create_dir_if_missing in c.h that calls underlying file system's CreateDirIfMissing API to create the directory. -* Added last level and non-last level read statistics: `LAST_LEVEL_READ_*`, `NON_LAST_LEVEL_READ_*`. -* Experimental: Add support for new APIs ReadAsync in FSRandomAccessFile that reads the data asynchronously and Poll API in FileSystem that checks if requested read request has completed or not. ReadAsync takes a callback function. Poll API checks for completion of read IO requests and should call callback functions to indicate completion of read requests. - -## 6.29.0 (01/21/2022) -Note: The next release will be major release 7.0. See https://github.com/facebook/rocksdb/issues/9390 for more info. -### Public API change -* Added values to `TraceFilterType`: `kTraceFilterIteratorSeek`, `kTraceFilterIteratorSeekForPrev`, and `kTraceFilterMultiGet`. They can be set in `TraceOptions` to filter out the operation types after which they are named. -* Added `TraceOptions::preserve_write_order`. When enabled it guarantees write records are traced in the same order they are logged to WAL and applied to the DB. By default it is disabled (false) to match the legacy behavior and prevent regression. -* Made the Env class extend the Customizable class. Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method. -* `Options::OldDefaults` is marked deprecated, as it is no longer maintained. -* Add ObjectLibrary::AddFactory and ObjectLibrary::PatternEntry classes. This method and associated class are the preferred mechanism for registering factories with the ObjectLibrary going forward. The ObjectLibrary::Register method, which uses regular expressions and may be problematic, is deprecated and will be in a future release. -* Changed `BlockBasedTableOptions::block_size` from `size_t` to `uint64_t`. -* Added API warning against using `Iterator::Refresh()` together with `DB::DeleteRange()`, which are incompatible and have always risked causing the refreshed iterator to return incorrect results. -* Made `AdvancedColumnFamilyOptions.bottommost_temperature` dynamically changeable with `SetOptions()`. - -### Behavior Changes -* `DB::DestroyColumnFamilyHandle()` will return Status::InvalidArgument() if called with `DB::DefaultColumnFamily()`. -* On 32-bit platforms, mmap reads are no longer quietly disabled, just discouraged. - -### New Features -* Added `Options::DisableExtraChecks()` that can be used to improve peak write performance by disabling checks that should not be necessary in the absence of software logic errors or CPU+memory hardware errors. (Default options are slowly moving toward some performance overheads for extra correctness checking.) - -### Performance Improvements -* Improved read performance when a prefix extractor is used (Seek, Get, MultiGet), even compared to version 6.25 baseline (see bug fix below), by optimizing the common case of prefix extractor compatible with table file and unchanging. - -### Bug Fixes -* Fix a bug that FlushMemTable may return ok even flush not succeed. -* Fixed a bug of Sync() and Fsync() not using `fcntl(F_FULLFSYNC)` on OS X and iOS. -* Fixed a significant performance regression in version 6.26 when a prefix extractor is used on the read path (Seek, Get, MultiGet). (Excessive time was spent in SliceTransform::AsString().) -* Fixed a race condition in SstFileManagerImpl error recovery code that can cause a crash during process shutdown. - -### New Features -* Added RocksJava support for MacOS universal binary (ARM+x86) - -## 6.28.0 (2021-12-17) -### New Features -* Introduced 'CommitWithTimestamp' as a new tag. Currently, there is no API for user to trigger a write with this tag to the WAL. This is part of the efforts to support write-commited transactions with user-defined timestamps. -* Introduce SimulatedHybridFileSystem which can help simulating HDD latency in db_bench. Tiered Storage latency simulation can be enabled using -simulate_hybrid_fs_file (note that it doesn't work if db_bench is interrupted in the middle). -simulate_hdd can also be used to simulate all files on HDD. - -### Bug Fixes -* Fixed a bug in rocksdb automatic implicit prefetching which got broken because of new feature adaptive_readahead and internal prefetching got disabled when iterator moves from one file to next. -* Fixed a bug in TableOptions.prepopulate_block_cache which causes segmentation fault when used with TableOptions.partition_filters = true and TableOptions.cache_index_and_filter_blocks = true. -* Fixed a bug affecting custom memtable factories which are not registered with the `ObjectRegistry`. The bug could result in failure to save the OPTIONS file. -* Fixed a bug causing two duplicate entries to be appended to a file opened in non-direct mode and tracked by `FaultInjectionTestFS`. -* Fixed a bug in TableOptions.prepopulate_block_cache to support block-based filters also. -* Block cache keys no longer use `FSRandomAccessFile::GetUniqueId()` (previously used when available), so a filesystem recycling unique ids can no longer lead to incorrect result or crash (#7405). For files generated by RocksDB >= 6.24, the cache keys are stable across DB::Open and DB directory move / copy / import / export / migration, etc. Although collisions are still theoretically possible, they are (a) impossible in many common cases, (b) not dependent on environmental factors, and (c) much less likely than a CPU miscalculation while executing RocksDB. -* Fixed a bug in C bindings causing iterator to return incorrect result (#9343). - -### Behavior Changes -* MemTableList::TrimHistory now use allocated bytes when max_write_buffer_size_to_maintain > 0(default in TrasactionDB, introduced in PR#5022) Fix #8371. - -### Public API change -* Extend WriteBatch::AssignTimestamp and AssignTimestamps API so that both functions can accept an optional `checker` argument that performs additional checking on timestamp sizes. -* Introduce a new EventListener callback that will be called upon the end of automatic error recovery. -* Add IncreaseFullHistoryTsLow API so users can advance each column family's full_history_ts_low seperately. -* Add GetFullHistoryTsLow API so users can query current full_history_low value of specified column family. - -### Performance Improvements -* Replaced map property `TableProperties::properties_offsets` with uint64_t property `external_sst_file_global_seqno_offset` to save table properties's memory. -* Block cache accesses are faster by RocksDB using cache keys of fixed size (16 bytes). - -### Java API Changes -* Removed Java API `TableProperties.getPropertiesOffsets()` as it exposed internal details to external users. - -## 6.27.0 (2021-11-19) -### New Features -* Added new ChecksumType kXXH3 which is faster than kCRC32c on almost all x86\_64 hardware. -* Added a new online consistency check for BlobDB which validates that the number/total size of garbage blobs does not exceed the number/total size of all blobs in any given blob file. -* Provided support for tracking per-sst user-defined timestamp information in MANIFEST. -* Added new option "adaptive_readahead" in ReadOptions. For iterators, RocksDB does auto-readahead on noticing sequential reads and by enabling this option, readahead_size of current file (if reads are sequential) will be carried forward to next file instead of starting from the scratch at each level (except L0 level files). If reads are not sequential it will fall back to 8KB. This option is applicable only for RocksDB internal prefetch buffer and isn't supported with underlying file system prefetching. -* Added the read count and read bytes related stats to Statistics for tiered storage hot, warm, and cold file reads. -* Added an option to dynamically charge an updating estimated memory usage of block-based table building to block cache if block cache available. It currently only includes charging memory usage of constructing (new) Bloom Filter and Ribbon Filter to block cache. To enable this feature, set `BlockBasedTableOptions::reserve_table_builder_memory = true`. -* Add a new API OnIOError in listener.h that notifies listeners when an IO error occurs during FileSystem operation along with filename, status etc. -* Added compaction readahead support for blob files to the integrated BlobDB implementation, which can improve compaction performance when the database resides on higher-latency storage like HDDs or remote filesystems. Readahead can be configured using the column family option `blob_compaction_readahead_size`. - -### Bug Fixes -* Prevent a `CompactRange()` with `CompactRangeOptions::change_level == true` from possibly causing corruption to the LSM state (overlapping files within a level) when run in parallel with another manual compaction. Note that setting `force_consistency_checks == true` (the default) would cause the DB to enter read-only mode in this scenario and return `Status::Corruption`, rather than committing any corruption. -* Fixed a bug in CompactionIterator when write-prepared transaction is used. A released earliest write conflict snapshot may cause assertion failure in dbg mode and unexpected key in opt mode. -* Fix ticker WRITE_WITH_WAL("rocksdb.write.wal"), this bug is caused by a bad extra `RecordTick(stats_, WRITE_WITH_WAL)` (at 2 place), this fix remove the extra `RecordTick`s and fix the corresponding test case. -* EventListener::OnTableFileCreated was previously called with OK status and file_size==0 in cases of no SST file contents written (because there was no content to add) and the empty file deleted before calling the listener. Now the status is Aborted. -* Fixed a bug in CompactionIterator when write-preared transaction is used. Releasing earliest_snapshot during compaction may cause a SingleDelete to be output after a PUT of the same user key whose seq has been zeroed. -* Added input sanitization on negative bytes passed into `GenericRateLimiter::Request`. -* Fixed an assertion failure in CompactionIterator when write-prepared transaction is used. We prove that certain operations can lead to a Delete being followed by a SingleDelete (same user key). We can drop the SingleDelete. -* Fixed a bug of timestamp-based GC which can cause all versions of a key under full_history_ts_low to be dropped. This bug will be triggered when some of the ikeys' timestamps are lower than full_history_ts_low, while others are newer. -* In some cases outside of the DB read and compaction paths, SST block checksums are now checked where they were not before. -* Explicitly check for and disallow the `BlockBasedTableOptions` if insertion into one of {`block_cache`, `block_cache_compressed`, `persistent_cache`} can show up in another of these. (RocksDB expects to be able to use the same key for different physical data among tiers.) -* Users who configured a dedicated thread pool for bottommost compactions by explicitly adding threads to the `Env::Priority::BOTTOM` pool will no longer see RocksDB schedule automatic compactions exceeding the DB's compaction concurrency limit. For details on per-DB compaction concurrency limit, see API docs of `max_background_compactions` and `max_background_jobs`. -* Fixed a bug of background flush thread picking more memtables to flush and prematurely advancing column family's log_number. -* Fixed an assertion failure in ManifestTailer. -* Fixed a bug that could, with WAL enabled, cause backups, checkpoints, and `GetSortedWalFiles()` to fail randomly with an error like `IO error: 001234.log: No such file or directory` - -### Behavior Changes -* `NUM_FILES_IN_SINGLE_COMPACTION` was only counting the first input level files, now it's including all input files. -* `TransactionUtil::CheckKeyForConflicts` can also perform conflict-checking based on user-defined timestamps in addition to sequence numbers. -* Removed `GenericRateLimiter`'s minimum refill bytes per period previously enforced. - -### Public API change -* When options.ttl is used with leveled compaction with compactinon priority kMinOverlappingRatio, files exceeding half of TTL value will be prioritized more, so that by the time TTL is reached, fewer extra compactions will be scheduled to clear them up. At the same time, when compacting files with data older than half of TTL, output files may be cut off based on those files' boundaries, in order for the early TTL compaction to work properly. -* Made FileSystem and RateLimiter extend the Customizable class and added a CreateFromString method. Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method. -* Clarified in API comments that RocksDB is not exception safe for callbacks and custom extensions. An exception propagating into RocksDB can lead to undefined behavior, including data loss, unreported corruption, deadlocks, and more. -* Marked `WriteBufferManager` as `final` because it is not intended for extension. -* Removed unimportant implementation details from table_properties.h -* Add API `FSDirectory::FsyncWithDirOptions()`, which provides extra information like directory fsync reason in `DirFsyncOptions`. File system like btrfs is using that to skip directory fsync for creating a new file, or when renaming a file, fsync the target file instead of the directory, which improves the `DB::Open()` speed by ~20%. -* `DB::Open()` is not going be blocked by obsolete file purge if `DBOptions::avoid_unnecessary_blocking_io` is set to true. -* In builds where glibc provides `gettid()`, info log ("LOG" file) lines now print a system-wide thread ID from `gettid()` instead of the process-local `pthread_self()`. For all users, the thread ID format is changed from hexadecimal to decimal integer. -* In builds where glibc provides `pthread_setname_np()`, the background thread names no longer contain an ID suffix. For example, "rocksdb:bottom7" (and all other threads in the `Env::Priority::BOTTOM` pool) are now named "rocksdb:bottom". Previously large thread pools could breach the name size limit (e.g., naming "rocksdb:bottom10" would fail). -* Deprecating `ReadOptions::iter_start_seqnum` and `DBOptions::preserve_deletes`, please try using user defined timestamp feature instead. The options will be removed in a future release, currently it logs a warning message when using. - -### Performance Improvements -* Released some memory related to filter construction earlier in `BlockBasedTableBuilder` for `FullFilter` and `PartitionedFilter` case (#9070) - -### Behavior Changes -* `NUM_FILES_IN_SINGLE_COMPACTION` was only counting the first input level files, now it's including all input files. - -## 6.26.0 (2021-10-20) -### Bug Fixes -* Fixes a bug in directed IO mode when calling MultiGet() for blobs in the same blob file. The bug is caused by not sorting the blob read requests by file offsets. -* Fix the incorrect disabling of SST rate limited deletion when the WAL and DB are in different directories. Only WAL rate limited deletion should be disabled if its in a different directory. -* Fix `DisableManualCompaction()` to cancel compactions even when they are waiting on automatic compactions to drain due to `CompactRangeOptions::exclusive_manual_compactions == true`. -* Fix contract of `Env::ReopenWritableFile()` and `FileSystem::ReopenWritableFile()` to specify any existing file must not be deleted or truncated. -* Fixed bug in calls to `IngestExternalFiles()` with files for multiple column families. The bug could have introduced a delay in ingested file keys becoming visible after `IngestExternalFiles()` returned. Furthermore, mutations to ingested file keys while they were invisible could have been dropped (not necessarily immediately). -* Fixed a possible race condition impacting users of `WriteBufferManager` who constructed it with `allow_stall == true`. The race condition led to undefined behavior (in our experience, typically a process crash). -* Fixed a bug where stalled writes would remain stalled forever after the user calls `WriteBufferManager::SetBufferSize()` with `new_size == 0` to dynamically disable memory limiting. -* Make `DB::close()` thread-safe. -* Fix a bug in atomic flush where one bg flush thread will wait forever for a preceding bg flush thread to commit its result to MANIFEST but encounters an error which is mapped to a soft error (DB not stopped). -* Fix a bug in `BackupEngine` where some internal callers of `GenericRateLimiter::Request()` do not honor `bytes <= GetSingleBurstBytes()`. - -### New Features -* Print information about blob files when using "ldb list_live_files_metadata" -* Provided support for SingleDelete with user defined timestamp. -* Experimental new function DB::GetLiveFilesStorageInfo offers essentially a unified version of other functions like GetLiveFiles, GetLiveFilesChecksumInfo, and GetSortedWalFiles. Checkpoints and backups could show small behavioral changes and/or improved performance as they now use this new API. -* Add remote compaction read/write bytes statistics: `REMOTE_COMPACT_READ_BYTES`, `REMOTE_COMPACT_WRITE_BYTES`. -* Introduce an experimental feature to dump out the blocks from block cache and insert them to the secondary cache to reduce the cache warmup time (e.g., used while migrating DB instance). More information are in `class CacheDumper` and `CacheDumpedLoader` at `rocksdb/utilities/cache_dump_load.h` Note that, this feature is subject to the potential change in the future, it is still experimental. -* Introduced a new BlobDB configuration option `blob_garbage_collection_force_threshold`, which can be used to trigger compactions targeting the SST files which reference the oldest blob files when the ratio of garbage in those blob files meets or exceeds the specified threshold. This can reduce space amplification with skewed workloads where the affected SST files might not otherwise get picked up for compaction. -* Added EXPERIMENTAL support for table file (SST) unique identifiers that are stable and universally unique, available with new function `GetUniqueIdFromTableProperties`. Only SST files from RocksDB >= 6.24 support unique IDs. -* Added `GetMapProperty()` support for "rocksdb.dbstats" (`DB::Properties::kDBStats`). As a map property, it includes DB-level internal stats accumulated over the DB's lifetime, such as user write related stats and uptime. - -### Public API change -* Made SystemClock extend the Customizable class and added a CreateFromString method. Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method. -* Made SliceTransform extend the Customizable class and added a CreateFromString method. Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method. The Capped and Prefixed transform classes return a short name (no length); use GetId for the fully qualified name. -* Made FileChecksumGenFactory, SstPartitionerFactory, TablePropertiesCollectorFactory, and WalFilter extend the Customizable class and added a CreateFromString method. -* Some fields of SstFileMetaData are deprecated for compatibility with new base class FileStorageInfo. -* Add `file_temperature` to `IngestExternalFileArg` such that when ingesting SST files, we are able to indicate the temperature of the this batch of files. -* If `DB::Close()` failed with a non aborted status, calling `DB::Close()` again will return the original status instead of Status::OK. -* Add CacheTier to advanced_options.h to describe the cache tier we used. Add a `lowest_used_cache_tier` option to `DBOptions` (immutable) and pass it to BlockBasedTableReader. By default it is `CacheTier::kNonVolatileBlockTier`, which means, we always use both block cache (kVolatileTier) and secondary cache (kNonVolatileBlockTier). By set it to `CacheTier::kVolatileTier`, the DB will not use the secondary cache. -* Even when options.max_compaction_bytes is hit, compaction output files are only cut when it aligns with grandparent files' boundaries. options.max_compaction_bytes could be slightly violated with the change, but the violation is no more than one target SST file size, which is usually much smaller. - -### Performance Improvements -* Improved CPU efficiency of building block-based table (SST) files (#9039 and #9040). - -### Java API Changes -* Add Java API bindings for new integrated BlobDB options -* `keyMayExist()` supports ByteBuffer. -* Fix multiget throwing Null Pointer Exception for num of keys > 70k (https://github.com/facebook/rocksdb/issues/8039). - -## 6.25.0 (2021-09-20) -### Bug Fixes -* Allow secondary instance to refresh iterator. Assign read seq after referencing SuperVersion. -* Fixed a bug of secondary instance's last_sequence going backward, and reads on the secondary fail to see recent updates from the primary. -* Fixed a bug that could lead to duplicate DB ID or DB session ID in POSIX environments without /proc/sys/kernel/random/uuid. -* Fix a race in DumpStats() with column family destruction due to not taking a Ref on each entry while iterating the ColumnFamilySet. -* Fix a race in item ref counting in LRUCache when promoting an item from the SecondaryCache. -* Fix a race in BackupEngine if RateLimiter is reconfigured during concurrent Restore operations. -* Fix a bug on POSIX in which failure to create a lock file (e.g. out of space) can prevent future LockFile attempts in the same process on the same file from succeeding. -* Fix a bug that backup_rate_limiter and restore_rate_limiter in BackupEngine could not limit read rates. -* Fix the implementation of `prepopulate_block_cache = kFlushOnly` to only apply to flushes rather than to all generated files. -* Fix WAL log data corruption when using DBOptions.manual_wal_flush(true) and WriteOptions.sync(true) together. The sync WAL should work with locked log_write_mutex_. -* Add checks for validity of the IO uring completion queue entries, and fail the BlockBasedTableReader MultiGet sub-batch if there's an invalid completion -* Add an interface RocksDbIOUringEnable() that, if defined by the user, will allow them to enable/disable the use of IO uring by RocksDB -* Fix the bug that when direct I/O is used and MultiRead() returns a short result, RandomAccessFileReader::MultiRead() still returns full size buffer, with returned short value together with some data in original buffer. This bug is unlikely cause incorrect results, because (1) since FileSystem layer is expected to retry on short result, returning short results is only possible when asking more bytes in the end of the file, which RocksDB doesn't do when using MultiRead(); (2) checksum is unlikely to match. - -### New Features -* RemoteCompaction's interface now includes `db_name`, `db_id`, `session_id`, which could help the user uniquely identify compaction job between db instances and sessions. -* Added a ticker statistic, "rocksdb.verify_checksum.read.bytes", reporting how many bytes were read from file to serve `VerifyChecksum()` and `VerifyFileChecksums()` queries. -* Added ticker statistics, "rocksdb.backup.read.bytes" and "rocksdb.backup.write.bytes", reporting how many bytes were read and written during backup. -* Added properties for BlobDB: `rocksdb.num-blob-files`, `rocksdb.blob-stats`, `rocksdb.total-blob-file-size`, and `rocksdb.live-blob-file-size`. The existing property `rocksdb.estimate_live-data-size` was also extended to include live bytes residing in blob files. -* Added two new RateLimiter IOPriorities: `Env::IO_USER`,`Env::IO_MID`. `Env::IO_USER` will have superior priority over all other RateLimiter IOPriorities without being subject to fair scheduling constraint. -* `SstFileWriter` now supports `Put`s and `Delete`s with user-defined timestamps. Note that the ingestion logic itself is not timestamp-aware yet. -* Allow a single write batch to include keys from multiple column families whose timestamps' formats can differ. For example, some column families may disable timestamp, while others enable timestamp. -* Add compaction priority information in RemoteCompaction, which can be used to schedule high priority job first. -* Added new callback APIs `OnBlobFileCreationStarted`,`OnBlobFileCreated`and `OnBlobFileDeleted` in `EventListener` class of listener.h. It notifies listeners during creation/deletion of individual blob files in Integrated BlobDB. It also log blob file creation finished event and deletion event in LOG file. -* Batch blob read requests for `DB::MultiGet` using `MultiRead`. -* Add support for fallback to local compaction, the user can return `CompactionServiceJobStatus::kUseLocal` to instruct RocksDB to run the compaction locally instead of waiting for the remote compaction result. -* Add built-in rate limiter's implementation of `RateLimiter::GetTotalPendingRequest(int64_t* total_pending_requests, const Env::IOPriority pri)` for the total number of requests that are pending for bytes in the rate limiter. -* Charge memory usage during data buffering, from which training samples are gathered for dictionary compression, to block cache. Unbuffering data can now be triggered if the block cache becomes full and `strict_capacity_limit=true` for the block cache, in addition to existing conditions that can trigger unbuffering. - -### Public API change -* Remove obsolete implementation details FullKey and ParseFullKey from public API -* Change `SstFileMetaData::size` from `size_t` to `uint64_t`. -* Made Statistics extend the Customizable class and added a CreateFromString method. Implementations of Statistics need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method. -* Extended `FlushJobInfo` and `CompactionJobInfo` in listener.h to provide information about the blob files generated by a flush/compaction and garbage collected during compaction in Integrated BlobDB. Added struct members `blob_file_addition_infos` and `blob_file_garbage_infos` that contain this information. -* Extended parameter `output_file_names` of `CompactFiles` API to also include paths of the blob files generated by the compaction in Integrated BlobDB. -* Most `BackupEngine` functions now return `IOStatus` instead of `Status`. Most existing code should be compatible with this change but some calls might need to be updated. -* Add a new field `level_at_creation` in `TablePropertiesCollectorFactory::Context` to capture the level at creating the SST file (i.e, table), of which the properties are being collected. - -### Miscellaneous -* Add a paranoid check where in case FileSystem layer doesn't fill the buffer but returns succeed, checksum is unlikely to match even if buffer contains a previous block. The byte modified is not useful anyway, so it isn't expected to change any behavior when FileSystem is satisfying its contract. - -## 6.24.0 (2021-08-20) -### Bug Fixes -* If the primary's CURRENT file is missing or inaccessible, the secondary instance should not hang repeatedly trying to switch to a new MANIFEST. It should instead return the error code encountered while accessing the file. -* Restoring backups with BackupEngine is now a logically atomic operation, so that if a restore operation is interrupted, DB::Open on it will fail. Using BackupEngineOptions::sync (default) ensures atomicity even in case of power loss or OS crash. -* Fixed a race related to the destruction of `ColumnFamilyData` objects. The earlier logic unlocked the DB mutex before destroying the thread-local `SuperVersion` pointers, which could result in a process crash if another thread managed to get a reference to the `ColumnFamilyData` object. -* Removed a call to `RenameFile()` on a non-existent info log file ("LOG") when opening a new DB. Such a call was guaranteed to fail though did not impact applications since we swallowed the error. Now we also stopped swallowing errors in renaming "LOG" file. -* Fixed an issue where `OnFlushCompleted` was not called for atomic flush. -* Fixed a bug affecting the batched `MultiGet` API when used with keys spanning multiple column families and `sorted_input == false`. -* Fixed a potential incorrect result in opt mode and assertion failures caused by releasing snapshot(s) during compaction. -* Fixed passing of BlobFileCompletionCallback to Compaction job and Atomic flush job which was default paramter (nullptr). BlobFileCompletitionCallback is internal callback that manages addition of blob files to SSTFileManager. -* Fixed MultiGet not updating the block_read_count and block_read_byte PerfContext counters. - -### New Features -* Made the EventListener extend the Customizable class. -* EventListeners that have a non-empty Name() and that are registered with the ObjectRegistry can now be serialized to/from the OPTIONS file. -* Insert warm blocks (data blocks, uncompressed dict blocks, index and filter blocks) in Block cache during flush under option BlockBasedTableOptions.prepopulate_block_cache. Previously it was enabled for only data blocks. -* BlockBasedTableOptions.prepopulate_block_cache can be dynamically configured using DB::SetOptions. -* Add CompactionOptionsFIFO.age_for_warm, which allows RocksDB to move old files to warm tier in FIFO compactions. Note that file temperature is still an experimental feature. -* Add a comment to suggest btrfs user to disable file preallocation by setting `options.allow_fallocate=false`. -* Fast forward option in Trace replay changed to double type to allow replaying at a lower speed, by settings the value between 0 and 1. This option can be set via `ReplayOptions` in `Replayer::Replay()`, or via `--trace_replay_fast_forward` in db_bench. -* Add property `LiveSstFilesSizeAtTemperature` to retrieve sst file size at different temperature. -* Added a stat rocksdb.secondary.cache.hits. -* Added a PerfContext counter secondary_cache_hit_count. -* The integrated BlobDB implementation now supports the tickers `BLOB_DB_BLOB_FILE_BYTES_READ`, `BLOB_DB_GC_NUM_KEYS_RELOCATED`, and `BLOB_DB_GC_BYTES_RELOCATED`, as well as the histograms `BLOB_DB_COMPRESSION_MICROS` and `BLOB_DB_DECOMPRESSION_MICROS`. -* Added hybrid configuration of Ribbon filter and Bloom filter where some LSM levels use Ribbon for memory space efficiency and some use Bloom for speed. See NewRibbonFilterPolicy. This also changes the default behavior of NewRibbonFilterPolicy to use Bloom for flushes under Leveled and Universal compaction and Ribbon otherwise. The C API function `rocksdb_filterpolicy_create_ribbon` is unchanged but adds new `rocksdb_filterpolicy_create_ribbon_hybrid`. - -### Public API change -* Added APIs to decode and replay trace file via Replayer class. Added `DB::NewDefaultReplayer()` to create a default Replayer instance. Added `TraceReader::Reset()` to restart reading a trace file. Created trace_record.h, trace_record_result.h and utilities/replayer.h files to access the decoded Trace records, replay them, and query the actual operation results. -* Added Configurable::GetOptionsMap to the public API for use in creating new Customizable classes. -* Generalized bits_per_key parameters in C API from int to double for greater configurability. Although this is a compatible change for existing C source code, anything depending on C API signatures, such as foreign function interfaces, will need to be updated. - -### Performance Improvements -* Try to avoid updating DBOptions if `SetDBOptions()` does not change any option value. - -### Behavior Changes -* `StringAppendOperator` additionally accepts a string as the delimiter. -* BackupEngineOptions::sync (default true) now applies to restoring backups in addition to creating backups. This could slow down restores, but ensures they are fully persisted before returning OK. (Consider increasing max_background_operations to improve performance.) - -## 6.23.0 (2021-07-16) -### Behavior Changes -* Obsolete keys in the bottommost level that were preserved for a snapshot will now be cleaned upon snapshot release in all cases. This form of compaction (snapshot release triggered compaction) previously had an artificial limitation that multiple tombstones needed to be present. -### Bug Fixes -* Blob file checksums are now printed in hexadecimal format when using the `manifest_dump` `ldb` command. -* `GetLiveFilesMetaData()` now populates the `temperature`, `oldest_ancester_time`, and `file_creation_time` fields of its `LiveFileMetaData` results when the information is available. Previously these fields always contained zero indicating unknown. -* Fix mismatches of OnCompaction{Begin,Completed} in case of DisableManualCompaction(). -* Fix continuous logging of an existing background error on every user write -* Fix a bug that `Get()` return Status::OK() and an empty value for non-existent key when `read_options.read_tier = kBlockCacheTier`. -* Fix a bug that stat in `get_context` didn't accumulate to statistics when query is failed. -* Fixed handling of DBOptions::wal_dir with LoadLatestOptions() or ldb --try_load_options on a copied or moved DB. Previously, when the WAL directory is same as DB directory (default), a copied or moved DB would reference the old path of the DB as the WAL directory, potentially corrupting both copies. Under this change, the wal_dir from DB::GetOptions() or LoadLatestOptions() may now be empty, indicating that the current DB directory is used for WALs. This is also a subtle API change. - -### New Features -* ldb has a new feature, `list_live_files_metadata`, that shows the live SST files, as well as their LSM storage level and the column family they belong to. -* The new BlobDB implementation now tracks the amount of garbage in each blob file in the MANIFEST. -* Integrated BlobDB now supports Merge with base values (Put/Delete etc.). -* RemoteCompaction supports sub-compaction, the job_id in the user interface is changed from `int` to `uint64_t` to support sub-compaction id. -* Expose statistics option in RemoteCompaction worker. - -### Public API change -* Added APIs to the Customizable class to allow developers to create their own Customizable classes. Created the utilities/customizable_util.h file to contain helper methods for developing new Customizable classes. -* Change signature of SecondaryCache::Name(). Make SecondaryCache customizable and add SecondaryCache::CreateFromString method. - -## 6.22.0 (2021-06-18) -### Behavior Changes -* Added two additional tickers, MEMTABLE_PAYLOAD_BYTES_AT_FLUSH and MEMTABLE_GARBAGE_BYTES_AT_FLUSH. These stats can be used to estimate the ratio of "garbage" (outdated) bytes in the memtable that are discarded at flush time. -* Added API comments clarifying safe usage of Disable/EnableManualCompaction and EventListener callbacks for compaction. -### Bug Fixes -* fs_posix.cc GetFreeSpace() always report disk space available to root even when running as non-root. Linux defaults often have disk mounts with 5 to 10 percent of total space reserved only for root. Out of space could result for non-root users. -* Subcompactions are now disabled when user-defined timestamps are used, since the subcompaction boundary picking logic is currently not timestamp-aware, which could lead to incorrect results when different subcompactions process keys that only differ by timestamp. -* Fix an issue that `DeleteFilesInRange()` may cause ongoing compaction reports corruption exception, or ASSERT for debug build. There's no actual data loss or corruption that we find. -* Fixed confusingly duplicated output in LOG for periodic stats ("DUMPING STATS"), including "Compaction Stats" and "File Read Latency Histogram By Level". -* Fixed performance bugs in background gathering of block cache entry statistics, that could consume a lot of CPU when there are many column families with a shared block cache. - -### New Features -* Marked the Ribbon filter and optimize_filters_for_memory features as production-ready, each enabling memory savings for Bloom-like filters. Use `NewRibbonFilterPolicy` in place of `NewBloomFilterPolicy` to use Ribbon filters instead of Bloom, or `ribbonfilter` in place of `bloomfilter` in configuration string. -* Allow `DBWithTTL` to use `DeleteRange` api just like other DBs. `DeleteRangeCF()` which executes `WriteBatchInternal::DeleteRange()` has been added to the handler in `DBWithTTLImpl::Write()` to implement it. -* Add BlockBasedTableOptions.prepopulate_block_cache. If enabled, it prepopulate warm/hot data blocks which are already in memory into block cache at the time of flush. On a flush, the data block that is in memory (in memtables) get flushed to the device. If using Direct IO, additional IO is incurred to read this data back into memory again, which is avoided by enabling this option and it also helps with Distributed FileSystem. More details in include/rocksdb/table.h. -* Added a `cancel` field to `CompactRangeOptions`, allowing individual in-process manual range compactions to be cancelled. - -### New Features -* Added BlobMetaData to the ColumnFamilyMetaData to return information about blob files - -### Public API change -* Added GetAllColumnFamilyMetaData API to retrieve the ColumnFamilyMetaData about all column families. - -## 6.21.0 (2021-05-21) -### Bug Fixes -* Fixed a bug in handling file rename error in distributed/network file systems when the server succeeds but client returns error. The bug can cause CURRENT file to point to non-existing MANIFEST file, thus DB cannot be opened. -* Fixed a bug where ingested files were written with incorrect boundary key metadata. In rare cases this could have led to a level's files being wrongly ordered and queries for the boundary keys returning wrong results. -* Fixed a data race between insertion into memtables and the retrieval of the DB properties `rocksdb.cur-size-active-mem-table`, `rocksdb.cur-size-all-mem-tables`, and `rocksdb.size-all-mem-tables`. -* Fixed the false-positive alert when recovering from the WAL file. Avoid reporting "SST file is ahead of WAL" on a newly created empty column family, if the previous WAL file is corrupted. -* Fixed a bug where `GetLiveFiles()` output included a non-existent file called "OPTIONS-000000". Backups and checkpoints, which use `GetLiveFiles()`, failed on DBs impacted by this bug. Read-write DBs were impacted when the latest OPTIONS file failed to write and `fail_if_options_file_error == false`. Read-only DBs were impacted when no OPTIONS files existed. -* Handle return code by io_uring_submit_and_wait() and io_uring_wait_cqe(). -* In the IngestExternalFile() API, only try to sync the ingested file if the file is linked and the FileSystem/Env supports reopening a writable file. -* Fixed a bug that `AdvancedColumnFamilyOptions.max_compaction_bytes` is under-calculated for manual compaction (`CompactRange()`). Manual compaction is split to multiple compactions if the compaction size exceed the `max_compaction_bytes`. The bug creates much larger compaction which size exceed the user setting. On the other hand, larger manual compaction size can increase the subcompaction parallelism, you can tune that by setting `max_compaction_bytes`. - -### Behavior Changes -* Due to the fix of false-postive alert of "SST file is ahead of WAL", all the CFs with no SST file (CF empty) will bypass the consistency check. We fixed a false-positive, but introduced a very rare true-negative which will be triggered in the following conditions: A CF with some delete operations in the last a few queries which will result in an empty CF (those are flushed to SST file and a compaction triggered which combines this file and all other SST files and generates an empty CF, or there is another reason to write a manifest entry for this CF after a flush that generates no SST file from an empty CF). The deletion entries are logged in a WAL and this WAL was corrupted, while the CF's log number points to the next WAL (due to the flush). Therefore, the DB can only recover to the point without these trailing deletions and cause the inconsistent DB status. - -### New Features -* Add new option allow_stall passed during instance creation of WriteBufferManager. When allow_stall is set, WriteBufferManager will stall all writers shared across multiple DBs and columns if memory usage goes beyond specified WriteBufferManager::buffer_size (soft limit). Stall will be cleared when memory is freed after flush and memory usage goes down below buffer_size. -* Allow `CompactionFilter`s to apply in more table file creation scenarios such as flush and recovery. For compatibility, `CompactionFilter`s by default apply during compaction. Users can customize this behavior by overriding `CompactionFilterFactory::ShouldFilterTableFileCreation()`. -* Added more fields to FilterBuildingContext with LSM details, for custom filter policies that vary behavior based on where they are in the LSM-tree. -* Added DB::Properties::kBlockCacheEntryStats for querying statistics on what percentage of block cache is used by various kinds of blocks, etc. using DB::GetProperty and DB::GetMapProperty. The same information is now dumped to info LOG periodically according to `stats_dump_period_sec`. -* Add an experimental Remote Compaction feature, which allows the user to run Compaction on a different host or process. The feature is still under development, currently only works on some basic use cases. The interface will be changed without backward/forward compatibility support. -* RocksDB would validate total entries read in flush, and compare with counter inserted into it. If flush_verify_memtable_count = true (default), flush will fail. Otherwise, only log to info logs. -* Add `TableProperties::num_filter_entries`, which can be used with `TableProperties::filter_size` to calculate the effective bits per filter entry (unique user key or prefix) for a table file. - -### Performance Improvements -* BlockPrefetcher is used by iterators to prefetch data if they anticipate more data to be used in future. It is enabled implicitly by rocksdb. Added change to take in account read pattern if reads are sequential. This would disable prefetching for random reads in MultiGet and iterators as readahead_size is increased exponential doing large prefetches. - -### Public API change -* Removed a parameter from TableFactory::NewTableBuilder, which should not be called by user code because TableBuilder is not a public API. -* Removed unused structure `CompactionFilterContext`. -* The `skip_filters` parameter to SstFileWriter is now considered deprecated. Use `BlockBasedTableOptions::filter_policy` to control generation of filters. -* ClockCache is known to have bugs that could lead to crash or corruption, so should not be used until fixed. Use NewLRUCache instead. -* Added a new pure virtual function `ApplyToAllEntries` to `Cache`, to replace `ApplyToAllCacheEntries`. Custom `Cache` implementations must add an implementation. Because this function is for gathering statistics, an empty implementation could be acceptable for some applications. -* Added the ObjectRegistry to the ConfigOptions class. This registry instance will be used to find any customizable loadable objects during initialization. -* Expanded the ObjectRegistry functionality to allow nested ObjectRegistry instances. Added methods to register a set of functions with the registry/library as a group. -* Deprecated backupable_db.h and BackupableDBOptions in favor of new versions with appropriate names: backup_engine.h and BackupEngineOptions. Old API compatibility is preserved. - -### Default Option Change -* When options.arena_block_size <= 0 (default value 0), still use writer_buffer_size / 8 but cap to 1MB. Too large alloation size might not be friendly to allocator and might cause performance issues in extreme cases. - -### Build -* By default, try to build with liburing. For make, if ROCKSDB_USE_IO_URING is not set, treat as enable, which means RocksDB will try to build with liburing. Users can disable it with ROCKSDB_USE_IO_URING=0. For cmake, add WITH_LIBURING to control it, with default on. - -## 6.20.0 (2021-04-16) -### Behavior Changes -* `ColumnFamilyOptions::sample_for_compression` now takes effect for creation of all block-based tables. Previously it only took effect for block-based tables created by flush. -* `CompactFiles()` can no longer compact files from lower level to up level, which has the risk to corrupt DB (details: #8063). The validation is also added to all compactions. -* Fixed some cases in which DB::OpenForReadOnly() could write to the filesystem. If you want a Logger with a read-only DB, you must now set DBOptions::info_log yourself, such as using CreateLoggerFromOptions(). -* get_iostats_context() will never return nullptr. If thread-local support is not available, and user does not opt-out iostats context, then compilation will fail. The same applies to perf context as well. -* Added support for WriteBatchWithIndex::NewIteratorWithBase when overwrite_key=false. Previously, this combination was not supported and would assert or return nullptr. -* Improve the behavior of WriteBatchWithIndex for Merge operations. Now more operations may be stored in order to return the correct merged result. - -### Bug Fixes -* Use thread-safe `strerror_r()` to get error messages. -* Fixed a potential hang in shutdown for a DB whose `Env` has high-pri thread pool disabled (`Env::GetBackgroundThreads(Env::Priority::HIGH) == 0`) -* Made BackupEngine thread-safe and added documentation comments to clarify what is safe for multiple BackupEngine objects accessing the same backup directory. -* Fixed crash (divide by zero) when compression dictionary is applied to a file containing only range tombstones. -* Fixed a backward iteration bug with partitioned filter enabled: not including the prefix of the last key of the previous filter partition in current filter partition can cause wrong iteration result. -* Fixed a bug that allowed `DBOptions::max_open_files` to be set with a non-negative integer with `ColumnFamilyOptions::compaction_style = kCompactionStyleFIFO`. - -### Performance Improvements -* On ARM platform, use `yield` instead of `wfe` to relax cpu to gain better performance. - -### Public API change -* Added `TableProperties::slow_compression_estimated_data_size` and `TableProperties::fast_compression_estimated_data_size`. When `ColumnFamilyOptions::sample_for_compression > 0`, they estimate what `TableProperties::data_size` would have been if the "fast" or "slow" (see `ColumnFamilyOptions::sample_for_compression` API doc for definitions) compression had been used instead. -* Update DB::StartIOTrace and remove Env object from the arguments as its redundant and DB already has Env object that is passed down to IOTracer::StartIOTrace -* Added `FlushReason::kWalFull`, which is reported when a memtable is flushed due to the WAL reaching its size limit; those flushes were previously reported as `FlushReason::kWriteBufferManager`. Also, changed the reason for flushes triggered by the write buffer manager to `FlushReason::kWriteBufferManager`; they were previously reported as `FlushReason::kWriteBufferFull`. -* Extend file_checksum_dump ldb command and DB::GetLiveFilesChecksumInfo API for IntegratedBlobDB and get checksum of blob files along with SST files. - -### New Features -* Added the ability to open BackupEngine backups as read-only DBs, using BackupInfo::name_for_open and env_for_open provided by BackupEngine::GetBackupInfo() with include_file_details=true. -* Added BackupEngine support for integrated BlobDB, with blob files shared between backups when table files are shared. Because of current limitations, blob files always use the kLegacyCrc32cAndFileSize naming scheme, and incremental backups must read and checksum all blob files in a DB, even for files that are already backed up. -* Added an optional output parameter to BackupEngine::CreateNewBackup(WithMetadata) to return the BackupID of the new backup. -* Added BackupEngine::GetBackupInfo / GetLatestBackupInfo for querying individual backups. -* Made the Ribbon filter a long-term supported feature in terms of the SST schema(compatible with version >= 6.15.0) though the API for enabling it is expected to change. - -## 6.19.0 (2021-03-21) -### Bug Fixes -* Fixed the truncation error found in APIs/tools when dumping block-based SST files in a human-readable format. After fix, the block-based table can be fully dumped as a readable file. -* When hitting a write slowdown condition, no write delay (previously 1 millisecond) is imposed until `delayed_write_rate` is actually exceeded, with an initial burst allowance of 1 millisecond worth of bytes. Also, beyond the initial burst allowance, `delayed_write_rate` is now more strictly enforced, especially with multiple column families. - -### Public API change -* Changed default `BackupableDBOptions::share_files_with_checksum` to `true` and deprecated `false` because of potential for data loss. Note that accepting this change in behavior can temporarily increase backup data usage because files are not shared between backups using the two different settings. Also removed obsolete option kFlagMatchInterimNaming. -* Add a new option BlockBasedTableOptions::max_auto_readahead_size. RocksDB does auto-readahead for iterators on noticing more than two reads for a table file if user doesn't provide readahead_size. The readahead starts at 8KB and doubles on every additional read upto max_auto_readahead_size and now max_auto_readahead_size can be configured dynamically as well. Found that 256 KB readahead size provides the best performance, based on experiments, for auto readahead. Experiment data is in PR #3282. If value is set 0 then no automatic prefetching will be done by rocksdb. Also changing the value will only affect files opened after the change. -* Add suppport to extend DB::VerifyFileChecksums API to also verify blob files checksum. -* When using the new BlobDB, the amount of data written by flushes/compactions is now broken down into table files and blob files in the compaction statistics; namely, Write(GB) denotes the amount of data written to table files, while Wblob(GB) means the amount of data written to blob files. -* New default BlockBasedTableOptions::format_version=5 to enable new Bloom filter implementation by default, compatible with RocksDB versions >= 6.6.0. -* Add new SetBufferSize API to WriteBufferManager to allow dynamic management of memory allotted to all write buffers. This allows user code to adjust memory monitoring provided by WriteBufferManager as process memory needs change datasets grow and shrink. -* Clarified the required semantics of Read() functions in FileSystem and Env APIs. Please ensure any custom implementations are compliant. -* For the new integrated BlobDB implementation, compaction statistics now include the amount of data read from blob files during compaction (due to garbage collection or compaction filters). Write amplification metrics have also been extended to account for data read from blob files. -* Add EqualWithoutTimestamp() to Comparator. -* Extend support to track blob files in SSTFileManager whenever a blob file is created/deleted. Blob files will be scheduled to delete via SSTFileManager and SStFileManager will now take blob files in account while calculating size and space limits along with SST files. -* Add new Append and PositionedAppend API with checksum handoff to legacy Env. - -### New Features -* Support compaction filters for the new implementation of BlobDB. Add `FilterBlobByKey()` to `CompactionFilter`. Subclasses can override this method so that compaction filters can determine whether the actual blob value has to be read during compaction. Use a new `kUndetermined` in `CompactionFilter::Decision` to indicated that further action is necessary for compaction filter to make a decision. -* Add support to extend retrieval of checksums for blob files from the MANIFEST when checkpointing. During backup, rocksdb can detect corruption in blob files during file copies. -* Add new options for db_bench --benchmarks: flush, waitforcompaction, compact0, compact1. -* Add an option to BackupEngine::GetBackupInfo to include the name and size of each backed-up file. Especially in the presence of file sharing among backups, this offers detailed insight into backup space usage. -* Enable backward iteration on keys with user-defined timestamps. -* Add statistics and info log for error handler: counters for bg error, bg io error, bg retryable io error, auto resume count, auto resume total retry number, and auto resume sucess; Histogram for auto resume retry count in each recovery call. Note that, each auto resume attempt will have one or multiple retries. - -### Behavior Changes -* During flush, only WAL sync retryable IO error is mapped to hard error, which will stall the writes. When WAL is used but only SST file write has retryable IO error, it will be mapped to soft error and write will not be affected. - -## 6.18.0 (2021-02-19) -### Behavior Changes -* When retryable IO error occurs during compaction, it is mapped to soft error and set the BG error. However, auto resume is not called to clean the soft error since compaction will reschedule by itself. In this change, When retryable IO error occurs during compaction, BG error is not set. User will be informed the error via EventHelper. -* Introduce a new trace file format for query tracing and replay and trace file version is bump up to 0.2. A payload map is added as the first portion of the payload. We will not have backward compatible issues when adding new entries to trace records. Added the iterator_upper_bound and iterator_lower_bound in Seek and SeekForPrev tracing function. Added them as the new payload member for iterator tracing. - -### New Features -* Add support for key-value integrity protection in live updates from the user buffers provided to `WriteBatch` through the write to RocksDB's in-memory update buffer (memtable). This is intended to detect some cases of in-memory data corruption, due to either software or hardware errors. Users can enable protection by constructing their `WriteBatch` with `protection_bytes_per_key == 8`. -* Add support for updating `full_history_ts_low` option in manual compaction, which is for old timestamp data GC. -* Add a mechanism for using Makefile to build external plugin code into the RocksDB libraries/binaries. This intends to simplify compatibility and distribution for plugins (e.g., special-purpose `FileSystem`s) whose source code resides outside the RocksDB repo. See "plugin/README.md" for developer details, and "PLUGINS.md" for a listing of available plugins. -* Added memory pre-fetching for experimental Ribbon filter, which especially optimizes performance with batched MultiGet. -* A new, experimental version of BlobDB (key-value separation) is now available. The new implementation is integrated into the RocksDB core, i.e. it is accessible via the usual `rocksdb::DB` API, as opposed to the separate `rocksdb::blob_db::BlobDB` interface used by the earlier version, and can be configured on a per-column family basis using the configuration options `enable_blob_files`, `min_blob_size`, `blob_file_size`, `blob_compression_type`, `enable_blob_garbage_collection`, and `blob_garbage_collection_age_cutoff`. It extends RocksDB's consistency guarantees to blobs, and offers more features and better performance. Note that some features, most notably `Merge`, compaction filters, and backup/restore are not yet supported, and there is no support for migrating a database created by the old implementation. - -### Bug Fixes -* Since 6.15.0, `TransactionDB` returns error `Status`es from calls to `DeleteRange()` and calls to `Write()` where the `WriteBatch` contains a range deletion. Previously such operations may have succeeded while not providing the expected transactional guarantees. There are certain cases where range deletion can still be used on such DBs; see the API doc on `TransactionDB::DeleteRange()` for details. -* `OptimisticTransactionDB` now returns error `Status`es from calls to `DeleteRange()` and calls to `Write()` where the `WriteBatch` contains a range deletion. Previously such operations may have succeeded while not providing the expected transactional guarantees. -* Fix `WRITE_PREPARED`, `WRITE_UNPREPARED` TransactionDB `MultiGet()` may return uncommitted data with snapshot. -* In DB::OpenForReadOnly, if any error happens while checking Manifest file path, it was overridden by Status::NotFound. It has been fixed and now actual error is returned. - -### Public API Change -* Added a "only_mutable_options" flag to the ConfigOptions. When this flag is "true", the Configurable functions and convenience methods (such as GetDBOptionsFromString) will only deal with options that are marked as mutable. When this flag is true, only options marked as mutable can be configured (a Status::InvalidArgument will be returned) and options not marked as mutable will not be returned or compared. The default is "false", meaning to compare all options. -* Add new Append and PositionedAppend APIs to FileSystem to bring the data verification information (data checksum information) from upper layer (e.g., WritableFileWriter) to the storage layer. In this way, the customized FileSystem is able to verify the correctness of data being written to the storage on time. Add checksum_handoff_file_types to DBOptions. User can use this option to control which file types (Currently supported file tyes: kWALFile, kTableFile, kDescriptorFile.) should use the new Append and PositionedAppend APIs to handoff the verification information. Currently, RocksDB only use crc32c to calculate the checksum for write handoff. -* Add an option, `CompressionOptions::max_dict_buffer_bytes`, to limit the in-memory buffering for selecting samples for generating/training a dictionary. The limit is currently loosely adhered to. - - -## 6.17.0 (2021-01-15) -### Behavior Changes -* When verifying full file checksum with `DB::VerifyFileChecksums()`, we now fail with `Status::InvalidArgument` if the name of the checksum generator used for verification does not match the name of the checksum generator used for protecting the file when it was created. -* Since RocksDB does not continue write the same file if a file write fails for any reason, the file scope write IO error is treated the same as retryable IO error. More information about error handling of file scope IO error is included in `ErrorHandler::SetBGError`. - -### Bug Fixes -* Version older than 6.15 cannot decode VersionEdits `WalAddition` and `WalDeletion`, fixed this by changing the encoded format of them to be ignorable by older versions. -* Fix a race condition between DB startups and shutdowns in managing the periodic background worker threads. One effect of this race condition could be the process being terminated. - -### Public API Change -* Add a public API WriteBufferManager::dummy_entries_in_cache_usage() which reports the size of dummy entries stored in cache (passed to WriteBufferManager). Dummy entries are used to account for DataBlocks. -* Add a SystemClock class that contains the time-related methods from Env. The original methods in Env may be deprecated in a future release. This class will allow easier testing, development, and expansion of time-related features. -* Add a public API GetRocksBuildProperties and GetRocksBuildInfoAsString to get properties about the current build. These properties may include settings related to the GIT settings (branch, timestamp). This change also sets the "build date" based on the GIT properties, rather than the actual build time, thereby enabling more reproducible builds. - -## 6.16.0 (2020-12-18) -### Behavior Changes -* Attempting to write a merge operand without explicitly configuring `merge_operator` now fails immediately, causing the DB to enter read-only mode. Previously, failure was deferred until the `merge_operator` was needed by a user read or a background operation. - -### Bug Fixes -* Truncated WALs ending in incomplete records can no longer produce gaps in the recovered data when `WALRecoveryMode::kPointInTimeRecovery` is used. Gaps are still possible when WALs are truncated exactly on record boundaries; for complete protection, users should enable `track_and_verify_wals_in_manifest`. -* Fix a bug where compressed blocks read by MultiGet are not inserted into the compressed block cache when use_direct_reads = true. -* Fixed the issue of full scanning on obsolete files when there are too many outstanding compactions with ConcurrentTaskLimiter enabled. -* Fixed the logic of populating native data structure for `read_amp_bytes_per_bit` during OPTIONS file parsing on big-endian architecture. Without this fix, original code introduced in PR7659, when running on big-endian machine, can mistakenly store read_amp_bytes_per_bit (an uint32) in little endian format. Future access to `read_amp_bytes_per_bit` will give wrong values. Little endian architecture is not affected. -* Fixed prefix extractor with timestamp issues. -* Fixed a bug in atomic flush: in two-phase commit mode, the minimum WAL log number to keep is incorrect. -* Fixed a bug related to checkpoint in PR7789: if there are multiple column families, and the checkpoint is not opened as read only, then in rare cases, data loss may happen in the checkpoint. Since backup engine relies on checkpoint, it may also be affected. -* When ldb --try_load_options is used with the --column_family option, the ColumnFamilyOptions for the specified column family was not loaded from the OPTIONS file. Fix it so its loaded from OPTIONS and then overridden with command line overrides. - -### New Features -* User defined timestamp feature supports `CompactRange` and `GetApproximateSizes`. -* Support getting aggregated table properties (kAggregatedTableProperties and kAggregatedTablePropertiesAtLevel) with DB::GetMapProperty, for easier access to the data in a structured format. -* Experimental option BlockBasedTableOptions::optimize_filters_for_memory now works with experimental Ribbon filter (as well as Bloom filter). - -### Public API Change -* Deprecated public but rarely-used FilterBitsBuilder::CalculateNumEntry, which is replaced with ApproximateNumEntries taking a size_t parameter and returning size_t. -* To improve portability the functions `Env::GetChildren` and `Env::GetChildrenFileAttributes` will no longer return entries for the special directories `.` or `..`. -* Added a new option `track_and_verify_wals_in_manifest`. If `true`, the log numbers and sizes of the synced WALs are tracked in MANIFEST, then during DB recovery, if a synced WAL is missing from disk, or the WAL's size does not match the recorded size in MANIFEST, an error will be reported and the recovery will be aborted. Note that this option does not work with secondary instance. -* `rocksdb_approximate_sizes` and `rocksdb_approximate_sizes_cf` in the C API now requires an error pointer (`char** errptr`) for receiving any error. -* All overloads of DB::GetApproximateSizes now return Status, so that any failure to obtain the sizes is indicated to the caller. - -## 6.15.0 (2020-11-13) -### Bug Fixes -* Fixed a bug in the following combination of features: indexes with user keys (`format_version >= 3`), indexes are partitioned (`index_type == kTwoLevelIndexSearch`), and some index partitions are pinned in memory (`BlockBasedTableOptions::pin_l0_filter_and_index_blocks_in_cache`). The bug could cause keys to be truncated when read from the index leading to wrong read results or other unexpected behavior. -* Fixed a bug when indexes are partitioned (`index_type == kTwoLevelIndexSearch`), some index partitions are pinned in memory (`BlockBasedTableOptions::pin_l0_filter_and_index_blocks_in_cache`), and partitions reads could be mixed between block cache and directly from the file (e.g., with `enable_index_compression == 1` and `mmap_read == 1`, partitions that were stored uncompressed due to poor compression ratio would be read directly from the file via mmap, while partitions that were stored compressed would be read from block cache). The bug could cause index partitions to be mistakenly considered empty during reads leading to wrong read results. -* Since 6.12, memtable lookup should report unrecognized value_type as corruption (#7121). -* Since 6.14, fix false positive flush/compaction `Status::Corruption` failure when `paranoid_file_checks == true` and range tombstones were written to the compaction output files. -* Since 6.14, fix a bug that could cause a stalled write to crash with mixed of slowdown and no_slowdown writes (`WriteOptions.no_slowdown=true`). -* Fixed a bug which causes hang in closing DB when refit level is set in opt build. It was because ContinueBackgroundWork() was called in assert statement which is a no op. It was introduced in 6.14. -* Fixed a bug which causes Get() to return incorrect result when a key's merge operand is applied twice. This can occur if the thread performing Get() runs concurrently with a background flush thread and another thread writing to the MANIFEST file (PR6069). -* Reverted a behavior change silently introduced in 6.14.2, in which the effects of the `ignore_unknown_options` flag (used in option parsing/loading functions) changed. -* Reverted a behavior change silently introduced in 6.14, in which options parsing/loading functions began returning `NotFound` instead of `InvalidArgument` for option names not available in the present version. -* Fixed MultiGet bugs it doesn't return valid data with user defined timestamp. -* Fixed a potential bug caused by evaluating `TableBuilder::NeedCompact()` before `TableBuilder::Finish()` in compaction job. For example, the `NeedCompact()` method of `CompactOnDeletionCollector` returned by built-in `CompactOnDeletionCollectorFactory` requires `BlockBasedTable::Finish()` to return the correct result. The bug can cause a compaction-generated file not to be marked for future compaction based on deletion ratio. -* Fixed a seek issue with prefix extractor and timestamp. -* Fixed a bug of encoding and parsing BlockBasedTableOptions::read_amp_bytes_per_bit as a 64-bit integer. -* Fixed a bug of a recovery corner case, details in PR7621. - -### Public API Change -* Deprecate `BlockBasedTableOptions::pin_l0_filter_and_index_blocks_in_cache` and `BlockBasedTableOptions::pin_top_level_index_and_filter`. These options still take effect until users migrate to the replacement APIs in `BlockBasedTableOptions::metadata_cache_options`. Migration guidance can be found in the API comments on the deprecated options. -* Add new API `DB::VerifyFileChecksums` to verify SST file checksum with corresponding entries in the MANIFEST if present. Current implementation requires scanning and recomputing file checksums. - -### Behavior Changes -* The dictionary compression settings specified in `ColumnFamilyOptions::compression_opts` now additionally affect files generated by flush and compaction to non-bottommost level. Previously those settings at most affected files generated by compaction to bottommost level, depending on whether `ColumnFamilyOptions::bottommost_compression_opts` overrode them. Users who relied on dictionary compression settings in `ColumnFamilyOptions::compression_opts` affecting only the bottommost level can keep the behavior by moving their dictionary settings to `ColumnFamilyOptions::bottommost_compression_opts` and setting its `enabled` flag. -* When the `enabled` flag is set in `ColumnFamilyOptions::bottommost_compression_opts`, those compression options now take effect regardless of the value in `ColumnFamilyOptions::bottommost_compression`. Previously, those compression options only took effect when `ColumnFamilyOptions::bottommost_compression != kDisableCompressionOption`. Now, they additionally take effect when `ColumnFamilyOptions::bottommost_compression == kDisableCompressionOption` (such a setting causes bottommost compression type to fall back to `ColumnFamilyOptions::compression_per_level` if configured, and otherwise fall back to `ColumnFamilyOptions::compression`). - -### New Features -* An EXPERIMENTAL new Bloom alternative that saves about 30% space compared to Bloom filters, with about 3-4x construction time and similar query times is available using NewExperimentalRibbonFilterPolicy. - -## 6.14 (2020-10-09) -### Bug fixes -* Fixed a bug after a `CompactRange()` with `CompactRangeOptions::change_level` set fails due to a conflict in the level change step, which caused all subsequent calls to `CompactRange()` with `CompactRangeOptions::change_level` set to incorrectly fail with a `Status::NotSupported("another thread is refitting")` error. -* Fixed a bug that the bottom most level compaction could still be a trivial move even if `BottommostLevelCompaction.kForce` or `kForceOptimized` is set. - -### Public API Change -* The methods to create and manage EncrypedEnv have been changed. The EncryptionProvider is now passed to NewEncryptedEnv as a shared pointer, rather than a raw pointer. Comparably, the CTREncryptedProvider now takes a shared pointer, rather than a reference, to a BlockCipher. CreateFromString methods have been added to BlockCipher and EncryptionProvider to provide a single API by which different ciphers and providers can be created, respectively. -* The internal classes (CTREncryptionProvider, ROT13BlockCipher, CTRCipherStream) associated with the EncryptedEnv have been moved out of the public API. To create a CTREncryptionProvider, one can either use EncryptionProvider::NewCTRProvider, or EncryptionProvider::CreateFromString("CTR"). To create a new ROT13BlockCipher, one can either use BlockCipher::NewROT13Cipher or BlockCipher::CreateFromString("ROT13"). -* The EncryptionProvider::AddCipher method has been added to allow keys to be added to an EncryptionProvider. This API will allow future providers to support multiple cipher keys. -* Add a new option "allow_data_in_errors". When this new option is set by users, it allows users to opt-in to get error messages containing corrupted keys/values. Corrupt keys, values will be logged in the messages, logs, status etc. that will help users with the useful information regarding affected data. By default value of this option is set false to prevent users data to be exposed in the messages so currently, data will be redacted from logs, messages, status by default. -* AdvancedColumnFamilyOptions::force_consistency_checks is now true by default, for more proactive DB corruption detection at virtually no cost (estimated two extra CPU cycles per million on a major production workload). Corruptions reported by these checks now mention "force_consistency_checks" in case a false positive corruption report is suspected and the option needs to be disabled (unlikely). Since existing column families have a saved setting for force_consistency_checks, only new column families will pick up the new default. - -### General Improvements -* The settings of the DBOptions and ColumnFamilyOptions are now managed by Configurable objects (see New Features). The same convenience methods to configure these options still exist but the backend implementation has been unified under a common implementation. - -### New Features - -* Methods to configure serialize, and compare -- such as TableFactory -- are exposed directly through the Configurable base class (from which these objects inherit). This change will allow for better and more thorough configuration management and retrieval in the future. The options for a Configurable object can be set via the ConfigureFromMap, ConfigureFromString, or ConfigureOption method. The serialized version of the options of an object can be retrieved via the GetOptionString, ToString, or GetOption methods. The list of options supported by an object can be obtained via the GetOptionNames method. The "raw" object (such as the BlockBasedTableOption) for an option may be retrieved via the GetOptions method. Configurable options can be compared via the AreEquivalent method. The settings within a Configurable object may be validated via the ValidateOptions method. The object may be intialized (at which point only mutable options may be updated) via the PrepareOptions method. -* Introduce options.check_flush_compaction_key_order with default value to be true. With this option, during flush and compaction, key order will be checked when writing to each SST file. If the order is violated, the flush or compaction will fail. -* Added is_full_compaction to CompactionJobStats, so that the information is available through the EventListener interface. -* Add more stats for MultiGet in Histogram to get number of data blocks, index blocks, filter blocks and sst files read from file system per level. -* SST files have a new table property called db_host_id, which is set to the hostname by default. A new option in DBOptions, db_host_id, allows the property value to be overridden with a user specified string, or disable it completely by making the option string empty. -* Methods to create customizable extensions -- such as TableFactory -- are exposed directly through the Customizable base class (from which these objects inherit). This change will allow these Customizable classes to be loaded and configured in a standard way (via CreateFromString). More information on how to write and use Customizable classes is in the customizable.h header file. - -## 6.13 (2020-09-12) -### Bug fixes -* Fix a performance regression introduced in 6.4 that makes a upper bound check for every Next() even if keys are within a data block that is within the upper bound. -* Fix a possible corruption to the LSM state (overlapping files within a level) when a `CompactRange()` for refitting levels (`CompactRangeOptions::change_level == true`) and another manual compaction are executed in parallel. -* Sanitize `recycle_log_file_num` to zero when the user attempts to enable it in combination with `WALRecoveryMode::kTolerateCorruptedTailRecords`. Previously the two features were allowed together, which compromised the user's configured crash-recovery guarantees. -* Fix a bug where a level refitting in CompactRange() might race with an automatic compaction that puts the data to the target level of the refitting. The bug has been there for years. -* Fixed a bug in version 6.12 in which BackupEngine::CreateNewBackup could fail intermittently with non-OK status when backing up a read-write DB configured with a DBOptions::file_checksum_gen_factory. -* Fix useless no-op compactions scheduled upon snapshot release when options.disable-auto-compactions = true. -* Fix a bug when max_write_buffer_size_to_maintain is set, immutable flushed memtable destruction is delayed until the next super version is installed. A memtable is not added to delete list because of its reference hold by super version and super version doesn't switch because of empt delete list. So memory usage keeps on increasing beyond write_buffer_size + max_write_buffer_size_to_maintain. -* Avoid converting MERGES to PUTS when allow_ingest_behind is true. -* Fix compression dictionary sampling together with `SstFileWriter`. Previously, the dictionary would be trained/finalized immediately with zero samples. Now, the whole `SstFileWriter` file is buffered in memory and then sampled. -* Fix a bug with `avoid_unnecessary_blocking_io=1` and creating backups (BackupEngine::CreateNewBackup) or checkpoints (Checkpoint::Create). With this setting and WAL enabled, these operations could randomly fail with non-OK status. -* Fix a bug in which bottommost compaction continues to advance the underlying InternalIterator to skip tombstones even after shutdown. - -### New Features -* A new field `std::string requested_checksum_func_name` is added to `FileChecksumGenContext`, which enables the checksum factory to create generators for a suite of different functions. -* Added a new subcommand, `ldb unsafe_remove_sst_file`, which removes a lost or corrupt SST file from a DB's metadata. This command involves data loss and must not be used on a live DB. - -### Performance Improvements -* Reduce thread number for multiple DB instances by re-using one global thread for statistics dumping and persisting. -* Reduce write-amp in heavy write bursts in `kCompactionStyleLevel` compaction style with `level_compaction_dynamic_level_bytes` set. -* BackupEngine incremental backups no longer read DB table files that are already saved to a shared part of the backup directory, unless `share_files_with_checksum` is used with `kLegacyCrc32cAndFileSize` naming (discouraged). - * For `share_files_with_checksum`, we are confident there is no regression (vs. pre-6.12) in detecting DB or backup corruption at backup creation time, mostly because the old design did not leverage this extra checksum computation for detecting inconsistencies at backup creation time. - * For `share_table_files` without "checksum" (not recommended), there is a regression in detecting fundamentally unsafe use of the option, greatly mitigated by file size checking (under "Behavior Changes"). Almost no reason to use `share_files_with_checksum=false` should remain. - * `DB::VerifyChecksum` and `BackupEngine::VerifyBackup` with checksum checking are still able to catch corruptions that `CreateNewBackup` does not. - -### Public API Change -* Expose kTypeDeleteWithTimestamp in EntryType and update GetEntryType() accordingly. -* Added file_checksum and file_checksum_func_name to TableFileCreationInfo, which can pass the table file checksum information through the OnTableFileCreated callback during flush and compaction. -* A warning is added to `DB::DeleteFile()` API describing its known problems and deprecation plan. -* Add a new stats level, i.e. StatsLevel::kExceptTickers (PR7329) to exclude tickers even if application passes a non-null Statistics object. -* Added a new status code IOStatus::IOFenced() for the Env/FileSystem to indicate that writes from this instance are fenced off. Like any other background error, this error is returned to the user in Put/Merge/Delete/Flush calls and can be checked using Status::IsIOFenced(). - -### Behavior Changes -* File abstraction `FSRandomAccessFile.Prefetch()` default return status is changed from `OK` to `NotSupported`. If the user inherited file doesn't implement prefetch, RocksDB will create internal prefetch buffer to improve read performance. -* When retryabel IO error happens during Flush (manifest write error is excluded) and WAL is disabled, originally it is mapped to kHardError. Now,it is mapped to soft error. So DB will not stall the writes unless the memtable is full. At the same time, when auto resume is triggered to recover the retryable IO error during Flush, SwitchMemtable is not called to avoid generating to many small immutable memtables. If WAL is enabled, no behavior changes. -* When considering whether a table file is already backed up in a shared part of backup directory, BackupEngine would already query the sizes of source (DB) and pre-existing destination (backup) files. BackupEngine now uses these file sizes to detect corruption, as at least one of (a) old backup, (b) backup in progress, or (c) current DB is corrupt if there's a size mismatch. - -### Others -* Error in prefetching partitioned index blocks will not be swallowed. It will fail the query and return the IOError users. - -## 6.12 (2020-07-28) -### Public API Change -* Encryption file classes now exposed for inheritance in env_encryption.h -* File I/O listener is extended to cover more I/O operations. Now class `EventListener` in listener.h contains new callback functions: `OnFileFlushFinish()`, `OnFileSyncFinish()`, `OnFileRangeSyncFinish()`, `OnFileTruncateFinish()`, and ``OnFileCloseFinish()``. -* `FileOperationInfo` now reports `duration` measured by `std::chrono::steady_clock` and `start_ts` measured by `std::chrono::system_clock` instead of start and finish timestamps measured by `system_clock`. Note that `system_clock` is called before `steady_clock` in program order at operation starts. -* `DB::GetDbSessionId(std::string& session_id)` is added. `session_id` stores a unique identifier that gets reset every time the DB is opened. This DB session ID should be unique among all open DB instances on all hosts, and should be unique among re-openings of the same or other DBs. This identifier is recorded in the LOG file on the line starting with "DB Session ID:". -* `DB::OpenForReadOnly()` now returns `Status::NotFound` when the specified DB directory does not exist. Previously the error returned depended on the underlying `Env`. This change is available in all 6.11 releases as well. -* A parameter `verify_with_checksum` is added to `BackupEngine::VerifyBackup`, which is false by default. If it is ture, `BackupEngine::VerifyBackup` verifies checksums and file sizes of backup files. Pass `false` for `verify_with_checksum` to maintain the previous behavior and performance of `BackupEngine::VerifyBackup`, by only verifying sizes of backup files. - -### Behavior Changes -* Best-efforts recovery ignores CURRENT file completely. If CURRENT file is missing during recovery, best-efforts recovery still proceeds with MANIFEST file(s). -* In best-efforts recovery, an error that is not Corruption or IOError::kNotFound or IOError::kPathNotFound will be overwritten silently. Fix this by checking all non-ok cases and return early. -* When `file_checksum_gen_factory` is set to `GetFileChecksumGenCrc32cFactory()`, BackupEngine will compare the crc32c checksums of table files computed when creating a backup to the expected checksums stored in the DB manifest, and will fail `CreateNewBackup()` on mismatch (corruption). If the `file_checksum_gen_factory` is not set or set to any other customized factory, there is no checksum verification to detect if SST files in a DB are corrupt when read, copied, and independently checksummed by BackupEngine. -* When a DB sets `stats_dump_period_sec > 0`, either as the initial value for DB open or as a dynamic option change, the first stats dump is staggered in the following X seconds, where X is an integer in `[0, stats_dump_period_sec)`. Subsequent stats dumps are still spaced `stats_dump_period_sec` seconds apart. -* When the paranoid_file_checks option is true, a hash is generated of all keys and values are generated when the SST file is written, and then the values are read back in to validate the file. A corruption is signaled if the two hashes do not match. - -### Bug fixes -* Compressed block cache was automatically disabled with read-only DBs by mistake. Now it is fixed: compressed block cache will be in effective with read-only DB too. -* Fix a bug of wrong iterator result if another thread finishes an update and a DB flush between two statement. -* Disable file deletion after MANIFEST write/sync failure until db re-open or Resume() so that subsequent re-open will not see MANIFEST referencing deleted SSTs. -* Fix a bug when index_type == kTwoLevelIndexSearch in PartitionedIndexBuilder to update FlushPolicy to point to internal key partitioner when it changes from user-key mode to internal-key mode in index partition. -* Make compaction report InternalKey corruption while iterating over the input. -* Fix a bug which may cause MultiGet to be slow because it may read more data than requested, but this won't affect correctness. The bug was introduced in 6.10 release. -* Fail recovery and report once hitting a physical log record checksum mismatch, while reading MANIFEST. RocksDB should not continue processing the MANIFEST any further. -* Fixed a bug in size-amp-triggered and periodic-triggered universal compaction, where the compression settings for the first input level were used rather than the compression settings for the output (bottom) level. - -### New Features -* DB identity (`db_id`) and DB session identity (`db_session_id`) are added to table properties and stored in SST files. SST files generated from SstFileWriter and Repairer have DB identity “SST Writer” and “DB Repairer”, respectively. Their DB session IDs are generated in the same way as `DB::GetDbSessionId`. The session ID for SstFileWriter (resp., Repairer) resets every time `SstFileWriter::Open` (resp., `Repairer::Run`) is called. -* Added experimental option BlockBasedTableOptions::optimize_filters_for_memory for reducing allocated memory size of Bloom filters (~10% savings with Jemalloc) while preserving the same general accuracy. To have an effect, the option requires format_version=5 and malloc_usable_size. Enabling this option is forward and backward compatible with existing format_version=5. -* `BackupableDBOptions::share_files_with_checksum_naming` is added with new default behavior for naming backup files with `share_files_with_checksum`, to address performance and backup integrity issues. See API comments for details. -* Added auto resume function to automatically recover the DB from background Retryable IO Error. When retryable IOError happens during flush and WAL write, the error is mapped to Hard Error and DB will be in read mode. When retryable IO Error happens during compaction, the error will be mapped to Soft Error. DB is still in write/read mode. Autoresume function will create a thread for a DB to call DB->ResumeImpl() to try the recover for Retryable IO Error during flush and WAL write. Compaction will be rescheduled by itself if retryable IO Error happens. Auto resume may also cause other Retryable IO Error during the recovery, so the recovery will fail. Retry the auto resume may solve the issue, so we use max_bgerror_resume_count to decide how many resume cycles will be tried in total. If it is <=0, auto resume retryable IO Error is disabled. Default is INT_MAX, which will lead to a infinit auto resume. bgerror_resume_retry_interval decides the time interval between two auto resumes. -* Option `max_subcompactions` can be set dynamically using DB::SetDBOptions(). -* Added experimental ColumnFamilyOptions::sst_partitioner_factory to define determine the partitioning of sst files. This helps compaction to split the files on interesting boundaries (key prefixes) to make propagation of sst files less write amplifying (covering the whole key space). - -### Performance Improvements -* Eliminate key copies for internal comparisons while accessing ingested block-based tables. -* Reduce key comparisons during random access in all block-based tables. -* BackupEngine avoids unnecessary repeated checksum computation for backing up a table file to the `shared_checksum` directory when using `share_files_with_checksum_naming = kUseDbSessionId` (new default), except on SST files generated before this version of RocksDB, which fall back on using `kLegacyCrc32cAndFileSize`. - -## 6.11 (2020-06-12) -### Bug Fixes -* Fix consistency checking error swallowing in some cases when options.force_consistency_checks = true. -* Fix possible false NotFound status from batched MultiGet using index type kHashSearch. -* Fix corruption caused by enabling delete triggered compaction (NewCompactOnDeletionCollectorFactory) in universal compaction mode, along with parallel compactions. The bug can result in two parallel compactions picking the same input files, resulting in the DB resurrecting older and deleted versions of some keys. -* Fix a use-after-free bug in best-efforts recovery. column_family_memtables_ needs to point to valid ColumnFamilySet. -* Let best-efforts recovery ignore corrupted files during table loading. -* Fix corrupt key read from ingested file when iterator direction switches from reverse to forward at a key that is a prefix of another key in the same file. It is only possible in files with a non-zero global seqno. -* Fix abnormally large estimate from GetApproximateSizes when a range starts near the end of one SST file and near the beginning of another. Now GetApproximateSizes consistently and fairly includes the size of SST metadata in addition to data blocks, attributing metadata proportionally among the data blocks based on their size. -* Fix potential file descriptor leakage in PosixEnv's IsDirectory() and NewRandomAccessFile(). -* Fix false negative from the VerifyChecksum() API when there is a checksum mismatch in an index partition block in a BlockBasedTable format table file (index_type is kTwoLevelIndexSearch). -* Fix sst_dump to return non-zero exit code if the specified file is not a recognized SST file or fails requested checks. -* Fix incorrect results from batched MultiGet for duplicate keys, when the duplicate key matches the largest key of an SST file and the value type for the key in the file is a merge value. - -### Public API Change -* Flush(..., column_family) may return Status::ColumnFamilyDropped() instead of Status::InvalidArgument() if column_family is dropped while processing the flush request. -* BlobDB now explicitly disallows using the default column family's storage directories as blob directory. -* DeleteRange now returns `Status::InvalidArgument` if the range's end key comes before its start key according to the user comparator. Previously the behavior was undefined. -* ldb now uses options.force_consistency_checks = true by default and "--disable_consistency_checks" is added to disable it. -* DB::OpenForReadOnly no longer creates files or directories if the named DB does not exist, unless create_if_missing is set to true. -* The consistency checks that validate LSM state changes (table file additions/deletions during flushes and compactions) are now stricter, more efficient, and no longer optional, i.e. they are performed even if `force_consistency_checks` is `false`. -* Disable delete triggered compaction (NewCompactOnDeletionCollectorFactory) in universal compaction mode and num_levels = 1 in order to avoid a corruption bug. -* `pin_l0_filter_and_index_blocks_in_cache` no longer applies to L0 files larger than `1.5 * write_buffer_size` to give more predictable memory usage. Such L0 files may exist due to intra-L0 compaction, external file ingestion, or user dynamically changing `write_buffer_size` (note, however, that files that are already pinned will continue being pinned, even after such a dynamic change). -* In point-in-time wal recovery mode, fail database recovery in case of IOError while reading the WAL to avoid data loss. -* A new method `Env::LowerThreadPoolCPUPriority(Priority, CpuPriority)` is added to `Env` to be able to lower to a specific priority such as `CpuPriority::kIdle`. - -### New Features -* sst_dump to add a new --readahead_size argument. Users can specify read size when scanning the data. Sst_dump also tries to prefetch tail part of the SST files so usually some number of I/Os are saved there too. -* Generate file checksum in SstFileWriter if Options.file_checksum_gen_factory is set. The checksum and checksum function name are stored in ExternalSstFileInfo after the sst file write is finished. -* Add a value_size_soft_limit in read options which limits the cumulative value size of keys read in batches in MultiGet. Once the cumulative value size of found keys exceeds read_options.value_size_soft_limit, all the remaining keys are returned with status Abort without further finding their values. By default the value_size_soft_limit is std::numeric_limits::max(). -* Enable SST file ingestion with file checksum information when calling IngestExternalFiles(const std::vector& args). Added files_checksums and files_checksum_func_names to IngestExternalFileArg such that user can ingest the sst files with their file checksum information. Added verify_file_checksum to IngestExternalFileOptions (default is True). To be backward compatible, if DB does not enable file checksum or user does not provide checksum information (vectors of files_checksums and files_checksum_func_names are both empty), verification of file checksum is always sucessful. If DB enables file checksum, DB will always generate the checksum for each ingested SST file during Prepare stage of ingestion and store the checksum in Manifest, unless verify_file_checksum is False and checksum information is provided by the application. In this case, we only verify the checksum function name and directly store the ingested checksum in Manifest. If verify_file_checksum is set to True, DB will verify the ingested checksum and function name with the genrated ones. Any mismatch will fail the ingestion. Note that, if IngestExternalFileOptions::write_global_seqno is True, the seqno will be changed in the ingested file. Therefore, the checksum of the file will be changed. In this case, a new checksum will be generated after the seqno is updated and be stored in the Manifest. - -### Performance Improvements -* Eliminate redundant key comparisons during random access in block-based tables. - -## 6.10 (2020-05-02) -### Bug Fixes -* Fix wrong result being read from ingested file. May happen when a key in the file happen to be prefix of another key also in the file. The issue can further cause more data corruption. The issue exists with rocksdb >= 5.0.0 since DB::IngestExternalFile() was introduced. -* Finish implementation of BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey. It's now ready for use. Significantly reduces read amplification in some setups, especially for iterator seeks. -* Fix a bug by updating CURRENT file so that it points to the correct MANIFEST file after best-efforts recovery. -* Fixed a bug where ColumnFamilyHandle objects were not cleaned up in case an error happened during BlobDB's open after the base DB had been opened. -* Fix a potential undefined behavior caused by trying to dereference nullable pointer (timestamp argument) in DB::MultiGet. -* Fix a bug caused by not including user timestamp in MultiGet LookupKey construction. This can lead to wrong query result since the trailing bytes of a user key, if not shorter than timestamp, will be mistaken for user timestamp. -* Fix a bug caused by using wrong compare function when sorting the input keys of MultiGet with timestamps. -* Upgraded version of bzip library (1.0.6 -> 1.0.8) used with RocksJava to address potential vulnerabilities if an attacker can manipulate compressed data saved and loaded by RocksDB (not normal). See issue #6703. - -### Public API Change -* Add a ConfigOptions argument to the APIs dealing with converting options to and from strings and files. The ConfigOptions is meant to replace some of the options (such as input_strings_escaped and ignore_unknown_options) and allow for more parameters to be passed in the future without changing the function signature. -* Add NewFileChecksumGenCrc32cFactory to the file checksum public API, such that the builtin Crc32c based file checksum generator factory can be used by applications. -* Add IsDirectory to Env and FS to indicate if a path is a directory. - -### New Features -* Added support for pipelined & parallel compression optimization for `BlockBasedTableBuilder`. This optimization makes block building, block compression and block appending a pipeline, and uses multiple threads to accelerate block compression. Users can set `CompressionOptions::parallel_threads` greater than 1 to enable compression parallelism. This feature is experimental for now. -* Provide an allocator for memkind to be used with block cache. This is to work with memory technologies (Intel DCPMM is one such technology currently available) that require different libraries for allocation and management (such as PMDK and memkind). The high capacities available make it possible to provision large caches (up to several TBs in size) beyond what is achievable with DRAM. -* Option `max_background_flushes` can be set dynamically using DB::SetDBOptions(). -* Added functionality in sst_dump tool to check the compressed file size for different compression levels and print the time spent on compressing files with each compression type. Added arguments `--compression_level_from` and `--compression_level_to` to report size of all compression levels and one compression_type must be specified with it so that it will report compressed sizes of one compression type with different levels. -* Added statistics for redundant insertions into block cache: rocksdb.block.cache.*add.redundant. (There is currently no coordination to ensure that only one thread loads a table block when many threads are trying to access that same table block.) - -### Bug Fixes -* Fix a bug when making options.bottommost_compression, options.compression_opts and options.bottommost_compression_opts dynamically changeable: the modified values are not written to option files or returned back to users when being queried. -* Fix a bug where index key comparisons were unaccounted in `PerfContext::user_key_comparison_count` for lookups in files written with `format_version >= 3`. -* Fix many bloom.filter statistics not being updated in batch MultiGet. - -### Performance Improvements -* Improve performance of batch MultiGet with partitioned filters, by sharing block cache lookups to applicable filter blocks. -* Reduced memory copies when fetching and uncompressing compressed blocks from sst files. - -## 6.9.0 (2020-03-29) -### Behavior changes -* Since RocksDB 6.8, ttl-based FIFO compaction can drop a file whose oldest key becomes older than options.ttl while others have not. This fix reverts this and makes ttl-based FIFO compaction use the file's flush time as the criterion. This fix also requires that max_open_files = -1 and compaction_options_fifo.allow_compaction = false to function properly. - -### Public API Change -* Fix spelling so that API now has correctly spelled transaction state name `COMMITTED`, while the old misspelled `COMMITED` is still available as an alias. -* Updated default format_version in BlockBasedTableOptions from 2 to 4. SST files generated with the new default can be read by RocksDB versions 5.16 and newer, and use more efficient encoding of keys in index blocks. -* A new parameter `CreateBackupOptions` is added to both `BackupEngine::CreateNewBackup` and `BackupEngine::CreateNewBackupWithMetadata`, you can decrease CPU priority of `BackupEngine`'s background threads by setting `decrease_background_thread_cpu_priority` and `background_thread_cpu_priority` in `CreateBackupOptions`. -* Updated the public API of SST file checksum. Introduce the FileChecksumGenFactory to create the FileChecksumGenerator for each SST file, such that the FileChecksumGenerator is not shared and it can be more general for checksum implementations. Changed the FileChecksumGenerator interface from Value, Extend, and GetChecksum to Update, Finalize, and GetChecksum. Finalize should be only called once after all data is processed to generate the final checksum. Temproal data should be maintained by the FileChecksumGenerator object itself and finally it can return the checksum string. - -### Bug Fixes -* Fix a bug where range tombstone blocks in ingested files were cached incorrectly during ingestion. If range tombstones were read from those incorrectly cached blocks, the keys they covered would be exposed. -* Fix a data race that might cause crash when calling DB::GetCreationTimeOfOldestFile() by a small chance. The bug was introduced in 6.6 Release. -* Fix a bug where a boolean value optimize_filters_for_hits was for max threads when calling load table handles after a flush or compaction. The value is correct to 1. The bug should not cause user visible problems. -* Fix a bug which might crash the service when write buffer manager fails to insert the dummy handle to the block cache. - -### Performance Improvements -* In CompactRange, for levels starting from 0, if the level does not have any file with any key falling in the specified range, the level is skipped. So instead of always compacting from level 0, the compaction starts from the first level with keys in the specified range until the last such level. -* Reduced memory copy when reading sst footer and blobdb in direct IO mode. -* When restarting a database with large numbers of sst files, large amount of CPU time is spent on getting logical block size of the sst files, which slows down the starting progress, this inefficiency is optimized away with an internal cache for the logical block sizes. - -### New Features -* Basic support for user timestamp in iterator. Seek/SeekToFirst/Next and lower/upper bounds are supported. Reverse iteration is not supported. Merge is not considered. -* When file lock failure when the lock is held by the current process, return acquiring time and thread ID in the error message. -* Added a new option, best_efforts_recovery (default: false), to allow database to open in a db dir with missing table files. During best efforts recovery, missing table files are ignored, and database recovers to the most recent state without missing table file. Cross-column-family consistency is not guaranteed even if WAL is enabled. -* options.bottommost_compression, options.compression_opts and options.bottommost_compression_opts are now dynamically changeable. - -## 6.8.0 (2020-02-24) -### Java API Changes -* Major breaking changes to Java comparators, toward standardizing on ByteBuffer for performant, locale-neutral operations on keys (#6252). -* Added overloads of common API methods using direct ByteBuffers for keys and values (#2283). - -### Bug Fixes -* Fix incorrect results while block-based table uses kHashSearch, together with Prev()/SeekForPrev(). -* Fix a bug that prevents opening a DB after two consecutive crash with TransactionDB, where the first crash recovers from a corrupted WAL with kPointInTimeRecovery but the second cannot. -* Fixed issue #6316 that can cause a corruption of the MANIFEST file in the middle when writing to it fails due to no disk space. -* Add DBOptions::skip_checking_sst_file_sizes_on_db_open. It disables potentially expensive checking of all sst file sizes in DB::Open(). -* BlobDB now ignores trivially moved files when updating the mapping between blob files and SSTs. This should mitigate issue #6338 where out of order flush/compaction notifications could trigger an assertion with the earlier code. -* Batched MultiGet() ignores IO errors while reading data blocks, causing it to potentially continue looking for a key and returning stale results. -* `WriteBatchWithIndex::DeleteRange` returns `Status::NotSupported`. Previously it returned success even though reads on the batch did not account for range tombstones. The corresponding language bindings now cannot be used. In C, that includes `rocksdb_writebatch_wi_delete_range`, `rocksdb_writebatch_wi_delete_range_cf`, `rocksdb_writebatch_wi_delete_rangev`, and `rocksdb_writebatch_wi_delete_rangev_cf`. In Java, that includes `WriteBatchWithIndex::deleteRange`. -* Assign new MANIFEST file number when caller tries to create a new MANIFEST by calling LogAndApply(..., new_descriptor_log=true). This bug can cause MANIFEST being overwritten during recovery if options.write_dbid_to_manifest = true and there are WAL file(s). - -### Performance Improvements -* Perfom readahead when reading from option files. Inside DB, options.log_readahead_size will be used as the readahead size. In other cases, a default 512KB is used. - -### Public API Change -* The BlobDB garbage collector now emits the statistics `BLOB_DB_GC_NUM_FILES` (number of blob files obsoleted during GC), `BLOB_DB_GC_NUM_NEW_FILES` (number of new blob files generated during GC), `BLOB_DB_GC_FAILURES` (number of failed GC passes), `BLOB_DB_GC_NUM_KEYS_RELOCATED` (number of blobs relocated during GC), and `BLOB_DB_GC_BYTES_RELOCATED` (total size of blobs relocated during GC). On the other hand, the following statistics, which are not relevant for the new GC implementation, are now deprecated: `BLOB_DB_GC_NUM_KEYS_OVERWRITTEN`, `BLOB_DB_GC_NUM_KEYS_EXPIRED`, `BLOB_DB_GC_BYTES_OVERWRITTEN`, `BLOB_DB_GC_BYTES_EXPIRED`, and `BLOB_DB_GC_MICROS`. -* Disable recycle_log_file_num when an inconsistent recovery modes are requested: kPointInTimeRecovery and kAbsoluteConsistency - -### New Features -* Added the checksum for each SST file generated by Flush or Compaction. Added sst_file_checksum_func to Options such that user can plugin their own SST file checksum function via override the FileChecksumFunc class. If user does not set the sst_file_checksum_func, SST file checksum calculation will not be enabled. The checksum information inlcuding uint32_t checksum value and a checksum function name (string). The checksum information is stored in FileMetadata in version store and also logged to MANIFEST. A new tool is added to LDB such that user can dump out a list of file checksum information from MANIFEST (stored in an unordered_map). -* `db_bench` now supports `value_size_distribution_type`, `value_size_min`, `value_size_max` options for generating random variable sized value. Added `blob_db_compression_type` option for BlobDB to enable blob compression. -* Replace RocksDB namespace "rocksdb" with flag "ROCKSDB_NAMESPACE" which if is not defined, defined as "rocksdb" in header file rocksdb_namespace.h. - -## 6.7.0 (2020-01-21) -### Public API Change -* Added a rocksdb::FileSystem class in include/rocksdb/file_system.h to encapsulate file creation/read/write operations, and an option DBOptions::file_system to allow a user to pass in an instance of rocksdb::FileSystem. If its a non-null value, this will take precendence over DBOptions::env for file operations. A new API rocksdb::FileSystem::Default() returns a platform default object. The DBOptions::env option and Env::Default() API will continue to be used for threading and other OS related functions, and where DBOptions::file_system is not specified, for file operations. For storage developers who are accustomed to rocksdb::Env, the interface in rocksdb::FileSystem is new and will probably undergo some changes as more storage systems are ported to it from rocksdb::Env. As of now, no env other than Posix has been ported to the new interface. -* A new rocksdb::NewSstFileManager() API that allows the caller to pass in separate Env and FileSystem objects. -* Changed Java API for RocksDB.keyMayExist functions to use Holder instead of StringBuilder, so that retrieved values need not decode to Strings. -* A new `OptimisticTransactionDBOptions` Option that allows users to configure occ validation policy. The default policy changes from kValidateSerial to kValidateParallel to reduce mutex contention. - -### Bug Fixes -* Fix a bug that can cause unnecessary bg thread to be scheduled(#6104). -* Fix crash caused by concurrent CF iterations and drops(#6147). -* Fix a race condition for cfd->log_number_ between manifest switch and memtable switch (PR 6249) when number of column families is greater than 1. -* Fix a bug on fractional cascading index when multiple files at the same level contain the same smallest user key, and those user keys are for merge operands. In this case, Get() the exact key may miss some merge operands. -* Delcare kHashSearch index type feature-incompatible with index_block_restart_interval larger than 1. -* Fixed an issue where the thread pools were not resized upon setting `max_background_jobs` dynamically through the `SetDBOptions` interface. -* Fix a bug that can cause write threads to hang when a slowdown/stall happens and there is a mix of writers with WriteOptions::no_slowdown set/unset. -* Fixed an issue where an incorrect "number of input records" value was used to compute the "records dropped" statistics for compactions. -* Fix a regression bug that causes segfault when hash is used, max_open_files != -1 and total order seek is used and switched back. - -### New Features -* It is now possible to enable periodic compactions for the base DB when using BlobDB. -* BlobDB now garbage collects non-TTL blobs when `enable_garbage_collection` is set to `true` in `BlobDBOptions`. Garbage collection is performed during compaction: any valid blobs located in the oldest N files (where N is the number of non-TTL blob files multiplied by the value of `BlobDBOptions::garbage_collection_cutoff`) encountered during compaction get relocated to new blob files, and old blob files are dropped once they are no longer needed. Note: we recommend enabling periodic compactions for the base DB when using this feature to deal with the case when some old blob files are kept alive by SSTs that otherwise do not get picked for compaction. -* `db_bench` now supports the `garbage_collection_cutoff` option for BlobDB. -* Introduce ReadOptions.auto_prefix_mode. When set to true, iterator will return the same result as total order seek, but may choose to use prefix seek internally based on seek key and iterator upper bound. -* MultiGet() can use IO Uring to parallelize read from the same SST file. This featuer is by default disabled. It can be enabled with environment variable ROCKSDB_USE_IO_URING. - -## 6.6.2 (2020-01-13) -### Bug Fixes -* Fixed a bug where non-L0 compaction input files were not considered to compute the `creation_time` of new compaction outputs. - -## 6.6.1 (2020-01-02) -### Bug Fixes -* Fix a bug in WriteBatchWithIndex::MultiGetFromBatchAndDB, which is called by Transaction::MultiGet, that causes due to stale pointer access when the number of keys is > 32 -* Fixed two performance issues related to memtable history trimming. First, a new SuperVersion is now created only if some memtables were actually trimmed. Second, trimming is only scheduled if there is at least one flushed memtable that is kept in memory for the purposes of transaction conflict checking. -* BlobDB no longer updates the SST to blob file mapping upon failed compactions. -* Fix a bug in which a snapshot read through an iterator could be affected by a DeleteRange after the snapshot (#6062). -* Fixed a bug where BlobDB was comparing the `ColumnFamilyHandle` pointers themselves instead of only the column family IDs when checking whether an API call uses the default column family or not. -* Delete superversions in BackgroundCallPurge. -* Fix use-after-free and double-deleting files in BackgroundCallPurge(). - -## 6.6.0 (2019-11-25) -### Bug Fixes -* Fix data corruption caused by output of intra-L0 compaction on ingested file not being placed in correct order in L0. -* Fix a data race between Version::GetColumnFamilyMetaData() and Compaction::MarkFilesBeingCompacted() for access to being_compacted (#6056). The current fix acquires the db mutex during Version::GetColumnFamilyMetaData(), which may cause regression. -* Fix a bug in DBIter that is_blob_ state isn't updated when iterating backward using seek. -* Fix a bug when format_version=3, partitioned filters, and prefix search are used in conjunction. The bug could result into Seek::(prefix) returning NotFound for an existing prefix. -* Revert the feature "Merging iterator to avoid child iterator reseek for some cases (#5286)" since it might cause strong results when reseek happens with a different iterator upper bound. -* Fix a bug causing a crash during ingest external file when background compaction cause severe error (file not found). -* Fix a bug when partitioned filters and prefix search are used in conjunction, ::SeekForPrev could return invalid for an existing prefix. ::SeekForPrev might be called by the user, or internally on ::Prev, or within ::Seek if the return value involves Delete or a Merge operand. -* Fix OnFlushCompleted fired before flush result persisted in MANIFEST when there's concurrent flush job. The bug exists since OnFlushCompleted was introduced in rocksdb 3.8. -* Fixed an sst_dump crash on some plain table SST files. -* Fixed a memory leak in some error cases of opening plain table SST files. -* Fix a bug when a crash happens while calling WriteLevel0TableForRecovery for multiple column families, leading to a column family's log number greater than the first corrutped log number when the DB is being opened in PointInTime recovery mode during next recovery attempt (#5856). - -### New Features -* Universal compaction to support options.periodic_compaction_seconds. A full compaction will be triggered if any file is over the threshold. -* `GetLiveFilesMetaData` and `GetColumnFamilyMetaData` now expose the file number of SST files as well as the oldest blob file referenced by each SST. -* A batched MultiGet API (DB::MultiGet()) that supports retrieving keys from multiple column families. -* Full and partitioned filters in the block-based table use an improved Bloom filter implementation, enabled with format_version 5 (or above) because previous releases cannot read this filter. This replacement is faster and more accurate, especially for high bits per key or millions of keys in a single (full) filter. For example, the new Bloom filter has the same false positive rate at 9.55 bits per key as the old one at 10 bits per key, and a lower false positive rate at 16 bits per key than the old one at 100 bits per key. -* Added AVX2 instructions to USE_SSE builds to accelerate the new Bloom filter and XXH3-based hash function on compatible x86_64 platforms (Haswell and later, ~2014). -* Support options.ttl or options.periodic_compaction_seconds with options.max_open_files = -1. File's oldest ancester time and file creation time will be written to manifest. If it is availalbe, this information will be used instead of creation_time and file_creation_time in table properties. -* Setting options.ttl for universal compaction now has the same meaning as setting periodic_compaction_seconds. -* SstFileMetaData also returns file creation time and oldest ancester time. -* The `sst_dump` command line tool `recompress` command now displays how many blocks were compressed and how many were not, in particular how many were not compressed because the compression ratio was not met (12.5% threshold for GoodCompressionRatio), as seen in the `number.block.not_compressed` counter stat since version 6.0.0. -* The block cache usage is now takes into account the overhead of metadata per each entry. This results into more accurate management of memory. A side-effect of this feature is that less items are fit into the block cache of the same size, which would result to higher cache miss rates. This can be remedied by increasing the block cache size or passing kDontChargeCacheMetadata to its constuctor to restore the old behavior. -* When using BlobDB, a mapping is maintained and persisted in the MANIFEST between each SST file and the oldest non-TTL blob file it references. -* `db_bench` now supports and by default issues non-TTL Puts to BlobDB. TTL Puts can be enabled by specifying a non-zero value for the `blob_db_max_ttl_range` command line parameter explicitly. -* `sst_dump` now supports printing BlobDB blob indexes in a human-readable format. This can be enabled by specifying the `decode_blob_index` flag on the command line. -* A number of new information elements are now exposed through the EventListener interface. For flushes, the file numbers of the new SST file and the oldest blob file referenced by the SST are propagated. For compactions, the level, file number, and the oldest blob file referenced are passed to the client for each compaction input and output file. - -### Public API Change -* RocksDB release 4.1 or older will not be able to open DB generated by the new release. 4.2 was released on Feb 23, 2016. -* TTL Compactions in Level compaction style now initiate successive cascading compactions on a key range so that it reaches the bottom level quickly on TTL expiry. `creation_time` table property for compaction output files is now set to the minimum of the creation times of all compaction inputs. -* With FIFO compaction style, options.periodic_compaction_seconds will have the same meaning as options.ttl. Whichever stricter will be used. With the default options.periodic_compaction_seconds value with options.ttl's default of 0, RocksDB will give a default of 30 days. -* Added an API GetCreationTimeOfOldestFile(uint64_t* creation_time) to get the file_creation_time of the oldest SST file in the DB. -* FilterPolicy now exposes additional API to make it possible to choose filter configurations based on context, such as table level and compaction style. See `LevelAndStyleCustomFilterPolicy` in db_bloom_filter_test.cc. While most existing custom implementations of FilterPolicy should continue to work as before, those wrapping the return of NewBloomFilterPolicy will require overriding new function `GetBuilderWithContext()`, because calling `GetFilterBitsBuilder()` on the FilterPolicy returned by NewBloomFilterPolicy is no longer supported. -* An unlikely usage of FilterPolicy is no longer supported. Calling GetFilterBitsBuilder() on the FilterPolicy returned by NewBloomFilterPolicy will now cause an assertion violation in debug builds, because RocksDB has internally migrated to a more elaborate interface that is expected to evolve further. Custom implementations of FilterPolicy should work as before, except those wrapping the return of NewBloomFilterPolicy, which will require a new override of a protected function in FilterPolicy. -* NewBloomFilterPolicy now takes bits_per_key as a double instead of an int. This permits finer control over the memory vs. accuracy trade-off in the new Bloom filter implementation and should not change source code compatibility. -* The option BackupableDBOptions::max_valid_backups_to_open is now only used when opening BackupEngineReadOnly. When opening a read/write BackupEngine, anything but the default value logs a warning and is treated as the default. This change ensures that backup deletion has proper accounting of shared files to ensure they are deleted when no longer referenced by a backup. -* Deprecate `snap_refresh_nanos` option. -* Added DisableManualCompaction/EnableManualCompaction to stop and resume manual compaction. -* Add TryCatchUpWithPrimary() to StackableDB in non-LITE mode. -* Add a new Env::LoadEnv() overloaded function to return a shared_ptr to Env. -* Flush sets file name to "(nil)" for OnTableFileCreationCompleted() if the flush does not produce any L0. This can happen if the file is empty thus delete by RocksDB. - -### Default Option Changes -* Changed the default value of periodic_compaction_seconds to `UINT64_MAX - 1` which allows RocksDB to auto-tune periodic compaction scheduling. When using the default value, periodic compactions are now auto-enabled if a compaction filter is used. A value of `0` will turn off the feature completely. -* Changed the default value of ttl to `UINT64_MAX - 1` which allows RocksDB to auto-tune ttl value. When using the default value, TTL will be auto-enabled to 30 days, when the feature is supported. To revert the old behavior, you can explicitly set it to 0. - -### Performance Improvements -* For 64-bit hashing, RocksDB is standardizing on a slightly modified preview version of XXH3. This function is now used for many non-persisted hashes, along with fastrange64() in place of the modulus operator, and some benchmarks show a slight improvement. -* Level iterator to invlidate the iterator more often in prefix seek and the level is filtered out by prefix bloom. - -## 6.5.2 (2019-11-15) -### Bug Fixes -* Fix a assertion failure in MultiGet() when BlockBasedTableOptions::no_block_cache is true and there is no compressed block cache -* Fix a buffer overrun problem in BlockBasedTable::MultiGet() when compression is enabled and no compressed block cache is configured. -* If a call to BackupEngine::PurgeOldBackups or BackupEngine::DeleteBackup suffered a crash, power failure, or I/O error, files could be left over from old backups that could only be purged with a call to GarbageCollect. Any call to PurgeOldBackups, DeleteBackup, or GarbageCollect should now suffice to purge such files. - -## 6.5.1 (2019-10-16) -### Bug Fixes -* Revert the feature "Merging iterator to avoid child iterator reseek for some cases (#5286)" since it might cause strange results when reseek happens with a different iterator upper bound. -* Fix a bug in BlockBasedTableIterator that might return incorrect results when reseek happens with a different iterator upper bound. -* Fix a bug when partitioned filters and prefix search are used in conjunction, ::SeekForPrev could return invalid for an existing prefix. ::SeekForPrev might be called by the user, or internally on ::Prev, or within ::Seek if the return value involves Delete or a Merge operand. - -## 6.5.0 (2019-09-13) -### Bug Fixes -* Fixed a number of data races in BlobDB. -* Fix a bug where the compaction snapshot refresh feature is not disabled as advertised when `snap_refresh_nanos` is set to 0.. -* Fix bloom filter lookups by the MultiGet batching API when BlockBasedTableOptions::whole_key_filtering is false, by checking that a key is in the perfix_extractor domain and extracting the prefix before looking up. -* Fix a bug in file ingestion caused by incorrect file number allocation when the number of column families involved in the ingestion exceeds 2. - -### New Features -* Introduced DBOptions::max_write_batch_group_size_bytes to configure maximum limit on number of bytes that are written in a single batch of WAL or memtable write. It is followed when the leader write size is larger than 1/8 of this limit. -* VerifyChecksum() by default will issue readahead. Allow ReadOptions to be passed in to those functions to override the readhead size. For checksum verifying before external SST file ingestion, a new option IngestExternalFileOptions.verify_checksums_readahead_size, is added for this readahead setting. -* When user uses options.force_consistency_check in RocksDb, instead of crashing the process, we now pass the error back to the users without killing the process. -* Add an option `memtable_insert_hint_per_batch` to WriteOptions. If it is true, each WriteBatch will maintain its own insert hints for each memtable in concurrent write. See include/rocksdb/options.h for more details. - -### Public API Change -* Added max_write_buffer_size_to_maintain option to better control memory usage of immutable memtables. -* Added a lightweight API GetCurrentWalFile() to get last live WAL filename and size. Meant to be used as a helper for backup/restore tooling in a larger ecosystem such as MySQL with a MyRocks storage engine. -* The MemTable Bloom filter, when enabled, now always uses cache locality. Options::bloom_locality now only affects the PlainTable SST format. - -### Performance Improvements -* Improve the speed of the MemTable Bloom filter, reducing the write overhead of enabling it by 1/3 to 1/2, with similar benefit to read performance. - -## 6.4.0 (2019-07-30) -### Default Option Change -* LRUCacheOptions.high_pri_pool_ratio is set to 0.5 (previously 0.0) by default, which means that by default midpoint insertion is enabled. The same change is made for the default value of high_pri_pool_ratio argument in NewLRUCache(). When block cache is not explicitly created, the small block cache created by BlockBasedTable will still has this option to be 0.0. -* Change BlockBasedTableOptions.cache_index_and_filter_blocks_with_high_priority's default value from false to true. - -### Public API Change -* Filter and compression dictionary blocks are now handled similarly to data blocks with regards to the block cache: instead of storing objects in the cache, only the blocks themselves are cached. In addition, filter and compression dictionary blocks (as well as filter partitions) no longer get evicted from the cache when a table is closed. -* Due to the above refactoring, block cache eviction statistics for filter and compression dictionary blocks are temporarily broken. We plan to reintroduce them in a later phase. -* The semantics of the per-block-type block read counts in the performance context now match those of the generic block_read_count. -* Errors related to the retrieval of the compression dictionary are now propagated to the user. -* db_bench adds a "benchmark" stats_history, which prints out the whole stats history. -* Overload GetAllKeyVersions() to support non-default column family. -* Added new APIs ExportColumnFamily() and CreateColumnFamilyWithImport() to support export and import of a Column Family. https://github.com/facebook/rocksdb/issues/3469 -* ldb sometimes uses a string-append merge operator if no merge operator is passed in. This is to allow users to print keys from a DB with a merge operator. -* Replaces old Registra with ObjectRegistry to allow user to create custom object from string, also add LoadEnv() to Env. -* Added new overload of GetApproximateSizes which gets SizeApproximationOptions object and returns a Status. The older overloads are redirecting their calls to this new method and no longer assert if the include_flags doesn't have either of INCLUDE_MEMTABLES or INCLUDE_FILES bits set. It's recommended to use the new method only, as it is more type safe and returns a meaningful status in case of errors. -* LDBCommandRunner::RunCommand() to return the status code as an integer, rather than call exit() using the code. - -### New Features -* Add argument `--secondary_path` to ldb to open the database as the secondary instance. This would keep the original DB intact. -* Compression dictionary blocks are now prefetched and pinned in the cache (based on the customer's settings) the same way as index and filter blocks. -* Added DBOptions::log_readahead_size which specifies the number of bytes to prefetch when reading the log. This is mostly useful for reading a remotely located log, as it can save the number of round-trips. If 0 (default), then the prefetching is disabled. -* Added new option in SizeApproximationOptions used with DB::GetApproximateSizes. When approximating the files total size that is used to store a keys range, allow approximation with an error margin of up to total_files_size * files_size_error_margin. This allows to take some shortcuts in files size approximation, resulting in better performance, while guaranteeing the resulting error is within a reasonable margin. -* Support loading custom objects in unit tests. In the affected unit tests, RocksDB will create custom Env objects based on environment variable TEST_ENV_URI. Users need to make sure custom object types are properly registered. For example, a static library should expose a `RegisterCustomObjects` function. By linking the unit test binary with the static library, the unit test can execute this function. - -### Performance Improvements -* Reduce iterator key comparison for upper/lower bound check. -* Improve performance of row_cache: make reads with newer snapshots than data in an SST file share the same cache key, except in some transaction cases. -* The compression dictionary is no longer copied to a new object upon retrieval. - -### Bug Fixes -* Fix ingested file and directory not being fsync. -* Return TryAgain status in place of Corruption when new tail is not visible to TransactionLogIterator. -* Fixed a regression where the fill_cache read option also affected index blocks. -* Fixed an issue where using cache_index_and_filter_blocks==false affected partitions of partitioned indexes/filters as well. - -## 6.3.2 (2019-08-15) -### Public API Change -* The semantics of the per-block-type block read counts in the performance context now match those of the generic block_read_count. - -### Bug Fixes -* Fixed a regression where the fill_cache read option also affected index blocks. -* Fixed an issue where using cache_index_and_filter_blocks==false affected partitions of partitioned indexes as well. - -## 6.3.1 (2019-07-24) -### Bug Fixes -* Fix auto rolling bug introduced in 6.3.0, which causes segfault if log file creation fails. - -## 6.3.0 (2019-06-18) -### Public API Change -* Now DB::Close() will return Aborted() error when there is unreleased snapshot. Users can retry after all snapshots are released. -* Index blocks are now handled similarly to data blocks with regards to the block cache: instead of storing objects in the cache, only the blocks themselves are cached. In addition, index blocks no longer get evicted from the cache when a table is closed, can now use the compressed block cache (if any), and can be shared among multiple table readers. -* Partitions of partitioned indexes no longer affect the read amplification statistics. -* Due to the above refactoring, block cache eviction statistics for indexes are temporarily broken. We plan to reintroduce them in a later phase. -* options.keep_log_file_num will be enforced strictly all the time. File names of all log files will be tracked, which may take significantly amount of memory if options.keep_log_file_num is large and either of options.max_log_file_size or options.log_file_time_to_roll is set. -* Add initial support for Get/Put with user timestamps. Users can specify timestamps via ReadOptions and WriteOptions when calling DB::Get and DB::Put. -* Accessing a partition of a partitioned filter or index through a pinned reference is no longer considered a cache hit. -* Add C bindings for secondary instance, i.e. DBImplSecondary. -* Rate limited deletion of WALs is only enabled if DBOptions::wal_dir is not set, or explicitly set to db_name passed to DB::Open and DBOptions::db_paths is empty, or same as db_paths[0].path - -### New Features -* Add an option `snap_refresh_nanos` (default to 0) to periodically refresh the snapshot list in compaction jobs. Assign to 0 to disable the feature. -* Add an option `unordered_write` which trades snapshot guarantees with higher write throughput. When used with WRITE_PREPARED transactions with two_write_queues=true, it offers higher throughput with however no compromise on guarantees. -* Allow DBImplSecondary to remove memtables with obsolete data after replaying MANIFEST and WAL. -* Add an option `failed_move_fall_back_to_copy` (default is true) for external SST ingestion. When `move_files` is true and hard link fails, ingestion falls back to copy if `failed_move_fall_back_to_copy` is true. Otherwise, ingestion reports an error. -* Add command `list_file_range_deletes` in ldb, which prints out tombstones in SST files. - -### Performance Improvements -* Reduce binary search when iterator reseek into the same data block. -* DBIter::Next() can skip user key checking if previous entry's seqnum is 0. -* Merging iterator to avoid child iterator reseek for some cases -* Log Writer will flush after finishing the whole record, rather than a fragment. -* Lower MultiGet batching API latency by reading data blocks from disk in parallel - -### General Improvements -* Added new status code kColumnFamilyDropped to distinguish between Column Family Dropped and DB Shutdown in progress. -* Improve ColumnFamilyOptions validation when creating a new column family. - -### Bug Fixes -* Fix a bug in WAL replay of secondary instance by skipping write batches with older sequence numbers than the current last sequence number. -* Fix flush's/compaction's merge processing logic which allowed `Put`s covered by range tombstones to reappear. Note `Put`s may exist even if the user only ever called `Merge()` due to an internal conversion during compaction to the bottommost level. -* Fix/improve memtable earliest sequence assignment and WAL replay so that WAL entries of unflushed column families will not be skipped after replaying the MANIFEST and increasing db sequence due to another flushed/compacted column family. -* Fix a bug caused by secondary not skipping the beginning of new MANIFEST. -* On DB open, delete WAL trash files left behind in wal_dir - -## 6.2.0 (2019-04-30) -### New Features -* Add an option `strict_bytes_per_sync` that causes a file-writing thread to block rather than exceed the limit on bytes pending writeback specified by `bytes_per_sync` or `wal_bytes_per_sync`. -* Improve range scan performance by avoiding per-key upper bound check in BlockBasedTableIterator. -* Introduce Periodic Compaction for Level style compaction. Files are re-compacted periodically and put in the same level. -* Block-based table index now contains exact highest key in the file, rather than an upper bound. This may improve Get() and iterator Seek() performance in some situations, especially when direct IO is enabled and block cache is disabled. A setting BlockBasedTableOptions::index_shortening is introduced to control this behavior. Set it to kShortenSeparatorsAndSuccessor to get the old behavior. -* When reading from option file/string/map, customized envs can be filled according to object registry. -* Improve range scan performance when using explicit user readahead by not creating new table readers for every iterator. -* Add index type BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey. It significantly reduces read amplification in some setups, especially for iterator seeks. It's not fully implemented yet: IO errors are not handled right. - -### Public API Change -* Change the behavior of OptimizeForPointLookup(): move away from hash-based block-based-table index, and use whole key memtable filtering. -* Change the behavior of OptimizeForSmallDb(): use a 16MB block cache, put index and filter blocks into it, and cost the memtable size to it. DBOptions.OptimizeForSmallDb() and ColumnFamilyOptions.OptimizeForSmallDb() start to take an optional cache object. -* Added BottommostLevelCompaction::kForceOptimized to avoid double compacting newly compacted files in the bottommost level compaction of manual compaction. Note this option may prohibit the manual compaction to produce a single file in the bottommost level. - -### Bug Fixes -* Adjust WriteBufferManager's dummy entry size to block cache from 1MB to 256KB. -* Fix a race condition between WritePrepared::Get and ::Put with duplicate keys. -* Fix crash when memtable prefix bloom is enabled and read/write a key out of domain of prefix extractor. -* Close a WAL file before another thread deletes it. -* Fix an assertion failure `IsFlushPending() == true` caused by one bg thread releasing the db mutex in ~ColumnFamilyData and another thread clearing `flush_requested_` flag. - -## 6.1.1 (2019-04-09) -### New Features -* When reading from option file/string/map, customized comparators and/or merge operators can be filled according to object registry. - -### Public API Change - -### Bug Fixes -* Fix a bug in 2PC where a sequence of txn prepare, memtable flush, and crash could result in losing the prepared transaction. -* Fix a bug in Encryption Env which could cause encrypted files to be read beyond file boundaries. - -## 6.1.0 (2019-03-27) -### New Features -* Introduce two more stats levels, kExceptHistogramOrTimers and kExceptTimers. -* Added a feature to perform data-block sampling for compressibility, and report stats to user. -* Add support for trace filtering. -* Add DBOptions.avoid_unnecessary_blocking_io. If true, we avoid file deletion when destroying ColumnFamilyHandle and Iterator. Instead, a job is scheduled to delete the files in background. - -### Public API Change -* Remove bundled fbson library. -* statistics.stats_level_ becomes atomic. It is preferred to use statistics.set_stats_level() and statistics.get_stats_level() to access it. -* Introduce a new IOError subcode, PathNotFound, to indicate trying to open a nonexistent file or directory for read. -* Add initial support for multiple db instances sharing the same data in single-writer, multi-reader mode. -* Removed some "using std::xxx" from public headers. - -### Bug Fixes -* Fix JEMALLOC_CXX_THROW macro missing from older Jemalloc versions, causing build failures on some platforms. -* Fix SstFileReader not able to open file ingested with write_glbal_seqno=true. - -## 6.0.0 (2019-02-19) -### New Features -* Enabled checkpoint on readonly db (DBImplReadOnly). -* Make DB ignore dropped column families while committing results of atomic flush. -* RocksDB may choose to preopen some files even if options.max_open_files != -1. This may make DB open slightly longer. -* For users of dictionary compression with ZSTD v0.7.0+, we now reuse the same digested dictionary when compressing each of an SST file's data blocks for faster compression speeds. -* For all users of dictionary compression who set `cache_index_and_filter_blocks == true`, we now store dictionary data used for decompression in the block cache for better control over memory usage. For users of ZSTD v1.1.4+ who compile with -DZSTD_STATIC_LINKING_ONLY, this includes a digested dictionary, which is used to increase decompression speed. -* Add support for block checksums verification for external SST files before ingestion. -* Introduce stats history which periodically saves Statistics snapshots and added `GetStatsHistory` API to retrieve these snapshots. -* Add a place holder in manifest which indicate a record from future that can be safely ignored. -* Add support for trace sampling. -* Enable properties block checksum verification for block-based tables. -* For all users of dictionary compression, we now generate a separate dictionary for compressing each bottom-level SST file. Previously we reused a single dictionary for a whole compaction to bottom level. The new approach achieves better compression ratios; however, it uses more memory and CPU for buffering/sampling data blocks and training dictionaries. -* Add whole key bloom filter support in memtable. -* Files written by `SstFileWriter` will now use dictionary compression if it is configured in the file writer's `CompressionOptions`. - -### Public API Change -* Disallow CompactionFilter::IgnoreSnapshots() = false, because it is not very useful and the behavior is confusing. The filter will filter everything if there is no snapshot declared by the time the compaction starts. However, users can define a snapshot after the compaction starts and before it finishes and this new snapshot won't be repeatable, because after the compaction finishes, some keys may be dropped. -* CompactionPri = kMinOverlappingRatio also uses compensated file size, which boosts file with lots of tombstones to be compacted first. -* Transaction::GetForUpdate is extended with a do_validate parameter with default value of true. If false it skips validating the snapshot before doing the read. Similarly ::Merge, ::Put, ::Delete, and ::SingleDelete are extended with assume_tracked with default value of false. If true it indicates that call is assumed to be after a ::GetForUpdate. -* `TableProperties::num_entries` and `TableProperties::num_deletions` now also account for number of range tombstones. -* Remove geodb, spatial_db, document_db, json_document, date_tiered_db, and redis_lists. -* With "ldb ----try_load_options", when wal_dir specified by the option file doesn't exist, ignore it. -* Change time resolution in FileOperationInfo. -* Deleting Blob files also go through SStFileManager. -* Remove CuckooHash memtable. -* The counter stat `number.block.not_compressed` now also counts blocks not compressed due to poor compression ratio. -* Remove ttl option from `CompactionOptionsFIFO`. The option has been deprecated and ttl in `ColumnFamilyOptions` is used instead. -* Support SST file ingestion across multiple column families via DB::IngestExternalFiles. See the function's comment about atomicity. -* Remove Lua compaction filter. - -### Bug Fixes -* Fix a deadlock caused by compaction and file ingestion waiting for each other in the event of write stalls. -* Fix a memory leak when files with range tombstones are read in mmap mode and block cache is enabled -* Fix handling of corrupt range tombstone blocks such that corruptions cannot cause deleted keys to reappear -* Lock free MultiGet -* Fix incorrect `NotFound` point lookup result when querying the endpoint of a file that has been extended by a range tombstone. -* Fix with pipelined write, write leaders's callback failure lead to the whole write group fail. - -### Change Default Options -* Change options.compaction_pri's default to kMinOverlappingRatio - -## 5.18.0 (2018-11-30) -### New Features -* Introduced `JemallocNodumpAllocator` memory allocator. When being use, block cache will be excluded from core dump. -* Introduced `PerfContextByLevel` as part of `PerfContext` which allows storing perf context at each level. Also replaced `__thread` with `thread_local` keyword for perf_context. Added per-level perf context for bloom filter and `Get` query. -* With level_compaction_dynamic_level_bytes = true, level multiplier may be adjusted automatically when Level 0 to 1 compaction is lagged behind. -* Introduced DB option `atomic_flush`. If true, RocksDB supports flushing multiple column families and atomically committing the result to MANIFEST. Useful when WAL is disabled. -* Added `num_deletions` and `num_merge_operands` members to `TableProperties`. -* Added "rocksdb.min-obsolete-sst-number-to-keep" DB property that reports the lower bound on SST file numbers that are being kept from deletion, even if the SSTs are obsolete. -* Add xxhash64 checksum support -* Introduced `MemoryAllocator`, which lets the user specify custom memory allocator for block based table. -* Improved `DeleteRange` to prevent read performance degradation. The feature is no longer marked as experimental. - -### Public API Change -* `DBOptions::use_direct_reads` now affects reads issued by `BackupEngine` on the database's SSTs. -* `NO_ITERATORS` is divided into two counters `NO_ITERATOR_CREATED` and `NO_ITERATOR_DELETE`. Both of them are only increasing now, just as other counters. - -### Bug Fixes -* Fix corner case where a write group leader blocked due to write stall blocks other writers in queue with WriteOptions::no_slowdown set. -* Fix in-memory range tombstone truncation to avoid erroneously covering newer keys at a lower level, and include range tombstones in compacted files whose largest key is the range tombstone's start key. -* Properly set the stop key for a truncated manual CompactRange -* Fix slow flush/compaction when DB contains many snapshots. The problem became noticeable to us in DBs with 100,000+ snapshots, though it will affect others at different thresholds. -* Fix the bug that WriteBatchWithIndex's SeekForPrev() doesn't see the entries with the same key. -* Fix the bug where user comparator was sometimes fed with InternalKey instead of the user key. The bug manifests when during GenerateBottommostFiles. -* Fix a bug in WritePrepared txns where if the number of old snapshots goes beyond the snapshot cache size (128 default) the rest will not be checked when evicting a commit entry from the commit cache. -* Fixed Get correctness bug in the presence of range tombstones where merge operands covered by a range tombstone always result in NotFound. -* Start populating `NO_FILE_CLOSES` ticker statistic, which was always zero previously. -* The default value of NewBloomFilterPolicy()'s argument use_block_based_builder is changed to false. Note that this new default may cause large temp memory usage when building very large SST files. - -## 5.17.0 (2018-10-05) -### Public API Change -* `OnTableFileCreated` will now be called for empty files generated during compaction. In that case, `TableFileCreationInfo::file_path` will be "(nil)" and `TableFileCreationInfo::file_size` will be zero. -* Add `FlushOptions::allow_write_stall`, which controls whether Flush calls start working immediately, even if it causes user writes to stall, or will wait until flush can be performed without causing write stall (similar to `CompactRangeOptions::allow_write_stall`). Note that the default value is false, meaning we add delay to Flush calls until stalling can be avoided when possible. This is behavior change compared to previous RocksDB versions, where Flush calls didn't check if they might cause stall or not. -* Application using PessimisticTransactionDB is expected to rollback/commit recovered transactions before starting new ones. This assumption is used to skip concurrency control during recovery. -* Expose column family id to `OnCompactionCompleted`. - -### New Features -* TransactionOptions::skip_concurrency_control allows pessimistic transactions to skip the overhead of concurrency control. Could be used for optimizing certain transactions or during recovery. - -### Bug Fixes -* Avoid creating empty SSTs and subsequently deleting them in certain cases during compaction. -* Sync CURRENT file contents during checkpoint. - -## 5.16.3 (2018-10-01) -### Bug Fixes -* Fix crash caused when `CompactFiles` run with `CompactionOptions::compression == CompressionType::kDisableCompressionOption`. Now that setting causes the compression type to be chosen according to the column family-wide compression options. - -## 5.16.2 (2018-09-21) -### Bug Fixes -* Fix bug in partition filters with format_version=4. - -## 5.16.1 (2018-09-17) -### Bug Fixes -* Remove trace_analyzer_tool from rocksdb_lib target in TARGETS file. -* Fix RocksDB Java build and tests. -* Remove sync point in Block destructor. - -## 5.16.0 (2018-08-21) -### Public API Change -* The merge operands are passed to `MergeOperator::ShouldMerge` in the reversed order relative to how they were merged (passed to FullMerge or FullMergeV2) for performance reasons -* GetAllKeyVersions() to take an extra argument of `max_num_ikeys`. -* Using ZSTD dictionary trainer (i.e., setting `CompressionOptions::zstd_max_train_bytes` to a nonzero value) now requires ZSTD version 1.1.3 or later. - -### New Features -* Changes the format of index blocks by delta encoding the index values, which are the block handles. This saves the encoding of BlockHandle::offset of the non-head index entries in each restart interval. The feature is backward compatible but not forward compatible. It is disabled by default unless format_version 4 or above is used. -* Add a new tool: trace_analyzer. Trace_analyzer analyzes the trace file generated by using trace_replay API. It can convert the binary format trace file to a human readable txt file, output the statistics of the analyzed query types such as access statistics and size statistics, combining the dumped whole key space file to analyze, support query correlation analyzing, and etc. Current supported query types are: Get, Put, Delete, SingleDelete, DeleteRange, Merge, Iterator (Seek, SeekForPrev only). -* Add hash index support to data blocks, which helps reducing the cpu utilization of point-lookup operations. This feature is backward compatible with the data block created without the hash index. It is disabled by default unless BlockBasedTableOptions::data_block_index_type is set to data_block_index_type = kDataBlockBinaryAndHash. - -### Bug Fixes -* Fix a bug in misreporting the estimated partition index size in properties block. - -## 5.15.0 (2018-07-17) -### Public API Change -* Remove managed iterator. ReadOptions.managed is not effective anymore. -* For bottommost_compression, a compatible CompressionOptions is added via `bottommost_compression_opts`. To keep backward compatible, a new boolean `enabled` is added to CompressionOptions. For compression_opts, it will be always used no matter what value of `enabled` is. For bottommost_compression_opts, it will only be used when user set `enabled=true`, otherwise, compression_opts will be used for bottommost_compression as default. -* With LRUCache, when high_pri_pool_ratio > 0, midpoint insertion strategy will be enabled to put low-pri items to the tail of low-pri list (the midpoint) when they first inserted into the cache. This is to make cache entries never get hit age out faster, improving cache efficiency when large background scan presents. -* For users of `Statistics` objects created via `CreateDBStatistics()`, the format of the string returned by its `ToString()` method has changed. -* The "rocksdb.num.entries" table property no longer counts range deletion tombstones as entries. - -### New Features -* Changes the format of index blocks by storing the key in their raw form rather than converting them to InternalKey. This saves 8 bytes per index key. The feature is backward compatible but not forward compatible. It is disabled by default unless format_version 3 or above is used. -* Avoid memcpy when reading mmap files with OpenReadOnly and max_open_files==-1. -* Support dynamically changing `ColumnFamilyOptions::ttl` via `SetOptions()`. -* Add a new table property, "rocksdb.num.range-deletions", which counts the number of range deletion tombstones in the table. -* Improve the performance of iterators doing long range scans by using readahead, when using direct IO. -* pin_top_level_index_and_filter (default true) in BlockBasedTableOptions can be used in combination with cache_index_and_filter_blocks to prefetch and pin the top-level index of partitioned index and filter blocks in cache. It has no impact when cache_index_and_filter_blocks is false. -* Write properties meta-block at the end of block-based table to save read-ahead IO. - -### Bug Fixes -* Fix deadlock with enable_pipelined_write=true and max_successive_merges > 0 -* Check conflict at output level in CompactFiles. -* Fix corruption in non-iterator reads when mmap is used for file reads -* Fix bug with prefix search in partition filters where a shared prefix would be ignored from the later partitions. The bug could report an eixstent key as missing. The bug could be triggered if prefix_extractor is set and partition filters is enabled. -* Change default value of `bytes_max_delete_chunk` to 0 in NewSstFileManager() as it doesn't work well with checkpoints. -* Fix a bug caused by not copying the block trailer with compressed SST file, direct IO, prefetcher and no compressed block cache. -* Fix write can stuck indefinitely if enable_pipelined_write=true. The issue exists since pipelined write was introduced in 5.5.0. - -## 5.14.0 (2018-05-16) -### Public API Change -* Add a BlockBasedTableOption to align uncompressed data blocks on the smaller of block size or page size boundary, to reduce flash reads by avoiding reads spanning 4K pages. -* The background thread naming convention changed (on supporting platforms) to "rocksdb:", e.g., "rocksdb:low0". -* Add a new ticker stat rocksdb.number.multiget.keys.found to count number of keys successfully read in MultiGet calls -* Touch-up to write-related counters in PerfContext. New counters added: write_scheduling_flushes_compactions_time, write_thread_wait_nanos. Counters whose behavior was fixed or modified: write_memtable_time, write_pre_and_post_process_time, write_delay_time. -* Posix Env's NewRandomRWFile() will fail if the file doesn't exist. -* Now, `DBOptions::use_direct_io_for_flush_and_compaction` only applies to background writes, and `DBOptions::use_direct_reads` applies to both user reads and background reads. This conforms with Linux's `open(2)` manpage, which advises against simultaneously reading a file in buffered and direct modes, due to possibly undefined behavior and degraded performance. -* Iterator::Valid() always returns false if !status().ok(). So, now when doing a Seek() followed by some Next()s, there's no need to check status() after every operation. -* Iterator::Seek()/SeekForPrev()/SeekToFirst()/SeekToLast() always resets status(). -* Introduced `CompressionOptions::kDefaultCompressionLevel`, which is a generic way to tell RocksDB to use the compression library's default level. It is now the default value for `CompressionOptions::level`. Previously the level defaulted to -1, which gave poor compression ratios in ZSTD. - -### New Features -* Introduce TTL for level compaction so that all files older than ttl go through the compaction process to get rid of old data. -* TransactionDBOptions::write_policy can be configured to enable WritePrepared 2PC transactions. Read more about them in the wiki. -* Add DB properties "rocksdb.block-cache-capacity", "rocksdb.block-cache-usage", "rocksdb.block-cache-pinned-usage" to show block cache usage. -* Add `Env::LowerThreadPoolCPUPriority(Priority)` method, which lowers the CPU priority of background (esp. compaction) threads to minimize interference with foreground tasks. -* Fsync parent directory after deleting a file in delete scheduler. -* In level-based compaction, if bottom-pri thread pool was setup via `Env::SetBackgroundThreads()`, compactions to the bottom level will be delegated to that thread pool. -* `prefix_extractor` has been moved from ImmutableCFOptions to MutableCFOptions, meaning it can be dynamically changed without a DB restart. - -### Bug Fixes -* Fsync after writing global seq number to the ingestion file in ExternalSstFileIngestionJob. -* Fix WAL corruption caused by race condition between user write thread and FlushWAL when two_write_queue is not set. -* Fix `BackupableDBOptions::max_valid_backups_to_open` to not delete backup files when refcount cannot be accurately determined. -* Fix memory leak when pin_l0_filter_and_index_blocks_in_cache is used with partitioned filters -* Disable rollback of merge operands in WritePrepared transactions to work around an issue in MyRocks. It can be enabled back by setting TransactionDBOptions::rollback_merge_operands to true. -* Fix wrong results by ReverseBytewiseComparator::FindShortSuccessor() - -### Java API Changes -* Add `BlockBasedTableConfig.setBlockCache` to allow sharing a block cache across DB instances. -* Added SstFileManager to the Java API to allow managing SST files across DB instances. - -## 5.13.0 (2018-03-20) -### Public API Change -* RocksDBOptionsParser::Parse()'s `ignore_unknown_options` argument will only be effective if the option file shows it is generated using a higher version of RocksDB than the current version. -* Remove CompactionEventListener. - -### New Features -* SstFileManager now can cancel compactions if they will result in max space errors. SstFileManager users can also use SetCompactionBufferSize to specify how much space must be leftover during a compaction for auxiliary file functions such as logging and flushing. -* Avoid unnecessarily flushing in `CompactRange()` when the range specified by the user does not overlap unflushed memtables. -* If `ColumnFamilyOptions::max_subcompactions` is set greater than one, we now parallelize large manual level-based compactions. -* Add "rocksdb.live-sst-files-size" DB property to return total bytes of all SST files belong to the latest LSM tree. -* NewSstFileManager to add an argument bytes_max_delete_chunk with default 64MB. With this argument, a file larger than 64MB will be ftruncated multiple times based on this size. - -### Bug Fixes -* Fix a leak in prepared_section_completed_ where the zeroed entries would not removed from the map. -* Fix WAL corruption caused by race condition between user write thread and backup/checkpoint thread. - -## 5.12.0 (2018-02-14) -### Public API Change -* Iterator::SeekForPrev is now a pure virtual method. This is to prevent user who implement the Iterator interface fail to implement SeekForPrev by mistake. -* Add `include_end` option to make the range end exclusive when `include_end == false` in `DeleteFilesInRange()`. -* Add `CompactRangeOptions::allow_write_stall`, which makes `CompactRange` start working immediately, even if it causes user writes to stall. The default value is false, meaning we add delay to `CompactRange` calls until stalling can be avoided when possible. Note this delay is not present in previous RocksDB versions. -* Creating checkpoint with empty directory now returns `Status::InvalidArgument`; previously, it returned `Status::IOError`. -* Adds a BlockBasedTableOption to turn off index block compression. -* Close() method now returns a status when closing a db. - -### New Features -* Improve the performance of iterators doing long range scans by using readahead. -* Add new function `DeleteFilesInRanges()` to delete files in multiple ranges at once for better performance. -* FreeBSD build support for RocksDB and RocksJava. -* Improved performance of long range scans with readahead. -* Updated to and now continuously tested in Visual Studio 2017. - -### Bug Fixes -* Fix `DisableFileDeletions()` followed by `GetSortedWalFiles()` to not return obsolete WAL files that `PurgeObsoleteFiles()` is going to delete. -* Fix Handle error return from WriteBuffer() during WAL file close and DB close. -* Fix advance reservation of arena block addresses. -* Fix handling of empty string as checkpoint directory. - -## 5.11.0 (2018-01-08) -### Public API Change -* Add `autoTune` and `getBytesPerSecond()` to RocksJava RateLimiter - -### New Features -* Add a new histogram stat called rocksdb.db.flush.micros for memtable flush. -* Add "--use_txn" option to use transactional API in db_stress. -* Disable onboard cache for compaction output in Windows platform. -* Improve the performance of iterators doing long range scans by using readahead. - -### Bug Fixes -* Fix a stack-use-after-scope bug in ForwardIterator. -* Fix builds on platforms including Linux, Windows, and PowerPC. -* Fix buffer overrun in backup engine for DBs with huge number of files. -* Fix a mislabel bug for bottom-pri compaction threads. -* Fix DB::Flush() keep waiting after flush finish under certain condition. - -## 5.10.0 (2017-12-11) -### Public API Change -* When running `make` with environment variable `USE_SSE` set and `PORTABLE` unset, will use all machine features available locally. Previously this combination only compiled SSE-related features. - -### New Features -* Provide lifetime hints when writing files on Linux. This reduces hardware write-amp on storage devices supporting multiple streams. -* Add a DB stat, `NUMBER_ITER_SKIP`, which returns how many internal keys were skipped during iterations (e.g., due to being tombstones or duplicate versions of a key). -* Add PerfContext counters, `key_lock_wait_count` and `key_lock_wait_time`, which measure the number of times transactions wait on key locks and total amount of time waiting. - -### Bug Fixes -* Fix IOError on WAL write doesn't propagate to write group follower -* Make iterator invalid on merge error. -* Fix performance issue in `IngestExternalFile()` affecting databases with large number of SST files. -* Fix possible corruption to LSM structure when `DeleteFilesInRange()` deletes a subset of files spanned by a `DeleteRange()` marker. - -## 5.9.0 (2017-11-01) -### Public API Change -* `BackupableDBOptions::max_valid_backups_to_open == 0` now means no backups will be opened during BackupEngine initialization. Previously this condition disabled limiting backups opened. -* `DBOptions::preserve_deletes` is a new option that allows one to specify that DB should not drop tombstones for regular deletes if they have sequence number larger than what was set by the new API call `DB::SetPreserveDeletesSequenceNumber(SequenceNumber seqnum)`. Disabled by default. -* API call `DB::SetPreserveDeletesSequenceNumber(SequenceNumber seqnum)` was added, users who wish to preserve deletes are expected to periodically call this function to advance the cutoff seqnum (all deletes made before this seqnum can be dropped by DB). It's user responsibility to figure out how to advance the seqnum in the way so the tombstones are kept for the desired period of time, yet are eventually processed in time and don't eat up too much space. -* `ReadOptions::iter_start_seqnum` was added; -if set to something > 0 user will see 2 changes in iterators behavior 1) only keys written with sequence larger than this parameter would be returned and 2) the `Slice` returned by iter->key() now points to the memory that keep User-oriented representation of the internal key, rather than user key. New struct `FullKey` was added to represent internal keys, along with a new helper function `ParseFullKey(const Slice& internal_key, FullKey* result);`. -* Deprecate trash_dir param in NewSstFileManager, right now we will rename deleted files to .trash instead of moving them to trash directory -* Allow setting a custom trash/DB size ratio limit in the SstFileManager, after which files that are to be scheduled for deletion are deleted immediately, regardless of any delete ratelimit. -* Return an error on write if write_options.sync = true and write_options.disableWAL = true to warn user of inconsistent options. Previously we will not write to WAL and not respecting the sync options in this case. - -### New Features -* CRC32C is now using the 3-way pipelined SSE algorithm `crc32c_3way` on supported platforms to improve performance. The system will choose to use this algorithm on supported platforms automatically whenever possible. If PCLMULQDQ is not supported it will fall back to the old Fast_CRC32 algorithm. -* `DBOptions::writable_file_max_buffer_size` can now be changed dynamically. -* `DBOptions::bytes_per_sync`, `DBOptions::compaction_readahead_size`, and `DBOptions::wal_bytes_per_sync` can now be changed dynamically, `DBOptions::wal_bytes_per_sync` will flush all memtables and switch to a new WAL file. -* Support dynamic adjustment of rate limit according to demand for background I/O. It can be enabled by passing `true` to the `auto_tuned` parameter in `NewGenericRateLimiter()`. The value passed as `rate_bytes_per_sec` will still be respected as an upper-bound. -* Support dynamically changing `ColumnFamilyOptions::compaction_options_fifo`. -* Introduce `EventListener::OnStallConditionsChanged()` callback. Users can implement it to be notified when user writes are stalled, stopped, or resumed. -* Add a new db property "rocksdb.estimate-oldest-key-time" to return oldest data timestamp. The property is available only for FIFO compaction with compaction_options_fifo.allow_compaction = false. -* Upon snapshot release, recompact bottommost files containing deleted/overwritten keys that previously could not be dropped due to the snapshot. This alleviates space-amp caused by long-held snapshots. -* Support lower bound on iterators specified via `ReadOptions::iterate_lower_bound`. -* Support for differential snapshots (via iterator emitting the sequence of key-values representing the difference between DB state at two different sequence numbers). Supports preserving and emitting puts and regular deletes, doesn't support SingleDeletes, MergeOperator, Blobs and Range Deletes. - -### Bug Fixes -* Fix a potential data inconsistency issue during point-in-time recovery. `DB:Open()` will abort if column family inconsistency is found during PIT recovery. -* Fix possible metadata corruption in databases using `DeleteRange()`. - -## 5.8.0 (2017-08-30) -### Public API Change -* Users of `Statistics::getHistogramString()` will see fewer histogram buckets and different bucket endpoints. -* `Slice::compare` and BytewiseComparator `Compare` no longer accept `Slice`s containing nullptr. -* `Transaction::Get` and `Transaction::GetForUpdate` variants with `PinnableSlice` added. - -### New Features -* Add Iterator::Refresh(), which allows users to update the iterator state so that they can avoid some initialization costs of recreating iterators. -* Replace dynamic_cast<> (except unit test) so people can choose to build with RTTI off. With make, release mode is by default built with -fno-rtti and debug mode is built without it. Users can override it by setting USE_RTTI=0 or 1. -* Universal compactions including the bottom level can be executed in a dedicated thread pool. This alleviates head-of-line blocking in the compaction queue, which cause write stalling, particularly in multi-instance use cases. Users can enable this feature via `Env::SetBackgroundThreads(N, Env::Priority::BOTTOM)`, where `N > 0`. -* Allow merge operator to be called even with a single merge operand during compactions, by appropriately overriding `MergeOperator::AllowSingleOperand`. -* Add `DB::VerifyChecksum()`, which verifies the checksums in all SST files in a running DB. -* Block-based table support for disabling checksums by setting `BlockBasedTableOptions::checksum = kNoChecksum`. - -### Bug Fixes -* Fix wrong latencies in `rocksdb.db.get.micros`, `rocksdb.db.write.micros`, and `rocksdb.sst.read.micros`. -* Fix incorrect dropping of deletions during intra-L0 compaction. -* Fix transient reappearance of keys covered by range deletions when memtable prefix bloom filter is enabled. -* Fix potentially wrong file smallest key when range deletions separated by snapshot are written together. - -## 5.7.0 (2017-07-13) -### Public API Change -* DB property "rocksdb.sstables" now prints keys in hex form. - -### New Features -* Measure estimated number of reads per file. The information can be accessed through DB::GetColumnFamilyMetaData or "rocksdb.sstables" DB property. -* RateLimiter support for throttling background reads, or throttling the sum of background reads and writes. This can give more predictable I/O usage when compaction reads more data than it writes, e.g., due to lots of deletions. -* [Experimental] FIFO compaction with TTL support. It can be enabled by setting CompactionOptionsFIFO.ttl > 0. -* Introduce `EventListener::OnBackgroundError()` callback. Users can implement it to be notified of errors causing the DB to enter read-only mode, and optionally override them. -* Partitioned Index/Filters exiting the experimental mode. To enable partitioned indexes set index_type to kTwoLevelIndexSearch and to further enable partitioned filters set partition_filters to true. To configure the partition size set metadata_block_size. - - -### Bug Fixes -* Fix discarding empty compaction output files when `DeleteRange()` is used together with subcompactions. - -## 5.6.0 (2017-06-06) -### Public API Change -* Scheduling flushes and compactions in the same thread pool is no longer supported by setting `max_background_flushes=0`. Instead, users can achieve this by configuring their high-pri thread pool to have zero threads. -* Replace `Options::max_background_flushes`, `Options::max_background_compactions`, and `Options::base_background_compactions` all with `Options::max_background_jobs`, which automatically decides how many threads to allocate towards flush/compaction. -* options.delayed_write_rate by default take the value of options.rate_limiter rate. -* Replace global variable `IOStatsContext iostats_context` with `IOStatsContext* get_iostats_context()`; replace global variable `PerfContext perf_context` with `PerfContext* get_perf_context()`. - -### New Features -* Change ticker/histogram statistics implementations to use core-local storage. This improves aggregation speed compared to our previous thread-local approach, particularly for applications with many threads. -* Users can pass a cache object to write buffer manager, so that they can cap memory usage for memtable and block cache using one single limit. -* Flush will be triggered when 7/8 of the limit introduced by write_buffer_manager or db_write_buffer_size is triggered, so that the hard threshold is hard to hit. -* Introduce WriteOptions.low_pri. If it is true, low priority writes will be throttled if the compaction is behind. -* `DB::IngestExternalFile()` now supports ingesting files into a database containing range deletions. - -### Bug Fixes -* Shouldn't ignore return value of fsync() in flush. - -## 5.5.0 (2017-05-17) -### New Features -* FIFO compaction to support Intra L0 compaction too with CompactionOptionsFIFO.allow_compaction=true. -* DB::ResetStats() to reset internal stats. -* Statistics::Reset() to reset user stats. -* ldb add option --try_load_options, which will open DB with its own option file. -* Introduce WriteBatch::PopSavePoint to pop the most recent save point explicitly. -* Support dynamically change `max_open_files` option via SetDBOptions() -* Added DB::CreateColumnFamilie() and DB::DropColumnFamilies() to bulk create/drop column families. -* Add debugging function `GetAllKeyVersions` to see internal versions of a range of keys. -* Support file ingestion with universal compaction style -* Support file ingestion behind with option `allow_ingest_behind` -* New option enable_pipelined_write which may improve write throughput in case writing from multiple threads and WAL enabled. - -### Bug Fixes -* Fix the bug that Direct I/O uses direct reads for non-SST file - -## 5.4.0 (2017-04-11) -### Public API Change -* random_access_max_buffer_size no longer has any effect -* Removed Env::EnableReadAhead(), Env::ShouldForwardRawRequest() -* Support dynamically change `stats_dump_period_sec` option via SetDBOptions(). -* Added ReadOptions::max_skippable_internal_keys to set a threshold to fail a request as incomplete when too many keys are being skipped when using iterators. -* DB::Get in place of std::string accepts PinnableSlice, which avoids the extra memcpy of value to std::string in most of cases. - * PinnableSlice releases the pinned resources that contain the value when it is destructed or when ::Reset() is called on it. - * The old API that accepts std::string, although discouraged, is still supported. -* Replace Options::use_direct_writes with Options::use_direct_io_for_flush_and_compaction. Read Direct IO wiki for details. -* Added CompactionEventListener and EventListener::OnFlushBegin interfaces. - -### New Features -* Memtable flush can be avoided during checkpoint creation if total log file size is smaller than a threshold specified by the user. -* Introduce level-based L0->L0 compactions to reduce file count, so write delays are incurred less often. -* (Experimental) Partitioning filters which creates an index on the partitions. The feature can be enabled by setting partition_filters when using kFullFilter. Currently the feature also requires two-level indexing to be enabled. Number of partitions is the same as the number of partitions for indexes, which is controlled by metadata_block_size. - -## 5.3.0 (2017-03-08) -### Public API Change -* Remove disableDataSync option. -* Remove timeout_hint_us option from WriteOptions. The option has been deprecated and has no effect since 3.13.0. -* Remove option min_partial_merge_operands. Partial merge operands will always be merged in flush or compaction if there are more than one. -* Remove option verify_checksums_in_compaction. Compaction will always verify checksum. - -### Bug Fixes -* Fix the bug that iterator may skip keys - -## 5.2.0 (2017-02-08) -### Public API Change -* NewLRUCache() will determine number of shard bits automatically based on capacity, if the user doesn't pass one. This also impacts the default block cache when the user doesn't explicit provide one. -* Change the default of delayed slowdown value to 16MB/s and further increase the L0 stop condition to 36 files. -* Options::use_direct_writes and Options::use_direct_reads are now ready to use. -* (Experimental) Two-level indexing that partition the index and creates a 2nd level index on the partitions. The feature can be enabled by setting kTwoLevelIndexSearch as IndexType and configuring index_per_partition. - -### New Features -* Added new overloaded function GetApproximateSizes that allows to specify if memtable stats should be computed only without computing SST files' stats approximations. -* Added new function GetApproximateMemTableStats that approximates both number of records and size of memtables. -* Add Direct I/O mode for SST file I/O - -### Bug Fixes -* RangeSync() should work if ROCKSDB_FALLOCATE_PRESENT is not set -* Fix wrong results in a data race case in Get() -* Some fixes related to 2PC. -* Fix bugs of data corruption in direct I/O - -## 5.1.0 (2017-01-13) -* Support dynamically change `delete_obsolete_files_period_micros` option via SetDBOptions(). -* Added EventListener::OnExternalFileIngested which will be called when IngestExternalFile() add a file successfully. -* BackupEngine::Open and BackupEngineReadOnly::Open now always return error statuses matching those of the backup Env. - -### Bug Fixes -* Fix the bug that if 2PC is enabled, checkpoints may loss some recent transactions. -* When file copying is needed when creating checkpoints or bulk loading files, fsync the file after the file copying. - -## 5.0.0 (2016-11-17) -### Public API Change -* Options::max_bytes_for_level_multiplier is now a double along with all getters and setters. -* Support dynamically change `delayed_write_rate` and `max_total_wal_size` options via SetDBOptions(). -* Introduce DB::DeleteRange for optimized deletion of large ranges of contiguous keys. -* Support dynamically change `delayed_write_rate` option via SetDBOptions(). -* Options::allow_concurrent_memtable_write and Options::enable_write_thread_adaptive_yield are now true by default. -* Remove Tickers::SEQUENCE_NUMBER to avoid confusion if statistics object is shared among RocksDB instance. Alternatively DB::GetLatestSequenceNumber() can be used to get the same value. -* Options.level0_stop_writes_trigger default value changes from 24 to 32. -* New compaction filter API: CompactionFilter::FilterV2(). Allows to drop ranges of keys. -* Removed flashcache support. -* DB::AddFile() is deprecated and is replaced with DB::IngestExternalFile(). DB::IngestExternalFile() remove all the restrictions that existed for DB::AddFile. - -### New Features -* Add avoid_flush_during_shutdown option, which speeds up DB shutdown by not flushing unpersisted data (i.e. with disableWAL = true). Unpersisted data will be lost. The options is dynamically changeable via SetDBOptions(). -* Add memtable_insert_with_hint_prefix_extractor option. The option is mean to reduce CPU usage for inserting keys into memtable, if keys can be group by prefix and insert for each prefix are sequential or almost sequential. See include/rocksdb/options.h for more details. -* Add LuaCompactionFilter in utilities. This allows developers to write compaction filters in Lua. To use this feature, LUA_PATH needs to be set to the root directory of Lua. -* No longer populate "LATEST_BACKUP" file in backup directory, which formerly contained the number of the latest backup. The latest backup can be determined by finding the highest numbered file in the "meta/" subdirectory. - -## 4.13.0 (2016-10-18) -### Public API Change -* DB::GetOptions() reflect dynamic changed options (i.e. through DB::SetOptions()) and return copy of options instead of reference. -* Added Statistics::getAndResetTickerCount(). - -### New Features -* Add DB::SetDBOptions() to dynamic change base_background_compactions and max_background_compactions. -* Added Iterator::SeekForPrev(). This new API will seek to the last key that less than or equal to the target key. - -## 4.12.0 (2016-09-12) -### Public API Change -* CancelAllBackgroundWork() flushes all memtables for databases containing writes that have bypassed the WAL (writes issued with WriteOptions::disableWAL=true) before shutting down background threads. -* Merge options source_compaction_factor, max_grandparent_overlap_bytes and expanded_compaction_factor into max_compaction_bytes. -* Remove ImmutableCFOptions. -* Add a compression type ZSTD, which can work with ZSTD 0.8.0 or up. Still keep ZSTDNotFinal for compatibility reasons. - -### New Features -* Introduce NewClockCache, which is based on CLOCK algorithm with better concurrent performance in some cases. It can be used to replace the default LRU-based block cache and table cache. To use it, RocksDB need to be linked with TBB lib. -* Change ticker/histogram statistics implementations to accumulate data in thread-local storage, which improves CPU performance by reducing cache coherency costs. Callers of CreateDBStatistics do not need to change anything to use this feature. -* Block cache mid-point insertion, where index and filter block are inserted into LRU block cache with higher priority. The feature can be enabled by setting BlockBasedTableOptions::cache_index_and_filter_blocks_with_high_priority to true and high_pri_pool_ratio > 0 when creating NewLRUCache. - -## 4.11.0 (2016-08-01) -### Public API Change -* options.memtable_prefix_bloom_huge_page_tlb_size => memtable_huge_page_size. When it is set, RocksDB will try to allocate memory from huge page for memtable too, rather than just memtable bloom filter. - -### New Features -* A tool to migrate DB after options change. See include/rocksdb/utilities/option_change_migration.h. -* Add ReadOptions.background_purge_on_iterator_cleanup. If true, we avoid file deletion when destroying iterators. - -## 4.10.0 (2016-07-05) -### Public API Change -* options.memtable_prefix_bloom_bits changes to options.memtable_prefix_bloom_bits_ratio and deprecate options.memtable_prefix_bloom_probes -* enum type CompressionType and PerfLevel changes from char to unsigned char. Value of all PerfLevel shift by one. -* Deprecate options.filter_deletes. - -### New Features -* Add avoid_flush_during_recovery option. -* Add a read option background_purge_on_iterator_cleanup to avoid deleting files in foreground when destroying iterators. Instead, a job is scheduled in high priority queue and would be executed in a separate background thread. -* RepairDB support for column families. RepairDB now associates data with non-default column families using information embedded in the SST/WAL files (4.7 or later). For data written by 4.6 or earlier, RepairDB associates it with the default column family. -* Add options.write_buffer_manager which allows users to control total memtable sizes across multiple DB instances. - -## 4.9.0 (2016-06-09) -### Public API changes -* Add bottommost_compression option, This option can be used to set a specific compression algorithm for the bottommost level (Last level containing files in the DB). -* Introduce CompactionJobInfo::compression, This field state the compression algorithm used to generate the output files of the compaction. -* Deprecate BlockBaseTableOptions.hash_index_allow_collision=false -* Deprecate options builder (GetOptions()). - -### New Features -* Introduce NewSimCache() in rocksdb/utilities/sim_cache.h. This function creates a block cache that is able to give simulation results (mainly hit rate) of simulating block behavior with a configurable cache size. - -## 4.8.0 (2016-05-02) -### Public API Change -* Allow preset compression dictionary for improved compression of block-based tables. This is supported for zlib, zstd, and lz4. The compression dictionary's size is configurable via CompressionOptions::max_dict_bytes. -* Delete deprecated classes for creating backups (BackupableDB) and restoring from backups (RestoreBackupableDB). Now, BackupEngine should be used for creating backups, and BackupEngineReadOnly should be used for restorations. For more details, see https://github.com/facebook/rocksdb/wiki/How-to-backup-RocksDB%3F -* Expose estimate of per-level compression ratio via DB property: "rocksdb.compression-ratio-at-levelN". -* Added EventListener::OnTableFileCreationStarted. EventListener::OnTableFileCreated will be called on failure case. User can check creation status via TableFileCreationInfo::status. - -### New Features -* Add ReadOptions::readahead_size. If non-zero, NewIterator will create a new table reader which performs reads of the given size. - -## 4.7.0 (2016-04-08) -### Public API Change -* rename options compaction_measure_io_stats to report_bg_io_stats and include flush too. -* Change some default options. Now default options will optimize for server-workloads. Also enable slowdown and full stop triggers for pending compaction bytes. These changes may cause sub-optimal performance or significant increase of resource usage. To avoid these risks, users can open existing RocksDB with options extracted from RocksDB option files. See https://github.com/facebook/rocksdb/wiki/RocksDB-Options-File for how to use RocksDB option files. Or you can call Options.OldDefaults() to recover old defaults. DEFAULT_OPTIONS_HISTORY.md will track change history of default options. - -## 4.6.0 (2016-03-10) -### Public API Changes -* Change default of BlockBasedTableOptions.format_version to 2. It means default DB created by 4.6 or up cannot be opened by RocksDB version 3.9 or earlier. -* Added strict_capacity_limit option to NewLRUCache. If the flag is set to true, insert to cache will fail if no enough capacity can be free. Signature of Cache::Insert() is updated accordingly. -* Tickers [NUMBER_DB_NEXT, NUMBER_DB_PREV, NUMBER_DB_NEXT_FOUND, NUMBER_DB_PREV_FOUND, ITER_BYTES_READ] are not updated immediately. The are updated when the Iterator is deleted. -* Add monotonically increasing counter (DB property "rocksdb.current-super-version-number") that increments upon any change to the LSM tree. - -### New Features -* Add CompactionPri::kMinOverlappingRatio, a compaction picking mode friendly to write amplification. -* Deprecate Iterator::IsKeyPinned() and replace it with Iterator::GetProperty() with prop_name="rocksdb.iterator.is.key.pinned" - -## 4.5.0 (2016-02-05) -### Public API Changes -* Add a new perf context level between kEnableCount and kEnableTime. Level 2 now does not include timers for mutexes. -* Statistics of mutex operation durations will not be measured by default. If you want to have them enabled, you need to set Statistics::stats_level_ to kAll. -* DBOptions::delete_scheduler and NewDeleteScheduler() are removed, please use DBOptions::sst_file_manager and NewSstFileManager() instead - -### New Features -* ldb tool now supports operations to non-default column families. -* Add kPersistedTier to ReadTier. This option allows Get and MultiGet to read only the persited data and skip mem-tables if writes were done with disableWAL = true. -* Add DBOptions::sst_file_manager. Use NewSstFileManager() in include/rocksdb/sst_file_manager.h to create a SstFileManager that can be used to track the total size of SST files and control the SST files deletion rate. - -## 4.4.0 (2016-01-14) -### Public API Changes -* Change names in CompactionPri and add a new one. -* Deprecate options.soft_rate_limit and add options.soft_pending_compaction_bytes_limit. -* If options.max_write_buffer_number > 3, writes will be slowed down when writing to the last write buffer to delay a full stop. -* Introduce CompactionJobInfo::compaction_reason, this field include the reason to trigger the compaction. -* After slow down is triggered, if estimated pending compaction bytes keep increasing, slowdown more. -* Increase default options.delayed_write_rate to 2MB/s. -* Added a new parameter --path to ldb tool. --path accepts the name of either MANIFEST, SST or a WAL file. Either --db or --path can be used when calling ldb. - -## 4.3.0 (2015-12-08) -### New Features -* CompactionFilter has new member function called IgnoreSnapshots which allows CompactionFilter to be called even if there are snapshots later than the key. -* RocksDB will now persist options under the same directory as the RocksDB database on successful DB::Open, CreateColumnFamily, DropColumnFamily, and SetOptions. -* Introduce LoadLatestOptions() in rocksdb/utilities/options_util.h. This function can construct the latest DBOptions / ColumnFamilyOptions used by the specified RocksDB intance. -* Introduce CheckOptionsCompatibility() in rocksdb/utilities/options_util.h. This function checks whether the input set of options is able to open the specified DB successfully. - -### Public API Changes -* When options.db_write_buffer_size triggers, only the column family with the largest column family size will be flushed, not all the column families. - -## 4.2.0 (2015-11-09) -### New Features -* Introduce CreateLoggerFromOptions(), this function create a Logger for provided DBOptions. -* Add GetAggregatedIntProperty(), which returns the sum of the GetIntProperty of all the column families. -* Add MemoryUtil in rocksdb/utilities/memory.h. It currently offers a way to get the memory usage by type from a list rocksdb instances. - -### Public API Changes -* CompactionFilter::Context includes information of Column Family ID -* The need-compaction hint given by TablePropertiesCollector::NeedCompact() will be persistent and recoverable after DB recovery. This introduces a breaking format change. If you use this experimental feature, including NewCompactOnDeletionCollectorFactory() in the new version, you may not be able to directly downgrade the DB back to version 4.0 or lower. -* TablePropertiesCollectorFactory::CreateTablePropertiesCollector() now takes an option Context, containing the information of column family ID for the file being written. -* Remove DefaultCompactionFilterFactory. - - -## 4.1.0 (2015-10-08) -### New Features -* Added single delete operation as a more efficient way to delete keys that have not been overwritten. -* Added experimental AddFile() to DB interface that allow users to add files created by SstFileWriter into an empty Database, see include/rocksdb/sst_file_writer.h and DB::AddFile() for more info. -* Added support for opening SST files with .ldb suffix which enables opening LevelDB databases. -* CompactionFilter now supports filtering of merge operands and merge results. - -### Public API Changes -* Added SingleDelete() to the DB interface. -* Added AddFile() to DB interface. -* Added SstFileWriter class. -* CompactionFilter has a new method FilterMergeOperand() that RocksDB applies to every merge operand during compaction to decide whether to filter the operand. -* We removed CompactionFilterV2 interfaces from include/rocksdb/compaction_filter.h. The functionality was deprecated already in version 3.13. - -## 4.0.0 (2015-09-09) -### New Features -* Added support for transactions. See include/rocksdb/utilities/transaction.h for more info. -* DB::GetProperty() now accepts "rocksdb.aggregated-table-properties" and "rocksdb.aggregated-table-properties-at-levelN", in which case it returns aggregated table properties of the target column family, or the aggregated table properties of the specified level N if the "at-level" version is used. -* Add compression option kZSTDNotFinalCompression for people to experiment ZSTD although its format is not finalized. -* We removed the need for LATEST_BACKUP file in BackupEngine. We still keep writing it when we create new backups (because of backward compatibility), but we don't read it anymore. - -### Public API Changes -* Removed class Env::RandomRWFile and Env::NewRandomRWFile(). -* Renamed DBOptions.num_subcompactions to DBOptions.max_subcompactions to make the name better match the actual functionality of the option. -* Added Equal() method to the Comparator interface that can optionally be overwritten in cases where equality comparisons can be done more efficiently than three-way comparisons. -* Previous 'experimental' OptimisticTransaction class has been replaced by Transaction class. - -## 3.13.0 (2015-08-06) -### New Features -* RollbackToSavePoint() in WriteBatch/WriteBatchWithIndex -* Add NewCompactOnDeletionCollectorFactory() in utilities/table_properties_collectors, which allows rocksdb to mark a SST file as need-compaction when it observes at least D deletion entries in any N consecutive entries in that SST file. Note that this feature depends on an experimental NeedCompact() API --- the result of this API will not persist after DB restart. -* Add DBOptions::delete_scheduler. Use NewDeleteScheduler() in include/rocksdb/delete_scheduler.h to create a DeleteScheduler that can be shared among multiple RocksDB instances to control the file deletion rate of SST files that exist in the first db_path. - -### Public API Changes -* Deprecated WriteOptions::timeout_hint_us. We no longer support write timeout. If you really need this option, talk to us and we might consider returning it. -* Deprecated purge_redundant_kvs_while_flush option. -* Removed BackupEngine::NewBackupEngine() and NewReadOnlyBackupEngine() that were deprecated in RocksDB 3.8. Please use BackupEngine::Open() instead. -* Deprecated Compaction Filter V2. We are not aware of any existing use-cases. If you use this filter, your compile will break with RocksDB 3.13. Please let us know if you use it and we'll put it back in RocksDB 3.14. -* Env::FileExists now returns a Status instead of a boolean -* Add statistics::getHistogramString() to print detailed distribution of a histogram metric. -* Add DBOptions::skip_stats_update_on_db_open. When it is on, DB::Open() will run faster as it skips the random reads required for loading necessary stats from SST files to optimize compaction. - -## 3.12.0 (2015-07-02) -### New Features -* Added experimental support for optimistic transactions. See include/rocksdb/utilities/optimistic_transaction.h for more info. -* Added a new way to report QPS from db_bench (check out --report_file and --report_interval_seconds) -* Added a cache for individual rows. See DBOptions::row_cache for more info. -* Several new features on EventListener (see include/rocksdb/listener.h): - - OnCompactionCompleted() now returns per-compaction job statistics, defined in include/rocksdb/compaction_job_stats.h. - - Added OnTableFileCreated() and OnTableFileDeleted(). -* Add compaction_options_universal.enable_trivial_move to true, to allow trivial move while performing universal compaction. Trivial move will happen only when all the input files are non overlapping. - -### Public API changes -* EventListener::OnFlushCompleted() now passes FlushJobInfo instead of a list of parameters. -* DB::GetDbIdentity() is now a const function. If this function is overridden in your application, be sure to also make GetDbIdentity() const to avoid compile error. -* Move listeners from ColumnFamilyOptions to DBOptions. -* Add max_write_buffer_number_to_maintain option -* DB::CompactRange()'s parameter reduce_level is changed to change_level, to allow users to move levels to lower levels if allowed. It can be used to migrate a DB from options.level_compaction_dynamic_level_bytes=false to options.level_compaction_dynamic_level_bytes.true. -* Change default value for options.compaction_filter_factory and options.compaction_filter_factory_v2 to nullptr instead of DefaultCompactionFilterFactory and DefaultCompactionFilterFactoryV2. -* If CancelAllBackgroundWork is called without doing a flush after doing loads with WAL disabled, the changes which haven't been flushed before the call to CancelAllBackgroundWork will be lost. -* WBWIIterator::Entry() now returns WriteEntry instead of `const WriteEntry&` -* options.hard_rate_limit is deprecated. -* When options.soft_rate_limit or options.level0_slowdown_writes_trigger is triggered, the way to slow down writes is changed to: write rate to DB is limited to to options.delayed_write_rate. -* DB::GetApproximateSizes() adds a parameter to allow the estimation to include data in mem table, with default to be not to include. It is now only supported in skip list mem table. -* DB::CompactRange() now accept CompactRangeOptions instead of multiple parameters. CompactRangeOptions is defined in include/rocksdb/options.h. -* CompactRange() will now skip bottommost level compaction for level based compaction if there is no compaction filter, bottommost_level_compaction is introduced in CompactRangeOptions to control when it's possible to skip bottommost level compaction. This mean that if you want the compaction to produce a single file you need to set bottommost_level_compaction to BottommostLevelCompaction::kForce. -* Add Cache.GetPinnedUsage() to get the size of memory occupied by entries that are in use by the system. -* DB:Open() will fail if the compression specified in Options is not linked with the binary. If you see this failure, recompile RocksDB with compression libraries present on your system. Also, previously our default compression was snappy. This behavior is now changed. Now, the default compression is snappy only if it's available on the system. If it isn't we change the default to kNoCompression. -* We changed how we account for memory used in block cache. Previously, we only counted the sum of block sizes currently present in block cache. Now, we count the actual memory usage of the blocks. For example, a block of size 4.5KB will use 8KB memory with jemalloc. This might decrease your memory usage and possibly decrease performance. Increase block cache size if you see this happening after an upgrade. -* Add BackupEngineImpl.options_.max_background_operations to specify the maximum number of operations that may be performed in parallel. Add support for parallelized backup and restore. -* Add DB::SyncWAL() that does a WAL sync without blocking writers. - -## 3.11.0 (2015-05-19) -### New Features -* Added a new API Cache::SetCapacity(size_t capacity) to dynamically change the maximum configured capacity of the cache. If the new capacity is less than the existing cache usage, the implementation will try to lower the usage by evicting the necessary number of elements following a strict LRU policy. -* Added an experimental API for handling flashcache devices (blacklists background threads from caching their reads) -- NewFlashcacheAwareEnv -* If universal compaction is used and options.num_levels > 1, compact files are tried to be stored in none-L0 with smaller files based on options.target_file_size_base. The limitation of DB size when using universal compaction is greatly mitigated by using more levels. You can set num_levels = 1 to make universal compaction behave as before. If you set num_levels > 1 and want to roll back to a previous version, you need to compact all files to a big file in level 0 (by setting target_file_size_base to be large and CompactRange(, nullptr, nullptr, true, 0) and reopen the DB with the same version to rewrite the manifest, and then you can open it using previous releases. -* More information about rocksdb background threads are available in Env::GetThreadList(), including the number of bytes read / written by a compaction job, mem-table size and current number of bytes written by a flush job and many more. Check include/rocksdb/thread_status.h for more detail. - -### Public API changes -* TablePropertiesCollector::AddUserKey() is added to replace TablePropertiesCollector::Add(). AddUserKey() exposes key type, sequence number and file size up to now to users. -* DBOptions::bytes_per_sync used to apply to both WAL and table files. As of 3.11 it applies only to table files. If you want to use this option to sync WAL in the background, please use wal_bytes_per_sync - -## 3.10.0 (2015-03-24) -### New Features -* GetThreadStatus() is now able to report detailed thread status, including: - - Thread Operation including flush and compaction. - - The stage of the current thread operation. - - The elapsed time in micros since the current thread operation started. - More information can be found in include/rocksdb/thread_status.h. In addition, when running db_bench with --thread_status_per_interval, db_bench will also report thread status periodically. -* Changed the LRU caching algorithm so that referenced blocks (by iterators) are never evicted. This change made parameter removeScanCountLimit obsolete. Because of that NewLRUCache doesn't take three arguments anymore. table_cache_remove_scan_limit option is also removed -* By default we now optimize the compilation for the compilation platform (using -march=native). If you want to build portable binary, use 'PORTABLE=1' before the make command. -* We now allow level-compaction to place files in different paths by - specifying them in db_paths along with the target_size. - Lower numbered levels will be placed earlier in the db_paths and higher - numbered levels will be placed later in the db_paths vector. -* Potentially big performance improvements if you're using RocksDB with lots of column families (100-1000) -* Added BlockBasedTableOptions.format_version option, which allows user to specify which version of block based table he wants. As a general guideline, newer versions have more features, but might not be readable by older versions of RocksDB. -* Added new block based table format (version 2), which you can enable by setting BlockBasedTableOptions.format_version = 2. This format changes how we encode size information in compressed blocks and should help with memory allocations if you're using Zlib or BZip2 compressions. -* MemEnv (env that stores data in memory) is now available in default library build. You can create it by calling NewMemEnv(). -* Add SliceTransform.SameResultWhenAppended() to help users determine it is safe to apply prefix bloom/hash. -* Block based table now makes use of prefix bloom filter if it is a full fulter. -* Block based table remembers whether a whole key or prefix based bloom filter is supported in SST files. Do a sanity check when reading the file with users' configuration. -* Fixed a bug in ReadOnlyBackupEngine that deleted corrupted backups in some cases, even though the engine was ReadOnly -* options.level_compaction_dynamic_level_bytes, a feature to allow RocksDB to pick dynamic base of bytes for levels. With this feature turned on, we will automatically adjust max bytes for each level. The goal of this feature is to have lower bound on size amplification. For more details, see comments in options.h. -* Added an abstract base class WriteBatchBase for write batches -* Fixed a bug where we start deleting files of a dropped column families even if there are still live references to it - -### Public API changes -* Deprecated skip_log_error_on_recovery and table_cache_remove_scan_count_limit options. -* Logger method logv with log level parameter is now virtual - -### RocksJava -* Added compression per level API. -* MemEnv is now available in RocksJava via RocksMemEnv class. -* lz4 compression is now included in rocksjava static library when running `make rocksdbjavastatic`. -* Overflowing a size_t when setting rocksdb options now throws an IllegalArgumentException, which removes the necessity for a developer to catch these Exceptions explicitly. - -## 3.9.0 (2014-12-08) - -### New Features -* Add rocksdb::GetThreadList(), which in the future will return the current status of all - rocksdb-related threads. We will have more code instruments in the following RocksDB - releases. -* Change convert function in rocksdb/utilities/convenience.h to return Status instead of boolean. - Also add support for nested options in convert function - -### Public API changes -* New API to create a checkpoint added. Given a directory name, creates a new - database which is an image of the existing database. -* New API LinkFile added to Env. If you implement your own Env class, an - implementation of the API LinkFile will have to be provided. -* MemTableRep takes MemTableAllocator instead of Arena - -### Improvements -* RocksDBLite library now becomes smaller and will be compiled with -fno-exceptions flag. - -## 3.8.0 (2014-11-14) - -### Public API changes -* BackupEngine::NewBackupEngine() was deprecated; please use BackupEngine::Open() from now on. -* BackupableDB/RestoreBackupableDB have new GarbageCollect() methods, which will clean up files from corrupt and obsolete backups. -* BackupableDB/RestoreBackupableDB have new GetCorruptedBackups() methods which list corrupt backups. - -### Cleanup -* Bunch of code cleanup, some extra warnings turned on (-Wshadow, -Wshorten-64-to-32, -Wnon-virtual-dtor) - -### New features -* CompactFiles and EventListener, although they are still in experimental state -* Full ColumnFamily support in RocksJava. - -## 3.7.0 (2014-11-06) -### Public API changes -* Introduce SetOptions() API to allow adjusting a subset of options dynamically online -* Introduce 4 new convenient functions for converting Options from string: GetColumnFamilyOptionsFromMap(), GetColumnFamilyOptionsFromString(), GetDBOptionsFromMap(), GetDBOptionsFromString() -* Remove WriteBatchWithIndex.Delete() overloads using SliceParts -* When opening a DB, if options.max_background_compactions is larger than the existing low pri pool of options.env, it will enlarge it. Similarly, options.max_background_flushes is larger than the existing high pri pool of options.env, it will enlarge it. - -## 3.6.0 (2014-10-07) -### Disk format changes -* If you're using RocksDB on ARM platforms and you're using default bloom filter, there is a disk format change you need to be aware of. There are three steps you need to do when you convert to new release: 1. turn off filter policy, 2. compact the whole database, 3. turn on filter policy - -### Behavior changes -* We have refactored our system of stalling writes. Any stall-related statistics' meanings are changed. Instead of per-write stall counts, we now count stalls per-epoch, where epochs are periods between flushes and compactions. You'll find more information in our Tuning Perf Guide once we release RocksDB 3.6. -* When disableDataSync=true, we no longer sync the MANIFEST file. -* Add identity_as_first_hash property to CuckooTable. SST file needs to be rebuilt to be opened by reader properly. - -### Public API changes -* Change target_file_size_base type to uint64_t from int. -* Remove allow_thread_local. This feature was proved to be stable, so we are turning it always-on. - -## 3.5.0 (2014-09-03) -### New Features -* Add include/utilities/write_batch_with_index.h, providing a utility class to query data out of WriteBatch when building it. -* Move BlockBasedTable related options to BlockBasedTableOptions from Options. Change corresponding JNI interface. Options affected include: - no_block_cache, block_cache, block_cache_compressed, block_size, block_size_deviation, block_restart_interval, filter_policy, whole_key_filtering. filter_policy is changed to shared_ptr from a raw pointer. -* Remove deprecated options: disable_seek_compaction and db_stats_log_interval -* OptimizeForPointLookup() takes one parameter for block cache size. It now builds hash index, bloom filter, and block cache. - -### Public API changes -* The Prefix Extractor used with V2 compaction filters is now passed user key to SliceTransform::Transform instead of unparsed RocksDB key. - -## 3.4.0 (2014-08-18) -### New Features -* Support Multiple DB paths in universal style compactions -* Add feature of storing plain table index and bloom filter in SST file. -* CompactRange() will never output compacted files to level 0. This used to be the case when all the compaction input files were at level 0. -* Added iterate_upper_bound to define the extent upto which the forward iterator will return entries. This will prevent iterating over delete markers and overwritten entries for edge cases where you want to break out the iterator anyways. This may improve performance in case there are a large number of delete markers or overwritten entries. - -### Public API changes -* DBOptions.db_paths now is a vector of a DBPath structure which indicates both of path and target size -* NewPlainTableFactory instead of bunch of parameters now accepts PlainTableOptions, which is defined in include/rocksdb/table.h -* Moved include/utilities/*.h to include/rocksdb/utilities/*.h -* Statistics APIs now take uint32_t as type instead of Tickers. Also make two access functions getTickerCount and histogramData const -* Add DB property rocksdb.estimate-num-keys, estimated number of live keys in DB. -* Add DB::GetIntProperty(), which returns DB properties that are integer as uint64_t. -* The Prefix Extractor used with V2 compaction filters is now passed user key to SliceTransform::Transform instead of unparsed RocksDB key. - -## 3.3.0 (2014-07-10) -### New Features -* Added JSON API prototype. -* HashLinklist reduces performance outlier caused by skewed bucket by switching data in the bucket from linked list to skip list. Add parameter threshold_use_skiplist in NewHashLinkListRepFactory(). -* RocksDB is now able to reclaim storage space more effectively during the compaction process. This is done by compensating the size of each deletion entry by the 2X average value size, which makes compaction to be triggered by deletion entries more easily. -* Add TimeOut API to write. Now WriteOptions have a variable called timeout_hint_us. With timeout_hint_us set to non-zero, any write associated with this timeout_hint_us may be aborted when it runs longer than the specified timeout_hint_us, and it is guaranteed that any write completes earlier than the specified time-out will not be aborted due to the time-out condition. -* Add a rate_limiter option, which controls total throughput of flush and compaction. The throughput is specified in bytes/sec. Flush always has precedence over compaction when available bandwidth is constrained. - -### Public API changes -* Removed NewTotalOrderPlainTableFactory because it is not used and implemented semantically incorrect. - -## 3.2.0 (2014-06-20) - -### Public API changes -* We removed seek compaction as a concept from RocksDB because: -1) It makes more sense for spinning disk workloads, while RocksDB is primarily designed for flash and memory, -2) It added some complexity to the important code-paths, -3) None of our internal customers were really using it. -Because of that, Options::disable_seek_compaction is now obsolete. It is still a parameter in Options, so it does not break the build, but it does not have any effect. We plan to completely remove it at some point, so we ask users to please remove this option from your code base. -* Add two parameters to NewHashLinkListRepFactory() for logging on too many entries in a hash bucket when flushing. -* Added new option BlockBasedTableOptions::hash_index_allow_collision. When enabled, prefix hash index for block-based table will not store prefix and allow hash collision, reducing memory consumption. - -### New Features -* PlainTable now supports a new key encoding: for keys of the same prefix, the prefix is only written once. It can be enabled through encoding_type parameter of NewPlainTableFactory() -* Add AdaptiveTableFactory, which is used to convert from a DB of PlainTable to BlockBasedTabe, or vise versa. It can be created using NewAdaptiveTableFactory() - -### Performance Improvements -* Tailing Iterator re-implemeted with ForwardIterator + Cascading Search Hint , see ~20% throughput improvement. - -## 3.1.0 (2014-05-21) - -### Public API changes -* Replaced ColumnFamilyOptions::table_properties_collectors with ColumnFamilyOptions::table_properties_collector_factories - -### New Features -* Hash index for block-based table will be materialized and reconstructed more efficiently. Previously hash index is constructed by scanning the whole table during every table open. -* FIFO compaction style - -## 3.0.0 (2014-05-05) - -### Public API changes -* Added _LEVEL to all InfoLogLevel enums -* Deprecated ReadOptions.prefix and ReadOptions.prefix_seek. Seek() defaults to prefix-based seek when Options.prefix_extractor is supplied. More detail is documented in https://github.com/facebook/rocksdb/wiki/Prefix-Seek-API-Changes -* MemTableRepFactory::CreateMemTableRep() takes info logger as an extra parameter. - -### New Features -* Column family support -* Added an option to use different checksum functions in BlockBasedTableOptions -* Added ApplyToAllCacheEntries() function to Cache - -## 2.8.0 (2014-04-04) - -* Removed arena.h from public header files. -* By default, checksums are verified on every read from database -* Change default value of several options, including: paranoid_checks=true, max_open_files=5000, level0_slowdown_writes_trigger=20, level0_stop_writes_trigger=24, disable_seek_compaction=true, max_background_flushes=1 and allow_mmap_writes=false -* Added is_manual_compaction to CompactionFilter::Context -* Added "virtual void WaitForJoin()" in class Env. Default operation is no-op. -* Removed BackupEngine::DeleteBackupsNewerThan() function -* Added new option -- verify_checksums_in_compaction -* Changed Options.prefix_extractor from raw pointer to shared_ptr (take ownership) - Changed HashSkipListRepFactory and HashLinkListRepFactory constructor to not take SliceTransform object (use Options.prefix_extractor implicitly) -* Added Env::GetThreadPoolQueueLen(), which returns the waiting queue length of thread pools -* Added a command "checkconsistency" in ldb tool, which checks - if file system state matches DB state (file existence and file sizes) -* Separate options related to block based table to a new struct BlockBasedTableOptions. -* WriteBatch has a new function Count() to return total size in the batch, and Data() now returns a reference instead of a copy -* Add more counters to perf context. -* Supports several more DB properties: compaction-pending, background-errors and cur-size-active-mem-table. - -### New Features -* If we find one truncated record at the end of the MANIFEST or WAL files, - we will ignore it. We assume that writers of these records were interrupted - and that we can safely ignore it. -* A new SST format "PlainTable" is added, which is optimized for memory-only workloads. It can be created through NewPlainTableFactory() or NewTotalOrderPlainTableFactory(). -* A new mem table implementation hash linked list optimizing for the case that there are only few keys for each prefix, which can be created through NewHashLinkListRepFactory(). -* Merge operator supports a new function PartialMergeMulti() to allow users to do partial merges against multiple operands. -* Now compaction filter has a V2 interface. It buffers the kv-pairs sharing the same key prefix, process them in batches, and return the batched results back to DB. The new interface uses a new structure CompactionFilterContext for the same purpose as CompactionFilter::Context in V1. -* Geo-spatial support for locations and radial-search. - -## 2.7.0 (2014-01-28) - -### Public API changes - -* Renamed `StackableDB::GetRawDB()` to `StackableDB::GetBaseDB()`. -* Renamed `WriteBatch::Data()` `const std::string& Data() const`. -* Renamed class `TableStats` to `TableProperties`. -* Deleted class `PrefixHashRepFactory`. Please use `NewHashSkipListRepFactory()` instead. -* Supported multi-threaded `EnableFileDeletions()` and `DisableFileDeletions()`. -* Added `DB::GetOptions()`. -* Added `DB::GetDbIdentity()`. - -### New Features - -* Added [BackupableDB](https://github.com/facebook/rocksdb/wiki/How-to-backup-RocksDB%3F) -* Implemented [TailingIterator](https://github.com/facebook/rocksdb/wiki/Tailing-Iterator), a special type of iterator that - doesn't create a snapshot (can be used to read newly inserted data) - and is optimized for doing sequential reads. -* Added property block for table, which allows (1) a table to store - its metadata and (2) end user to collect and store properties they - are interested in. -* Enabled caching index and filter block in block cache (turned off by default). -* Supported error report when doing manual compaction. -* Supported additional Linux platform flavors and Mac OS. -* Put with `SliceParts` - Variant of `Put()` that gathers output like `writev(2)` -* Bug fixes and code refactor for compatibility with upcoming Column - Family feature. - -### Performance Improvements - -* Huge benchmark performance improvements by multiple efforts. For example, increase in readonly QPS from about 530k in 2.6 release to 1.1 million in 2.7 [1] -* Speeding up a way RocksDB deleted obsolete files - no longer listing the whole directory under a lock -- decrease in p99 -* Use raw pointer instead of shared pointer for statistics: [5b825d](https://github.com/facebook/rocksdb/commit/5b825d6964e26ec3b4bb6faa708ebb1787f1d7bd) -- huge increase in performance -- shared pointers are slow -* Optimized locking for `Get()` -- [1fdb3f](https://github.com/facebook/rocksdb/commit/1fdb3f7dc60e96394e3e5b69a46ede5d67fb976c) -- 1.5x QPS increase for some workloads -* Cache speedup - [e8d40c3](https://github.com/facebook/rocksdb/commit/e8d40c31b3cca0c3e1ae9abe9b9003b1288026a9) -* Implemented autovector, which allocates first N elements on stack. Most of vectors in RocksDB are small. Also, we never want to allocate heap objects while holding a mutex. -- [c01676e4](https://github.com/facebook/rocksdb/commit/c01676e46d3be08c3c140361ef1f5884f47d3b3c) -* Lots of efforts to move malloc, memcpy and IO outside of locks diff --git a/LICENSE.Apache b/LICENSE similarity index 100% rename from LICENSE.Apache rename to LICENSE diff --git a/README.md b/README.md index 8fcc4abc2..6ad228706 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,7 @@ -## RocksDB: A Persistent Key-Value Store for Flash and RAM Storage +## ForSt: A Persistent Key-Value Store designed for Streaming processing -[![CircleCI Status](https://circleci.com/gh/facebook/rocksdb.svg?style=svg)](https://circleci.com/gh/facebook/rocksdb) - -RocksDB is developed and maintained by Facebook Database Engineering Team. -It is built on earlier work on [LevelDB](https://github.com/google/leveldb) by Sanjay Ghemawat (sanjay@google.com) -and Jeff Dean (jeff@google.com) +ForSt is developed and maintained by Flink community and hosted by ververica. +It is built on top of [RocksDB](https://github.com/facebook/rocksdb) by facebook. This code is a library that forms the core building block for a fast key-value server, especially suited for storing data on flash drives. @@ -14,16 +11,14 @@ and Space-Amplification-Factor (SAF). It has multi-threaded compactions, making it especially suitable for storing multiple terabytes of data in a single database. -Start with example usage here: https://github.com/facebook/rocksdb/tree/main/examples - See the [github wiki](https://github.com/facebook/rocksdb/wiki) for more explanation. The public interface is in `include/`. Callers should not include or rely on the details of any other header files in this package. Those internal APIs may be changed without warning. -Questions and discussions are welcome on the [RocksDB Developers Public](https://www.facebook.com/groups/rocksdb.dev/) Facebook group and [email list](https://groups.google.com/g/rocksdb) on Google Groups. +Questions and discussions are welcome on the [Discussion](https://github.com/ververica/ForSt/discussions). ## License -RocksDB is dual-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). You may select, at your option, one of the above-listed licenses. +ForSt is licensed under Apache 2.0 License. From d73053f76a73a30113c0d96683ab2a4ae862c2bc Mon Sep 17 00:00:00 2001 From: Yanfei Lei Date: Wed, 13 Mar 2024 13:06:29 +0800 Subject: [PATCH 39/61] [build] Add pr-jobs check (#10) (cherry picked from commit 0d7fea8c7e47d2bfd137c4b096b8e55f7cd3a63d) --- .github/actions/build-folly/action.yml | 7 + .../action.yml | 10 + .../install-gflags-on-macos/action.yml | 7 + .github/actions/install-gflags/action.yml | 7 + .../actions/install-jdk8-on-macos/action.yml | 9 + .github/actions/post-steps/action.yml | 38 ++++ .github/actions/pre-steps-macos/action.yml | 5 + .github/actions/pre-steps/action.yml | 18 ++ .github/actions/setup-folly/action.yml | 7 + .github/actions/setup-upstream/action.yml | 20 ++ .github/workflows/pr-jobs.yml | 173 ++++++++++++++++++ Makefile | 6 + java/Makefile | 2 - 13 files changed, 307 insertions(+), 2 deletions(-) create mode 100644 .github/actions/build-folly/action.yml create mode 100644 .github/actions/increase-max-open-files-on-macos/action.yml create mode 100644 .github/actions/install-gflags-on-macos/action.yml create mode 100644 .github/actions/install-gflags/action.yml create mode 100644 .github/actions/install-jdk8-on-macos/action.yml create mode 100644 .github/actions/post-steps/action.yml create mode 100644 .github/actions/pre-steps-macos/action.yml create mode 100644 .github/actions/pre-steps/action.yml create mode 100644 .github/actions/setup-folly/action.yml create mode 100644 .github/actions/setup-upstream/action.yml create mode 100644 .github/workflows/pr-jobs.yml diff --git a/.github/actions/build-folly/action.yml b/.github/actions/build-folly/action.yml new file mode 100644 index 000000000..cd6cdfc06 --- /dev/null +++ b/.github/actions/build-folly/action.yml @@ -0,0 +1,7 @@ +name: build-folly +runs: + using: composite + steps: + - name: Build folly and dependencies + run: make build_folly + shell: bash \ No newline at end of file diff --git a/.github/actions/increase-max-open-files-on-macos/action.yml b/.github/actions/increase-max-open-files-on-macos/action.yml new file mode 100644 index 000000000..869cd14ed --- /dev/null +++ b/.github/actions/increase-max-open-files-on-macos/action.yml @@ -0,0 +1,10 @@ +name: increase-max-open-files-on-macos +runs: + using: composite + steps: + - name: Increase max open files + run: |- + sudo sysctl -w kern.maxfiles=1048576 + sudo sysctl -w kern.maxfilesperproc=1048576 + sudo launchctl limit maxfiles 1048576 + shell: bash \ No newline at end of file diff --git a/.github/actions/install-gflags-on-macos/action.yml b/.github/actions/install-gflags-on-macos/action.yml new file mode 100644 index 000000000..3de06f614 --- /dev/null +++ b/.github/actions/install-gflags-on-macos/action.yml @@ -0,0 +1,7 @@ +name: install-gflags-on-macos +runs: + using: composite + steps: + - name: Install gflags on macos + run: HOMEBREW_NO_AUTO_UPDATE=1 brew install gflags + shell: bash \ No newline at end of file diff --git a/.github/actions/install-gflags/action.yml b/.github/actions/install-gflags/action.yml new file mode 100644 index 000000000..d47619722 --- /dev/null +++ b/.github/actions/install-gflags/action.yml @@ -0,0 +1,7 @@ +name: install-gflags +runs: + using: composite + steps: + - name: Install gflags + run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev + shell: bash \ No newline at end of file diff --git a/.github/actions/install-jdk8-on-macos/action.yml b/.github/actions/install-jdk8-on-macos/action.yml new file mode 100644 index 000000000..80c56da09 --- /dev/null +++ b/.github/actions/install-jdk8-on-macos/action.yml @@ -0,0 +1,9 @@ +name: install-jdk8-on-macos +runs: + using: composite + steps: + - name: Install JDK 8 on macos + run: |- + HOMEBREW_NO_AUTO_UPDATE=1 brew tap bell-sw/liberica + HOMEBREW_NO_AUTO_UPDATE=1 brew install --cask liberica-jdk8 + shell: bash \ No newline at end of file diff --git a/.github/actions/post-steps/action.yml b/.github/actions/post-steps/action.yml new file mode 100644 index 000000000..5bb7502ec --- /dev/null +++ b/.github/actions/post-steps/action.yml @@ -0,0 +1,38 @@ +name: post-steps +description: Steps that are taken after a RocksDB job +inputs: + artifact-prefix: + description: Prefix to append to the name of artifacts that are uploaded + required: true + default: "${{ github.job }}" +runs: + using: composite + steps: + - name: Upload Test Results artifact + uses: actions/upload-artifact@v4.0.0 + with: + name: "${{ inputs.artifact-prefix }}-test-results" + path: "${{ runner.temp }}/test-results/**" + - name: Upload DB LOG file artifact + uses: actions/upload-artifact@v4.0.0 + with: + name: "${{ inputs.artifact-prefix }}-db-log-file" + path: LOG + - name: Copy Test Logs (on Failure) + if: ${{ failure() }} + run: | + mkdir -p ${{ runner.temp }}/failure-test-logs + cp -r t/* ${{ runner.temp }}/failure-test-logs + shell: bash + - name: Upload Test Logs (on Failure) artifact + uses: actions/upload-artifact@v4.0.0 + with: + name: "${{ inputs.artifact-prefix }}-failure-test-logs" + path: ${{ runner.temp }}/failure-test-logs/** + if-no-files-found: ignore + - name: Upload Core Dumps artifact + uses: actions/upload-artifact@v4.0.0 + with: + name: "${{ inputs.artifact-prefix }}-core-dumps" + path: "core.*" + if-no-files-found: ignore \ No newline at end of file diff --git a/.github/actions/pre-steps-macos/action.yml b/.github/actions/pre-steps-macos/action.yml new file mode 100644 index 000000000..86c83b3b4 --- /dev/null +++ b/.github/actions/pre-steps-macos/action.yml @@ -0,0 +1,5 @@ +name: pre-steps-macos +runs: + using: composite + steps: + - uses: "./.github/actions/pre-steps" \ No newline at end of file diff --git a/.github/actions/pre-steps/action.yml b/.github/actions/pre-steps/action.yml new file mode 100644 index 000000000..d40254610 --- /dev/null +++ b/.github/actions/pre-steps/action.yml @@ -0,0 +1,18 @@ +name: pre-steps +runs: + using: composite + steps: + - name: Setup Environment Variables + run: |- + echo "GTEST_THROW_ON_FAILURE=0" >> "$GITHUB_ENV" + echo "GTEST_OUTPUT=\"xml:${{ runner.temp }}/test-results/\"" >> "$GITHUB_ENV" + echo "SKIP_FORMAT_BUCK_CHECKS=1" >> "$GITHUB_ENV" + echo "GTEST_COLOR=1" >> "$GITHUB_ENV" + echo "CTEST_OUTPUT_ON_FAILURE=1" >> "$GITHUB_ENV" + echo "CTEST_TEST_TIMEOUT=300" >> "$GITHUB_ENV" + echo "ZLIB_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/zlib" >> "$GITHUB_ENV" + echo "BZIP2_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/bzip2" >> "$GITHUB_ENV" + echo "SNAPPY_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/snappy" >> "$GITHUB_ENV" + echo "LZ4_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/lz4" >> "$GITHUB_ENV" + echo "ZSTD_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/zstd" >> "$GITHUB_ENV" + shell: bash \ No newline at end of file diff --git a/.github/actions/setup-folly/action.yml b/.github/actions/setup-folly/action.yml new file mode 100644 index 000000000..cf2b2900b --- /dev/null +++ b/.github/actions/setup-folly/action.yml @@ -0,0 +1,7 @@ +name: setup-folly +runs: + using: composite + steps: + - name: Checkout folly sources + run: make checkout_folly + shell: bash \ No newline at end of file diff --git a/.github/actions/setup-upstream/action.yml b/.github/actions/setup-upstream/action.yml new file mode 100644 index 000000000..6cbe22771 --- /dev/null +++ b/.github/actions/setup-upstream/action.yml @@ -0,0 +1,20 @@ +name: build-folly +runs: + using: composite + steps: + - name: Fix repo ownership + # Needed in some cases, as safe.directory setting doesn't take effect + # under env -i + run: chown `whoami` . || true + shell: bash + - name: Set upstream + run: git remote add upstream https://github.com/facebook/rocksdb.git + shell: bash + - name: Fetch upstream + run: git fetch upstream + shell: bash + - name: Git status + # NOTE: some old branch builds under check_format_compatible.sh invoke + # git under env -i + run: git status && git remote -v && env -i git branch + shell: bash \ No newline at end of file diff --git a/.github/workflows/pr-jobs.yml b/.github/workflows/pr-jobs.yml new file mode 100644 index 000000000..385bd2dde --- /dev/null +++ b/.github/workflows/pr-jobs.yml @@ -0,0 +1,173 @@ +name: ververica/forst/pr-jobs +on: [push, pull_request] +jobs: + # ======================== Fast Initial Checks ====================== # + check-format-and-targets: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4.1.0 + with: + fetch-depth: 0 # Need full checkout to determine merge base + fetch-tags: true + - uses: "./.github/actions/setup-upstream" + - name: Setup Python + uses: actions/setup-python@v5 + - name: Install Dependencies + run: python -m pip install --upgrade pip + - name: Install argparse + run: pip install argparse + - name: Download clang-format-diff.py + run: wget https://raw.githubusercontent.com/llvm/llvm-project/release/12.x/clang/tools/clang-format/clang-format-diff.py + - name: Check format + run: VERBOSE_CHECK=1 make check-format + - name: Simple source code checks + run: make check-sources + # ========================= Linux With Tests ======================== # + build-linux: + runs-on: ubuntu-latest + timeout-minutes: 120 + steps: + - uses: actions/checkout@v4.1.0 + - uses: "./.github/actions/pre-steps" + - uses: "./.github/actions/install-gflags" + - run: echo "JAVA_HOME=${JAVA_HOME}" + - run: DISABLE_WARNING_AS_ERROR=1 make V=1 J=8 -j8 check + - uses: "./.github/actions/post-steps" + # ======================== Linux No Test Runs ======================= # + build-linux-release: + runs-on: ubuntu-latest + timeout-minutes: 120 + steps: + - uses: actions/checkout@v4.1.0 + - uses: "./.github/actions/install-gflags" + - run: echo "JAVA_HOME=${JAVA_HOME}" + - run: echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $GITHUB_PATH + - run: DISABLE_WARNING_AS_ERROR=1 make V=1 -j32 LIB_MODE=shared release + - run: ls librocksdb.so + - run: "./db_stress --version" + - run: DISABLE_WARNING_AS_ERROR=1 make clean + - run: DISABLE_WARNING_AS_ERROR=1 make V=1 -j32 release + - run: ls librocksdb.a + - run: "./db_stress --version" + - run: DISABLE_WARNING_AS_ERROR=1 make clean + - run: sudo apt-get remove -y libgflags-dev + - run: DISABLE_WARNING_AS_ERROR=1 make V=1 -j32 LIB_MODE=shared release + - run: ls librocksdb.so + - run: if ./db_stress --version; then false; else true; fi + - run: DISABLE_WARNING_AS_ERROR=1 make clean + - run: DISABLE_WARNING_AS_ERROR=1 make V=1 -j32 release + - run: ls librocksdb.a + - run: if ./db_stress --version; then false; else true; fi + - uses: "./.github/actions/post-steps" + # ============================ Java Jobs ============================ # + build-linux-java: + runs-on: ubuntu-latest + container: evolvedbinary/rocksjava:centos6_x64-be + steps: + # The docker image is intentionally based on an OS that has an older GLIBC version. + # That GLIBC is incompatibile with GitHub's actions/checkout. Thus we implement a manual checkout step. + - name: Checkout + env: + GH_TOKEN: ${{ github.token }} + run: | + chown `whoami` . || true + git clone --no-checkout https://oath2:$GH_TOKEN@github.com/${{ github.repository }}.git . + git -c protocol.version=2 fetch --update-head-ok --no-tags --prune --no-recurse-submodules --depth=1 origin +${{ github.sha }}:${{ github.ref }} + git checkout --progress --force ${{ github.ref }} + git log -1 --format='%H' + - uses: "./.github/actions/pre-steps" + - name: Set Java Environment + run: |- + echo "JAVA_HOME=${JAVA_HOME}" + echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $GITHUB_PATH + which java && java -version + which javac && javac -version + - name: Test RocksDBJava + run: scl enable devtoolset-7 'DISABLE_WARNING_AS_ERROR=1 make V=1 J=8 -j8 jtest' + # NOTE: post-steps skipped because of compatibility issues with docker image + build-linux-java-static: + runs-on: ubuntu-latest + container: evolvedbinary/rocksjava:centos6_x64-be + steps: + # The docker image is intentionally based on an OS that has an older GLIBC version. + # That GLIBC is incompatibile with GitHub's actions/checkout. Thus we implement a manual checkout step. + - name: Checkout + env: + GH_TOKEN: ${{ github.token }} + run: | + chown `whoami` . || true + git clone --no-checkout https://oath2:$GH_TOKEN@github.com/${{ github.repository }}.git . + git -c protocol.version=2 fetch --update-head-ok --no-tags --prune --no-recurse-submodules --depth=1 origin +${{ github.sha }}:${{ github.ref }} + git checkout --progress --force ${{ github.ref }} + git log -1 --format='%H' + - uses: "./.github/actions/pre-steps" + - name: Set Java Environment + run: |- + echo "JAVA_HOME=${JAVA_HOME}" + which java && java -version + which javac && javac -version + - name: Build RocksDBJava Static Library + run: scl enable devtoolset-7 'DISABLE_WARNING_AS_ERROR=1 make V=1 J=8 -j8 rocksdbjavastatic' + # NOTE: post-steps skipped because of compatibility issues with docker image + + # ========================= MacOS build only ======================== # + build-macos: + runs-on: macos-13 + timeout-minutes: 120 + env: + ROCKSDB_DISABLE_JEMALLOC: 1 + steps: + - uses: actions/checkout@v4.1.0 + - uses: maxim-lobanov/setup-xcode@v1.6.0 + with: + xcode-version: 14.3.1 + - uses: "./.github/actions/increase-max-open-files-on-macos" + - uses: "./.github/actions/install-gflags-on-macos" + - uses: "./.github/actions/pre-steps-macos" + - name: Build + run: ulimit -S -n `ulimit -H -n` && DISABLE_WARNING_AS_ERROR=1 make V=1 J=16 -j16 all + - uses: "./.github/actions/post-steps" + # ========================= MacOS with java ======================== # + build-macos-java: + runs-on: macos-13 + env: + JAVA_HOME: "/Library/Java/JavaVirtualMachines/liberica-jdk-8.jdk/Contents/Home" + ROCKSDB_DISABLE_JEMALLOC: 1 + steps: + - uses: actions/checkout@v4.1.0 + - uses: maxim-lobanov/setup-xcode@v1.6.0 + with: + xcode-version: 14.3.1 + - uses: "./.github/actions/increase-max-open-files-on-macos" + - uses: "./.github/actions/install-gflags-on-macos" + - uses: "./.github/actions/install-jdk8-on-macos" + - uses: "./.github/actions/pre-steps-macos" + - name: Set Java Environment + run: |- + echo "JAVA_HOME=${JAVA_HOME}" + which java && java -version + which javac && javac -version + - name: Test RocksDBJava + run: DISABLE_WARNING_AS_ERROR=1 make V=1 J=16 -j16 jtest + - uses: "./.github/actions/post-steps" + build-macos-java-static: + runs-on: macos-13 + env: + JAVA_HOME: "/Library/Java/JavaVirtualMachines/liberica-jdk-8.jdk/Contents/Home" + steps: + - uses: actions/checkout@v4.1.0 + - uses: maxim-lobanov/setup-xcode@v1.6.0 + with: + xcode-version: 14.3.1 + - uses: "./.github/actions/increase-max-open-files-on-macos" + - uses: "./.github/actions/install-gflags-on-macos" + - uses: "./.github/actions/install-jdk8-on-macos" + - uses: "./.github/actions/pre-steps-macos" + - name: Set Java Environment + run: |- + echo "JAVA_HOME=${JAVA_HOME}" + which java && java -version + which javac && javac -version + - name: Build RocksDBJava x86 and ARM Static Libraries + run: DISABLE_WARNING_AS_ERROR=1 make V=1 J=16 -j16 rocksdbjavastaticosx + - uses: "./.github/actions/post-steps" \ No newline at end of file diff --git a/Makefile b/Makefile index bb39c2350..e35a9feb7 100644 --- a/Makefile +++ b/Makefile @@ -12,9 +12,15 @@ BASH_EXISTS := $(shell which bash) SHELL := $(shell which bash) include common.mk +MY_JAVA_INCLUDE = -I$(JAVA_HOME)/include/ -I$(JAVA_HOME)/include/linux +ifneq ("$(wildcard $(JAVA_HOME)/include/darwin)","") + MY_JAVA_INCLUDE = -I$(JAVA_HOME)/include -I $(JAVA_HOME)/include/darwin +endif + CLEAN_FILES = # deliberately empty, so we can append below. CFLAGS += ${EXTRA_CFLAGS} CXXFLAGS += ${EXTRA_CXXFLAGS} +CXXFLAGS += ${MY_JAVA_INCLUDE} LDFLAGS += $(EXTRA_LDFLAGS) MACHINE ?= $(shell uname -m) ARFLAGS = ${EXTRA_ARFLAGS} rs diff --git a/java/Makefile b/java/Makefile index 1a3dd3643..e80c8130b 100644 --- a/java/Makefile +++ b/java/Makefile @@ -349,8 +349,6 @@ javalib: java java_test javadocs java: java-version $(AM_V_GEN)mkdir -p $(MAIN_CLASSES) $(AM_V_at) $(JAVAC_CMD) $(JAVAC_ARGS) -h $(NATIVE_INCLUDE) -d $(MAIN_CLASSES) $(SOURCES) - $(AM_V_at)@cp ../HISTORY.md ./HISTORY-CPP.md - $(AM_V_at)@rm -f ./HISTORY-CPP.md sample: java $(AM_V_GEN)mkdir -p $(SAMPLES_MAIN_CLASSES) From e1d10833253155f2a7ec69100d74a4df84f267e1 Mon Sep 17 00:00:00 2001 From: Jinzhong Li Date: Mon, 18 Mar 2024 15:01:42 +0800 Subject: [PATCH 40/61] [env] Fix jvm_util unused parameter error (#14) (cherry picked from commit d4e8ef1b41d3042bca39d6e0da96d483f2f5a91e) --- env/flink/jvm_util.cc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/env/flink/jvm_util.cc b/env/flink/jvm_util.cc index 8e2c6f07a..ecd6f9677 100644 --- a/env/flink/jvm_util.cc +++ b/env/flink/jvm_util.cc @@ -18,11 +18,14 @@ #include "env/flink/jvm_util.h" +#define UNUSED(x) (void)(x) + namespace ROCKSDB_NAMESPACE { std::atomic jvm_ = std::atomic(nullptr); JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { + UNUSED(reserved); JNIEnv* env = nullptr; if (vm->GetEnv((void**)&env, JNI_VERSION_1_8) != JNI_OK) { return -1; @@ -33,6 +36,8 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { } JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) { + UNUSED(vm); + UNUSED(reserved); jvm_.store(nullptr); } From f845fe48eee62bef6b3abb76127e15c87466cfd2 Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Fri, 15 Mar 2024 09:38:58 +0800 Subject: [PATCH 41/61] [env] Implement all methods of env_flink (#13) (cherry picked from commit 7c0c8da59ae8d27b7db68752ac84ec3004efba87) --- env/flink/env_flink.cc | 843 +++++++++++++++++++++++++++++++++++++++- env/flink/env_flink.h | 37 +- env/flink/jni_helper.cc | 325 ++++++++++++++-- env/flink/jni_helper.h | 103 ++++- 4 files changed, 1243 insertions(+), 65 deletions(-) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index 87183f131..8987084d0 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -3,8 +3,843 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -// TODO: -// 1. Register flink env to ObjectLibrary -// 2. Implement all methods of env_flink.h +#include "env_flink.h" -#include "env_flink.h" \ No newline at end of file +#include "jvm_util.h" + +// +// This file defines a Flink environment for ForSt. It uses the JNI call +// to access Flink FileSystem. All files created by one instance of ForSt +// will reside on the actual Flink FileSystem. +// +namespace ROCKSDB_NAMESPACE { + +// Appends to an existing file in Flink FileSystem. +class FlinkWritableFile : public FSWritableFile { + private: + const std::string file_path_; + const jobject file_system_instance_; + jobject fs_data_output_stream_instance_; + JavaClassCache* class_cache_; + + public: + FlinkWritableFile(jobject file_system_instance, + JavaClassCache* java_class_cache, + const std::string& file_path, const FileOptions& options) + : FSWritableFile(options), + file_path_(file_path), + file_system_instance_(file_system_instance), + class_cache_(java_class_cache) {} + + ~FlinkWritableFile() override { + JNIEnv* jniEnv = getJNIEnv(); + if (fs_data_output_stream_instance_ != nullptr) { + jniEnv->DeleteGlobalRef(fs_data_output_stream_instance_); + } + } + + IOStatus Init() { + JNIEnv* jniEnv = getJNIEnv(); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(file_path_, &pathInstance); + if (!status.ok()) { + return status; + } + + JavaClassCache::JavaMethodContext fileSystemCreateMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_CREATE); + jobject fsDataOutputStream = jniEnv->CallObjectMethod( + file_system_instance_, fileSystemCreateMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + if (fsDataOutputStream == nullptr) { + return CheckThenError( + std::string( + "CallObjectMethod Exception when Init FlinkWritableFile, ") + .append(fileSystemCreateMethod.ToString()) + .append(", args: Path(") + .append(file_path_) + .append(")")); + } + fs_data_output_stream_instance_ = jniEnv->NewGlobalRef(fsDataOutputStream); + jniEnv->DeleteLocalRef(fsDataOutputStream); + return IOStatus::OK(); + } + + IOStatus Append(const Slice& data, const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override { + JNIEnv* jniEnv = getJNIEnv(); + if (data.size() > static_cast(LONG_MAX)) { + return IOStatus::IOError( + std::string("Append too big data to file, data: ") + .append(data.ToString())); + } + jobject directByteBuffer = jniEnv->NewDirectByteBuffer( + (void*)data.data(), static_cast(data.size())); + + JavaClassCache::JavaMethodContext writeMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_OUTPUT_STREAM_WRITE); + jniEnv->CallVoidMethod(fs_data_output_stream_instance_, + writeMethod.javaMethod, directByteBuffer); + jniEnv->DeleteLocalRef(directByteBuffer); + + std::string filePath = file_path_; + return CurrentStatus([filePath]() { + return std::string("Exception when Appending file, path: ") + .append(filePath); + }); + } + + IOStatus Append(const Slice& data, const IOOptions& options, + const DataVerificationInfo& /* verification_info */, + IODebugContext* dbg) override { + return Append(data, options, dbg); + } + + IOStatus Flush(const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override { + JavaClassCache::JavaMethodContext flushMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_OUTPUT_STREAM_FLUSH); + JNIEnv* jniEnv = getJNIEnv(); + jniEnv->CallVoidMethod(fs_data_output_stream_instance_, + flushMethod.javaMethod); + + std::string filePath = file_path_; + return CurrentStatus([filePath]() { + return std::string("Exception when Flush file, path: ").append(filePath); + }); + } + + IOStatus Sync(const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override { + JavaClassCache::JavaMethodContext flushMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_OUTPUT_STREAM_SYNC); + JNIEnv* jniEnv = getJNIEnv(); + jniEnv->CallVoidMethod(fs_data_output_stream_instance_, + flushMethod.javaMethod); + + std::string filePath = file_path_; + return CurrentStatus([filePath]() { + return std::string("Exception when Sync file, path: ").append(filePath); + }); + } + + IOStatus Close(const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override { + JavaClassCache::JavaMethodContext closeMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_OUTPUT_STREAM_CLOSE); + JNIEnv* jniEnv = getJNIEnv(); + jniEnv->CallVoidMethod(fs_data_output_stream_instance_, + closeMethod.javaMethod); + + std::string filePath = file_path_; + return CurrentStatus([filePath]() { + return std::string("Exception when Close file, path: ").append(filePath); + }); + } +}; + +// Used for reading a file from Flink FileSystem. It implements both +// sequential-read access methods and random read access methods. +class FlinkReadableFile : virtual public FSSequentialFile, + virtual public FSRandomAccessFile { + private: + const std::string file_path_; + const jobject file_system_instance_; + jobject fs_data_input_stream_instance_; + JavaClassCache* class_cache_; + + public: + FlinkReadableFile(jobject file_system_instance, + JavaClassCache* java_class_cache, + const std::string& file_path) + : file_path_(file_path), + file_system_instance_(file_system_instance), + class_cache_(java_class_cache) {} + + ~FlinkReadableFile() override { + JNIEnv* jniEnv = getJNIEnv(); + if (fs_data_input_stream_instance_ != nullptr) { + jniEnv->DeleteGlobalRef(fs_data_input_stream_instance_); + } + } + + IOStatus Init() { + JNIEnv* jniEnv = getJNIEnv(); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(file_path_, &pathInstance); + if (!status.ok()) { + return status; + } + + JavaClassCache::JavaMethodContext openMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_OPEN); + jobject fsDataInputStream = jniEnv->CallObjectMethod( + file_system_instance_, openMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + if (fsDataInputStream == nullptr) { + return CheckThenError( + std::string( + "CallObjectMethod Exception when Init FlinkReadableFile, ") + .append(openMethod.ToString()) + .append(", args: Path(") + .append(file_path_) + .append(")")); + } + + fs_data_input_stream_instance_ = jniEnv->NewGlobalRef(fsDataInputStream); + jniEnv->DeleteLocalRef(fsDataInputStream); + return IOStatus::OK(); + } + + // sequential access, read data at current offset in file + IOStatus Read(size_t n, const IOOptions& /*options*/, Slice* result, + char* scratch, IODebugContext* /*dbg*/) override { + JNIEnv* jniEnv = getJNIEnv(); + if (n > static_cast(LONG_MAX)) { + return IOStatus::IOError( + std::string("Read too big data to file, data size: ") + .append(std::to_string(n))); + } + jobject directByteBuffer = + jniEnv->NewDirectByteBuffer((void*)scratch, static_cast(n)); + + JavaClassCache::JavaMethodContext readMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_INPUT_STREAM_SEQ_READ); + jint totalBytesRead = + jniEnv->CallIntMethod(fs_data_input_stream_instance_, + readMethod.javaMethod, directByteBuffer); + + jniEnv->DeleteLocalRef(directByteBuffer); + + std::string filePath = file_path_; + IOStatus status = CurrentStatus([filePath]() { + return std::string("Exception when Reading file, path: ") + .append(filePath); + }); + if (!status.ok()) { + return status; + } + + *result = Slice(scratch, totalBytesRead == -1 ? 0 : totalBytesRead); + return IOStatus::OK(); + } + + // random access, read data from specified offset in file + IOStatus Read(uint64_t offset, size_t n, const IOOptions& /*options*/, + Slice* result, char* scratch, + IODebugContext* /*dbg*/) const override { + JNIEnv* jniEnv = getJNIEnv(); + if (n > static_cast(LONG_MAX)) { + return IOStatus::IOError( + std::string("Read too big data to file, data size: ") + .append(std::to_string(n))); + } + jobject directByteBuffer = + jniEnv->NewDirectByteBuffer((void*)scratch, static_cast(n)); + + JavaClassCache::JavaMethodContext readMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_INPUT_STREAM_RANDOM_READ); + jint totalBytesRead = + jniEnv->CallIntMethod(fs_data_input_stream_instance_, + readMethod.javaMethod, offset, directByteBuffer); + + jniEnv->DeleteLocalRef(directByteBuffer); + + std::string filePath = file_path_; + IOStatus status = CurrentStatus([filePath]() { + return std::string("Exception when Reading file, path: ") + .append(filePath); + }); + if (!status.ok()) { + return status; + } + + *result = Slice(scratch, totalBytesRead == -1 ? 0 : totalBytesRead); + return IOStatus::OK(); + } + + IOStatus Skip(uint64_t n) override { + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaMethodContext skipMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FS_INPUT_STREAM_SKIP); + jniEnv->CallVoidMethod(fs_data_input_stream_instance_, + skipMethod.javaMethod, n); + + std::string filePath = file_path_; + return CurrentStatus([filePath]() { + return std::string("Exception when skipping file, path: ") + .append(filePath); + }); + } +}; + +// Simple implementation of FSDirectory, Shouldn't influence the normal usage +class FlinkDirectory : public FSDirectory { + public: + explicit FlinkDirectory() = default; + ~FlinkDirectory() override = default; + + IOStatus Fsync(const IOOptions& /*options*/, + IODebugContext* /*dbg*/) override { + // TODO: Syncing directory is managed by specific flink file system + // currently, consider to implement in the future + return IOStatus::OK(); + } +}; + +FlinkFileSystem::FlinkFileSystem(const std::shared_ptr& base_fs, + const std::string& base_path) + : FileSystemWrapper(base_fs), base_path_(base_path) {} + +FlinkFileSystem::~FlinkFileSystem() { + if (file_system_instance_ != nullptr) { + JNIEnv* env = getJNIEnv(); + env->DeleteGlobalRef(file_system_instance_); + } + delete class_cache_; +} + +Status FlinkFileSystem::Init() { + JNIEnv* jniEnv = getJNIEnv(); + std::unique_ptr javaClassCache; + Status status = JavaClassCache::Create(jniEnv, &javaClassCache); + if (!status.ok()) { + return status; + } + class_cache_ = javaClassCache.release(); + + // Delegate Flink to load real FileSystem (e.g. + // S3FileSystem/OSSFileSystem/...) + JavaClassCache::JavaClassContext fileSystemClass = + class_cache_->GetJClass(JavaClassCache::JC_FLINK_FILE_SYSTEM); + JavaClassCache::JavaMethodContext fileSystemGetMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_GET); + + JavaClassCache::JavaClassContext uriClass = + class_cache_->GetJClass(JavaClassCache::JC_URI); + JavaClassCache::JavaMethodContext uriConstructor = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_URI_CONSTRUCTOR); + + // Construct URI + jstring uriStringArg = jniEnv->NewStringUTF(base_path_.c_str()); + jobject uriInstance = jniEnv->NewObject( + uriClass.javaClass, uriConstructor.javaMethod, uriStringArg); + jniEnv->DeleteLocalRef(uriStringArg); + if (uriInstance == nullptr) { + return CheckThenError( + std::string("NewObject Exception when Init FlinkFileSystem, ") + .append(uriClass.ToString()) + .append(uriConstructor.ToString()) + .append(", args: ") + .append(base_path_)); + } + + // Construct FileSystem + jobject fileSystemInstance = jniEnv->CallStaticObjectMethod( + fileSystemClass.javaClass, fileSystemGetMethod.javaMethod, uriInstance); + jniEnv->DeleteLocalRef(uriInstance); + if (fileSystemInstance == nullptr) { + return CheckThenError( + std::string( + "CallStaticObjectMethod Exception when Init FlinkFileSystem, ") + .append(fileSystemClass.ToString()) + .append(fileSystemGetMethod.ToString()) + .append(", args: URI(") + .append(base_path_) + .append(")")); + } + file_system_instance_ = jniEnv->NewGlobalRef(fileSystemInstance); + jniEnv->DeleteLocalRef(fileSystemInstance); + return Status::OK(); +} + +std::string FlinkFileSystem::ConstructPath(const std::string& fname) { + return fname.at(0) == '/' ? base_path_ + fname : base_path_ + "/" + fname; +} + +// open a file for sequential reading +IOStatus FlinkFileSystem::NewSequentialFile( + const std::string& fname, const FileOptions& options, + std::unique_ptr* result, IODebugContext* dbg) { + result->reset(); + IOStatus status = FileExists(fname, IOOptions(), dbg); + if (!status.ok()) { + return status; + } + + auto f = new FlinkReadableFile(file_system_instance_, class_cache_, + ConstructPath(fname)); + IOStatus valid = f->Init(); + if (!valid.ok()) { + delete f; + return valid; + } + result->reset(f); + return IOStatus::OK(); +} + +// open a file for random reading +IOStatus FlinkFileSystem::NewRandomAccessFile( + const std::string& fname, const FileOptions& options, + std::unique_ptr* result, IODebugContext* dbg) { + result->reset(); + IOStatus status = FileExists(fname, IOOptions(), dbg); + if (!status.ok()) { + return status; + } + + auto f = new FlinkReadableFile(file_system_instance_, class_cache_, + ConstructPath(fname)); + IOStatus valid = f->Init(); + if (!valid.ok()) { + delete f; + return valid; + } + result->reset(f); + return IOStatus::OK(); +} + +// create a new file for writing +IOStatus FlinkFileSystem::NewWritableFile( + const std::string& fname, const FileOptions& options, + std::unique_ptr* result, IODebugContext* /*dbg*/) { + result->reset(); + auto f = new FlinkWritableFile(file_system_instance_, class_cache_, + ConstructPath(fname), options); + IOStatus valid = f->Init(); + if (!valid.ok()) { + delete f; + return valid; + } + result->reset(f); + return IOStatus::OK(); +} + +IOStatus FlinkFileSystem::NewDirectory(const std::string& name, + const IOOptions& options, + std::unique_ptr* result, + IODebugContext* dbg) { + result->reset(); + IOStatus s = FileExists(name, options, dbg); + if (s.ok()) { + result->reset(new FlinkDirectory()); + } + return s; +} + +IOStatus FlinkFileSystem::FileExists(const std::string& file_name, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) { + std::string filePath = ConstructPath(file_name); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(filePath, &pathInstance); + if (!status.ok()) { + return status; + } + + // Call exist method + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaMethodContext existsMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_EXISTS); + jboolean exists = jniEnv->CallBooleanMethod( + file_system_instance_, existsMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + + status = CurrentStatus([filePath]() { + return std::string("Exception when FileExists, path: ").append(filePath); + }); + if (!status.ok()) { + return status; + } + + return exists == JNI_TRUE ? IOStatus::OK() : IOStatus::NotFound(); +} + +// TODO: Not Efficient! Consider adding usable methods in FLink FileSystem +IOStatus FlinkFileSystem::GetChildren(const std::string& file_name, + const IOOptions& options, + std::vector* result, + IODebugContext* dbg) { + IOStatus fileExistsStatus = FileExists(file_name, options, dbg); + if (!fileExistsStatus.ok()) { + return fileExistsStatus.IsNotFound() + ? IOStatus::PathNotFound( + std::string("Could not find path when GetChildren, path: ") + .append(ConstructPath(file_name))) + : fileExistsStatus; + } + + std::string filePath = ConstructPath(file_name); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(filePath, &pathInstance); + if (!status.ok()) { + return status; + } + + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaMethodContext listStatusMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FILE_SYSTEM_LIST_STATUS); + + auto fileStatusArray = (jobjectArray)jniEnv->CallObjectMethod( + file_system_instance_, listStatusMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + if (fileStatusArray == nullptr) { + return CheckThenError( + std::string("Exception when CallObjectMethod in GetChildren, ") + .append(listStatusMethod.ToString()) + .append(", args: Path(") + .append(filePath) + .append(")")); + } + + jsize fileStatusArrayLen = jniEnv->GetArrayLength(fileStatusArray); + for (jsize i = 0; i < fileStatusArrayLen; i++) { + jobject fileStatusObj = jniEnv->GetObjectArrayElement(fileStatusArray, i); + if (fileStatusObj == nullptr) { + jniEnv->DeleteLocalRef(fileStatusArray); + return CheckThenError( + "Exception when GetObjectArrayElement in GetChildren"); + } + + JavaClassCache::JavaMethodContext getPathMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_STATUS_GET_PATH); + jobject subPath = + jniEnv->CallObjectMethod(fileStatusObj, getPathMethod.javaMethod); + jniEnv->DeleteLocalRef(fileStatusObj); + if (subPath == nullptr) { + jniEnv->DeleteLocalRef(fileStatusArray); + return CheckThenError( + std::string("Exception when CallObjectMethod in GetChildren, ") + .append(getPathMethod.ToString())); + } + + JavaClassCache::JavaMethodContext pathToStringMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_PATH_TO_STRING); + auto subPathStr = (jstring)jniEnv->CallObjectMethod( + subPath, pathToStringMethod.javaMethod); + jniEnv->DeleteLocalRef(subPath); + const char* str = jniEnv->GetStringUTFChars(subPathStr, nullptr); + result->emplace_back(str); + jniEnv->ReleaseStringUTFChars(subPathStr, str); + jniEnv->DeleteLocalRef(subPathStr); + } + + jniEnv->DeleteLocalRef(fileStatusArray); + return IOStatus::OK(); +} + +IOStatus FlinkFileSystem::DeleteDir(const std::string& file_name, + const IOOptions& options, + IODebugContext* dbg) { + return Delete(file_name, options, dbg, true); +}; + +IOStatus FlinkFileSystem::DeleteFile(const std::string& file_name, + const IOOptions& options, + IODebugContext* dbg) { + return Delete(file_name, options, dbg, false); +} + +IOStatus FlinkFileSystem::Delete(const std::string& file_name, + const IOOptions& options, IODebugContext* dbg, + bool recursive) { + IOStatus fileExistsStatus = FileExists(file_name, options, dbg); + if (!fileExistsStatus.ok()) { + return fileExistsStatus.IsNotFound() + ? IOStatus::PathNotFound( + std::string("Could not find path when Delete, path: ") + .append(ConstructPath(file_name))) + : fileExistsStatus; + } + + std::string filePath = ConstructPath(file_name); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(filePath, &pathInstance); + if (!status.ok()) { + return status; + } + + // Call delete method + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaMethodContext deleteMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_DELETE); + jboolean deleted = jniEnv->CallBooleanMethod( + file_system_instance_, deleteMethod.javaMethod, pathInstance, recursive); + jniEnv->DeleteLocalRef(pathInstance); + + status = CurrentStatus([filePath]() { + return std::string("Exception when Delete, path: ").append(filePath); + }); + if (!status.ok()) { + return status; + } + + return deleted + ? IOStatus::OK() + : IOStatus::IOError(std::string("Exception when Delete, path: ") + .append(filePath)); +} + +IOStatus FlinkFileSystem::CreateDir(const std::string& file_name, + const IOOptions& options, + IODebugContext* dbg) { + IOStatus s = FileExists(file_name, options, dbg); + if (!s.ok()) { + return CreateDirIfMissing(file_name, options, dbg); + } + return IOStatus::IOError(std::string("Exception when CreateDir because Dir (") + .append(file_name) + .append(") exists")); +} + +IOStatus FlinkFileSystem::CreateDirIfMissing(const std::string& file_name, + const IOOptions& options, + IODebugContext* dbg) { + JNIEnv* jniEnv = getJNIEnv(); + + std::string filePath = ConstructPath(file_name); + // Construct Path Instance + jobject pathInstance; + IOStatus status = + class_cache_->ConstructPathInstance(filePath, &pathInstance); + if (!status.ok()) { + return status; + } + + // Call mkdirs method + JavaClassCache::JavaMethodContext mkdirMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_MKDIR); + jboolean created = jniEnv->CallBooleanMethod( + file_system_instance_, mkdirMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + status = CurrentStatus([filePath]() { + return std::string("Exception when CreateDirIfMissing, path: ") + .append(filePath); + }); + if (!status.ok()) { + return status; + } + + return created ? IOStatus::OK() + : IOStatus::IOError( + std::string("Exception when CreateDirIfMissing, path: ") + .append(filePath)); +} + +IOStatus FlinkFileSystem::GetFileSize(const std::string& file_name, + const IOOptions& options, uint64_t* size, + IODebugContext* dbg) { + JNIEnv* jniEnv = getJNIEnv(); + jobject fileStatus; + IOStatus status = GetFileStatus(file_name, options, dbg, &fileStatus); + if (!status.ok()) { + return status; + } + + JavaClassCache::JavaMethodContext getLenMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_STATUS_GET_LEN); + jlong fileSize = jniEnv->CallLongMethod(fileStatus, getLenMethod.javaMethod); + jniEnv->DeleteLocalRef(fileStatus); + + status = CurrentStatus([file_name]() { + return std::string("Exception when GetFileSize, file name: ") + .append(file_name); + }); + if (!status.ok()) { + return status; + } + + *size = fileSize; + return IOStatus::OK(); +} + +// The life cycle of fileStatus is maintained by caller. +IOStatus FlinkFileSystem::GetFileStatus(const std::string& file_name, + const IOOptions& options, + IODebugContext* dbg, + jobject* fileStatus) { + IOStatus status = FileExists(file_name, options, dbg); + if (!status.ok()) { + return status.IsNotFound() + ? IOStatus::PathNotFound( + std::string( + "Could not find path when GetFileStatus, path: ") + .append(ConstructPath(file_name))) + : status; + } + + std::string filePath = ConstructPath(file_name); + // Construct Path Instance + jobject pathInstance; + status = class_cache_->ConstructPathInstance(filePath, &pathInstance); + if (!status.ok()) { + return status; + } + + // Call getFileStatus method + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaMethodContext getFileStatusMethod = + class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FILE_SYSTEM_GET_FILE_STATUS); + *fileStatus = jniEnv->CallObjectMethod( + file_system_instance_, getFileStatusMethod.javaMethod, pathInstance); + jniEnv->DeleteLocalRef(pathInstance); + + return CurrentStatus([filePath]() { + return std::string("Exception when GetFileStatus, path: ").append(filePath); + }); +} + +IOStatus FlinkFileSystem::GetFileModificationTime(const std::string& file_name, + const IOOptions& options, + uint64_t* time, + IODebugContext* dbg) { + JNIEnv* jniEnv = getJNIEnv(); + jobject fileStatus; + IOStatus status = GetFileStatus(file_name, options, dbg, &fileStatus); + if (!status.ok()) { + return status; + } + + JavaClassCache::JavaMethodContext getModificationTimeMethod = + class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FILE_STATUS_GET_MODIFICATION_TIME); + jlong fileModificationTime = + jniEnv->CallLongMethod(fileStatus, getModificationTimeMethod.javaMethod); + jniEnv->DeleteLocalRef(fileStatus); + + status = CurrentStatus([file_name]() { + return std::string("Exception when GetFileModificationTime, file name: ") + .append(file_name); + }); + if (!status.ok()) { + return status; + } + + *time = fileModificationTime; + return IOStatus::OK(); +} + +IOStatus FlinkFileSystem::IsDirectory(const std::string& path, + const IOOptions& options, bool* is_dir, + IODebugContext* dbg) { + JNIEnv* jniEnv = getJNIEnv(); + jobject fileStatus; + IOStatus status = GetFileStatus(path, options, dbg, &fileStatus); + if (!status.ok()) { + return status; + } + + JavaClassCache::JavaMethodContext isDirMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_STATUS_IS_DIR); + jboolean isDir = + jniEnv->CallBooleanMethod(fileStatus, isDirMethod.javaMethod); + jniEnv->DeleteLocalRef(fileStatus); + + status = CurrentStatus([path]() { + return std::string("Exception when IsDirectory, file name: ").append(path); + }); + if (!status.ok()) { + return status; + } + + *is_dir = isDir; + return IOStatus::OK(); +} + +IOStatus FlinkFileSystem::RenameFile(const std::string& src, + const std::string& target, + const IOOptions& options, + IODebugContext* dbg) { + IOStatus status = FileExists(src, options, dbg); + if (!status.ok()) { + return status.IsNotFound() + ? IOStatus::PathNotFound( + std::string( + "Could not find src path when RenameFile, path: ") + .append(ConstructPath(src))) + : status; + } + + JNIEnv* jniEnv = getJNIEnv(); + + std::string srcFilePath = ConstructPath(src); + // Construct src Path Instance + jobject srcPathInstance; + status = class_cache_->ConstructPathInstance(srcFilePath, &srcPathInstance); + if (!status.ok()) { + return status; + } + + std::string targetFilePath = ConstructPath(target); + // Construct target Path Instance + jobject targetPathInstance; + status = + class_cache_->ConstructPathInstance(targetFilePath, &targetPathInstance); + if (!status.ok()) { + jniEnv->DeleteLocalRef(srcPathInstance); + return status; + } + + JavaClassCache::JavaMethodContext renameMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FILE_SYSTEM_RENAME_FILE); + jboolean renamed = + jniEnv->CallBooleanMethod(file_system_instance_, renameMethod.javaMethod, + srcPathInstance, targetPathInstance); + jniEnv->DeleteLocalRef(srcPathInstance); + jniEnv->DeleteLocalRef(targetPathInstance); + + status = CurrentStatus([srcFilePath, targetFilePath]() { + return std::string("Exception when RenameFile, src: ") + .append(srcFilePath) + .append(", target: ") + .append(targetFilePath); + }); + if (!status.ok()) { + return status; + } + + return renamed + ? IOStatus::OK() + : IOStatus::IOError(std::string("Exception when RenameFile, src: ") + .append(srcFilePath) + .append(", target: ") + .append(targetFilePath)); +} + +IOStatus FlinkFileSystem::LockFile(const std::string& /*file_name*/, + const IOOptions& /*options*/, + FileLock** lock, IODebugContext* /*dbg*/) { + // There isn't a very good way to atomically check and create a file, + // Since it will not influence the usage of Flink, just leave it OK() now; + *lock = nullptr; + return IOStatus::OK(); +} + +IOStatus FlinkFileSystem::UnlockFile(FileLock* /*lock*/, + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) { + // There isn't a very good way to atomically check and create a file, + // Since it will not influence the usage of Flink, just leave it OK() now; + return IOStatus::OK(); +} + +Status FlinkFileSystem::Create(const std::shared_ptr& base, + const std::string& uri, + std::unique_ptr* result) { + auto* fileSystem = new FlinkFileSystem(base, uri); + Status status = fileSystem->Init(); + result->reset(fileSystem); + return status; +} +} // namespace ROCKSDB_NAMESPACE diff --git a/env/flink/env_flink.h b/env/flink/env_flink.h index d1912a3de..a4d1892b4 100644 --- a/env/flink/env_flink.h +++ b/env/flink/env_flink.h @@ -5,6 +5,7 @@ #pragma once +#include "jni_helper.h" #include "rocksdb/env.h" #include "rocksdb/file_system.h" #include "rocksdb/status.h" @@ -28,16 +29,9 @@ class FlinkFileSystem : public FileSystemWrapper { static const char* kNickName() { return "flink"; } const char* NickName() const override { return kNickName(); } - // Constructor and Destructor - explicit FlinkFileSystem(const std::shared_ptr& base, - const std::string& fsname); ~FlinkFileSystem() override; // Several methods current FileSystem must implement - - std::string GetId() const override; - Status ValidateOptions(const DBOptions& /*db_opts*/, - const ColumnFamilyOptions& /*cf_opts*/) const override; IOStatus NewSequentialFile(const std::string& /*fname*/, const FileOptions& /*options*/, std::unique_ptr* /*result*/, @@ -54,14 +48,14 @@ class FlinkFileSystem : public FileSystemWrapper { const IOOptions& /*options*/, std::unique_ptr* /*result*/, IODebugContext* /*dbg*/) override; - IOStatus FileExists(const std::string& /*fname*/, + IOStatus FileExists(const std::string& /*file_name*/, const IOOptions& /*options*/, IODebugContext* /*dbg*/) override; - IOStatus GetChildren(const std::string& /*path*/, + IOStatus GetChildren(const std::string& /*file_name*/, const IOOptions& /*options*/, std::vector* /*result*/, IODebugContext* /*dbg*/) override; - IOStatus DeleteFile(const std::string& /*fname*/, + IOStatus DeleteFile(const std::string& /*file_name*/, const IOOptions& /*options*/, IODebugContext* /*dbg*/) override; IOStatus CreateDir(const std::string& /*name*/, const IOOptions& /*options*/, @@ -69,9 +63,10 @@ class FlinkFileSystem : public FileSystemWrapper { IOStatus CreateDirIfMissing(const std::string& /*name*/, const IOOptions& /*options*/, IODebugContext* /*dbg*/) override; - IOStatus DeleteDir(const std::string& /*name*/, const IOOptions& /*options*/, + IOStatus DeleteDir(const std::string& /*file_name*/, + const IOOptions& /*options*/, IODebugContext* /*dbg*/) override; - IOStatus GetFileSize(const std::string& /*fname*/, + IOStatus GetFileSize(const std::string& /*file_name*/, const IOOptions& /*options*/, uint64_t* /*size*/, IODebugContext* /*dbg*/) override; IOStatus GetFileModificationTime(const std::string& /*fname*/, @@ -90,7 +85,23 @@ class FlinkFileSystem : public FileSystemWrapper { IODebugContext* /*dbg*/) override; private: - std::string base_path_; + const std::string base_path_; + JavaClassCache* class_cache_; + jobject file_system_instance_; + + explicit FlinkFileSystem(const std::shared_ptr& base, + const std::string& fsname); + + // Init FileSystem + Status Init(); + + IOStatus Delete(const std::string& /*file_name*/, + const IOOptions& /*options*/, IODebugContext* /*dbg*/, + bool /*recursive*/); + IOStatus GetFileStatus(const std::string& /*file_name*/, + const IOOptions& /*options*/, IODebugContext* /*dbg*/, + jobject* /*fileStatus*/); + std::string ConstructPath(const std::string& /*file_name*/); }; // Returns a `FlinkEnv` with base_path diff --git a/env/flink/jni_helper.cc b/env/flink/jni_helper.cc index 8d1ac5acf..6d18219cb 100644 --- a/env/flink/jni_helper.cc +++ b/env/flink/jni_helper.cc @@ -5,72 +5,325 @@ #include "jni_helper.h" +#include "jvm_util.h" + namespace ROCKSDB_NAMESPACE { -JavaClassCache::JavaClassCache(JNIEnv *env) : jni_env_(env) { +JavaClassCache::JavaClassCache(JNIEnv* env) : jni_env_(env) {} + +JavaClassCache::~JavaClassCache() { + // Release all global ref of cached jclasses + for (const auto& item : cached_java_classes_) { + if (item.javaClass) { + jni_env_->DeleteGlobalRef(item.javaClass); + } + } +} + +IOStatus JavaClassCache::Create(JNIEnv* env, + std::unique_ptr* result) { + auto classCache = new JavaClassCache(env); + IOStatus status = classCache->Init(); + if (!status.ok()) { + delete classCache; + result->reset(); + return status; + } + result->reset(classCache); + return status; +} + +IOStatus JavaClassCache::Init() { // Set all class names - cached_java_classes_[JavaClassCache::JC_URI].className = "java/net/URI"; - cached_java_classes_[JavaClassCache::JC_BYTE_BUFFER].className = + cached_java_classes_[CachedJavaClass::JC_URI].className = "java/net/URI"; + cached_java_classes_[CachedJavaClass::JC_BYTE_BUFFER].className = "java/nio/ByteBuffer"; - cached_java_classes_[JavaClassCache::JC_THROWABLE].className = + cached_java_classes_[CachedJavaClass::JC_THROWABLE].className = "java/lang/Throwable"; - cached_java_classes_[JavaClassCache::JC_FLINK_PATH].className = + cached_java_classes_[CachedJavaClass::JC_FLINK_PATH].className = "org/apache/flink/core/fs/Path"; - cached_java_classes_[JavaClassCache::JC_FLINK_FILE_SYSTEM].className = + cached_java_classes_[CachedJavaClass::JC_FLINK_FILE_SYSTEM].className = "org/apache/flink/state/forst/fs/ForStFlinkFileSystem"; - cached_java_classes_[JavaClassCache::JC_FLINK_FILE_STATUS].className = + cached_java_classes_[CachedJavaClass::JC_FLINK_FILE_STATUS].className = "org/apache/flink/core/fs/FileStatus"; - cached_java_classes_[JavaClassCache::JC_FLINK_FS_INPUT_STREAM].className = + cached_java_classes_[CachedJavaClass::JC_FLINK_FS_INPUT_STREAM].className = "org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream"; - cached_java_classes_[JavaClassCache::JC_FLINK_FS_OUTPUT_STREAM].className = + cached_java_classes_[CachedJavaClass::JC_FLINK_FS_OUTPUT_STREAM].className = "org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream"; - // Try best to create and set the jclass objects based on the class names set - // above + // Create and set the jclass objects based on the class names set above int numCachedClasses = - sizeof(cached_java_classes_) / sizeof(javaClassAndName); + sizeof(cached_java_classes_) / sizeof(JavaClassContext); for (int i = 0; i < numCachedClasses; i++) { - initCachedClass(cached_java_classes_[i].className, - &cached_java_classes_[i].javaClass); + IOStatus status = initCachedClass(cached_java_classes_[i].className, + &cached_java_classes_[i].javaClass); + if (!status.ok()) { + return status; + } } -} -JavaClassCache::~JavaClassCache() { - // Release all global ref of cached jclasses - for (const auto &item : cached_java_classes_) { - if (item.javaClass) { - jni_env_->DeleteGlobalRef(item.javaClass); + // Set all method names, signatures and class infos + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_CONSTRUCTOR] + .javaClassAndName = cached_java_classes_[JC_FLINK_PATH]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_CONSTRUCTOR].methodName = + ""; + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_CONSTRUCTOR].signature = + "(Lorg/apache/flink/core/fs/Path;)Z"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_TO_STRING] + .javaClassAndName = cached_java_classes_[JC_FLINK_PATH]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_TO_STRING].methodName = + "toString"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_TO_STRING].signature = + "()Ljava/lang/String;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_URI_CONSTRUCTOR] + .javaClassAndName = cached_java_classes_[JC_URI]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_URI_CONSTRUCTOR].methodName = + ""; + cached_java_methods_[CachedJavaMethod::JM_FLINK_URI_CONSTRUCTOR].signature = + "(Ljava/lang/String;)V"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET].methodName = + "get"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET].signature = + "(Ljava/net/URI;)Lorg/apache/flink/core/fs/FileSystem;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_EXISTS] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_EXISTS] + .methodName = "exists"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_EXISTS] + .signature = "(Lorg/apache/flink/core/fs/Path;)Z"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_LIST_STATUS] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_LIST_STATUS] + .methodName = "listStatus"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_LIST_STATUS] + .signature = + "(Lorg/apache/flink/core/fs/Path;)[Lorg/apache/flink/core/fs/FileStatus;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET_FILE_STATUS] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET_FILE_STATUS] + .methodName = "getFileStatus"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET_FILE_STATUS] + .signature = + "(Lorg/apache/flink/core/fs/Path;)Lorg/apache/flink/core/fs/FileStatus;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_DELETE] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_DELETE] + .methodName = "delete"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_DELETE] + .signature = "(Lorg/apache/flink/core/fs/Path;Z)Z"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_MKDIR] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_MKDIR] + .methodName = "mkdirs"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_MKDIR].signature = + "(Lorg/apache/flink/core/fs/Path;)Z"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_RENAME_FILE] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_RENAME_FILE] + .methodName = "rename"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_RENAME_FILE] + .signature = + "(Lorg/apache/flink/core/fs/Path;Lorg/apache/flink/core/fs/Path;)Z"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_OPEN] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_OPEN].methodName = + "open"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_OPEN].signature = + "(Lorg/apache/flink/core/fs/Path;)Lorg/apache/flink/state/forst/fs/" + "ByteBufferReadableFSDataInputStream;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SEQ_READ] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_INPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SEQ_READ] + .methodName = "readFully"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SEQ_READ] + .signature = "(Ljava/nio/ByteBuffer;)I"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_RANDOM_READ] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_INPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_RANDOM_READ] + .methodName = "readFully"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_RANDOM_READ] + .signature = "(JLjava/nio/ByteBuffer;)I"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SKIP] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_INPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SKIP] + .methodName = "skip"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SKIP] + .signature = "(J)J"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_WRITE] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_OUTPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_WRITE] + .methodName = "write"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_WRITE] + .signature = "(Ljava/nio/ByteBuffer;)V"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_FLUSH] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_OUTPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_FLUSH] + .methodName = "flush"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_FLUSH] + .signature = "()V"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_SYNC] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_OUTPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_SYNC] + .methodName = "sync"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_SYNC] + .signature = "()V"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_CLOSE] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_OUTPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_CLOSE] + .methodName = "close"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_CLOSE] + .signature = "()V"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_CREATE] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_CREATE] + .methodName = "create"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_CREATE] + .signature = + "(Lorg/apache/flink/core/fs/Path;)Lorg/apache/flink/state/forst/fs/" + "ByteBufferWritableFSDataOutputStream;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_PATH] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_STATUS]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_PATH] + .methodName = "getPath"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_PATH] + .signature = "()Lorg/apache/flink/core/fs/Path;"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_LEN] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_STATUS]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_LEN] + .methodName = "getLen"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_LEN] + .signature = "()J"; + + cached_java_methods_ + [CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_MODIFICATION_TIME] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_STATUS]; + cached_java_methods_ + [CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_MODIFICATION_TIME] + .methodName = "getModificationTime"; + cached_java_methods_ + [CachedJavaMethod::JM_FLINK_FILE_STATUS_GET_MODIFICATION_TIME] + .signature = "()J"; + + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_IS_DIR] + .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_STATUS]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_IS_DIR] + .methodName = "isDir"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_STATUS_IS_DIR] + .signature = "()Z"; + + // Create and set the jmethod based on the method names and signatures set + // above + int numCachedMethods = + sizeof(cached_java_methods_) / sizeof(JavaMethodContext); + for (int i = 0; i < numCachedMethods; i++) { + cached_java_methods_[i].javaMethod = jni_env_->GetMethodID( + cached_java_methods_[i].javaClassAndName.javaClass, + cached_java_methods_[i].methodName, cached_java_methods_[i].signature); + + if (!cached_java_methods_[i].javaMethod) { + return IOStatus::IOError(std::string("Exception when GetMethodID, ") + .append(cached_java_methods_[i].ToString())); } } + return IOStatus::OK(); } -Status JavaClassCache::initCachedClass(const char *className, - jclass *cachedJclass) { +IOStatus JavaClassCache::initCachedClass(const char* className, + jclass* cachedJclass) { jclass tempLocalClassRef = jni_env_->FindClass(className); if (!tempLocalClassRef) { - return Status::IOError("Exception when FindClass, class name: " + - std::string(className)); + return IOStatus::IOError("Exception when FindClass, class name: " + + std::string(className)); } *cachedJclass = (jclass)jni_env_->NewGlobalRef(tempLocalClassRef); if (!*cachedJclass) { - return Status::IOError("Exception when NewGlobalRef, class name " + - std::string(className)); + return IOStatus::IOError("Exception when NewGlobalRef, class name " + + std::string(className)); } jni_env_->DeleteLocalRef(tempLocalClassRef); - return Status::OK(); + return IOStatus::OK(); +} + +JavaClassCache::JavaClassContext JavaClassCache::GetJClass( + CachedJavaClass cachedJavaClass) { + return cached_java_classes_[cachedJavaClass]; +} + +JavaClassCache::JavaMethodContext JavaClassCache::GetJMethod( + CachedJavaMethod cachedJavaMethod) { + return cached_java_methods_[cachedJavaMethod]; } -Status JavaClassCache::GetJClass(CachedJavaClass cachedJavaClass, - jclass *javaClass) { - jclass targetClass = cached_java_classes_[cachedJavaClass].javaClass; - Status status = Status::OK(); - if (!targetClass) { - status = initCachedClass(cached_java_classes_[cachedJavaClass].className, - &targetClass); +IOStatus JavaClassCache::ConstructPathInstance(const std::string& file_path, + jobject* pathInstance) { + JNIEnv* jniEnv = getJNIEnv(); + JavaClassCache::JavaClassContext pathClass = + GetJClass(JavaClassCache::JC_FLINK_PATH); + JavaClassCache::JavaMethodContext pathConstructor = + GetJMethod(JavaClassCache::JM_FLINK_PATH_CONSTRUCTOR); + jstring pathString = jniEnv->NewStringUTF(file_path.c_str()); + jobject tempPathInstance = jniEnv->NewObject( + pathClass.javaClass, pathConstructor.javaMethod, pathString); + jniEnv->DeleteLocalRef(pathString); + if (tempPathInstance == nullptr) { + return CheckThenError(std::string("Exception when ConstructPathInstance, ") + .append(pathClass.ToString()) + .append(pathConstructor.ToString()) + .append(", args: Path(") + .append(file_path) + .append(")")); } - *javaClass = targetClass; - return status; + *pathInstance = tempPathInstance; + return IOStatus::OK(); +} + +IOStatus CurrentStatus( + const std::function& exceptionMessageIfError) { + JNIEnv* jniEnv = getJNIEnv(); + if (jniEnv->ExceptionCheck()) { + // Throw Exception to Java side, stop any call from Java. + jthrowable throwable = jniEnv->ExceptionOccurred(); + jniEnv->ExceptionDescribe(); + jniEnv->ExceptionClear(); + jniEnv->Throw(throwable); + return IOStatus::IOError(exceptionMessageIfError()); + } + return IOStatus::OK(); +} + +IOStatus CheckThenError(const std::string& exceptionMessageIfError) { + JNIEnv* jniEnv = getJNIEnv(); + if (jniEnv->ExceptionCheck()) { + // Throw Exception to Java side, stop any call from Java. + jthrowable throwable = jniEnv->ExceptionOccurred(); + jniEnv->ExceptionDescribe(); + jniEnv->ExceptionClear(); + jniEnv->Throw(throwable); + } + return IOStatus::IOError(exceptionMessageIfError); } } // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/jni_helper.h b/env/flink/jni_helper.h index 39d9e9f9a..fefaea8fb 100644 --- a/env/flink/jni_helper.h +++ b/env/flink/jni_helper.h @@ -3,8 +3,11 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). +#include +#include + #include "jni.h" -#include "rocksdb/status.h" +#include "rocksdb/io_status.h" namespace ROCKSDB_NAMESPACE { @@ -24,22 +27,98 @@ class JavaClassCache { NUM_CACHED_CLASSES } CachedJavaClass; - // Constructor and Destructor - explicit JavaClassCache(JNIEnv* env); - ~JavaClassCache(); - - // Get jclass by specific CachedJavaClass - Status GetJClass(CachedJavaClass cachedJavaClass, jclass* javaClass); + // Frequently-used method type representing jmethods which will be cached. + typedef enum { + JM_FLINK_PATH_CONSTRUCTOR, + JM_FLINK_PATH_TO_STRING, + JM_FLINK_URI_CONSTRUCTOR, + JM_FLINK_FILE_SYSTEM_GET, + JM_FLINK_FILE_SYSTEM_EXISTS, + JM_FLINK_FILE_SYSTEM_LIST_STATUS, + JM_FLINK_FILE_SYSTEM_GET_FILE_STATUS, + JM_FLINK_FILE_SYSTEM_DELETE, + JM_FLINK_FILE_SYSTEM_MKDIR, + JM_FLINK_FILE_SYSTEM_RENAME_FILE, + JM_FLINK_FILE_SYSTEM_OPEN, + JM_FLINK_FS_INPUT_STREAM_SEQ_READ, + JM_FLINK_FS_INPUT_STREAM_RANDOM_READ, + JM_FLINK_FS_INPUT_STREAM_SKIP, + JM_FLINK_FS_OUTPUT_STREAM_WRITE, + JM_FLINK_FS_OUTPUT_STREAM_FLUSH, + JM_FLINK_FS_OUTPUT_STREAM_SYNC, + JM_FLINK_FS_OUTPUT_STREAM_CLOSE, + JM_FLINK_FILE_SYSTEM_CREATE, + JM_FLINK_FILE_STATUS_GET_PATH, + JM_FLINK_FILE_STATUS_GET_LEN, + JM_FLINK_FILE_STATUS_GET_MODIFICATION_TIME, + JM_FLINK_FILE_STATUS_IS_DIR, + NUM_CACHED_METHODS + } CachedJavaMethod; - private: - typedef struct { + // jclass with its context description + struct JavaClassContext { jclass javaClass; const char* className; - } javaClassAndName; + std::string ToString() const { + return std::string("className: ").append(className); + } + }; + + // jmethod with its context description + struct JavaMethodContext { + JavaClassContext javaClassAndName; + jmethodID javaMethod; + const char* methodName; + const char* signature; + + std::string ToString() const { + return javaClassAndName.ToString() + .append(", methodName: ") + .append(methodName) + .append(", signature: ") + .append(signature); + } + }; + + ~JavaClassCache(); + + // Create a unique instance which inits necessary cached classes and methods. + // Return Status representing whether these classes and methods are inited + // correctly or not. + static IOStatus Create(JNIEnv* env, + std::unique_ptr* javaClassCache); + + // Get JavaClassContext by specific CachedJavaClass. + JavaClassContext GetJClass(CachedJavaClass cachedJavaClass); + + // Get JavaMethodContext by specific CachedJavaMethod. + JavaMethodContext GetJMethod(CachedJavaMethod cachedJavaMethod); + + // Construct Java Path Instance based on cached classes and method related to + // Path. + IOStatus ConstructPathInstance(const std::string& /*file_path*/, + jobject* /*pathInstance*/); + + private: JNIEnv* jni_env_; - javaClassAndName cached_java_classes_[JavaClassCache::NUM_CACHED_CLASSES]; + JavaClassContext cached_java_classes_[CachedJavaClass::NUM_CACHED_CLASSES]; + JavaMethodContext cached_java_methods_[CachedJavaMethod::NUM_CACHED_METHODS]; - Status initCachedClass(const char* className, jclass* cachedClass); + explicit JavaClassCache(JNIEnv* env); + + // Init all classes and methods. + IOStatus Init(); + + // Init cached class. + IOStatus initCachedClass(const char* className, jclass* cachedClass); }; + +// Return current status of JNIEnv. +IOStatus CurrentStatus( + const std::function& /*exceptionMessageIfError*/); + +// Wrap error status of JNIEnv. +IOStatus CheckThenError(const std::string& /*exceptionMessageIfError*/); + } // namespace ROCKSDB_NAMESPACE \ No newline at end of file From d749df58731691bd5d23bbf00415cf96f986da8a Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Mon, 18 Mar 2024 16:40:03 +0800 Subject: [PATCH 42/61] [env] Modify the license (#13) (cherry picked from commit a5c920d35dcf7a5a9a09bdd00b06cffdbff8a919) --- env/flink/env_flink.cc | 21 +++++++++++++++++---- env/flink/env_flink.h | 21 +++++++++++++++++---- env/flink/jni_helper.cc | 21 +++++++++++++++++---- env/flink/jni_helper.h | 21 +++++++++++++++++---- 4 files changed, 68 insertions(+), 16 deletions(-) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index 8987084d0..290aa215b 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -1,7 +1,20 @@ -// Copyright (c) 2021-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). +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ #include "env_flink.h" diff --git a/env/flink/env_flink.h b/env/flink/env_flink.h index a4d1892b4..2b937b050 100644 --- a/env/flink/env_flink.h +++ b/env/flink/env_flink.h @@ -1,7 +1,20 @@ -// Copyright (c) 2021-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). +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ #pragma once diff --git a/env/flink/jni_helper.cc b/env/flink/jni_helper.cc index 6d18219cb..de82978e3 100644 --- a/env/flink/jni_helper.cc +++ b/env/flink/jni_helper.cc @@ -1,7 +1,20 @@ -// Copyright (c) 2019-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). +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ #include "jni_helper.h" diff --git a/env/flink/jni_helper.h b/env/flink/jni_helper.h index fefaea8fb..1927a2c07 100644 --- a/env/flink/jni_helper.h +++ b/env/flink/jni_helper.h @@ -1,7 +1,20 @@ -// Copyright (c) 2019-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). +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ #include #include From 40bf82a40fa90961a5d040d3d32bc0046b39e992 Mon Sep 17 00:00:00 2001 From: Jinzhong Li Date: Thu, 21 Mar 2024 16:35:09 +0800 Subject: [PATCH 43/61] [env] Support JNI of FlinkEnv (#12) * [env] Support JNI of FlinkEnv (cherry picked from commit ec88681c32e5f9d80b0bf331070bd05d740d685c) --- env/flink/env_flink.cc | 21 +++++++ java/CMakeLists.txt | 3 + java/rocksjni/env_flink.cc | 63 ++++++++++++++++++++ java/src/main/java/org/rocksdb/FlinkEnv.java | 41 +++++++++++++ src.mk | 1 + 5 files changed, 129 insertions(+) create mode 100644 java/rocksjni/env_flink.cc create mode 100644 java/src/main/java/org/rocksdb/FlinkEnv.java diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index 290aa215b..9ff8f5b6d 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -855,4 +855,25 @@ Status FlinkFileSystem::Create(const std::shared_ptr& base, result->reset(fileSystem); return status; } + +Status NewFlinkEnv(const std::string& uri, + std::unique_ptr* flinkFileSystem) { + std::shared_ptr fs; + Status s = NewFlinkFileSystem(uri, &fs); + if (s.ok()) { + *flinkFileSystem = NewCompositeEnv(fs); + } + return s; +} + +Status NewFlinkFileSystem(const std::string& uri, + std::shared_ptr* fs) { + std::unique_ptr flinkFileSystem; + Status s = + FlinkFileSystem::Create(FileSystem::Default(), uri, &flinkFileSystem); + if (s.ok()) { + fs->reset(flinkFileSystem.release()); + } + return s; +} } // namespace ROCKSDB_NAMESPACE diff --git a/java/CMakeLists.txt b/java/CMakeLists.txt index f9fd9b564..fc9e0cfe7 100644 --- a/java/CMakeLists.txt +++ b/java/CMakeLists.txt @@ -37,6 +37,7 @@ set(JNI_NATIVE_SOURCES rocksjni/concurrent_task_limiter.cc rocksjni/config_options.cc rocksjni/env.cc + rocksjni/env_flink.cc rocksjni/env_options.cc rocksjni/event_listener.cc rocksjni/event_listener_jnicallback.cc @@ -167,6 +168,7 @@ set(JAVA_MAIN_CLASSES src/main/java/org/rocksdb/FilterPolicyType.java src/main/java/org/rocksdb/FileOperationInfo.java src/main/java/org/rocksdb/FlinkCompactionFilter.java + src/main/java/org/rocksdb/FlinkEnv.java src/main/java/org/rocksdb/FlushJobInfo.java src/main/java/org/rocksdb/FlushReason.java src/main/java/org/rocksdb/FlushOptions.java @@ -688,6 +690,7 @@ if(${CMAKE_VERSION} VERSION_LESS "3.11.4") org.rocksdb.EnvOptions org.rocksdb.Filter org.rocksdb.FlinkCompactionFilter + org.rocksdb.FlinkEnv org.rocksdb.FlushOptions org.rocksdb.HashLinkedListMemTableConfig org.rocksdb.HashSkipListMemTableConfig diff --git a/java/rocksjni/env_flink.cc b/java/rocksjni/env_flink.cc new file mode 100644 index 000000000..f6d4b44ca --- /dev/null +++ b/java/rocksjni/env_flink.cc @@ -0,0 +1,63 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "env/flink/env_flink.h" + +#include + +#include + +#include "java/rocksjni/portal.h" +#include "rocksdb/env.h" + +/* + * Class: org_rocksdb_FlinkEnv + * Method: createFlinkEnv + * Signature: (Ljava/lang/String;)J + */ +jlong Java_org_rocksdb_FlinkEnv_createFlinkEnv(JNIEnv* env, jclass, + jstring base_path) { + jboolean has_exception = JNI_FALSE; + auto path = + ROCKSDB_NAMESPACE::JniUtil::copyStdString(env, base_path, &has_exception); + if (has_exception == JNI_TRUE) { + ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew( + env, "Could not copy jstring to std::string"); + return 0; + } + std::unique_ptr flink_env; + auto status = ROCKSDB_NAMESPACE::NewFlinkEnv(path, &flink_env); + if (!status.ok()) { + ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, status); + return 0; + } + auto ptr_as_handle = flink_env.release(); + return reinterpret_cast(ptr_as_handle); +} + +/* + * Class: org_rocksdb_FlinkEnv + * Method: disposeInternal + * Signature: (J)V + */ +void Java_org_rocksdb_FlinkEnv_disposeInternal(JNIEnv*, jobject, + jlong jhandle) { + auto* handle = reinterpret_cast(jhandle); + assert(handle != nullptr); + delete handle; +} diff --git a/java/src/main/java/org/rocksdb/FlinkEnv.java b/java/src/main/java/org/rocksdb/FlinkEnv.java new file mode 100644 index 000000000..91e6d46b6 --- /dev/null +++ b/java/src/main/java/org/rocksdb/FlinkEnv.java @@ -0,0 +1,41 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.rocksdb; + +/** + * Flink Env which proxy all filesystem access to Flink FileSystem. + */ +public class FlinkEnv extends Env { + /** +

Creates a new environment that is used for Flink environment.

+ * + *

The caller must delete the result when it is + * no longer needed.

+ * + * @param basePath the base path string for the given Flink file system, + * formatted as "{fs-schema-supported-by-flink}://xxx" + */ + public FlinkEnv(final String basePath) { + super(createFlinkEnv(basePath)); + } + + private static native long createFlinkEnv(final String basePath); + + @Override protected final native void disposeInternal(final long handle); +} \ No newline at end of file diff --git a/src.mk b/src.mk index 4beae92a3..c58fc70fe 100644 --- a/src.mk +++ b/src.mk @@ -670,6 +670,7 @@ JNI_NATIVE_SOURCES = \ java/rocksjni/config_options.cc \ java/rocksjni/export_import_files_metadatajni.cc \ java/rocksjni/env.cc \ + java/rocksjni/env_flink.cc \ java/rocksjni/env_options.cc \ java/rocksjni/event_listener.cc \ java/rocksjni/event_listener_jnicallback.cc \ From a4ada5b6e3195371a873c89e0b7b78ade9da97ba Mon Sep 17 00:00:00 2001 From: Jinzhong Li Date: Fri, 29 Mar 2024 11:41:31 +0800 Subject: [PATCH 44/61] [env]Introduce flink-env test suite (#17) * [env]Introduce flink-env test suite (cherry picked from commit de9582bb42d8451ec36c15521507f6a9e1c951e8) --- CMakeLists.txt | 3 +- env/flink/env_flink.cc | 2 +- env/flink/env_flink.h | 8 + env/flink/env_flink_test_suite.cc | 66 +++ env/flink/env_flink_test_suite.h | 34 ++ env/flink/jni_helper.cc | 18 +- env/flink/jni_helper.h | 5 +- java/CMakeLists.txt | 3 + java/Makefile | 20 +- .../org/apache/flink/core/fs/FileStatus.java | 79 +++ .../org/apache/flink/core/fs/FileSystem.java | 257 ++++++++++ .../flink/core/fs/LocalDataInputStream.java | 83 ++++ .../flink/core/fs/LocalDataOutputStream.java | 92 ++++ .../apache/flink/core/fs/LocalFileStatus.java | 93 ++++ .../apache/flink/core/fs/LocalFileSystem.java | 296 +++++++++++ .../java/org/apache/flink/core/fs/Path.java | 469 ++++++++++++++++++ .../ByteBufferReadableFSDataInputStream.java | 133 +++++ .../ByteBufferWritableFSDataOutputStream.java | 83 ++++ .../state/forst/fs/ForStFlinkFileSystem.java | 126 +++++ java/rocksjni/env_flink_test_suite.cc | 73 +++ .../java/org/rocksdb/EnvFlinkTestSuite.java | 50 ++ .../java/org/rocksdb/flink/FlinkEnvTest.java | 45 ++ src.mk | 2 + 23 files changed, 2030 insertions(+), 10 deletions(-) create mode 100644 env/flink/env_flink_test_suite.cc create mode 100644 env/flink/env_flink_test_suite.h create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileStatus.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileSystem.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataInputStream.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataOutputStream.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileStatus.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileSystem.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/core/fs/Path.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream.java create mode 100644 java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ForStFlinkFileSystem.java create mode 100644 java/rocksjni/env_flink_test_suite.cc create mode 100644 java/src/main/java/org/rocksdb/EnvFlinkTestSuite.java create mode 100644 java/src/test/java/org/rocksdb/flink/FlinkEnvTest.java diff --git a/CMakeLists.txt b/CMakeLists.txt index 1efcde659..0f93b43e4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1022,7 +1022,8 @@ else() env/io_posix.cc env/flink/env_flink.cc env/flink/jvm_util.cc - env/flink/jni_helper.cc) + env/flink/jni_helper.cc + env/flink/env_flink_test_suite.cc) endif() if(USE_FOLLY_LITE) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index 9ff8f5b6d..b963fe508 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -306,7 +306,7 @@ class FlinkDirectory : public FSDirectory { FlinkFileSystem::FlinkFileSystem(const std::shared_ptr& base_fs, const std::string& base_path) - : FileSystemWrapper(base_fs), base_path_(base_path) {} + : FileSystemWrapper(base_fs), base_path_(TrimTrailingSlash(base_path)) {} FlinkFileSystem::~FlinkFileSystem() { if (file_system_instance_ != nullptr) { diff --git a/env/flink/env_flink.h b/env/flink/env_flink.h index 2b937b050..04295815f 100644 --- a/env/flink/env_flink.h +++ b/env/flink/env_flink.h @@ -115,6 +115,14 @@ class FlinkFileSystem : public FileSystemWrapper { const IOOptions& /*options*/, IODebugContext* /*dbg*/, jobject* /*fileStatus*/); std::string ConstructPath(const std::string& /*file_name*/); + + static std::string TrimTrailingSlash(const std::string& base_path) { + if (!base_path.empty() && base_path.back() == '/') { + return base_path.substr(0, base_path.size() - 1); + } else { + return base_path; + } + } }; // Returns a `FlinkEnv` with base_path diff --git a/env/flink/env_flink_test_suite.cc b/env/flink/env_flink_test_suite.cc new file mode 100644 index 000000000..2b1a312ab --- /dev/null +++ b/env/flink/env_flink_test_suite.cc @@ -0,0 +1,66 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "env/flink/env_flink_test_suite.h" + +#include +#include + +#define ASSERT_TRUE(expression) \ + if (!(expression)) { \ + std::cerr << "Assertion failed: " << #expression << ", file " << __FILE__ \ + << ", line " << __LINE__ << "." << std::endl; \ + std::abort(); \ + } + +namespace ROCKSDB_NAMESPACE { + +EnvFlinkTestSuites::EnvFlinkTestSuites(const std::string& basePath) + : base_path_(basePath) {} + +void EnvFlinkTestSuites::runAllTestSuites() { + setUp(); + testFileExist(); +} + +void EnvFlinkTestSuites::setUp() { + auto status = ROCKSDB_NAMESPACE::NewFlinkEnv(base_path_, &flink_env_); + if (!status.ok()) { + throw std::runtime_error("New FlinkEnv failed"); + } +} + +void EnvFlinkTestSuites::testFileExist() { + std::string fileName("test-file"); + Status result = flink_env_->FileExists(fileName); + ASSERT_TRUE(result.IsNotFound()); + + // Generate a file manually + const std::string prefix = "file:"; + std::string writeFileName = base_path_ + fileName; + if (writeFileName.compare(0, prefix.size(), prefix) == 0) { + writeFileName = writeFileName.substr(prefix.size()); + } + std::ofstream writeFile(writeFileName); + writeFile << "testFileExist"; + writeFile.close(); + + result = flink_env_->FileExists(fileName); + ASSERT_TRUE(result.ok()); +} +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/env_flink_test_suite.h b/env/flink/env_flink_test_suite.h new file mode 100644 index 000000000..3826060d5 --- /dev/null +++ b/env/flink/env_flink_test_suite.h @@ -0,0 +1,34 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "env_flink.h" + +namespace ROCKSDB_NAMESPACE { + +class EnvFlinkTestSuites { + public: + EnvFlinkTestSuites(const std::string& basePath); + void runAllTestSuites(); + + private: + std::unique_ptr flink_env_; + const std::string base_path_; + void setUp(); + void testFileExist(); +}; +} // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/jni_helper.cc b/env/flink/jni_helper.cc index de82978e3..9be816c39 100644 --- a/env/flink/jni_helper.cc +++ b/env/flink/jni_helper.cc @@ -81,7 +81,7 @@ IOStatus JavaClassCache::Init() { cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_CONSTRUCTOR].methodName = ""; cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_CONSTRUCTOR].signature = - "(Lorg/apache/flink/core/fs/Path;)Z"; + "(Ljava/lang/String;)V"; cached_java_methods_[CachedJavaMethod::JM_FLINK_PATH_TO_STRING] .javaClassAndName = cached_java_classes_[JC_FLINK_PATH]; @@ -103,6 +103,8 @@ IOStatus JavaClassCache::Init() { "get"; cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET].signature = "(Ljava/net/URI;)Lorg/apache/flink/core/fs/FileSystem;"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_GET].isStatic = + true; cached_java_methods_[CachedJavaMethod::JM_FLINK_FILE_SYSTEM_EXISTS] .javaClassAndName = cached_java_classes_[JC_FLINK_FILE_SYSTEM]; @@ -251,9 +253,17 @@ IOStatus JavaClassCache::Init() { int numCachedMethods = sizeof(cached_java_methods_) / sizeof(JavaMethodContext); for (int i = 0; i < numCachedMethods; i++) { - cached_java_methods_[i].javaMethod = jni_env_->GetMethodID( - cached_java_methods_[i].javaClassAndName.javaClass, - cached_java_methods_[i].methodName, cached_java_methods_[i].signature); + if (cached_java_methods_[i].isStatic) { + cached_java_methods_[i].javaMethod = jni_env_->GetStaticMethodID( + cached_java_methods_[i].javaClassAndName.javaClass, + cached_java_methods_[i].methodName, + cached_java_methods_[i].signature); + } else { + cached_java_methods_[i].javaMethod = jni_env_->GetMethodID( + cached_java_methods_[i].javaClassAndName.javaClass, + cached_java_methods_[i].methodName, + cached_java_methods_[i].signature); + } if (!cached_java_methods_[i].javaMethod) { return IOStatus::IOError(std::string("Exception when GetMethodID, ") diff --git a/env/flink/jni_helper.h b/env/flink/jni_helper.h index 1927a2c07..54a6da85b 100644 --- a/env/flink/jni_helper.h +++ b/env/flink/jni_helper.h @@ -84,13 +84,16 @@ class JavaClassCache { jmethodID javaMethod; const char* methodName; const char* signature; + bool isStatic = false; std::string ToString() const { return javaClassAndName.ToString() .append(", methodName: ") .append(methodName) .append(", signature: ") - .append(signature); + .append(signature) + .append(", isStatic:") + .append(isStatic ? "true" : "false"); } }; diff --git a/java/CMakeLists.txt b/java/CMakeLists.txt index fc9e0cfe7..c31083b6f 100644 --- a/java/CMakeLists.txt +++ b/java/CMakeLists.txt @@ -38,6 +38,7 @@ set(JNI_NATIVE_SOURCES rocksjni/config_options.cc rocksjni/env.cc rocksjni/env_flink.cc + rocksjni/env_flink_test_suite.cc rocksjni/env_options.cc rocksjni/event_listener.cc rocksjni/event_listener_jnicallback.cc @@ -159,6 +160,7 @@ set(JAVA_MAIN_CLASSES src/main/java/org/rocksdb/DirectSlice.java src/main/java/org/rocksdb/EncodingType.java src/main/java/org/rocksdb/Env.java + src/main/java/org/rocksdb/EnvFlinkTestSuite.java src/main/java/org/rocksdb/EnvOptions.java src/main/java/org/rocksdb/EventListener.java src/main/java/org/rocksdb/Experimental.java @@ -687,6 +689,7 @@ if(${CMAKE_VERSION} VERSION_LESS "3.11.4") org.rocksdb.DBOptions org.rocksdb.DirectSlice org.rocksdb.Env + org.rocksdb.EnvFlinkTestSuite org.rocksdb.EnvOptions org.rocksdb.Filter org.rocksdb.FlinkCompactionFilter diff --git a/java/Makefile b/java/Makefile index e80c8130b..aae28e0cd 100644 --- a/java/Makefile +++ b/java/Makefile @@ -209,6 +209,9 @@ JAVA_TESTS = \ org.rocksdb.WriteOptionsTest\ org.rocksdb.WriteBatchWithIndexTest +FLINK_TESTS = \ + org.rocksdb.flink.FlinkEnvTest + MAIN_SRC = src/main/java TEST_SRC = src/test/java OUTPUT = target @@ -303,14 +306,15 @@ PLUGIN_SOURCES = $(foreach root, $(ROCKSDB_PLUGIN_JAVA_ROOTS), $(foreach pkg, or CORE_SOURCES = $(foreach pkg, org/rocksdb/util org/rocksdb, $(MAIN_SRC)/$(pkg)/*.java) SOURCES = $(wildcard $(CORE_SOURCES) $(PLUGIN_SOURCES)) PLUGIN_TEST_SOURCES = $(foreach root, $(ROCKSDB_PLUGIN_JAVA_ROOTS), $(foreach pkg, org/rocksdb/test org/rocksdb/util org/rocksdb, $(root)/$(TEST_SRC)/$(pkg)/*.java)) -CORE_TEST_SOURCES = $(foreach pkg, org/rocksdb/test org/rocksdb/util org/rocksdb, $(TEST_SRC)/$(pkg)/*.java) +CORE_TEST_SOURCES = $(foreach pkg, org/rocksdb/test org/rocksdb/util org/rocksdb/flink org/rocksdb, $(TEST_SRC)/$(pkg)/*.java) TEST_SOURCES = $(wildcard $(CORE_TEST_SOURCES) $(PLUGIN_TEST_SOURCES)) +MOCK_FLINK_TEST_SOURCES = $(foreach pkg, org/apache/flink/core/fs org/apache/flink/state/forst/fs, flinktestmock/src/main/java/$(pkg)/*.java) # Configure the plugin tests and java classes ROCKSDB_PLUGIN_NATIVE_JAVA_CLASSES = $(foreach plugin, $(ROCKSDB_PLUGINS), $(foreach class, $($(plugin)_NATIVE_JAVA_CLASSES), $(class))) NATIVE_JAVA_CLASSES = $(NATIVE_JAVA_CLASSES) $(ROCKSDB_PLUGIN_NATIVE_JAVA_CLASSES) ROCKSDB_PLUGIN_JAVA_TESTS = $(foreach plugin, $(ROCKSDB_PLUGINS), $(foreach testclass, $($(plugin)_JAVA_TESTS), $(testclass))) -ALL_JAVA_TESTS = $(JAVA_TESTS) $(ROCKSDB_PLUGIN_JAVA_TESTS) +ALL_JAVA_TESTS = $(FLINK_TESTS) $(JAVA_TESTS) $(ROCKSDB_PLUGIN_JAVA_TESTS) # When debugging add -Xcheck:jni to the java args ifneq ($(DEBUG_LEVEL),0) @@ -450,7 +454,7 @@ java_test: java resolve_test_deps $(AM_V_at) $(JAVAC_CMD) $(JAVAC_ARGS) -cp $(MAIN_CLASSES):$(JAVA_TESTCLASSPATH) -h $(NATIVE_INCLUDE) -d $(TEST_CLASSES)\ $(TEST_SOURCES) -test: java java_test +test: java mock_flink_fs java_test $(MAKE) run_test run_test: @@ -466,3 +470,13 @@ db_bench: java pmd: $(MAVEN_CMD) pmd:pmd pmd:cpd pmd:check + +mock_flink_fs: + $(AM_V_at) $(JAVAC_CMD) $(JAVAC_ARGS) -cp $(MAIN_CLASSES):$(JAVA_TESTCLASSPATH) -h $(NATIVE_INCLUDE) -d $(TEST_CLASSES) \ + $(MOCK_FLINK_TEST_SOURCES) + +flink_test: java java_test mock_flink_fs + $(MAKE) run_flink_test + +run_flink_test: + $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp "$(MAIN_CLASSES):$(TEST_CLASSES):$(JAVA_TESTCLASSPATH):target/*" org.rocksdb.test.RocksJunitRunner $(FLINK_TESTS) diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileStatus.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileStatus.java new file mode 100644 index 000000000..52d3360b7 --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileStatus.java @@ -0,0 +1,79 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This file is based on source code from the Hadoop Project (http://hadoop.apache.org/), licensed + * by the Apache Software Foundation (ASF) under the Apache License, Version 2.0. See the NOTICE + * file distributed with this work for additional information regarding copyright ownership. + */ + +package org.apache.flink.core.fs; + +/** + * Interface that represents the client side information for a file independent of the file system. + */ +public interface FileStatus { + /** + * Return the length of this file. + * + * @return the length of this file + */ + long getLen(); + + /** + * Get the block size of the file. + * + * @return the number of bytes + */ + long getBlockSize(); + + /** + * Get the replication factor of a file. + * + * @return the replication factor of a file. + */ + short getReplication(); + + /** + * Get the modification time of the file. + * + * @return the modification time of file in milliseconds since January 1, 1970 UTC. + */ + long getModificationTime(); + + /** + * Get the access time of the file. + * + * @return the access time of file in milliseconds since January 1, 1970 UTC. + */ + long getAccessTime(); + + /** + * Checks if this object represents a directory. + * + * @return true if this is a directory, false otherwise + */ + boolean isDir(); + + /** + * Returns the corresponding Path to the FileStatus. + * + * @return the corresponding Path to the FileStatus + */ + Path getPath(); +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileSystem.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileSystem.java new file mode 100644 index 000000000..5fef72b42 --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/FileSystem.java @@ -0,0 +1,257 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This file is based on source code from the Hadoop Project (http://hadoop.apache.org/), licensed + * by the Apache Software Foundation (ASF) under the Apache License, Version 2.0. See the NOTICE + * file distributed with this work for additional information regarding copyright ownership. + */ + +package org.apache.flink.core.fs; + +import static org.apache.flink.core.fs.LocalFileSystem.LOCAL_URI; + +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.URI; +import java.util.Objects; + +/** + * Abstract base class of all file systems used by Flink. This class may be extended to implement + * distributed file systems, or local file systems. The abstraction by this file system is very + * simple, and the set of available operations quite limited, to support the common denominator of a + * wide range of file systems. For example, appending to or mutating existing files is not + * supported. + */ +public abstract class FileSystem { + /** + * The possible write modes. The write mode decides what happens if a file should be created, + * but already exists. + */ + public enum WriteMode { + + /** + * Creates the target file only if no file exists at that path already. Does not overwrite + * existing files and directories. + */ + NO_OVERWRITE, + + /** + * Creates a new target file regardless of any existing files or directories. Existing files + * and directories will be deleted (recursively) automatically before creating the new file. + */ + OVERWRITE + } + + /** + * Returns a reference to the {@link FileSystem} instance for accessing the local file system. + * + * @return a reference to the {@link FileSystem} instance for accessing the local file system. + */ + public static FileSystem getLocalFileSystem() { + return LocalFileSystem.getSharedInstance(); + } + + /** + * Returns a reference to the {@link FileSystem} instance for accessing the file system + * identified by the given {@link URI}. + * + * @param uri the {@link URI} identifying the file system + * @return a reference to the {@link FileSystem} instance for accessing the file system + * identified by the given {@link URI}. + * @throws IOException thrown if a reference to the file system instance could not be obtained + */ + public static FileSystem get(URI uri) throws IOException { + if (Objects.equals(LOCAL_URI.getScheme(), uri.getScheme()) + && Objects.equals(LOCAL_URI.getAuthority(), LOCAL_URI.getAuthority())) { + return getLocalFileSystem(); + } + throw new UnsupportedOperationException("Unsupported URI pattern:" + uri); + } + + // ------------------------------------------------------------------------ + // File System Methods + // ------------------------------------------------------------------------ + + /** + * Returns the path of the file system's current working directory. + * + * @return the path of the file system's current working directory + */ + public abstract Path getWorkingDirectory(); + + /** + * Returns the path of the user's home directory in this file system. + * + * @return the path of the user's home directory in this file system. + */ + public abstract Path getHomeDirectory(); + + /** + * Returns a URI whose scheme and authority identify this file system. + * + * @return a URI whose scheme and authority identify this file system + */ + public abstract URI getUri(); + + /** + * Return a file status object that represents the path. + * + * @param f The path we want information from + * @return a FileStatus object + * @throws FileNotFoundException when the path does not exist; IOException see specific + * implementation + */ + public abstract FileStatus getFileStatus(Path f) throws IOException; + + /** + * Opens an FSDataInputStream at the indicated Path. + * + * @param f the file name to open + * @param bufferSize the size of the buffer to be used. + */ + public abstract InputStream open(Path f, int bufferSize) throws IOException; + + /** + * Opens an FSDataInputStream at the indicated Path. + * + * @param f the file to open + */ + public abstract InputStream open(Path f) throws IOException; + + /** + * List the statuses of the files/directories in the given path if the path is a directory. + * + * @param f given path + * @return the statuses of the files/directories in the given path + * @throws IOException + */ + public abstract FileStatus[] listStatus(Path f) throws IOException; + + /** + * Check if exists. + * + * @param f source file + */ + public boolean exists(final Path f) throws IOException { + try { + return (getFileStatus(f) != null); + } catch (FileNotFoundException e) { + return false; + } + } + + /** + * Delete a file. + * + * @param f the path to delete + * @param recursive if path is a directory and set to true, the directory is + * deleted else throws an exception. In case of a file the recursive can be set to either + * true or false + * @return true if delete is successful, false otherwise + * @throws IOException + */ + public abstract boolean delete(Path f, boolean recursive) throws IOException; + + /** + * Make the given file and all non-existent parents into directories. Has the semantics of Unix + * 'mkdir -p'. Existence of the directory hierarchy is not an error. + * + * @param f the directory/directories to be created + * @return true if at least one new directory has been created, false + * otherwise + * @throws IOException thrown if an I/O error occurs while creating the directory + */ + public abstract boolean mkdirs(Path f) throws IOException; + + /** + * Opens an FSDataOutputStream at the indicated Path. + * + *

This method is deprecated, because most of its parameters are ignored by most file + * systems. To control for example the replication factor and block size in the Hadoop + * Distributed File system, make sure that the respective Hadoop configuration file is either + * linked from the Flink configuration, or in the classpath of either Flink or the user code. + * + * @param f the file name to open + * @param overwrite if a file with this name already exists, then if true, the file will be + * overwritten, and if false an error will be thrown. + * @param bufferSize the size of the buffer to be used. + * @param replication required block replication for the file. + * @param blockSize the size of the file blocks + * @throws IOException Thrown, if the stream could not be opened because of an I/O, or because a + * file already exists at that path and the write mode indicates to not overwrite the file. + * @deprecated Deprecated because not well supported across types of file systems. Control the + * behavior of specific file systems via configurations instead. + */ + @Deprecated + public OutputStream create(Path f, boolean overwrite, int bufferSize, short replication, + long blockSize) throws IOException { + return create(f, overwrite ? WriteMode.OVERWRITE : WriteMode.NO_OVERWRITE); + } + + /** + * Opens an FSDataOutputStream at the indicated Path. + * + * @param f the file name to open + * @param overwrite if a file with this name already exists, then if true, the file will be + * overwritten, and if false an error will be thrown. + * @throws IOException Thrown, if the stream could not be opened because of an I/O, or because a + * file already exists at that path and the write mode indicates to not overwrite the file. + * @deprecated Use {@link #create(Path, WriteMode)} instead. + */ + @Deprecated + public OutputStream create(Path f, boolean overwrite) throws IOException { + return create(f, overwrite ? WriteMode.OVERWRITE : WriteMode.NO_OVERWRITE); + } + + /** + * Opens an FSDataOutputStream to a new file at the given path. + * + *

If the file already exists, the behavior depends on the given {@code WriteMode}. If the + * mode is set to {@link WriteMode#NO_OVERWRITE}, then this method fails with an exception. + * + * @param f The file path to write to + * @param overwriteMode The action to take if a file or directory already exists at the given + * path. + * @return The stream to the new file at the target path. + * @throws IOException Thrown, if the stream could not be opened because of an I/O, or because a + * file already exists at that path and the write mode indicates to not overwrite the file. + */ + public abstract OutputStream create(Path f, WriteMode overwriteMode) throws IOException; + + /** + * Renames the file/directory src to dst. + * + * @param src the file/directory to rename + * @param dst the new name of the file/directory + * @return true if the renaming was successful, false otherwise + * @throws IOException + */ + public abstract boolean rename(Path src, Path dst) throws IOException; + + /** + * Returns true if this is a distributed file system. A distributed file system here means that + * the file system is shared among all Flink processes that participate in a cluster or job and + * that all these processes can see the same files. + * + * @return True, if this is a distributed file system, false otherwise. + */ + public abstract boolean isDistributedFS(); +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataInputStream.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataInputStream.java new file mode 100644 index 000000000..64706ba8d --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataInputStream.java @@ -0,0 +1,83 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.core.fs; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.channels.FileChannel; + +/** + * The LocalDataInputStream class is a wrapper class for a data input stream to the + * local file system. + */ +public class LocalDataInputStream extends InputStream { + /** The file input stream used to read data from. */ + private final FileInputStream fis; + + private final FileChannel fileChannel; + + /** + * Constructs a new LocalDataInputStream object from a given {@link File} object. + * + * @param file The File the data stream is read from + * @throws IOException Thrown if the data input stream cannot be created. + */ + public LocalDataInputStream(File file) throws IOException { + this.fis = new FileInputStream(file); + this.fileChannel = fis.getChannel(); + } + + public void seek(long desired) throws IOException { + if (desired != getPos()) { + this.fileChannel.position(desired); + } + } + + public long getPos() throws IOException { + return this.fileChannel.position(); + } + + @Override + public int read() throws IOException { + return this.fis.read(); + } + + @Override + public int read(byte[] buffer, int offset, int length) throws IOException { + return this.fis.read(buffer, offset, length); + } + + @Override + public void close() throws IOException { + // According to javadoc, this also closes the channel + this.fis.close(); + } + + @Override + public int available() throws IOException { + return this.fis.available(); + } + + @Override + public long skip(final long n) throws IOException { + return this.fis.skip(n); + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataOutputStream.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataOutputStream.java new file mode 100644 index 000000000..aabfcaa98 --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalDataOutputStream.java @@ -0,0 +1,92 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.core.fs; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.nio.channels.ClosedChannelException; + +/** + * The LocalDataOutputStream class is a wrapper class for a data output stream to the + * local file system. + */ +public class LocalDataOutputStream extends OutputStream { + /** The file output stream used to write data. */ + private final FileOutputStream fos; + + private boolean closed = false; + + /** + * Constructs a new LocalDataOutputStream object from a given {@link File} object. + * + * @param file the {@link File} object the data stream is read from + * @throws IOException thrown if the data output stream cannot be created + */ + public LocalDataOutputStream(final File file) throws IOException { + this.fos = new FileOutputStream(file); + } + + @Override + public void write(final int b) throws IOException { + checkOpen(); + fos.write(b); + } + + @Override + public void write(final byte[] b) throws IOException { + checkOpen(); + fos.write(b); + } + + @Override + public void write(final byte[] b, final int off, final int len) throws IOException { + checkOpen(); + fos.write(b, off, len); + } + + @Override + public void close() throws IOException { + closed = true; + fos.close(); + } + + @Override + public void flush() throws IOException { + checkOpen(); + fos.flush(); + } + + public void sync() throws IOException { + checkOpen(); + fos.getFD().sync(); + } + + public long getPos() throws IOException { + checkOpen(); + return fos.getChannel().position(); + } + + private void checkOpen() throws IOException { + if (closed) { + throw new ClosedChannelException(); + } + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileStatus.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileStatus.java new file mode 100644 index 000000000..b79f112ce --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileStatus.java @@ -0,0 +1,93 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.core.fs; + +import java.io.File; + +/** + * The class LocalFileStatus provides an implementation of the {@link FileStatus} + * interface for the local file system. + */ +public class LocalFileStatus implements FileStatus { + /** The file this file status belongs to. */ + private final File file; + + /** The path of this file this file status belongs to. */ + private final Path path; + + /** Cached length field, to avoid repeated native/syscalls. */ + private final long len; + + /** + * Creates a LocalFileStatus object from a given {@link File} object. + * + * @param f the {@link File} object this LocalFileStatus refers to + * @param fs the file system the corresponding file has been read from + */ + public LocalFileStatus(final File f, final FileSystem fs) { + this.file = f; + this.path = new Path(fs.getUri().getScheme() + ":" + f.toURI().getPath()); + this.len = f.length(); + } + + @Override + public long getAccessTime() { + return 0; // We don't have access files for local files + } + + @Override + public long getBlockSize() { + return this.len; + } + + @Override + public long getLen() { + return this.len; + } + + @Override + public long getModificationTime() { + return this.file.lastModified(); + } + + @Override + public short getReplication() { + return 1; // For local files replication is always 1 + } + + @Override + public boolean isDir() { + return this.file.isDirectory(); + } + + @Override + public Path getPath() { + return this.path; + } + + public File getFile() { + return this.file; + } + + @Override + public String toString() { + return "LocalFileStatus{" + + "file=" + file + ", path=" + path + '}'; + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileSystem.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileSystem.java new file mode 100644 index 000000000..863d689f3 --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/LocalFileSystem.java @@ -0,0 +1,296 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Parts of earlier versions of this file were based on source code from the + * Hadoop Project (http://hadoop.apache.org/), licensed by the Apache Software Foundation (ASF) + * under the Apache License, Version 2.0. See the NOTICE file distributed with this work for + * additional information regarding copyright ownership. + */ + +package org.apache.flink.core.fs; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.URI; +import java.nio.file.AccessDeniedException; +import java.nio.file.DirectoryNotEmptyException; +import java.nio.file.FileAlreadyExistsException; +import java.nio.file.Files; +import java.nio.file.NoSuchFileException; +import java.nio.file.StandardCopyOption; + +/** + * The class {@code LocalFileSystem} is an implementation of the {@link FileSystem} interface for + * the local file system of the machine where the JVM runs. + */ +public class LocalFileSystem extends FileSystem { + /** The URI representing the local file system. */ + public static final URI LOCAL_URI = URI.create("file:///"); + + /** The shared instance of the local file system. */ + private static final LocalFileSystem INSTANCE = new LocalFileSystem(); + + /** + * Path pointing to the current working directory. Because Paths are not immutable, we cannot + * cache the proper path here + */ + private final URI workingDir; + + /** + * Path pointing to the current user home directory. Because Paths are not immutable, we cannot + * cache the proper path here. + */ + private final URI homeDir; + + /** Constructs a new LocalFileSystem object. */ + public LocalFileSystem() { + this.workingDir = new File(System.getProperty("user.dir")).toURI(); + this.homeDir = new File(System.getProperty("user.home")).toURI(); + } + + // ------------------------------------------------------------------------ + + @Override + public FileStatus getFileStatus(Path f) throws IOException { + final File path = pathToFile(f); + if (path.exists()) { + return new LocalFileStatus(path, this); + } else { + throw new FileNotFoundException("File " + f + " does not exist or the user running " + + "Flink ('" + System.getProperty("user.name") + + "') has insufficient permissions to access it."); + } + } + + @Override + public URI getUri() { + return LOCAL_URI; + } + + @Override + public Path getWorkingDirectory() { + return new Path(workingDir); + } + + @Override + public Path getHomeDirectory() { + return new Path(homeDir); + } + + @Override + public InputStream open(final Path f, final int bufferSize) throws IOException { + return open(f); + } + + @Override + public InputStream open(final Path f) throws IOException { + final File file = pathToFile(f); + return new LocalDataInputStream(file); + } + + @Override + public boolean exists(Path f) throws IOException { + final File path = pathToFile(f); + return path.exists(); + } + + @Override + public FileStatus[] listStatus(final Path f) throws IOException { + final File localf = pathToFile(f); + FileStatus[] results; + + if (!localf.exists()) { + return null; + } + if (localf.isFile()) { + return new FileStatus[] {new LocalFileStatus(localf, this)}; + } + + final String[] names = localf.list(); + if (names == null) { + return null; + } + results = new FileStatus[names.length]; + for (int i = 0; i < names.length; i++) { + results[i] = getFileStatus(new Path(f, names[i])); + } + + return results; + } + + @Override + public boolean delete(final Path f, final boolean recursive) throws IOException { + final File file = pathToFile(f); + if (file.isFile()) { + return file.delete(); + } else if ((!recursive) && file.isDirectory()) { + File[] containedFiles = file.listFiles(); + if (containedFiles == null) { + throw new IOException( + "Directory " + file.toString() + " does not exist or an I/O error occurred"); + } else if (containedFiles.length != 0) { + throw new IOException("Directory " + file.toString() + " is not empty"); + } + } + + return delete(file); + } + + /** + * Deletes the given file or directory. + * + * @param f the file to be deleted + * @return true if all files were deleted successfully, false + * otherwise + * @throws IOException thrown if an error occurred while deleting the files/directories + */ + private boolean delete(final File f) throws IOException { + if (f.isDirectory()) { + final File[] files = f.listFiles(); + if (files != null) { + for (File file : files) { + final boolean del = delete(file); + if (!del) { + return false; + } + } + } + } else { + return f.delete(); + } + + // Now directory is empty + return f.delete(); + } + + /** + * Recursively creates the directory specified by the provided path. + * + * @return trueif the directories either already existed or have been created + * successfully, false otherwise + * @throws IOException thrown if an error occurred while creating the directory/directories + */ + @Override + public boolean mkdirs(final Path f) throws IOException { + assert f != null; + return mkdirsInternal(pathToFile(f)); + } + + private boolean mkdirsInternal(File file) throws IOException { + if (file.isDirectory()) { + return true; + } else if (file.exists() && !file.isDirectory()) { + // Important: The 'exists()' check above must come before the 'isDirectory()' check to + // be safe when multiple parallel instances try to create the directory + + // exists and is not a directory -> is a regular file + throw new FileAlreadyExistsException(file.getAbsolutePath()); + } else { + File parent = file.getParentFile(); + return (parent == null || mkdirsInternal(parent)) && (file.mkdir() || file.isDirectory()); + } + } + + @Override + public OutputStream create(final Path filePath, final WriteMode overwrite) throws IOException { + // checkNotNull(filePath, "filePath"); + + if (exists(filePath) && overwrite == WriteMode.NO_OVERWRITE) { + throw new FileAlreadyExistsException("File already exists: " + filePath); + } + + final Path parent = filePath.getParent(); + if (parent != null && !mkdirs(parent)) { + throw new IOException("Mkdirs failed to create " + parent); + } + + final File file = pathToFile(filePath); + return new LocalDataOutputStream(file); + } + + @Override + public boolean rename(final Path src, final Path dst) throws IOException { + final File srcFile = pathToFile(src); + final File dstFile = pathToFile(dst); + + final File dstParent = dstFile.getParentFile(); + + // Files.move fails if the destination directory doesn't exist + // noinspection ResultOfMethodCallIgnored -- we don't care if the directory existed or was + // created + dstParent.mkdirs(); + + try { + Files.move(srcFile.toPath(), dstFile.toPath(), StandardCopyOption.REPLACE_EXISTING); + return true; + } catch (NoSuchFileException | AccessDeniedException | DirectoryNotEmptyException + | SecurityException ex) { + // catch the errors that are regular "move failed" exceptions and return false + return false; + } + } + + @Override + public boolean isDistributedFS() { + return false; + } + + // ------------------------------------------------------------------------ + + /** + * Converts the given Path to a File for this file system. If the path is empty, we will return + * new File(".") instead of new File(""), since the latter returns + * false for isDirectory judgement (See issue + * https://issues.apache.org/jira/browse/FLINK-18612). + */ + public File pathToFile(Path path) { + String localPath = path.getPath(); + // checkState(localPath != null, "Cannot convert a null path to File"); + + if (localPath.length() == 0) { + return new File("."); + } + + return new File(localPath); + } + + // ------------------------------------------------------------------------ + + /** + * Gets the URI that represents the local file system. That URI is {@code "file:/"} on Windows + * platforms and {@code "file:///"} on other UNIX family platforms. + * + * @return The URI that represents the local file system. + */ + public static URI getLocalFsURI() { + return LOCAL_URI; + } + + /** + * Gets the shared instance of this file system. + * + * @return The shared instance of this file system. + */ + public static LocalFileSystem getSharedInstance() { + return INSTANCE; + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/core/fs/Path.java b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/Path.java new file mode 100644 index 000000000..1d06ae4be --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/core/fs/Path.java @@ -0,0 +1,469 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* This file is based on source code from the Hadoop Project (http://hadoop.apache.org/), licensed + * by the Apache Software Foundation (ASF) under the Apache License, Version 2.0. See the NOTICE + * file distributed with this work for additional information regarding copyright ownership. */ + +package org.apache.flink.core.fs; + +import java.io.File; +import java.io.IOException; +import java.io.Serializable; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.regex.Pattern; + +/** + * Names a file or directory in a {@link FileSystem}. Path strings use slash as the directory + * separator. A path string is absolute if it begins with a slash. + * + *

Tailing slashes are removed from the path. + * + *

Note: Path will no longer implement {@link IOReadableWritable} in future versions. Please use + * {@code serializeToDataOutputView} and {@code deserializeFromDataInputView} instead. + */ +public class Path implements Serializable { + private static final long serialVersionUID = 1L; + + /** The directory separator, a slash. */ + public static final String SEPARATOR = "/"; + + /** The directory separator, a slash (character). */ + public static final char SEPARATOR_CHAR = '/'; + + /** Character denoting the current directory. */ + public static final String CUR_DIR = "."; + + /** A pre-compiled regex/state-machine to match the windows drive pattern. */ + private static final Pattern WINDOWS_ROOT_DIR_REGEX = Pattern.compile("/\\p{Alpha}+:/"); + + /** The internal representation of the path, a hierarchical URI. */ + private URI uri; + + /** Constructs a new (empty) path object (used to reconstruct path object after RPC call). */ + public Path() {} + + /** + * Constructs a path object from a given URI. + * + * @param uri the URI to construct the path object from + */ + public Path(URI uri) { + this.uri = uri; + } + + /** + * Resolve a child path against a parent path. + * + * @param parent the parent path + * @param child the child path + */ + public Path(String parent, String child) { + this(new Path(parent), new Path(child)); + } + + /** + * Resolve a child path against a parent path. + * + * @param parent the parent path + * @param child the child path + */ + public Path(Path parent, String child) { + this(parent, new Path(child)); + } + + /** + * Resolve a child path against a parent path. + * + * @param parent the parent path + * @param child the child path + */ + public Path(String parent, Path child) { + this(new Path(parent), child); + } + + /** + * Resolve a child path against a parent path. + * + * @param parent the parent path + * @param child the child path + */ + public Path(Path parent, Path child) { + // Add a slash to parent's path so resolution is compatible with URI's + URI parentUri = parent.uri; + final String parentPath = parentUri.getPath(); + if (!(parentPath.equals("/") || parentPath.equals(""))) { + try { + parentUri = new URI( + parentUri.getScheme(), parentUri.getAuthority(), parentUri.getPath() + "/", null, null); + } catch (URISyntaxException e) { + throw new IllegalArgumentException(e); + } + } + + if (child.uri.getPath().startsWith(Path.SEPARATOR)) { + child = new Path( + child.uri.getScheme(), child.uri.getAuthority(), child.uri.getPath().substring(1)); + } + + final URI resolved = parentUri.resolve(child.uri); + initialize(resolved.getScheme(), resolved.getAuthority(), resolved.getPath()); + } + + /** + * Checks if the provided path string is either null or has zero length and throws a {@link + * IllegalArgumentException} if any of the two conditions apply. + * + * @param path the path string to be checked + * @return The checked path. + */ + private String checkPathArg(String path) { + // disallow construction of a Path from an empty string + if (path == null) { + throw new IllegalArgumentException("Can not create a Path from a null string"); + } + if (path.length() == 0) { + throw new IllegalArgumentException("Can not create a Path from an empty string"); + } + return path; + } + + /** + * Construct a path from a String. Path strings are URIs, but with unescaped elements and some + * additional normalization. + * + * @param pathString the string to construct a path from + */ + public Path(String pathString) { + pathString = checkPathArg(pathString); + + // We can't use 'new URI(String)' directly, since it assumes things are + // escaped, which we don't require of Paths. + + // add a slash in front of paths with Windows drive letters + if (hasWindowsDrive(pathString, false)) { + pathString = "/" + pathString; + } + + // parse uri components + String scheme = null; + String authority = null; + + int start = 0; + + // parse uri scheme, if any + final int colon = pathString.indexOf(':'); + final int slash = pathString.indexOf('/'); + if ((colon != -1) && ((slash == -1) || (colon < slash))) { // has a + // scheme + scheme = pathString.substring(0, colon); + start = colon + 1; + } + + // parse uri authority, if any + if (pathString.startsWith("//", start) && (pathString.length() - start > 2)) { // has authority + final int nextSlash = pathString.indexOf('/', start + 2); + final int authEnd = nextSlash > 0 ? nextSlash : pathString.length(); + authority = pathString.substring(start + 2, authEnd); + start = authEnd; + } + + // uri path is the rest of the string -- query & fragment not supported + final String path = pathString.substring(start, pathString.length()); + + initialize(scheme, authority, path); + } + + /** + * Construct a Path from a scheme, an authority and a path string. + * + * @param scheme the scheme string + * @param authority the authority string + * @param path the path string + */ + public Path(String scheme, String authority, String path) { + path = checkPathArg(path); + initialize(scheme, authority, path); + } + + /** + * Initializes a path object given the scheme, authority and path string. + * + * @param scheme the scheme string. + * @param authority the authority string. + * @param path the path string. + */ + private void initialize(String scheme, String authority, String path) { + try { + this.uri = new URI(scheme, authority, normalizePath(path), null, null).normalize(); + } catch (URISyntaxException e) { + throw new IllegalArgumentException(e); + } + } + + /** + * Normalizes a path string. + * + * @param path the path string to normalize + * @return the normalized path string + */ + private String normalizePath(String path) { + // remove consecutive slashes & backslashes + path = path.replace("\\", "/"); + path = path.replaceAll("/+", "/"); + + // remove tailing separator + if (path.endsWith(SEPARATOR) && !path.equals(SEPARATOR) && // UNIX root path + !WINDOWS_ROOT_DIR_REGEX.matcher(path).matches()) { // Windows root path) + + // remove tailing slash + path = path.substring(0, path.length() - SEPARATOR.length()); + } + + return path; + } + + /** + * Converts the path object to a {@link URI}. + * + * @return the {@link URI} object converted from the path object + */ + public URI toUri() { + return uri; + } + + /** + * Returns the FileSystem that owns this Path. + * + * @return the FileSystem that owns this Path + * @throws IOException thrown if the file system could not be retrieved + */ + public FileSystem getFileSystem() throws IOException { + return FileSystem.get(this.toUri()); + } + + /** + * Checks if the directory of this path is absolute. + * + * @return true if the directory of this path is absolute, false + * otherwise + */ + public boolean isAbsolute() { + final int start = hasWindowsDrive(uri.getPath(), true) ? 3 : 0; + return uri.getPath().startsWith(SEPARATOR, start); + } + + /** + * Returns the final component of this path, i.e., everything that follows the last separator. + * + * @return the final component of the path + */ + public String getName() { + final String path = uri.getPath(); + final int slash = path.lastIndexOf(SEPARATOR); + return path.substring(slash + 1); + } + + /** + * Return full path. + * + * @return full path + */ + public String getPath() { + return uri.getPath(); + } + + /** + * Returns the parent of a path, i.e., everything that precedes the last separator or null + * if at root. + * + * @return the parent of a path or null if at root. + */ + public Path getParent() { + final String path = uri.getPath(); + final int lastSlash = path.lastIndexOf('/'); + final int start = hasWindowsDrive(path, true) ? 3 : 0; + if ((path.length() == start) || // empty path + (lastSlash == start && path.length() == start + 1)) { // at root + return null; + } + String parent; + if (lastSlash == -1) { + parent = CUR_DIR; + } else { + final int end = hasWindowsDrive(path, true) ? 3 : 0; + parent = path.substring(0, lastSlash == end ? end + 1 : lastSlash); + } + return new Path(uri.getScheme(), uri.getAuthority(), parent); + } + + /** + * Adds a suffix to the final name in the path. + * + * @param suffix The suffix to be added + * @return the new path including the suffix + */ + public Path suffix(String suffix) { + return new Path(getParent(), getName() + suffix); + } + + @Override + public String toString() { + // we can't use uri.toString(), which escapes everything, because we want + // illegal characters unescaped in the string, for glob processing, etc. + final StringBuilder buffer = new StringBuilder(); + if (uri.getScheme() != null) { + buffer.append(uri.getScheme()); + buffer.append(":"); + } + if (uri.getAuthority() != null) { + buffer.append("//"); + buffer.append(uri.getAuthority()); + } + if (uri.getPath() != null) { + String path = uri.getPath(); + if (path.indexOf('/') == 0 && hasWindowsDrive(path, true) && // has windows drive + uri.getScheme() == null && // but no scheme + uri.getAuthority() == null) { // or authority + path = path.substring(1); // remove slash before drive + } + buffer.append(path); + } + return buffer.toString(); + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof Path)) { + return false; + } + Path that = (Path) o; + return this.uri.equals(that.uri); + } + + @Override + public int hashCode() { + return uri.hashCode(); + } + + public int compareTo(Object o) { + Path that = (Path) o; + return this.uri.compareTo(that.uri); + } + + /** + * Returns the number of elements in this path. + * + * @return the number of elements in this path + */ + public int depth() { + String path = uri.getPath(); + int depth = 0; + int slash = path.length() == 1 && path.charAt(0) == '/' ? -1 : 0; + while (slash != -1) { + depth++; + slash = path.indexOf(SEPARATOR, slash + 1); + } + return depth; + } + + /** + * Returns a qualified path object. + * + * @param fs the FileSystem that should be used to obtain the current working directory + * @return the qualified path object + */ + public Path makeQualified(FileSystem fs) { + Path path = this; + if (!isAbsolute()) { + path = new Path(fs.getWorkingDirectory(), this); + } + + final URI pathUri = path.toUri(); + final URI fsUri = fs.getUri(); + + String scheme = pathUri.getScheme(); + String authority = pathUri.getAuthority(); + + if (scheme != null && (authority != null || fsUri.getAuthority() == null)) { + return path; + } + + if (scheme == null) { + scheme = fsUri.getScheme(); + } + + if (authority == null) { + authority = fsUri.getAuthority(); + if (authority == null) { + authority = ""; + } + } + + return new Path(scheme + ":" + + "//" + authority + pathUri.getPath()); + } + + // ------------------------------------------------------------------------ + // Utilities + // ------------------------------------------------------------------------ + + /** + * Checks if the provided path string contains a windows drive letter. + * + * @return True, if the path string contains a windows drive letter, false otherwise. + */ + public boolean hasWindowsDrive() { + return hasWindowsDrive(uri.getPath(), true); + } + + /** + * Checks if the provided path string contains a windows drive letter. + * + * @param path the path to check + * @param slashed true to indicate the first character of the string is a slash, false otherwise + * @return true if the path string contains a windows drive letter, false otherwise + */ + private boolean hasWindowsDrive(String path, boolean slashed) { + final int start = slashed ? 1 : 0; + return path.length() >= start + 2 && (!slashed || path.charAt(0) == '/') + && path.charAt(start + 1) == ':' + && ((path.charAt(start) >= 'A' && path.charAt(start) <= 'Z') + || (path.charAt(start) >= 'a' && path.charAt(start) <= 'z')); + } + + // ------------------------------------------------------------------------ + // Utilities + // ------------------------------------------------------------------------ + + /** + * Creates a path for the given local file. + * + *

This method is useful to make sure the path creation for local files works seamlessly + * across different operating systems. Especially Windows has slightly different rules for + * slashes between schema and a local file path, making it sometimes tricky to produce + * cross-platform URIs for local files. + * + * @param file The file that the path should represent. + * @return A path representing the local file URI of the given file. + */ + public static Path fromLocalFile(File file) { + return new Path(file.toURI()); + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream.java b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream.java new file mode 100644 index 000000000..b38a518bc --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferReadableFSDataInputStream.java @@ -0,0 +1,133 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.state.forst.fs; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import org.apache.flink.core.fs.LocalDataInputStream; +import org.apache.flink.core.fs.Path; + +/** + * ByteBufferReadableFSDataInputStream. + */ +public class ByteBufferReadableFSDataInputStream extends InputStream { + private final LocalDataInputStream localDataInputStream; + private final Path path; + private final long totalFileSize; + + public ByteBufferReadableFSDataInputStream( + Path path, InputStream inputStream, long totalFileSize) { + if (!(inputStream instanceof LocalDataInputStream)) { + throw new UnsupportedOperationException("Unsupported input stream type"); + } + this.localDataInputStream = (LocalDataInputStream) inputStream; + this.path = path; + this.totalFileSize = totalFileSize; + } + + public void seek(long desired) throws IOException { + localDataInputStream.seek(desired); + } + + public long getPos() throws IOException { + return localDataInputStream.getPos(); + } + + @Override + public int read() throws IOException { + return localDataInputStream.read(); + } + + @Override + public int read(byte[] b) throws IOException { + return localDataInputStream.read(b); + } + + @Override + public int read(byte[] b, int off, int len) throws IOException { + return localDataInputStream.read(b, off, len); + } + + /** + * Return the total number of bytes read into the buffer. + * REQUIRES: External synchronization + */ + public int readFully(ByteBuffer bb) throws IOException { + return readFullyFromFSDataInputStream(localDataInputStream, bb); + } + + private int readFullyFromFSDataInputStream(LocalDataInputStream fsdis, ByteBuffer bb) + throws IOException { + byte[] tmp = new byte[bb.remaining()]; + int n = 0; + long pos = fsdis.getPos(); + while (n < tmp.length) { + int read = fsdis.read(tmp, n, tmp.length - n); + if (read == -1) { + break; + } + n += read; + } + if (n > 0) { + bb.put(tmp, 0, n); + } + return n; + } + + /** + * Return the total number of bytes read into the buffer. + * Safe for concurrent use by multiple threads. + */ + public int readFully(long position, ByteBuffer bb) throws IOException { + localDataInputStream.seek(position); + return readFullyFromFSDataInputStream(localDataInputStream, bb); + } + + @Override + public long skip(long n) throws IOException { + seek(getPos() + n); + return getPos(); + } + + @Override + public int available() throws IOException { + return localDataInputStream.available(); + } + + @Override + public void close() throws IOException { + localDataInputStream.close(); + } + + @Override + public synchronized void mark(int readlimit) { + localDataInputStream.mark(readlimit); + } + + @Override + public synchronized void reset() throws IOException { + localDataInputStream.reset(); + } + + @Override + public boolean markSupported() { + return localDataInputStream.markSupported(); + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream.java b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream.java new file mode 100644 index 000000000..9c59fda3b --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ByteBufferWritableFSDataOutputStream.java @@ -0,0 +1,83 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.state.forst.fs; + +import java.io.IOException; +import java.io.OutputStream; +import java.nio.ByteBuffer; +import org.apache.flink.core.fs.LocalDataOutputStream; +import org.apache.flink.core.fs.Path; + +/** + * ByteBufferWritableFSDataOutputStream. + */ +public class ByteBufferWritableFSDataOutputStream extends OutputStream { + private final Path path; + private final LocalDataOutputStream localDataOutputStream; + + public ByteBufferWritableFSDataOutputStream(Path path, OutputStream fsdos) { + if (!(fsdos instanceof LocalDataOutputStream)) { + throw new UnsupportedOperationException("Unsupported output stream type"); + } + this.path = path; + this.localDataOutputStream = (LocalDataOutputStream) fsdos; + } + + public long getPos() throws IOException { + return localDataOutputStream.getPos(); + } + + @Override + public void write(int b) throws IOException { + localDataOutputStream.write(b); + } + + public void write(byte[] b) throws IOException { + localDataOutputStream.write(b); + } + + @Override + public void write(byte[] b, int off, int len) throws IOException { + localDataOutputStream.write(b, off, len); + } + + public void write(ByteBuffer bb) throws IOException { + if (bb.hasArray()) { + write(bb.array(), bb.arrayOffset() + bb.position(), bb.remaining()); + } else { + byte[] tmp = new byte[bb.remaining()]; + bb.get(tmp); + write(tmp, 0, tmp.length); + } + } + + @Override + public void flush() throws IOException { + localDataOutputStream.flush(); + } + + public void sync() throws IOException { + localDataOutputStream.sync(); + } + + @Override + public void close() throws IOException { + localDataOutputStream.close(); + } +} diff --git a/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ForStFlinkFileSystem.java b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ForStFlinkFileSystem.java new file mode 100644 index 000000000..afb32d754 --- /dev/null +++ b/java/flinktestmock/src/main/java/org/apache/flink/state/forst/fs/ForStFlinkFileSystem.java @@ -0,0 +1,126 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.state.forst.fs; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.URI; +import org.apache.flink.core.fs.FileStatus; +import org.apache.flink.core.fs.FileSystem; +import org.apache.flink.core.fs.Path; + +/** + * RemoteRocksdbFlinkFileSystem, used to expose flink fileSystem interface to frocksdb. + */ +public class ForStFlinkFileSystem extends FileSystem { + private final FileSystem flinkFS; + + public ForStFlinkFileSystem(FileSystem flinkFS) { + this.flinkFS = flinkFS; + } + + public static FileSystem get(URI uri) throws IOException { + return new ForStFlinkFileSystem(FileSystem.get(uri)); + } + + @Override + public Path getWorkingDirectory() { + return flinkFS.getWorkingDirectory(); + } + + @Override + public Path getHomeDirectory() { + return flinkFS.getHomeDirectory(); + } + + @Override + public URI getUri() { + return flinkFS.getUri(); + } + + @Override + public FileStatus getFileStatus(Path f) throws IOException { + return flinkFS.getFileStatus(f); + } + + @Override + public ByteBufferReadableFSDataInputStream open(Path f, int bufferSize) throws IOException { + InputStream original = flinkFS.open(f, bufferSize); + long fileSize = flinkFS.getFileStatus(f).getLen(); + return new ByteBufferReadableFSDataInputStream(f, original, fileSize); + } + + @Override + public ByteBufferReadableFSDataInputStream open(Path f) throws IOException { + InputStream original = flinkFS.open(f); + long fileSize = flinkFS.getFileStatus(f).getLen(); + return new ByteBufferReadableFSDataInputStream(f, original, fileSize); + } + + @Override + public FileStatus[] listStatus(Path f) throws IOException { + return flinkFS.listStatus(f); + } + + @Override + public boolean exists(final Path f) throws IOException { + return flinkFS.exists(f); + } + + @Override + public boolean delete(Path f, boolean recursive) throws IOException { + return flinkFS.delete(f, recursive); + } + + @Override + public boolean mkdirs(Path f) throws IOException { + return flinkFS.mkdirs(f); + } + + public ByteBufferWritableFSDataOutputStream create(Path f) throws IOException { + return create(f, WriteMode.OVERWRITE); + } + + @Override + public ByteBufferWritableFSDataOutputStream create(Path f, WriteMode overwriteMode) + throws IOException { + OutputStream original = flinkFS.create(f, overwriteMode); + return new ByteBufferWritableFSDataOutputStream(f, original); + } + + @Override + public boolean rename(Path src, Path dst) throws IOException { + // The rename is not atomic for RocksDB. Some FileSystems e.g. HDFS, OSS does not allow a + // renaming if the target already exists. So, we delete the target before attempting the + // rename. + if (flinkFS.exists(dst)) { + boolean deleted = flinkFS.delete(dst, false); + if (!deleted) { + throw new IOException("Fail to delete dst path: " + dst); + } + } + return flinkFS.rename(src, dst); + } + + @Override + public boolean isDistributedFS() { + return flinkFS.isDistributedFS(); + } +} diff --git a/java/rocksjni/env_flink_test_suite.cc b/java/rocksjni/env_flink_test_suite.cc new file mode 100644 index 000000000..5e66ca746 --- /dev/null +++ b/java/rocksjni/env_flink_test_suite.cc @@ -0,0 +1,73 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "env/flink/env_flink_test_suite.h" + +#include + +#include "include/org_rocksdb_EnvFlinkTestSuite.h" +#include "java/rocksjni/portal.h" + +/* + * Class: org_rocksdb_EnvFlinkTestSuite + * Method: buildNativeObject + * Signature: (Ljava/lang/String;)J + */ +jlong Java_org_rocksdb_EnvFlinkTestSuite_buildNativeObject(JNIEnv* env, jobject, + jstring basePath) { + jboolean has_exception = JNI_FALSE; + auto path = + ROCKSDB_NAMESPACE::JniUtil::copyStdString(env, basePath, &has_exception); + if (has_exception == JNI_TRUE) { + ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew( + env, "Could not copy jstring to std::string"); + return 0; + } + auto env_flink_test_suites = new ROCKSDB_NAMESPACE::EnvFlinkTestSuites(path); + return reinterpret_cast(env_flink_test_suites); +} + +/* + * Class: org_rocksdb_EnvFlinkTestSuite + * Method: runAllTestSuites + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_rocksdb_EnvFlinkTestSuite_runAllTestSuites( + JNIEnv* jniEnv, jobject, jlong objectHandle) { + auto env_flink_test_suites = + reinterpret_cast(objectHandle); + env_flink_test_suites->runAllTestSuites(); + if (jniEnv->ExceptionCheck()) { + jthrowable throwable = jniEnv->ExceptionOccurred(); + jniEnv->ExceptionDescribe(); + jniEnv->ExceptionClear(); + jniEnv->Throw(throwable); + } +} + +/* + * Class: org_rocksdb_EnvFlinkTestSuite + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_rocksdb_EnvFlinkTestSuite_disposeInternal( + JNIEnv*, jobject, jlong objectHandle) { + auto test_suites = + reinterpret_cast(objectHandle); + delete test_suites; +} \ No newline at end of file diff --git a/java/src/main/java/org/rocksdb/EnvFlinkTestSuite.java b/java/src/main/java/org/rocksdb/EnvFlinkTestSuite.java new file mode 100644 index 000000000..92e503509 --- /dev/null +++ b/java/src/main/java/org/rocksdb/EnvFlinkTestSuite.java @@ -0,0 +1,50 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.rocksdb; + +/** + * The test suite used for flink-env interfaces testing. You could define and implement test + * procedures in the "env/flink/env_flink_test_suite.h" and "env/flink/env_flink_test_suite.cc", and + * these tests will be executed by EnvFlinkTestSuite#runAllTestSuites. + */ +public class EnvFlinkTestSuite implements AutoCloseable { + private final String basePath; + + private final long nativeObjectHandle; + + public EnvFlinkTestSuite(String basePath) { + this.basePath = basePath; + this.nativeObjectHandle = buildNativeObject(basePath); + } + + private native long buildNativeObject(String basePath); + + private native void runAllTestSuites(long nativeObjectHandle); + + private native void disposeInternal(long nativeObjectHandle); + + public void runAllTestSuites() { + runAllTestSuites(nativeObjectHandle); + } + + @Override + public void close() throws Exception { + disposeInternal(nativeObjectHandle); + } +} \ No newline at end of file diff --git a/java/src/test/java/org/rocksdb/flink/FlinkEnvTest.java b/java/src/test/java/org/rocksdb/flink/FlinkEnvTest.java new file mode 100644 index 000000000..5c7166557 --- /dev/null +++ b/java/src/test/java/org/rocksdb/flink/FlinkEnvTest.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.rocksdb.flink; + +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; +import org.rocksdb.EnvFlinkTestSuite; +import org.rocksdb.RocksNativeLibraryResource; + +/** + * Unit test for env/flink/env_flink.cc. + */ +public class FlinkEnvTest { + @ClassRule + public static final RocksNativeLibraryResource ROCKS_NATIVE_LIBRARY_RESOURCE = + new RocksNativeLibraryResource(); + + @Rule public TemporaryFolder parentFolder = new TemporaryFolder(); + + @Test + public void runEnvFlinkTestSuites() throws Exception { + String basePath = parentFolder.newFolder().toURI().toString(); + try (EnvFlinkTestSuite testSuite = new EnvFlinkTestSuite(basePath)) { + testSuite.runAllTestSuites(); + } + } +} \ No newline at end of file diff --git a/src.mk b/src.mk index c58fc70fe..e168fcd3e 100644 --- a/src.mk +++ b/src.mk @@ -116,6 +116,7 @@ LIB_SOURCES = \ env/flink/env_flink.cc \ env/flink/jvm_util.cc \ env/flink/jni_helper.cc \ + env/flink/env_flink_test_suite.cc \ file/delete_scheduler.cc \ file/file_prefetch_buffer.cc \ file/file_util.cc \ @@ -671,6 +672,7 @@ JNI_NATIVE_SOURCES = \ java/rocksjni/export_import_files_metadatajni.cc \ java/rocksjni/env.cc \ java/rocksjni/env_flink.cc \ + java/rocksjni/env_flink_test_suite.cc \ java/rocksjni/env_options.cc \ java/rocksjni/event_listener.cc \ java/rocksjni/event_listener_jnicallback.cc \ From ca371b1f9defdd6c1b77b9906db26462becb56e3 Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Mon, 1 Apr 2024 16:27:27 +0800 Subject: [PATCH 45/61] [env] Add test cases in flink-env test suite (cherry picked from commit 729cf5c764c5c40a3990912c2860f9319f8c354a) --- env/flink/env_flink.cc | 19 +++-- env/flink/env_flink_test_suite.cc | 127 +++++++++++++++++++++++++++--- env/flink/env_flink_test_suite.h | 7 +- 3 files changed, 137 insertions(+), 16 deletions(-) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index b963fe508..26deba9e7 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -66,7 +66,7 @@ class FlinkWritableFile : public FSWritableFile { jobject fsDataOutputStream = jniEnv->CallObjectMethod( file_system_instance_, fileSystemCreateMethod.javaMethod, pathInstance); jniEnv->DeleteLocalRef(pathInstance); - if (fsDataOutputStream == nullptr) { + if (fsDataOutputStream == nullptr || jniEnv->ExceptionCheck()) { return CheckThenError( std::string( "CallObjectMethod Exception when Init FlinkWritableFile, ") @@ -193,7 +193,7 @@ class FlinkReadableFile : virtual public FSSequentialFile, jobject fsDataInputStream = jniEnv->CallObjectMethod( file_system_instance_, openMethod.javaMethod, pathInstance); jniEnv->DeleteLocalRef(pathInstance); - if (fsDataInputStream == nullptr) { + if (fsDataInputStream == nullptr || jniEnv->ExceptionCheck()) { return CheckThenError( std::string( "CallObjectMethod Exception when Init FlinkReadableFile, ") @@ -355,7 +355,7 @@ Status FlinkFileSystem::Init() { jobject fileSystemInstance = jniEnv->CallStaticObjectMethod( fileSystemClass.javaClass, fileSystemGetMethod.javaMethod, uriInstance); jniEnv->DeleteLocalRef(uriInstance); - if (fileSystemInstance == nullptr) { + if (fileSystemInstance == nullptr || jniEnv->ExceptionCheck()) { return CheckThenError( std::string( "CallStaticObjectMethod Exception when Init FlinkFileSystem, ") @@ -504,7 +504,7 @@ IOStatus FlinkFileSystem::GetChildren(const std::string& file_name, auto fileStatusArray = (jobjectArray)jniEnv->CallObjectMethod( file_system_instance_, listStatusMethod.javaMethod, pathInstance); jniEnv->DeleteLocalRef(pathInstance); - if (fileStatusArray == nullptr) { + if (fileStatusArray == nullptr || jniEnv->ExceptionCheck()) { return CheckThenError( std::string("Exception when CallObjectMethod in GetChildren, ") .append(listStatusMethod.ToString()) @@ -516,7 +516,7 @@ IOStatus FlinkFileSystem::GetChildren(const std::string& file_name, jsize fileStatusArrayLen = jniEnv->GetArrayLength(fileStatusArray); for (jsize i = 0; i < fileStatusArrayLen; i++) { jobject fileStatusObj = jniEnv->GetObjectArrayElement(fileStatusArray, i); - if (fileStatusObj == nullptr) { + if (fileStatusObj == nullptr || jniEnv->ExceptionCheck()) { jniEnv->DeleteLocalRef(fileStatusArray); return CheckThenError( "Exception when GetObjectArrayElement in GetChildren"); @@ -527,7 +527,7 @@ IOStatus FlinkFileSystem::GetChildren(const std::string& file_name, jobject subPath = jniEnv->CallObjectMethod(fileStatusObj, getPathMethod.javaMethod); jniEnv->DeleteLocalRef(fileStatusObj); - if (subPath == nullptr) { + if (subPath == nullptr || jniEnv->ExceptionCheck()) { jniEnv->DeleteLocalRef(fileStatusArray); return CheckThenError( std::string("Exception when CallObjectMethod in GetChildren, ") @@ -539,6 +539,13 @@ IOStatus FlinkFileSystem::GetChildren(const std::string& file_name, auto subPathStr = (jstring)jniEnv->CallObjectMethod( subPath, pathToStringMethod.javaMethod); jniEnv->DeleteLocalRef(subPath); + if (subPathStr == nullptr || jniEnv->ExceptionCheck()) { + jniEnv->DeleteLocalRef(fileStatusArray); + return CheckThenError( + std::string("Exception when CallObjectMethod in GetChildren, ") + .append(pathToStringMethod.ToString())); + } + const char* str = jniEnv->GetStringUTFChars(subPathStr, nullptr); result->emplace_back(str); jniEnv->ReleaseStringUTFChars(subPathStr, str); diff --git a/env/flink/env_flink_test_suite.cc b/env/flink/env_flink_test_suite.cc index 2b1a312ab..4db7f6968 100644 --- a/env/flink/env_flink_test_suite.cc +++ b/env/flink/env_flink_test_suite.cc @@ -18,6 +18,7 @@ #include "env/flink/env_flink_test_suite.h" +#include #include #include @@ -28,6 +29,10 @@ std::abort(); \ } +#define ASSERT_FALSE(condition) ASSERT_TRUE(!(condition)) + +#define LOG(message) (std::cout << (message) << std::endl) + namespace ROCKSDB_NAMESPACE { EnvFlinkTestSuites::EnvFlinkTestSuites(const std::string& basePath) @@ -35,7 +40,15 @@ EnvFlinkTestSuites::EnvFlinkTestSuites(const std::string& basePath) void EnvFlinkTestSuites::runAllTestSuites() { setUp(); - testFileExist(); + LOG("Stage 1: setUp OK"); + testDirOperation(); + LOG("Stage 2: testDirOperation OK"); + testFileOperation(); + LOG("Stage 3: testFileOperation OK"); + testGetChildren(); + LOG("Stage 4: testGetChildren OK"); + testFileReadAndWrite(); + LOG("Stage 5: testFileReadAndWrite OK"); } void EnvFlinkTestSuites::setUp() { @@ -45,11 +58,110 @@ void EnvFlinkTestSuites::setUp() { } } -void EnvFlinkTestSuites::testFileExist() { - std::string fileName("test-file"); - Status result = flink_env_->FileExists(fileName); - ASSERT_TRUE(result.IsNotFound()); +void EnvFlinkTestSuites::testDirOperation() { + const std::string dir_name = "test-dir"; + ASSERT_TRUE(flink_env_->FileExists(dir_name).IsNotFound()); + ASSERT_TRUE(flink_env_->CreateDir(dir_name).ok()); + ASSERT_TRUE(flink_env_->CreateDirIfMissing(dir_name).ok()); + ASSERT_FALSE(flink_env_->CreateDir(dir_name).ok()); + + bool is_dir; + ASSERT_TRUE(flink_env_->IsDirectory(dir_name, &is_dir).ok() && is_dir); + ASSERT_TRUE(flink_env_->FileExists(dir_name).ok()); + ASSERT_TRUE(flink_env_->DeleteDir(dir_name).ok()); + ASSERT_TRUE(flink_env_->FileExists(dir_name).IsNotFound()); +} + +void EnvFlinkTestSuites::testFileOperation() { + const std::string file_name = "test-file"; + const std::string not_exist_file_name = "not-exist-file"; + + // test file exists + ASSERT_TRUE(flink_env_->FileExists(file_name).IsNotFound()); + generateFile(file_name); + ASSERT_TRUE(flink_env_->FileExists(file_name).ok()); + + // test file status + uint64_t file_size, file_mtime; + ASSERT_TRUE(flink_env_->GetFileSize(file_name, &file_size).ok()); + ASSERT_FALSE(flink_env_->GetFileSize(not_exist_file_name, &file_size).ok()); + ASSERT_TRUE(file_size > 0); + ASSERT_TRUE(flink_env_->GetFileModificationTime(file_name, &file_mtime).ok()); + ASSERT_FALSE( + flink_env_->GetFileModificationTime(not_exist_file_name, &file_mtime) + .ok()); + ASSERT_TRUE(file_mtime > 0); + + // test renaming file + const std::string file_name_2 = "test-file-2"; + flink_env_->RenameFile(file_name, file_name_2); + ASSERT_TRUE(flink_env_->FileExists(file_name).IsNotFound()); + ASSERT_TRUE(flink_env_->FileExists(file_name_2).ok()); + ASSERT_TRUE(flink_env_->DeleteFile(file_name_2).ok()); + ASSERT_TRUE(flink_env_->FileExists(file_name_2).IsNotFound()); +} + +void EnvFlinkTestSuites::testGetChildren() { + const std::string dir_name = "test-dir"; + const std::string sub_dir_name = dir_name + "/test-sub-dir"; + const std::string file_name_1 = dir_name + "/test-file-1"; + const std::string file_name_2 = dir_name + "/test-file-2"; + ASSERT_TRUE(flink_env_->CreateDirIfMissing(dir_name).ok()); + ASSERT_TRUE(flink_env_->CreateDirIfMissing(sub_dir_name).ok()); + generateFile(file_name_1); + generateFile(file_name_2); + std::vector result, + expected{base_path_ + sub_dir_name, base_path_ + file_name_1, + base_path_ + file_name_2}; + ASSERT_TRUE(flink_env_->GetChildren(dir_name, &result).ok()); + ASSERT_TRUE(result.size() == 3); + std::sort(result.begin(), result.end()); + std::sort(expected.begin(), expected.end()); + ASSERT_TRUE(expected == result); +} + +void EnvFlinkTestSuites::testFileReadAndWrite() { + const std::string file_name = "test-file"; + const std::string content1 = "Hello World", content2 = ", Hello ForSt", + content = content1 + content2; + + std::unique_ptr write_result; + ASSERT_TRUE( + flink_env_->NewWritableFile(file_name, &write_result, EnvOptions()).ok()); + write_result->Append(content1); + write_result->Append(content2); + write_result->Sync(); + write_result->Flush(); + write_result->Close(); + + std::unique_ptr sequential_result; + ASSERT_TRUE( + flink_env_->NewSequentialFile(file_name, &sequential_result, EnvOptions()) + .ok()); + + Slice sequential_data; + char* sequential_scratch = new char[content2.size()]; + sequential_result->Skip(content1.size()); + sequential_result->Read(content2.size(), &sequential_data, + sequential_scratch); + ASSERT_TRUE(sequential_data.data() == content2); + delete[] sequential_scratch; + + std::unique_ptr random_access_result; + ASSERT_TRUE( + flink_env_ + ->NewRandomAccessFile(file_name, &random_access_result, EnvOptions()) + .ok()); + Slice random_access_data; + char* random_access_scratch = new char[content2.size()]; + random_access_result->Read(content1.size(), content.size() - content1.size(), + &random_access_data, (char*)random_access_scratch); + ASSERT_TRUE(random_access_data.data() == content2); + delete[] random_access_scratch; +} + +void EnvFlinkTestSuites::generateFile(const std::string& fileName) { // Generate a file manually const std::string prefix = "file:"; std::string writeFileName = base_path_ + fileName; @@ -57,10 +169,7 @@ void EnvFlinkTestSuites::testFileExist() { writeFileName = writeFileName.substr(prefix.size()); } std::ofstream writeFile(writeFileName); - writeFile << "testFileExist"; + writeFile << "Hello World"; writeFile.close(); - - result = flink_env_->FileExists(fileName); - ASSERT_TRUE(result.ok()); } } // namespace ROCKSDB_NAMESPACE \ No newline at end of file diff --git a/env/flink/env_flink_test_suite.h b/env/flink/env_flink_test_suite.h index 3826060d5..c7512b031 100644 --- a/env/flink/env_flink_test_suite.h +++ b/env/flink/env_flink_test_suite.h @@ -29,6 +29,11 @@ class EnvFlinkTestSuites { std::unique_ptr flink_env_; const std::string base_path_; void setUp(); - void testFileExist(); + void testDirOperation(); + void testFileOperation(); + void testGetChildren(); + void testFileReadAndWrite(); + + void generateFile(const std::string& fileName); }; } // namespace ROCKSDB_NAMESPACE \ No newline at end of file From abe27da9bfdbdd2d3c4375cdbdd8be4d15950ee8 Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Mon, 1 Apr 2024 18:54:46 +0800 Subject: [PATCH 46/61] [build] Fix warning about unused parameters (cherry picked from commit 9c23507040c0efed8324ffc4dfbf0763d3884ae4) --- env/flink/env_flink.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index 26deba9e7..eae1773cf 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -379,7 +379,7 @@ IOStatus FlinkFileSystem::NewSequentialFile( const std::string& fname, const FileOptions& options, std::unique_ptr* result, IODebugContext* dbg) { result->reset(); - IOStatus status = FileExists(fname, IOOptions(), dbg); + IOStatus status = FileExists(fname, options.io_options, dbg); if (!status.ok()) { return status; } @@ -400,7 +400,7 @@ IOStatus FlinkFileSystem::NewRandomAccessFile( const std::string& fname, const FileOptions& options, std::unique_ptr* result, IODebugContext* dbg) { result->reset(); - IOStatus status = FileExists(fname, IOOptions(), dbg); + IOStatus status = FileExists(fname, options.io_options, dbg); if (!status.ok()) { return status; } @@ -623,8 +623,8 @@ IOStatus FlinkFileSystem::CreateDir(const std::string& file_name, } IOStatus FlinkFileSystem::CreateDirIfMissing(const std::string& file_name, - const IOOptions& options, - IODebugContext* dbg) { + const IOOptions& /*options*/, + IODebugContext* /*dbg*/) { JNIEnv* jniEnv = getJNIEnv(); std::string filePath = ConstructPath(file_name); From ae7d8214f22560d0ea9665e653d13b501b5a1f8c Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Sat, 6 Apr 2024 12:32:05 +0800 Subject: [PATCH 47/61] [build] Support releasing forst (cherry picked from commit 5d70ad0574987a530453cdd619ddd8aa6c476c45) --- CMakeLists.txt | 1 + FORST-RELEASE.md | 248 ++++++++++++++++++ Makefile | 27 +- java/deploysettings.xml | 18 +- java/pom.xml.template | 39 +-- ...ish-frocksdbjni.sh => publish-forstjni.sh} | 4 +- 6 files changed, 282 insertions(+), 55 deletions(-) create mode 100644 FORST-RELEASE.md rename java/{publish-frocksdbjni.sh => publish-forstjni.sh} (93%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0f93b43e4..15f2d133d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1168,6 +1168,7 @@ endif() if(WITH_JNI OR JNI) message(STATUS "JNI library is enabled") add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/java) + find_package(JNI) include_directories(${JNI_INCLUDE_DIRS}) if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux") include_directories(${JNI_INCLUDE_DIRS}/linux) diff --git a/FORST-RELEASE.md b/FORST-RELEASE.md new file mode 100644 index 000000000..f9f48fb20 --- /dev/null +++ b/FORST-RELEASE.md @@ -0,0 +1,248 @@ +# ForSt Release Process + +## Summary + +ForSt releases are a fat jar file that contain the following binaries: +* .so files for linux32 (glibc and musl-libc) +* .so files for linux64 (glibc and musl-libc) +* .so files for linux [aarch64](https://en.wikipedia.org/wiki/AArch64) (glibc and musl-libc) +* .so files for linux [ppc64le](https://en.wikipedia.org/wiki/Ppc64le) (glibc and musl-libc) +* .jnilib file for Mac OSX +* .dll for Windows x64 + +To build the binaries for a ForSt release, building on native architectures is advised. Building the binaries for ppc64le and aarch64 *can* be done using QEMU, but you may run into emulation bugs and the build times will be dramatically slower (up to x20). + +We recommend building the binaries on environments with at least 4 cores, 16GB RAM and 40GB of storage. The following environments are recommended for use in the build process: +* Windows x64 +* Linux aarch64 +* Linux ppc64le +* Mac OSX + +## Build for Windows + +For the Windows binary build, we recommend using a base [AWS Windows EC2 instance](https://aws.amazon.com/windows/products/ec2/) with 4 cores, 16GB RAM, 40GB storage for the build. + +Firstly, install [chocolatey](https://chocolatey.org/install). Once installed, the following required components can be installed using Powershell: + + choco install git.install jdk8 maven visualstudio2017community visualstudio2017-workload-nativedesktop + +Open the "Developer Command Prompt for VS 2017" and run the following commands: + + git clone git@github.com:ververica/ForSt.git + cd ForSt + java\crossbuild\build-win.bat + +The resulting native binary will be built and available at `build\java\Release\rocksdbjni-shared.dll`. You can also find it under project folder with name `librocksdbjni-win64.dll`. +The result windows jar is `build\java\rocksdbjni_classes.jar`. + +There is also a how-to in CMakeLists.txt. + +**Once finished, extract the `librocksdbjni-win64.dll` from the build environment. You will need this .dll in the final crossbuild.** + +## Build for aarch64 + +For the Linux aarch64 binary build, we recommend using a base [AWS Ubuntu Server 20.04 LTS EC2](https://aws.amazon.com/windows/products/ec2/) with a 4 core Arm processor, 16GB RAM, 40GB storage for the build. You can also attempt to build with QEMU on a non-aarch64 processor, but you may run into emulation bugs and very long build times. + +### Building in aarch64 environment + +First, install the required packages such as Java 8 and make: + + sudo apt-get update + sudo apt-get install build-essential openjdk-8-jdk + +then, install and setup [Docker](https://docs.docker.com/engine/install/ubuntu/): + + sudo apt-get install apt-transport-https ca-certificates curl gnupg lsb-release + + curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg + echo "deb [arch=arm64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null + + sudo apt-get update + sudo apt-get install docker-ce docker-ce-cli containerd.io + + sudo groupadd docker + sudo usermod -aG docker $USER + newgrp docker + +Then, clone the ForSt repo: + + git clone https://github.com/ververica/ForSt.git + cd ForSt + +First, build the glibc binary: + + make jclean clean rocksdbjavastaticdockerarm64v8 + +**Once finished, extract the `java/target/librocksdbjni-linux-aarch64.so` from the build environment. You will need this .so in the final crossbuild.** + +Next, build the musl-libc binary: + + make jclean clean rocksdbjavastaticdockerarm64v8musl + +**Once finished, extract the `java/target/librocksdbjni-linux-aarch64-musl.so` from the build environment. You will need this .so in the final crossbuild.** + +### Building via QEMU + +You can use QEMU on, for example, an `x86_64` system to build the aarch64 binaries. To set this up on an Ubuntu environment: + + sudo apt-get install qemu binfmt-support qemu-user-static + docker run --rm --privileged multiarch/qemu-user-static --reset -p yes + +To verify that you can now run aarch64 docker images: + + docker run --rm -t arm64v8/ubuntu uname -m + > aarch64 + +You can now attempt to build the aarch64 binaries as in the previous section. + +## Build in PPC64LE + +For the ppc64le binaries, we recommend building on a PowerPC machine if possible, as it can be tricky to spin up a ppc64le cloud environment. However, if a PowerPC machine is not available, [Travis-CI](https://www.travis-ci.com/) offers ppc64le build environments that work perfectly for building these binaries. If neither a machine or Travis are an option, you can use QEMU but the build may take a very long time and be prone to emulation errors. + +### Building in ppc64le environment + +As with the aarch64 environment, the ppc64le environment will require Java 8, Docker and build-essentials installed. Once installed, you can build the 2 binaries: + + make jclean clean rocksdbjavastaticdockerppc64le + +**Once finished, extract the `java/target/librocksdbjni-linux-ppc64le.so` from the build environment. You will need this .so in the final crossbuild.** + + make jclean clean rocksdbjavastaticdockerppc64lemusl + +**Once finished, extract the `java/target/librocksdbjni-linux-ppc64le-musl.so` from the build environment. You will need this .so in the final crossbuild.** + +### Building via Travis + +Travis-CI supports ppc64le build environments, and this can be a convenient way of building in the absence of a PowerPC machine. Assuming that you have an S3 bucket called **my-forst-release-artifacts**, the following Travis configuration will build the release artifacts and push them to the S3 bucket: + +``` +dist: xenial +language: cpp +os: + - linux +arch: + - ppc64le + +services: + - docker +addons: + artifacts: + paths: + - $TRAVIS_BUILD_DIR/java/target/librocksdbjni-linux-ppc64le-musl.so + - $TRAVIS_BUILD_DIR/java/target/librocksdbjni-linux-ppc64le.so + +env: + global: + - ARTIFACTS_BUCKET=my-forst-release-artifacts + jobs: + - CMD=rocksdbjavastaticdockerppc64le + - CMD=rocksdbjavastaticdockerppc64lemusl + +install: + - sudo apt-get install -y openjdk-8-jdk || exit $? + - export PATH=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture)/bin:$PATH + - export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture) + - echo "JAVA_HOME=${JAVA_HOME}" + - which java && java -version + - which javac && javac -version + +script: + - make jclean clean $CMD +``` + +**Make sure to set the `ARTIFACTS_KEY` and `ARTIFACTS_SECRET` environment variables in the Travis Job with valid AWS credentials to access the S3 bucket you defined.** + +**Make sure to avoid signatureV4-only S3 regions to store the uploaded artifacts (due to unresolved https://github.com/travis-ci/artifacts/issues/57). You can just choose the S3 bucket of `us-east-1` region for 100% compatibility.** + +**Once finished, the`librocksdbjni-linux-ppce64le.so` and `librocksdbjni-linux-ppce64le-musl.so` binaries will be in the S3 bucket. You will need these .so binaries in the final crossbuild.** + + +### Building via QEMU + +You can use QEMU on, for example, an `x86_64` system to build the ppc64le binaries. To set this up on an Ubuntu environment: + + sudo apt-get install qemu binfmt-support qemu-user-static + docker run --rm --privileged multiarch/qemu-user-static --reset -p yes + +To verify that you can now run ppc64le docker images: + + docker run --rm -t ppc64le/ubuntu uname -m + > ppc64le + +You can now attempt to build the ppc64le binaries as in the previous section. + +## Final crossbuild in Mac OSX + +Documentation for the final crossbuild for Mac OSX and Linux is described in [java/RELEASE.md](java/RELEASE.md) as has information on dependencies that should be installed. As above, this tends to be Java 8, build-essentials and Docker. + +Before you run this step, you should have 5 binaries from the previous build steps: + +1. `librocksdbjni-win64.dll` from the Windows build step. +2. `librocksdbjni-linux-aarch64.so` from the aarch64 build step. +3. `librocksdbjni-linux-aarch64-musl.so` from the aarch64 build step. +4. `librocksdbjni-linux-ppc64le.so` from the ppc64le build step. +5. `librocksdbjni-linux-ppc64le-musl.so` from the ppc64le build step. + +To start the crossbuild within a Mac OSX environment: + + make jclean clean + mkdir -p java/target + cp /librocksdbjni-win64.dll java/target/librocksdbjni-win64.dll + cp /librocksdbjni-linux-ppc64le.so java/target/librocksdbjni-linux-ppc64le.so + cp /librocksdbjni-linux-ppc64le-musl.so java/target/librocksdbjni-linux-ppc64le-musl.so + cp /librocksdbjni-linux-aarch64.so java/target/librocksdbjni-linux-aarch64.so + cp /librocksdbjni-linux-aarch64-musl.so java/target/librocksdbjni-linux-aarch64-musl.so + FORST_VERSION=0.1.0-SNAPSHOT PORTABLE=1 ROCKSDB_DISABLE_JEMALLOC=true DEBUG_LEVEL=0 make forstjavastaticreleasedocker + +*Note, we disable jemalloc on mac due to https://github.com/facebook/rocksdb/issues/5787*. + +Once finished, there should be a directory at `java/target/forst-release` with the ForSt jar, javadoc jar, sources jar and pom in it. You can inspect the jar file and ensure that contains the binaries, history file, etc: + +``` +$ jar tf forstjni-$(FORST_VERSION).jar +META-INF/ +META-INF/MANIFEST.MF +HISTORY-JAVA.md +HISTORY.md +librocksdbjni-linux-aarch64-musl.so +librocksdbjni-linux-aarch64.so +librocksdbjni-linux-ppc64le-musl.so +librocksdbjni-linux-ppc64le.so +librocksdbjni-linux32-musl.so +librocksdbjni-linux32.so +librocksdbjni-linux64-musl.so +librocksdbjni-linux64.so +librocksdbjni-osx.jnilib +librocksdbjni-win64.dl +... +``` + +*Note that it contains linux32/64.so binaries as well as librocksdbjni-osx.jnilib*. + +## Push to Maven Central + +For this step, you will need the following: + +- The OSX Crossbuild artifacts built in `java/target/forst-release` as above. +- A Sonatype account with access to the staging repository. If you do not have permission, open a ticket with Sonatype, [such as this one](https://issues.sonatype.org/browse/OSSRH-72185). +- A GPG key to sign the release, with your public key available for verification (for example, by uploading it to https://keys.openpgp.org/) + +To upload the release to the Sonatype staging repository: +```bash +VERSION= \ +USER= \ +PASSWORD= \ +KEYNAME= \ +PASSPHRASE= \ +java/publish-forstjni.sh +``` + +Go to the staging repositories on Sonatype: + +https://oss.sonatype.org/#stagingRepositories + +Select the open staging repository and click on "Close". + +The staging repository will look something like `https://oss.sonatype.org/content/repositories/xxxx-1020`. You can use this staged release to test the artifacts and ensure they are correct. + +Once you have verified the artifacts are correct, press the "Release" button. **WARNING: this can not be undone**. Within 24-48 hours, the artifact will be available on Maven Central for use. \ No newline at end of file diff --git a/Makefile b/Makefile index e35a9feb7..93fae2739 100644 --- a/Makefile +++ b/Makefile @@ -6,7 +6,7 @@ #----------------------------------------------- -FROCKSDB_VERSION ?= 1.0 +FORST_VERSION ?= 0.1.0 BASH_EXISTS := $(shell which bash) SHELL := $(shell which bash) @@ -2356,14 +2356,14 @@ rocksdbjavastaticreleasedocker: rocksdbjavastaticosx rocksdbjavastaticdockerx86 cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR_ALL) org/rocksdb/*.class org/rocksdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR_ALL) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR_ALL).sha1 -frocksdbjavastaticreleasedocker: rocksdbjavastaticreleasedocker +forstjavastaticreleasedocker: rocksdbjavastaticreleasedocker # update apache license mkdir -p java/target/META-INF - cp LICENSE.Apache java/target/META-INF/LICENSE + cp LICENSE java/target/META-INF/LICENSE cd java/target;jar -uf $(ROCKSDB_JAR_ALL) META-INF/LICENSE # jars to be released - $(eval JAR_PREF=rocksdbjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH)) + $(eval JAR_PREF=forstjni-$(FORST_VERSION)) $(eval JAR_DOCS=$(JAR_PREF)-javadoc.jar) $(eval JAR_SOURCES=$(JAR_PREF)-sources.jar) @@ -2371,21 +2371,22 @@ frocksdbjavastaticreleasedocker: rocksdbjavastaticreleasedocker cd java/target;jar -uf $(JAR_DOCS) META-INF/LICENSE cd java/target;jar -uf $(JAR_SOURCES) META-INF/LICENSE - # prepare frocksdb release - cd java/target;mkdir -p frocksdb-release + # prepare forst release + cd java/target;mkdir -p forst-release - $(eval FROCKSDB_JAVA_VERSION=$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH)-ververica-$(FROCKSDB_VERSION)) - $(eval FJAR_PREF=frocksdbjni-$(FROCKSDB_JAVA_VERSION)) + $(eval FORST_JAVA_VERSION=$(FORST_VERSION)) + $(eval FJAR_PREF=forstjni-$(FORST_JAVA_VERSION)) $(eval FJAR=$(FJAR_PREF).jar) $(eval FJAR_DOCS=$(FJAR_PREF)-javadoc.jar) $(eval FJAR_SOURCES=$(FJAR_PREF)-sources.jar) - cd java/target;cp $(ROCKSDB_JAR_ALL) frocksdb-release/$(FJAR) - cd java/target;cp $(JAR_DOCS) frocksdb-release/$(FJAR_DOCS) - cd java/target;cp $(JAR_SOURCES) frocksdb-release/$(FJAR_SOURCES) + cd java/target;cp $(ROCKSDB_JAR_ALL) forst-release/$(FJAR) + cd java/target;cp $(JAR_DOCS) forst-release/$(FJAR_DOCS) + cd java/target;cp $(JAR_SOURCES) forst-release/$(FJAR_SOURCES) openssl sha1 java/target/$(ROCKSDB_JAR_ALL) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR_ALL).sha1 - cd java;cat pom.xml.template | sed 's/\$${FROCKSDB_JAVA_VERSION}/$(FROCKSDB_JAVA_VERSION)/' > pom.xml - cd java;cp pom.xml target/frocksdb-release/$(FJAR_PREF).pom + cd java;cat pom.xml.template | sed 's/\$${FORST_JAVA_VERSION}/$(FORST_JAVA_VERSION)/' > pom.xml + cd java;cp pom.xml target/forst-release/$(FJAR_PREF).pom + rocksdbjavastaticdockerx86: mkdir -p java/target diff --git a/java/deploysettings.xml b/java/deploysettings.xml index 7b73248e0..acd06d518 100644 --- a/java/deploysettings.xml +++ b/java/deploysettings.xml @@ -1,12 +1,12 @@ - - - sonatype-nexus-staging - ${sonatype_user} - ${sonatype_pw} - - + + + sonatype-nexus-staging + ${sonatype_user} + ${sonatype_pw} + + \ No newline at end of file diff --git a/java/pom.xml.template b/java/pom.xml.template index bd882ec3a..52fabfc3e 100644 --- a/java/pom.xml.template +++ b/java/pom.xml.template @@ -3,11 +3,11 @@ 4.0.0 com.ververica - frocksdbjni - ${FROCKSDB_JAVA_VERSION} + forstjni + ${FORST_JAVA_VERSION} - RocksDB JNI - RocksDB fat jar with modifications specific for Apache Flink that contains .so files for linux32 and linux64 (glibc and musl-libc), jnilib files + ForSt JNI + ForSt fat jar that contains .so files for linux32 and linux64 (glibc and musl-libc), jnilib files for Mac OSX, and a .dll for Windows x64. https://rocksdb.org @@ -22,37 +22,16 @@ - scm:git:https://github.com/ververica/frocksdb.git - scm:git:https://github.com/ververica/frocksdb.git - scm:git:https://github.com/ververica/frocksdb.git + scm:git:https://github.com/ververica/ForSt.git + scm:git:https://github.com/ververica/ForSt.git + scm:git:https://github.com/ververica/ForSt.git - Facebook - https://www.facebook.com + Ververica + https://www.ververica.com - - - Facebook - help@facebook.com - America/New_York - - architect - - - - - - - rocksdb - Google Groups - rocksdb-subscribe@googlegroups.com - rocksdb-unsubscribe@googlegroups.com - rocksdb@googlegroups.com - https://groups.google.com/forum/#!forum/rocksdb - - - 1.8 1.8 diff --git a/java/publish-frocksdbjni.sh b/java/publish-forstjni.sh similarity index 93% rename from java/publish-frocksdbjni.sh rename to java/publish-forstjni.sh index 2a6bd2865..6518206fa 100644 --- a/java/publish-frocksdbjni.sh +++ b/java/publish-forstjni.sh @@ -20,7 +20,7 @@ # fail on errors set -e -PREFIX=java/target/frocksdb-release/frocksdbjni-${VERSION} +PREFIX=java/target/forst-release/forstjni-${VERSION} function deploy() { FILE=$1 @@ -37,8 +37,6 @@ function deploy() { -Dgpg.passphrase="${PASSPHRASE}" } -PREFIX=java/target/frocksdb-release/frocksdbjni-${VERSION} - deploy ${PREFIX}-sources.jar sources deploy ${PREFIX}-javadoc.jar javadoc deploy ${PREFIX}.jar From ab5912faf684b6048056c700283a6d6f6fb57abb Mon Sep 17 00:00:00 2001 From: fredia Date: Thu, 26 Sep 2024 15:34:30 +0800 Subject: [PATCH 48/61] [FLINK-35928][build] rename namespace/jni to forst --- Makefile | 14 +- db/db_basic_test.cc | 2 +- db/db_secondary_test.cc | 2 +- include/rocksdb/rocksdb_namespace.h | 2 +- java/CMakeLists.txt | 1198 ++++---- java/Makefile | 414 +-- .../org/rocksdb/benchmark/DbBenchmark.java | 8 +- .../backup_engine_options.cc | 106 +- .../{rocksjni => forstjni}/backupenginejni.cc | 50 +- java/{rocksjni => forstjni}/cache.cc | 10 +- .../cassandra_compactionfilterjni.cc | 8 +- .../cassandra_value_operator.cc | 14 +- java/{rocksjni => forstjni}/checkpoint.cc | 22 +- java/{rocksjni => forstjni}/clock_cache.cc | 12 +- .../columnfamilyhandle.cc | 20 +- .../compact_range_options.cc | 128 +- .../compaction_filter.cc | 6 +- .../compaction_filter_factory.cc | 14 +- .../compaction_filter_factory_jnicallback.cc | 4 +- .../compaction_filter_factory_jnicallback.h | 2 +- .../compaction_job_info.cc | 62 +- .../compaction_job_stats.cc | 114 +- .../compaction_options.cc | 38 +- .../compaction_options_fifo.cc | 28 +- .../compaction_options_universal.cc | 70 +- java/{rocksjni => forstjni}/comparator.cc | 22 +- .../comparatorjnicallback.cc | 4 +- .../comparatorjnicallback.h | 2 +- .../compression_options.cc | 76 +- .../concurrent_task_limiter.cc | 30 +- java/{rocksjni => forstjni}/config_options.cc | 34 +- .../cplusplus_to_java_convert.h | 0 java/{rocksjni => forstjni}/env.cc | 62 +- java/{rocksjni => forstjni}/env_flink.cc | 12 +- .../env_flink_test_suite.cc | 16 +- java/{rocksjni => forstjni}/env_options.cc | 108 +- java/{rocksjni => forstjni}/event_listener.cc | 16 +- .../event_listener_jnicallback.cc | 4 +- .../event_listener_jnicallback.h | 2 +- .../export_import_files_metadatajni.cc | 10 +- java/{rocksjni => forstjni}/filter.cc | 16 +- .../flink_compactionfilterjni.cc | 20 +- .../hyper_clock_cache.cc | 12 +- .../import_column_family_options.cc | 20 +- .../ingest_external_file_options.cc | 64 +- java/{rocksjni => forstjni}/iterator.cc | 84 +- .../jni_perf_context.cc | 394 +-- java/{rocksjni => forstjni}/jnicallback.cc | 4 +- java/{rocksjni => forstjni}/jnicallback.h | 0 java/{rocksjni => forstjni}/kv_helper.h | 2 +- .../loggerjnicallback.cc | 28 +- .../loggerjnicallback.h | 2 +- java/{rocksjni => forstjni}/lru_cache.cc | 16 +- java/{rocksjni => forstjni}/memory_util.cc | 8 +- java/{rocksjni => forstjni}/memtablejni.cc | 28 +- java/{rocksjni => forstjni}/merge_operator.cc | 26 +- .../native_comparator_wrapper_test.cc | 8 +- .../optimistic_transaction_db.cc | 42 +- .../optimistic_transaction_options.cc | 24 +- java/{rocksjni => forstjni}/options.cc | 2726 ++++++++--------- java/{rocksjni => forstjni}/options_util.cc | 20 +- .../persistent_cache.cc | 12 +- java/{rocksjni => forstjni}/portal.h | 20 +- java/{rocksjni => forstjni}/ratelimiterjni.cc | 38 +- .../remove_emptyvalue_compactionfilterjni.cc | 8 +- java/{rocksjni => forstjni}/restorejni.cc | 14 +- .../rocks_callback_object.cc | 6 +- .../rocksdb_exception_test.cc | 28 +- java/{rocksjni => forstjni}/rocksjni.cc | 470 +-- java/{rocksjni => forstjni}/slice.cc | 102 +- java/{rocksjni => forstjni}/snapshot.cc | 8 +- .../sst_file_manager.cc | 54 +- .../sst_file_reader_iterator.cc | 84 +- .../sst_file_readerjni.cc | 30 +- .../sst_file_writerjni.cc | 58 +- .../{rocksjni => forstjni}/sst_partitioner.cc | 14 +- java/{rocksjni => forstjni}/statistics.cc | 66 +- java/{rocksjni => forstjni}/statisticsjni.cc | 2 +- java/{rocksjni => forstjni}/statisticsjni.h | 0 java/{rocksjni => forstjni}/table.cc | 14 +- java/{rocksjni => forstjni}/table_filter.cc | 10 +- .../table_filter_jnicallback.cc | 4 +- .../table_filter_jnicallback.h | 2 +- .../testable_event_listener.cc | 6 +- java/{rocksjni => forstjni}/thread_status.cc | 30 +- java/{rocksjni => forstjni}/trace_writer.cc | 10 +- .../trace_writer_jnicallback.cc | 4 +- .../trace_writer_jnicallback.h | 2 +- java/{rocksjni => forstjni}/transaction.cc | 322 +- java/{rocksjni => forstjni}/transaction_db.cc | 58 +- .../transaction_db_options.cc | 54 +- .../{rocksjni => forstjni}/transaction_log.cc | 24 +- .../transaction_notifier.cc | 14 +- .../transaction_notifier_jnicallback.cc | 6 +- .../transaction_notifier_jnicallback.h | 2 +- .../transaction_options.cc | 60 +- java/{rocksjni => forstjni}/ttl.cc | 26 +- java/{rocksjni => forstjni}/wal_filter.cc | 10 +- .../wal_filter_jnicallback.cc | 6 +- .../wal_filter_jnicallback.h | 2 +- java/{rocksjni => forstjni}/write_batch.cc | 158 +- .../write_batch_test.cc | 26 +- .../write_batch_with_index.cc | 192 +- .../write_buffer_manager.cc | 12 +- .../writebatchhandlerjnicallback.cc | 4 +- .../writebatchhandlerjnicallback.h | 2 +- .../org_forstdb_AbstractCompactionFilter.h | 21 + ..._forstdb_AbstractCompactionFilterFactory.h | 29 + java/include/org_forstdb_AbstractComparator.h | 29 + .../org_forstdb_AbstractEventListener.h | 29 + java/include/org_forstdb_AbstractSlice.h | 69 + .../include/org_forstdb_AbstractTableFilter.h | 21 + .../include/org_forstdb_AbstractTraceWriter.h | 21 + .../org_forstdb_AbstractTransactionNotifier.h | 29 + java/include/org_forstdb_AbstractWalFilter.h | 21 + java/include/org_forstdb_BackupEngine.h | 101 + .../include/org_forstdb_BackupEngineOptions.h | 213 ++ .../org_forstdb_BlockBasedTableConfig.h | 21 + java/include/org_forstdb_BloomFilter.h | 23 + java/include/org_forstdb_Cache.h | 29 + .../org_forstdb_CassandraCompactionFilter.h | 21 + .../org_forstdb_CassandraValueMergeOperator.h | 29 + java/include/org_forstdb_Checkpoint.h | 45 + java/include/org_forstdb_ClockCache.h | 29 + java/include/org_forstdb_ColumnFamilyHandle.h | 45 + .../include/org_forstdb_ColumnFamilyOptions.h | 1141 +++++++ .../include/org_forstdb_CompactRangeOptions.h | 181 ++ java/include/org_forstdb_CompactionJobInfo.h | 125 + java/include/org_forstdb_CompactionJobStats.h | 229 ++ java/include/org_forstdb_CompactionOptions.h | 77 + .../org_forstdb_CompactionOptionsFIFO.h | 61 + .../org_forstdb_CompactionOptionsUniversal.h | 141 + java/include/org_forstdb_ComparatorOptions.h | 77 + java/include/org_forstdb_CompressionOptions.h | 125 + .../org_forstdb_ConcurrentTaskLimiterImpl.h | 61 + java/include/org_forstdb_ConfigOptions.h | 69 + java/include/org_forstdb_DBOptions.h | 1343 ++++++++ java/include/org_forstdb_DirectSlice.h | 77 + java/include/org_forstdb_Env.h | 77 + java/include/org_forstdb_EnvFlinkTestSuite.h | 37 + java/include/org_forstdb_EnvOptions.h | 221 ++ .../org_forstdb_ExportImportFilesMetaData.h | 21 + java/include/org_forstdb_Filter.h | 21 + .../org_forstdb_FlinkCompactionFilter.h | 45 + java/include/org_forstdb_FlinkEnv.h | 29 + java/include/org_forstdb_FlushOptions.h | 61 + ...org_forstdb_HashLinkedListMemTableConfig.h | 31 + .../org_forstdb_HashSkipListMemTableConfig.h | 27 + java/include/org_forstdb_HyperClockCache.h | 29 + .../org_forstdb_ImportColumnFamilyOptions.h | 45 + .../org_forstdb_IngestExternalFileOptions.h | 133 + java/include/org_forstdb_LRUCache.h | 29 + java/include/org_forstdb_LiveFileMetaData.h | 21 + java/include/org_forstdb_Logger.h | 57 + java/include/org_forstdb_MemoryUtil.h | 21 + .../org_forstdb_NativeComparatorWrapper.h | 21 + ...rapperTest_NativeStringComparatorWrapper.h | 21 + .../org_forstdb_OptimisticTransactionDB.h | 87 + ...org_forstdb_OptimisticTransactionOptions.h | 53 + java/include/org_forstdb_Options.h | 2405 +++++++++++++++ java/include/org_forstdb_OptionsUtil.h | 45 + java/include/org_forstdb_PerfContext.h | 805 +++++ java/include/org_forstdb_PersistentCache.h | 29 + java/include/org_forstdb_PlainTableConfig.h | 35 + java/include/org_forstdb_RateLimiter.h | 83 + java/include/org_forstdb_ReadOptions.h | 389 +++ ...forstdb_RemoveEmptyValueCompactionFilter.h | 21 + java/include/org_forstdb_RestoreOptions.h | 29 + .../include/org_forstdb_RocksCallbackObject.h | 21 + java/include/org_forstdb_RocksDB.h | 935 ++++++ .../org_forstdb_RocksDBExceptionTest.h | 61 + java/include/org_forstdb_RocksEnv.h | 21 + java/include/org_forstdb_RocksIterator.h | 173 ++ java/include/org_forstdb_RocksMemEnv.h | 29 + .../org_forstdb_SkipListMemTableConfig.h | 23 + java/include/org_forstdb_Slice.h | 61 + java/include/org_forstdb_Snapshot.h | 21 + java/include/org_forstdb_SstFileManager.h | 117 + java/include/org_forstdb_SstFileReader.h | 61 + .../org_forstdb_SstFileReaderIterator.h | 173 ++ java/include/org_forstdb_SstFileWriter.h | 117 + ...forstdb_SstPartitionerFixedPrefixFactory.h | 29 + java/include/org_forstdb_Statistics.h | 117 + .../org_forstdb_StringAppendOperator.h | 37 + java/include/org_forstdb_ThreadStatus.h | 69 + java/include/org_forstdb_TimedEnv.h | 29 + java/include/org_forstdb_Transaction.h | 613 ++++ java/include/org_forstdb_TransactionDB.h | 119 + .../org_forstdb_TransactionDBOptions.h | 109 + .../org_forstdb_TransactionLogIterator.h | 53 + java/include/org_forstdb_TransactionOptions.h | 125 + java/include/org_forstdb_TtlDB.h | 55 + java/include/org_forstdb_UInt64AddOperator.h | 29 + .../org_forstdb_VectorMemTableConfig.h | 23 + java/include/org_forstdb_WBWIRocksIterator.h | 133 + java/include/org_forstdb_WriteBatch.h | 301 ++ java/include/org_forstdb_WriteBatchTest.h | 21 + ...org_forstdb_WriteBatchTestInternalHelper.h | 37 + .../include/org_forstdb_WriteBatchWithIndex.h | 261 ++ java/include/org_forstdb_WriteBatch_Handler.h | 21 + java/include/org_forstdb_WriteBufferManager.h | 29 + java/include/org_forstdb_WriteOptions.h | 133 + .../org_forstdb_test_TestableEventListener.h | 21 + java/jmh/pom.xml | 4 +- .../org/rocksdb/jmh/ComparatorBenchmarks.java | 12 +- .../java/org/rocksdb/jmh/GetBenchmarks.java | 8 +- .../org/rocksdb/jmh/MultiGetBenchmarks.java | 10 +- .../java/org/rocksdb/jmh/PutBenchmarks.java | 8 +- .../main/java/org/rocksdb/util/FileUtils.java | 2 +- .../main/java/org/rocksdb/util/KVUtils.java | 2 +- .../java/OptimisticTransactionSample.java | 2 +- .../main/java/RocksDBColumnFamilySample.java | 2 +- java/samples/src/main/java/RocksDBSample.java | 4 +- .../src/main/java/TransactionSample.java | 2 +- java/spotbugs-exclude.xml | 68 +- .../AbstractCompactionFilter.java | 2 +- .../AbstractCompactionFilterFactory.java | 2 +- .../AbstractComparator.java | 2 +- .../AbstractComparatorJniBridge.java | 4 +- .../AbstractEventListener.java | 4 +- .../AbstractImmutableNativeReference.java | 2 +- .../AbstractMutableOptions.java | 2 +- .../AbstractNativeReference.java | 2 +- .../AbstractRocksIterator.java | 4 +- .../{rocksdb => forstdb}/AbstractSlice.java | 14 +- .../AbstractTableFilter.java | 2 +- .../AbstractTraceWriter.java | 2 +- .../AbstractTransactionNotifier.java | 2 +- .../AbstractWalFilter.java | 2 +- .../AbstractWriteBatch.java | 2 +- .../org/{rocksdb => forstdb}/AccessHint.java | 2 +- .../AdvancedColumnFamilyOptionsInterface.java | 8 +- ...edMutableColumnFamilyOptionsInterface.java | 2 +- .../BackgroundErrorReason.java | 2 +- .../{rocksdb => forstdb}/BackupEngine.java | 2 +- .../BackupEngineOptions.java | 6 +- .../org/{rocksdb => forstdb}/BackupInfo.java | 6 +- .../BlockBasedTableConfig.java | 20 +- .../org/{rocksdb => forstdb}/BloomFilter.java | 2 +- .../BuiltinComparator.java | 2 +- .../ByteBufferGetStatus.java | 2 +- .../java/org/{rocksdb => forstdb}/Cache.java | 2 +- .../CassandraCompactionFilter.java | 2 +- .../CassandraValueMergeOperator.java | 2 +- .../org/{rocksdb => forstdb}/Checkpoint.java | 2 +- .../{rocksdb => forstdb}/ChecksumType.java | 2 +- .../org/{rocksdb => forstdb}/ClockCache.java | 2 +- .../ColumnFamilyDescriptor.java | 2 +- .../ColumnFamilyHandle.java | 2 +- .../ColumnFamilyMetaData.java | 2 +- .../ColumnFamilyOptions.java | 8 +- .../ColumnFamilyOptionsInterface.java | 4 +- .../CompactRangeOptions.java | 2 +- .../CompactionJobInfo.java | 2 +- .../CompactionJobStats.java | 2 +- .../CompactionOptions.java | 2 +- .../CompactionOptionsFIFO.java | 2 +- .../CompactionOptionsUniversal.java | 2 +- .../CompactionPriority.java | 4 +- .../CompactionReason.java | 2 +- .../CompactionStopStyle.java | 4 +- .../{rocksdb => forstdb}/CompactionStyle.java | 2 +- .../ComparatorOptions.java | 2 +- .../{rocksdb => forstdb}/ComparatorType.java | 2 +- .../CompressionOptions.java | 2 +- .../{rocksdb => forstdb}/CompressionType.java | 2 +- .../ConcurrentTaskLimiter.java | 2 +- .../ConcurrentTaskLimiterImpl.java | 2 +- .../{rocksdb => forstdb}/ConfigOptions.java | 2 +- .../org/{rocksdb => forstdb}/DBOptions.java | 8 +- .../DBOptionsInterface.java | 14 +- .../DataBlockIndexType.java | 2 +- .../java/org/{rocksdb => forstdb}/DbPath.java | 2 +- .../org/{rocksdb => forstdb}/DirectSlice.java | 4 +- .../{rocksdb => forstdb}/EncodingType.java | 2 +- .../java/org/{rocksdb => forstdb}/Env.java | 4 +- .../EnvFlinkTestSuite.java | 2 +- .../org/{rocksdb => forstdb}/EnvOptions.java | 2 +- .../{rocksdb => forstdb}/EventListener.java | 2 +- .../{rocksdb => forstdb}/Experimental.java | 2 +- .../ExportImportFilesMetaData.java | 2 +- .../ExternalFileIngestionInfo.java | 2 +- .../FileOperationInfo.java | 2 +- .../java/org/{rocksdb => forstdb}/Filter.java | 2 +- .../FilterPolicyType.java | 2 +- .../FlinkCompactionFilter.java | 2 +- .../org/{rocksdb => forstdb}/FlinkEnv.java | 2 +- .../{rocksdb => forstdb}/FlushJobInfo.java | 2 +- .../{rocksdb => forstdb}/FlushOptions.java | 4 +- .../org/{rocksdb => forstdb}/FlushReason.java | 2 +- .../org/{rocksdb => forstdb}/GetStatus.java | 2 +- .../HashLinkedListMemTableConfig.java | 2 +- .../HashSkipListMemTableConfig.java | 2 +- .../{rocksdb => forstdb}/HistogramData.java | 2 +- .../{rocksdb => forstdb}/HistogramType.java | 4 +- .../java/org/{rocksdb => forstdb}/Holder.java | 2 +- .../{rocksdb => forstdb}/HyperClockCache.java | 2 +- .../ImportColumnFamilyOptions.java | 2 +- .../IndexShorteningMode.java | 2 +- .../org/{rocksdb => forstdb}/IndexType.java | 2 +- .../{rocksdb => forstdb}/InfoLogLevel.java | 4 +- .../IngestExternalFileOptions.java | 2 +- .../org/{rocksdb => forstdb}/KeyMayExist.java | 2 +- .../org/{rocksdb => forstdb}/LRUCache.java | 2 +- .../{rocksdb => forstdb}/LevelMetaData.java | 2 +- .../LiveFileMetaData.java | 2 +- .../org/{rocksdb => forstdb}/LogFile.java | 2 +- .../java/org/{rocksdb => forstdb}/Logger.java | 22 +- .../{rocksdb => forstdb}/MemTableConfig.java | 2 +- .../{rocksdb => forstdb}/MemTableInfo.java | 2 +- .../{rocksdb => forstdb}/MemoryUsageType.java | 2 +- .../org/{rocksdb => forstdb}/MemoryUtil.java | 2 +- .../{rocksdb => forstdb}/MergeOperator.java | 2 +- .../MutableColumnFamilyOptions.java | 2 +- .../MutableColumnFamilyOptionsInterface.java | 2 +- .../MutableDBOptions.java | 2 +- .../MutableDBOptionsInterface.java | 2 +- .../MutableOptionKey.java | 2 +- .../MutableOptionValue.java | 4 +- .../NativeComparatorWrapper.java | 2 +- .../NativeLibraryLoader.java | 6 +- .../{rocksdb => forstdb}/OperationStage.java | 2 +- .../{rocksdb => forstdb}/OperationType.java | 2 +- .../OptimisticTransactionDB.java | 6 +- .../OptimisticTransactionOptions.java | 2 +- .../{rocksdb => forstdb}/OptionString.java | 2 +- .../org/{rocksdb => forstdb}/Options.java | 8 +- .../org/{rocksdb => forstdb}/OptionsUtil.java | 16 +- .../org/{rocksdb => forstdb}/PerfContext.java | 2 +- .../org/{rocksdb => forstdb}/PerfLevel.java | 2 +- .../{rocksdb => forstdb}/PersistentCache.java | 2 +- .../PlainTableConfig.java | 4 +- .../PrepopulateBlobCache.java | 2 +- .../org/{rocksdb => forstdb}/Priority.java | 4 +- .../java/org/{rocksdb => forstdb}/Range.java | 2 +- .../org/{rocksdb => forstdb}/RateLimiter.java | 2 +- .../{rocksdb => forstdb}/RateLimiterMode.java | 2 +- .../org/{rocksdb => forstdb}/ReadOptions.java | 2 +- .../org/{rocksdb => forstdb}/ReadTier.java | 4 +- .../RemoveEmptyValueCompactionFilter.java | 2 +- .../{rocksdb => forstdb}/RestoreOptions.java | 2 +- .../ReusedSynchronisationType.java | 4 +- .../RocksCallbackObject.java | 2 +- .../org/{rocksdb => forstdb}/RocksDB.java | 138 +- .../RocksDBException.java | 2 +- .../org/{rocksdb => forstdb}/RocksEnv.java | 2 +- .../{rocksdb => forstdb}/RocksIterator.java | 6 +- .../RocksIteratorInterface.java | 4 +- .../org/{rocksdb => forstdb}/RocksMemEnv.java | 2 +- .../RocksMutableObject.java | 2 +- .../org/{rocksdb => forstdb}/RocksObject.java | 2 +- .../org/{rocksdb => forstdb}/SanityLevel.java | 2 +- .../SizeApproximationFlag.java | 2 +- .../SkipListMemTableConfig.java | 2 +- .../java/org/{rocksdb => forstdb}/Slice.java | 6 +- .../org/{rocksdb => forstdb}/Snapshot.java | 2 +- .../{rocksdb => forstdb}/SstFileManager.java | 2 +- .../{rocksdb => forstdb}/SstFileMetaData.java | 2 +- .../{rocksdb => forstdb}/SstFileReader.java | 2 +- .../SstFileReaderIterator.java | 2 +- .../{rocksdb => forstdb}/SstFileWriter.java | 6 +- .../SstPartitionerFactory.java | 2 +- .../SstPartitionerFixedPrefixFactory.java | 2 +- .../org/{rocksdb => forstdb}/StateType.java | 2 +- .../org/{rocksdb => forstdb}/Statistics.java | 2 +- .../StatisticsCollector.java | 2 +- .../StatisticsCollectorCallback.java | 2 +- .../StatsCollectorInput.java | 2 +- .../org/{rocksdb => forstdb}/StatsLevel.java | 4 +- .../java/org/{rocksdb => forstdb}/Status.java | 2 +- .../StringAppendOperator.java | 2 +- .../TableFileCreationBriefInfo.java | 2 +- .../TableFileCreationInfo.java | 2 +- .../TableFileCreationReason.java | 2 +- .../TableFileDeletionInfo.java | 2 +- .../org/{rocksdb => forstdb}/TableFilter.java | 2 +- .../TableFormatConfig.java | 2 +- .../{rocksdb => forstdb}/TableProperties.java | 2 +- .../{rocksdb => forstdb}/ThreadStatus.java | 2 +- .../org/{rocksdb => forstdb}/ThreadType.java | 2 +- .../org/{rocksdb => forstdb}/TickerType.java | 8 +- .../org/{rocksdb => forstdb}/TimedEnv.java | 2 +- .../{rocksdb => forstdb}/TraceOptions.java | 2 +- .../org/{rocksdb => forstdb}/TraceWriter.java | 2 +- .../org/{rocksdb => forstdb}/Transaction.java | 68 +- .../{rocksdb => forstdb}/TransactionDB.java | 10 +- .../TransactionDBOptions.java | 2 +- .../TransactionLogIterator.java | 12 +- .../TransactionOptions.java | 2 +- .../{rocksdb => forstdb}/TransactionalDB.java | 2 +- .../TransactionalOptions.java | 2 +- .../java/org/{rocksdb => forstdb}/TtlDB.java | 10 +- .../TxnDBWritePolicy.java | 2 +- .../UInt64AddOperator.java | 2 +- .../VectorMemTableConfig.java | 2 +- .../{rocksdb => forstdb}/WALRecoveryMode.java | 2 +- .../WBWIRocksIterator.java | 10 +- .../org/{rocksdb => forstdb}/WalFileType.java | 2 +- .../org/{rocksdb => forstdb}/WalFilter.java | 2 +- .../WalProcessingOption.java | 2 +- .../org/{rocksdb => forstdb}/WriteBatch.java | 2 +- .../WriteBatchInterface.java | 6 +- .../WriteBatchWithIndex.java | 30 +- .../WriteBufferManager.java | 2 +- .../{rocksdb => forstdb}/WriteOptions.java | 2 +- .../WriteStallCondition.java | 2 +- .../{rocksdb => forstdb}/WriteStallInfo.java | 2 +- .../{rocksdb => forstdb}/util/BufferUtil.java | 2 +- .../{rocksdb => forstdb}/util/ByteUtil.java | 2 +- .../util/BytewiseComparator.java | 8 +- .../util/Environment.java | 2 +- .../util/IntComparator.java | 6 +- .../util/ReverseBytewiseComparator.java | 10 +- .../{rocksdb => forstdb}/util/SizeUnit.java | 2 +- .../AbstractTransactionTest.java | 2 +- .../BackupEngineOptionsTest.java | 2 +- .../BackupEngineTest.java | 2 +- .../{rocksdb => forstdb}/BlobOptionsTest.java | 2 +- .../BlockBasedTableConfigTest.java | 2 +- .../BuiltinComparatorTest.java | 2 +- .../ByteBufferUnsupportedOperationTest.java | 4 +- .../BytewiseComparatorRegressionTest.java | 4 +- .../{rocksdb => forstdb}/CheckPointTest.java | 2 +- .../{rocksdb => forstdb}/ClockCacheTest.java | 2 +- .../ColumnFamilyOptionsTest.java | 4 +- .../ColumnFamilyTest.java | 2 +- .../CompactRangeOptionsTest.java | 4 +- .../CompactionFilterFactoryTest.java | 4 +- .../CompactionJobInfoTest.java | 2 +- .../CompactionJobStatsTest.java | 2 +- .../CompactionOptionsFIFOTest.java | 2 +- .../CompactionOptionsTest.java | 2 +- .../CompactionOptionsUniversalTest.java | 2 +- .../CompactionPriorityTest.java | 2 +- .../CompactionStopStyleTest.java | 2 +- .../ComparatorOptionsTest.java | 2 +- .../CompressionOptionsTest.java | 2 +- .../CompressionTypesTest.java | 2 +- .../ConcurrentTaskLimiterTest.java | 2 +- .../{rocksdb => forstdb}/DBOptionsTest.java | 2 +- .../{rocksdb => forstdb}/DefaultEnvTest.java | 2 +- .../{rocksdb => forstdb}/DirectSliceTest.java | 2 +- .../{rocksdb => forstdb}/EnvOptionsTest.java | 2 +- .../EventListenerTest.java | 6 +- .../org/{rocksdb => forstdb}/FilterTest.java | 2 +- .../FlinkCompactionFilterTest.java | 6 +- .../FlushOptionsTest.java | 2 +- .../org/{rocksdb => forstdb}/FlushTest.java | 2 +- .../HyperClockCacheTest.java | 2 +- .../ImportColumnFamilyTest.java | 4 +- .../InfoLogLevelTest.java | 4 +- .../IngestExternalFileOptionsTest.java | 2 +- .../{rocksdb => forstdb}/KeyExistsTest.java | 2 +- .../{rocksdb => forstdb}/KeyMayExistTest.java | 2 +- .../{rocksdb => forstdb}/LRUCacheTest.java | 2 +- .../org/{rocksdb => forstdb}/LoggerTest.java | 2 +- .../{rocksdb => forstdb}/MemTableTest.java | 2 +- .../{rocksdb => forstdb}/MemoryUtilTest.java | 2 +- .../MergeCFVariantsTest.java | 6 +- .../org/{rocksdb => forstdb}/MergeTest.java | 2 +- .../MergeVariantsTest.java | 6 +- .../MixedOptionsTest.java | 2 +- .../MultiColumnRegressionTest.java | 2 +- .../MultiGetManyKeysTest.java | 2 +- .../{rocksdb => forstdb}/MultiGetTest.java | 4 +- .../MutableColumnFamilyOptionsTest.java | 4 +- .../MutableDBOptionsTest.java | 4 +- .../MutableOptionsGetSetTest.java | 2 +- .../NativeComparatorWrapperTest.java | 2 +- .../NativeLibraryLoaderTest.java | 4 +- .../OptimisticTransactionDBTest.java | 2 +- .../OptimisticTransactionOptionsTest.java | 4 +- .../OptimisticTransactionTest.java | 2 +- .../org/{rocksdb => forstdb}/OptionsTest.java | 4 +- .../{rocksdb => forstdb}/OptionsUtilTest.java | 2 +- .../{rocksdb => forstdb}/PerfContextTest.java | 2 +- .../{rocksdb => forstdb}/PerfLevelTest.java | 4 +- .../PlainTableConfigTest.java | 2 +- .../PlatformRandomHelper.java | 2 +- .../PutCFVariantsTest.java | 6 +- .../PutMultiplePartsTest.java | 2 +- .../{rocksdb => forstdb}/PutVariantsTest.java | 6 +- .../{rocksdb => forstdb}/RateLimiterTest.java | 4 +- .../{rocksdb => forstdb}/ReadOnlyTest.java | 2 +- .../{rocksdb => forstdb}/ReadOptionsTest.java | 2 +- .../RocksDBExceptionTest.java | 6 +- .../org/{rocksdb => forstdb}/RocksDBTest.java | 2 +- .../RocksIteratorTest.java | 2 +- .../{rocksdb => forstdb}/RocksMemEnvTest.java | 2 +- .../RocksNativeLibraryResource.java | 2 +- .../{rocksdb => forstdb}/SecondaryDBTest.java | 2 +- .../org/{rocksdb => forstdb}/SliceTest.java | 2 +- .../{rocksdb => forstdb}/SnapshotTest.java | 2 +- .../SstFileManagerTest.java | 2 +- .../SstFileReaderTest.java | 4 +- .../SstFileWriterTest.java | 4 +- .../SstPartitionerTest.java | 2 +- .../StatisticsCollectorTest.java | 2 +- .../{rocksdb => forstdb}/StatisticsTest.java | 2 +- .../StatsCallbackMock.java | 2 +- .../{rocksdb => forstdb}/TableFilterTest.java | 2 +- .../{rocksdb => forstdb}/TimedEnvTest.java | 2 +- .../TransactionDBOptionsTest.java | 2 +- .../TransactionDBTest.java | 2 +- .../TransactionLogIteratorTest.java | 2 +- .../TransactionOptionsTest.java | 2 +- .../{rocksdb => forstdb}/TransactionTest.java | 2 +- .../org/{rocksdb => forstdb}/TtlDBTest.java | 2 +- .../java/org/{rocksdb => forstdb}/Types.java | 2 +- .../VerifyChecksumsTest.java | 2 +- .../WALRecoveryModeTest.java | 2 +- .../{rocksdb => forstdb}/WalFilterTest.java | 6 +- .../WriteBatchHandlerTest.java | 8 +- .../{rocksdb => forstdb}/WriteBatchTest.java | 20 +- .../WriteBatchThreadedTest.java | 2 +- .../WriteBatchWithIndexTest.java | 4 +- .../WriteOptionsTest.java | 2 +- .../flink/FlinkEnvTest.java | 6 +- ...moveEmptyValueCompactionFilterFactory.java | 8 +- .../test/RocksJunitRunner.java | 6 +- .../test/TestableEventListener.java | 4 +- .../util/ByteBufferAllocator.java | 2 +- .../util/BytewiseComparatorIntTest.java | 4 +- .../util/BytewiseComparatorTest.java | 6 +- .../util/CapturingWriteBatchHandler.java | 6 +- .../util/DirectByteBufferAllocator.java | 2 +- .../util/EnvironmentTest.java | 2 +- .../util/HeapByteBufferAllocator.java | 2 +- .../util/IntComparatorTest.java | 4 +- .../util/JNIComparatorTest.java | 4 +- .../ReverseBytewiseComparatorIntTest.java | 4 +- .../util/SizeUnitTest.java | 2 +- .../{rocksdb => forstdb}/util/TestUtil.java | 8 +- .../util/WriteBatchGetter.java | 6 +- logging/auto_roll_logger.cc | 2 +- src.mk | 170 +- 536 files changed, 18581 insertions(+), 4944 deletions(-) rename java/{rocksjni => forstjni}/backup_engine_options.cc (77%) rename java/{rocksjni => forstjni}/backupenginejni.cc (86%) rename java/{rocksjni => forstjni}/cache.cc (78%) rename java/{rocksjni => forstjni}/cassandra_compactionfilterjni.cc (78%) rename java/{rocksjni => forstjni}/cassandra_value_operator.cc (77%) rename java/{rocksjni => forstjni}/checkpoint.cc (85%) rename java/{rocksjni => forstjni}/clock_cache.cc (81%) rename java/{rocksjni => forstjni}/columnfamilyhandle.cc (80%) rename java/{rocksjni => forstjni}/compact_range_options.cc (70%) rename java/{rocksjni => forstjni}/compaction_filter.cc (83%) rename java/{rocksjni => forstjni}/compaction_filter_factory.cc (71%) rename java/{rocksjni => forstjni}/compaction_filter_factory_jnicallback.cc (96%) rename java/{rocksjni => forstjni}/compaction_filter_factory_jnicallback.h (97%) rename java/{rocksjni => forstjni}/compaction_job_info.cc (79%) rename java/{rocksjni => forstjni}/compaction_job_stats.cc (74%) rename java/{rocksjni => forstjni}/compaction_options.cc (74%) rename java/{rocksjni => forstjni}/compaction_options_fifo.cc (73%) rename java/{rocksjni => forstjni}/compaction_options_universal.cc (71%) rename java/{rocksjni => forstjni}/comparator.cc (71%) rename java/{rocksjni => forstjni}/comparatorjnicallback.cc (99%) rename java/{rocksjni => forstjni}/comparatorjnicallback.h (99%) rename java/{rocksjni => forstjni}/compression_options.cc (73%) rename java/{rocksjni => forstjni}/concurrent_task_limiter.cc (75%) rename java/{rocksjni => forstjni}/config_options.cc (76%) rename java/{rocksjni => forstjni}/cplusplus_to_java_convert.h (100%) rename java/{rocksjni => forstjni}/env.cc (78%) rename java/{rocksjni => forstjni}/env_flink.cc (87%) rename java/{rocksjni => forstjni}/env_flink_test_suite.cc (84%) rename java/{rocksjni => forstjni}/env_options.cc (72%) rename java/{rocksjni => forstjni}/event_listener.cc (74%) rename java/{rocksjni => forstjni}/event_listener_jnicallback.cc (99%) rename java/{rocksjni => forstjni}/event_listener_jnicallback.h (99%) rename java/{rocksjni => forstjni}/export_import_files_metadatajni.cc (67%) rename java/{rocksjni => forstjni}/filter.cc (76%) rename java/{rocksjni => forstjni}/flink_compactionfilterjni.cc (94%) rename java/{rocksjni => forstjni}/hyper_clock_cache.cc (78%) rename java/{rocksjni => forstjni}/import_column_family_options.cc (71%) rename java/{rocksjni => forstjni}/ingest_external_file_options.cc (73%) rename java/{rocksjni => forstjni}/iterator.cc (82%) rename java/{rocksjni => forstjni}/jni_perf_context.cc (75%) rename java/{rocksjni => forstjni}/jnicallback.cc (96%) rename java/{rocksjni => forstjni}/jnicallback.h (100%) rename java/{rocksjni => forstjni}/kv_helper.h (99%) rename java/{rocksjni => forstjni}/loggerjnicallback.cc (92%) rename java/{rocksjni => forstjni}/loggerjnicallback.h (97%) rename java/{rocksjni => forstjni}/lru_cache.cc (78%) rename java/{rocksjni => forstjni}/memory_util.cc (95%) rename java/{rocksjni => forstjni}/memtablejni.cc (79%) rename java/{rocksjni => forstjni}/merge_operator.cc (80%) rename java/{rocksjni => forstjni}/native_comparator_wrapper_test.cc (83%) rename java/{rocksjni => forstjni}/optimistic_transaction_db.cc (88%) rename java/{rocksjni => forstjni}/optimistic_transaction_options.cc (72%) rename java/{rocksjni => forstjni}/options.cc (76%) rename java/{rocksjni => forstjni}/options_util.cc (93%) rename java/{rocksjni => forstjni}/persistent_cache.cc (85%) rename java/{rocksjni => forstjni}/portal.h (99%) rename java/{rocksjni => forstjni}/ratelimiterjni.cc (79%) rename java/{rocksjni => forstjni}/remove_emptyvalue_compactionfilterjni.cc (75%) rename java/{rocksjni => forstjni}/restorejni.cc (76%) rename java/{rocksjni => forstjni}/rocks_callback_object.cc (87%) rename java/{rocksjni => forstjni}/rocksdb_exception_test.cc (72%) rename java/{rocksjni => forstjni}/rocksjni.cc (92%) rename java/{rocksjni => forstjni}/slice.cc (79%) rename java/{rocksjni => forstjni}/snapshot.cc (81%) rename java/{rocksjni => forstjni}/sst_file_manager.cc (84%) rename java/{rocksjni => forstjni}/sst_file_reader_iterator.cc (82%) rename java/{rocksjni => forstjni}/sst_file_readerjni.cc (82%) rename java/{rocksjni => forstjni}/sst_file_writerjni.cc (86%) rename java/{rocksjni => forstjni}/sst_partitioner.cc (74%) rename java/{rocksjni => forstjni}/statistics.cc (81%) rename java/{rocksjni => forstjni}/statisticsjni.cc (96%) rename java/{rocksjni => forstjni}/statisticsjni.h (100%) rename java/{rocksjni => forstjni}/table.cc (94%) rename java/{rocksjni => forstjni}/table_filter.cc (72%) rename java/{rocksjni => forstjni}/table_filter_jnicallback.cc (96%) rename java/{rocksjni => forstjni}/table_filter_jnicallback.h (96%) rename java/{rocksjni => forstjni}/testable_event_listener.cc (98%) rename java/{rocksjni => forstjni}/thread_status.cc (83%) rename java/{rocksjni => forstjni}/trace_writer.cc (72%) rename java/{rocksjni => forstjni}/trace_writer_jnicallback.cc (97%) rename java/{rocksjni => forstjni}/trace_writer_jnicallback.h (96%) rename java/{rocksjni => forstjni}/transaction.cc (88%) rename java/{rocksjni => forstjni}/transaction_db.cc (91%) rename java/{rocksjni => forstjni}/transaction_db_options.cc (75%) rename java/{rocksjni => forstjni}/transaction_log.cc (77%) rename java/{rocksjni => forstjni}/transaction_notifier.cc (76%) rename java/{rocksjni => forstjni}/transaction_notifier_jnicallback.cc (90%) rename java/{rocksjni => forstjni}/transaction_notifier_jnicallback.h (97%) rename java/{rocksjni => forstjni}/transaction_options.cc (75%) rename java/{rocksjni => forstjni}/ttl.cc (91%) rename java/{rocksjni => forstjni}/wal_filter.cc (71%) rename java/{rocksjni => forstjni}/wal_filter_jnicallback.cc (97%) rename java/{rocksjni => forstjni}/wal_filter_jnicallback.h (97%) rename java/{rocksjni => forstjni}/write_batch.cc (83%) rename java/{rocksjni => forstjni}/write_batch_test.cc (90%) rename java/{rocksjni => forstjni}/write_batch_with_index.cc (84%) rename java/{rocksjni => forstjni}/write_buffer_manager.cc (81%) rename java/{rocksjni => forstjni}/writebatchhandlerjnicallback.cc (99%) rename java/{rocksjni => forstjni}/writebatchhandlerjnicallback.h (99%) create mode 100644 java/include/org_forstdb_AbstractCompactionFilter.h create mode 100644 java/include/org_forstdb_AbstractCompactionFilterFactory.h create mode 100644 java/include/org_forstdb_AbstractComparator.h create mode 100644 java/include/org_forstdb_AbstractEventListener.h create mode 100644 java/include/org_forstdb_AbstractSlice.h create mode 100644 java/include/org_forstdb_AbstractTableFilter.h create mode 100644 java/include/org_forstdb_AbstractTraceWriter.h create mode 100644 java/include/org_forstdb_AbstractTransactionNotifier.h create mode 100644 java/include/org_forstdb_AbstractWalFilter.h create mode 100644 java/include/org_forstdb_BackupEngine.h create mode 100644 java/include/org_forstdb_BackupEngineOptions.h create mode 100644 java/include/org_forstdb_BlockBasedTableConfig.h create mode 100644 java/include/org_forstdb_BloomFilter.h create mode 100644 java/include/org_forstdb_Cache.h create mode 100644 java/include/org_forstdb_CassandraCompactionFilter.h create mode 100644 java/include/org_forstdb_CassandraValueMergeOperator.h create mode 100644 java/include/org_forstdb_Checkpoint.h create mode 100644 java/include/org_forstdb_ClockCache.h create mode 100644 java/include/org_forstdb_ColumnFamilyHandle.h create mode 100644 java/include/org_forstdb_ColumnFamilyOptions.h create mode 100644 java/include/org_forstdb_CompactRangeOptions.h create mode 100644 java/include/org_forstdb_CompactionJobInfo.h create mode 100644 java/include/org_forstdb_CompactionJobStats.h create mode 100644 java/include/org_forstdb_CompactionOptions.h create mode 100644 java/include/org_forstdb_CompactionOptionsFIFO.h create mode 100644 java/include/org_forstdb_CompactionOptionsUniversal.h create mode 100644 java/include/org_forstdb_ComparatorOptions.h create mode 100644 java/include/org_forstdb_CompressionOptions.h create mode 100644 java/include/org_forstdb_ConcurrentTaskLimiterImpl.h create mode 100644 java/include/org_forstdb_ConfigOptions.h create mode 100644 java/include/org_forstdb_DBOptions.h create mode 100644 java/include/org_forstdb_DirectSlice.h create mode 100644 java/include/org_forstdb_Env.h create mode 100644 java/include/org_forstdb_EnvFlinkTestSuite.h create mode 100644 java/include/org_forstdb_EnvOptions.h create mode 100644 java/include/org_forstdb_ExportImportFilesMetaData.h create mode 100644 java/include/org_forstdb_Filter.h create mode 100644 java/include/org_forstdb_FlinkCompactionFilter.h create mode 100644 java/include/org_forstdb_FlinkEnv.h create mode 100644 java/include/org_forstdb_FlushOptions.h create mode 100644 java/include/org_forstdb_HashLinkedListMemTableConfig.h create mode 100644 java/include/org_forstdb_HashSkipListMemTableConfig.h create mode 100644 java/include/org_forstdb_HyperClockCache.h create mode 100644 java/include/org_forstdb_ImportColumnFamilyOptions.h create mode 100644 java/include/org_forstdb_IngestExternalFileOptions.h create mode 100644 java/include/org_forstdb_LRUCache.h create mode 100644 java/include/org_forstdb_LiveFileMetaData.h create mode 100644 java/include/org_forstdb_Logger.h create mode 100644 java/include/org_forstdb_MemoryUtil.h create mode 100644 java/include/org_forstdb_NativeComparatorWrapper.h create mode 100644 java/include/org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper.h create mode 100644 java/include/org_forstdb_OptimisticTransactionDB.h create mode 100644 java/include/org_forstdb_OptimisticTransactionOptions.h create mode 100644 java/include/org_forstdb_Options.h create mode 100644 java/include/org_forstdb_OptionsUtil.h create mode 100644 java/include/org_forstdb_PerfContext.h create mode 100644 java/include/org_forstdb_PersistentCache.h create mode 100644 java/include/org_forstdb_PlainTableConfig.h create mode 100644 java/include/org_forstdb_RateLimiter.h create mode 100644 java/include/org_forstdb_ReadOptions.h create mode 100644 java/include/org_forstdb_RemoveEmptyValueCompactionFilter.h create mode 100644 java/include/org_forstdb_RestoreOptions.h create mode 100644 java/include/org_forstdb_RocksCallbackObject.h create mode 100644 java/include/org_forstdb_RocksDB.h create mode 100644 java/include/org_forstdb_RocksDBExceptionTest.h create mode 100644 java/include/org_forstdb_RocksEnv.h create mode 100644 java/include/org_forstdb_RocksIterator.h create mode 100644 java/include/org_forstdb_RocksMemEnv.h create mode 100644 java/include/org_forstdb_SkipListMemTableConfig.h create mode 100644 java/include/org_forstdb_Slice.h create mode 100644 java/include/org_forstdb_Snapshot.h create mode 100644 java/include/org_forstdb_SstFileManager.h create mode 100644 java/include/org_forstdb_SstFileReader.h create mode 100644 java/include/org_forstdb_SstFileReaderIterator.h create mode 100644 java/include/org_forstdb_SstFileWriter.h create mode 100644 java/include/org_forstdb_SstPartitionerFixedPrefixFactory.h create mode 100644 java/include/org_forstdb_Statistics.h create mode 100644 java/include/org_forstdb_StringAppendOperator.h create mode 100644 java/include/org_forstdb_ThreadStatus.h create mode 100644 java/include/org_forstdb_TimedEnv.h create mode 100644 java/include/org_forstdb_Transaction.h create mode 100644 java/include/org_forstdb_TransactionDB.h create mode 100644 java/include/org_forstdb_TransactionDBOptions.h create mode 100644 java/include/org_forstdb_TransactionLogIterator.h create mode 100644 java/include/org_forstdb_TransactionOptions.h create mode 100644 java/include/org_forstdb_TtlDB.h create mode 100644 java/include/org_forstdb_UInt64AddOperator.h create mode 100644 java/include/org_forstdb_VectorMemTableConfig.h create mode 100644 java/include/org_forstdb_WBWIRocksIterator.h create mode 100644 java/include/org_forstdb_WriteBatch.h create mode 100644 java/include/org_forstdb_WriteBatchTest.h create mode 100644 java/include/org_forstdb_WriteBatchTestInternalHelper.h create mode 100644 java/include/org_forstdb_WriteBatchWithIndex.h create mode 100644 java/include/org_forstdb_WriteBatch_Handler.h create mode 100644 java/include/org_forstdb_WriteBufferManager.h create mode 100644 java/include/org_forstdb_WriteOptions.h create mode 100644 java/include/org_forstdb_test_TestableEventListener.h rename java/src/main/java/org/{rocksdb => forstdb}/AbstractCompactionFilter.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractCompactionFilterFactory.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractComparator.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractComparatorJniBridge.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractEventListener.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractImmutableNativeReference.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractMutableOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractNativeReference.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractRocksIterator.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractSlice.java (93%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractTableFilter.java (95%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractTraceWriter.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractTransactionNotifier.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractWalFilter.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/AbstractWriteBatch.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/AccessHint.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/AdvancedColumnFamilyOptionsInterface.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/AdvancedMutableColumnFamilyOptionsInterface.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/BackgroundErrorReason.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/BackupEngine.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/BackupEngineOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/BackupInfo.java (93%) rename java/src/main/java/org/{rocksdb => forstdb}/BlockBasedTableConfig.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/BloomFilter.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/BuiltinComparator.java (96%) rename java/src/main/java/org/{rocksdb => forstdb}/ByteBufferGetStatus.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/Cache.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/CassandraCompactionFilter.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/CassandraValueMergeOperator.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/Checkpoint.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/ChecksumType.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/ClockCache.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/ColumnFamilyDescriptor.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/ColumnFamilyHandle.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/ColumnFamilyMetaData.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/ColumnFamilyOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/ColumnFamilyOptionsInterface.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/CompactRangeOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/CompactionJobInfo.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/CompactionJobStats.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/CompactionOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/CompactionOptionsFIFO.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/CompactionOptionsUniversal.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/CompactionPriority.java (96%) rename java/src/main/java/org/{rocksdb => forstdb}/CompactionReason.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/CompactionStopStyle.java (93%) rename java/src/main/java/org/{rocksdb => forstdb}/CompactionStyle.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/ComparatorOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/ComparatorType.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/CompressionOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/CompressionType.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/ConcurrentTaskLimiter.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/ConcurrentTaskLimiterImpl.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/ConfigOptions.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/DBOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/DBOptionsInterface.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/DataBlockIndexType.java (96%) rename java/src/main/java/org/{rocksdb => forstdb}/DbPath.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/DirectSlice.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/EncodingType.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/Env.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/EnvFlinkTestSuite.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/EnvOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/EventListener.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/Experimental.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/ExportImportFilesMetaData.java (96%) rename java/src/main/java/org/{rocksdb => forstdb}/ExternalFileIngestionInfo.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/FileOperationInfo.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/Filter.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/FilterPolicyType.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/FlinkCompactionFilter.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/FlinkEnv.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/FlushJobInfo.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/FlushOptions.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/FlushReason.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/GetStatus.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/HashLinkedListMemTableConfig.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/HashSkipListMemTableConfig.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/HistogramData.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/HistogramType.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/Holder.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/HyperClockCache.java (96%) rename java/src/main/java/org/{rocksdb => forstdb}/ImportColumnFamilyOptions.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/IndexShorteningMode.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/IndexType.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/InfoLogLevel.java (93%) rename java/src/main/java/org/{rocksdb => forstdb}/IngestExternalFileOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/KeyMayExist.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/LRUCache.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/LevelMetaData.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/LiveFileMetaData.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/LogFile.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/Logger.java (84%) rename java/src/main/java/org/{rocksdb => forstdb}/MemTableConfig.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/MemTableInfo.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/MemoryUsageType.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/MemoryUtil.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/MergeOperator.java (96%) rename java/src/main/java/org/{rocksdb => forstdb}/MutableColumnFamilyOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/MutableColumnFamilyOptionsInterface.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/MutableDBOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/MutableDBOptionsInterface.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/MutableOptionKey.java (92%) rename java/src/main/java/org/{rocksdb => forstdb}/MutableOptionValue.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/NativeComparatorWrapper.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/NativeLibraryLoader.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/OperationStage.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/OperationType.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/OptimisticTransactionDB.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/OptimisticTransactionOptions.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/OptionString.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/Options.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/OptionsUtil.java (90%) rename java/src/main/java/org/{rocksdb => forstdb}/PerfContext.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/PerfLevel.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/PersistentCache.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/PlainTableConfig.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/PrepopulateBlobCache.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/Priority.java (93%) rename java/src/main/java/org/{rocksdb => forstdb}/Range.java (95%) rename java/src/main/java/org/{rocksdb => forstdb}/RateLimiter.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/RateLimiterMode.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/ReadOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/ReadTier.java (93%) rename java/src/main/java/org/{rocksdb => forstdb}/RemoveEmptyValueCompactionFilter.java (96%) rename java/src/main/java/org/{rocksdb => forstdb}/RestoreOptions.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/ReusedSynchronisationType.java (95%) rename java/src/main/java/org/{rocksdb => forstdb}/RocksCallbackObject.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/RocksDB.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/RocksDBException.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/RocksEnv.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/RocksIterator.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/RocksIteratorInterface.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/RocksMemEnv.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/RocksMutableObject.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/RocksObject.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/SanityLevel.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/SizeApproximationFlag.java (96%) rename java/src/main/java/org/{rocksdb => forstdb}/SkipListMemTableConfig.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/Slice.java (96%) rename java/src/main/java/org/{rocksdb => forstdb}/Snapshot.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/SstFileManager.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/SstFileMetaData.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/SstFileReader.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/SstFileReaderIterator.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/SstFileWriter.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/SstPartitionerFactory.java (96%) rename java/src/main/java/org/{rocksdb => forstdb}/SstPartitionerFixedPrefixFactory.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/StateType.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/Statistics.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/StatisticsCollector.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/StatisticsCollectorCallback.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/StatsCollectorInput.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/StatsLevel.java (95%) rename java/src/main/java/org/{rocksdb => forstdb}/Status.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/StringAppendOperator.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/TableFileCreationBriefInfo.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/TableFileCreationInfo.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/TableFileCreationReason.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/TableFileDeletionInfo.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/TableFilter.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/TableFormatConfig.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/TableProperties.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/ThreadStatus.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/ThreadType.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/TickerType.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/TimedEnv.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/TraceOptions.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/TraceWriter.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/Transaction.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/TransactionDB.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/TransactionDBOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/TransactionLogIterator.java (89%) rename java/src/main/java/org/{rocksdb => forstdb}/TransactionOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/TransactionalDB.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/TransactionalOptions.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/TtlDB.java (97%) rename java/src/main/java/org/{rocksdb => forstdb}/TxnDBWritePolicy.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/UInt64AddOperator.java (96%) rename java/src/main/java/org/{rocksdb => forstdb}/VectorMemTableConfig.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/WALRecoveryMode.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/WBWIRocksIterator.java (95%) rename java/src/main/java/org/{rocksdb => forstdb}/WalFileType.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/WalFilter.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/WalProcessingOption.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/WriteBatch.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/WriteBatchInterface.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/WriteBatchWithIndex.java (94%) rename java/src/main/java/org/{rocksdb => forstdb}/WriteBufferManager.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/WriteOptions.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/WriteStallCondition.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/WriteStallInfo.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/util/BufferUtil.java (95%) rename java/src/main/java/org/{rocksdb => forstdb}/util/ByteUtil.java (98%) rename java/src/main/java/org/{rocksdb => forstdb}/util/BytewiseComparator.java (95%) rename java/src/main/java/org/{rocksdb => forstdb}/util/Environment.java (99%) rename java/src/main/java/org/{rocksdb => forstdb}/util/IntComparator.java (94%) rename java/src/main/java/org/{rocksdb => forstdb}/util/ReverseBytewiseComparator.java (93%) rename java/src/main/java/org/{rocksdb => forstdb}/util/SizeUnit.java (95%) rename java/src/test/java/org/{rocksdb => forstdb}/AbstractTransactionTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/BackupEngineOptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/BackupEngineTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/BlobOptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/BlockBasedTableConfigTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/BuiltinComparatorTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/ByteBufferUnsupportedOperationTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/BytewiseComparatorRegressionTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/CheckPointTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/ClockCacheTest.java (96%) rename java/src/test/java/org/{rocksdb => forstdb}/ColumnFamilyOptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/ColumnFamilyTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/CompactRangeOptionsTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/CompactionFilterFactoryTest.java (96%) rename java/src/test/java/org/{rocksdb => forstdb}/CompactionJobInfoTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/CompactionJobStatsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/CompactionOptionsFIFOTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/CompactionOptionsTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/CompactionOptionsUniversalTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/CompactionPriorityTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/CompactionStopStyleTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/ComparatorOptionsTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/CompressionOptionsTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/CompressionTypesTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/ConcurrentTaskLimiterTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/DBOptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/DefaultEnvTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/DirectSliceTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/EnvOptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/EventListenerTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/FilterTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/FlinkCompactionFilterTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/FlushOptionsTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/FlushTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/HyperClockCacheTest.java (95%) rename java/src/test/java/org/{rocksdb => forstdb}/ImportColumnFamilyTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/InfoLogLevelTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/IngestExternalFileOptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/KeyExistsTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/KeyMayExistTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/LRUCacheTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/LoggerTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/MemTableTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/MemoryUtilTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/MergeCFVariantsTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/MergeTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/MergeVariantsTest.java (96%) rename java/src/test/java/org/{rocksdb => forstdb}/MixedOptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/MultiColumnRegressionTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/MultiGetManyKeysTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/MultiGetTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/MutableColumnFamilyOptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/MutableDBOptionsTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/MutableOptionsGetSetTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/NativeComparatorWrapperTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/NativeLibraryLoaderTest.java (95%) rename java/src/test/java/org/{rocksdb => forstdb}/OptimisticTransactionDBTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/OptimisticTransactionOptionsTest.java (94%) rename java/src/test/java/org/{rocksdb => forstdb}/OptimisticTransactionTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/OptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/OptionsUtilTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/PerfContextTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/PerfLevelTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/PlainTableConfigTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/PlatformRandomHelper.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/PutCFVariantsTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/PutMultiplePartsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/PutVariantsTest.java (96%) rename java/src/test/java/org/{rocksdb => forstdb}/RateLimiterTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/ReadOnlyTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/ReadOptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/RocksDBExceptionTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/RocksDBTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/RocksIteratorTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/RocksMemEnvTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/RocksNativeLibraryResource.java (95%) rename java/src/test/java/org/{rocksdb => forstdb}/SecondaryDBTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/SliceTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/SnapshotTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/SstFileManagerTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/SstFileReaderTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/SstFileWriterTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/SstPartitionerTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/StatisticsCollectorTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/StatisticsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/StatsCallbackMock.java (96%) rename java/src/test/java/org/{rocksdb => forstdb}/TableFilterTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/TimedEnvTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/TransactionDBOptionsTest.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/TransactionDBTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/TransactionLogIteratorTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/TransactionOptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/TransactionTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/TtlDBTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/Types.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/VerifyChecksumsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/WALRecoveryModeTest.java (96%) rename java/src/test/java/org/{rocksdb => forstdb}/WalFilterTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/WriteBatchHandlerTest.java (91%) rename java/src/test/java/org/{rocksdb => forstdb}/WriteBatchTest.java (96%) rename java/src/test/java/org/{rocksdb => forstdb}/WriteBatchThreadedTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/WriteBatchWithIndexTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/WriteOptionsTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/flink/FlinkEnvTest.java (92%) rename java/src/test/java/org/{rocksdb => forstdb}/test/RemoveEmptyValueCompactionFilterFactory.java (77%) rename java/src/test/java/org/{rocksdb => forstdb}/test/RocksJunitRunner.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/test/TestableEventListener.java (90%) rename java/src/test/java/org/{rocksdb => forstdb}/util/ByteBufferAllocator.java (94%) rename java/src/test/java/org/{rocksdb => forstdb}/util/BytewiseComparatorIntTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/util/BytewiseComparatorTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/util/CapturingWriteBatchHandler.java (98%) rename java/src/test/java/org/{rocksdb => forstdb}/util/DirectByteBufferAllocator.java (95%) rename java/src/test/java/org/{rocksdb => forstdb}/util/EnvironmentTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/util/HeapByteBufferAllocator.java (95%) rename java/src/test/java/org/{rocksdb => forstdb}/util/IntComparatorTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/util/JNIComparatorTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/util/ReverseBytewiseComparatorIntTest.java (99%) rename java/src/test/java/org/{rocksdb => forstdb}/util/SizeUnitTest.java (97%) rename java/src/test/java/org/{rocksdb => forstdb}/util/TestUtil.java (93%) rename java/src/test/java/org/{rocksdb => forstdb}/util/WriteBatchGetter.java (97%) diff --git a/Makefile b/Makefile index 93fae2739..bd636c840 100644 --- a/Makefile +++ b/Makefile @@ -2282,14 +2282,14 @@ endif rocksdbjavastaticosx: rocksdbjavastaticosx_archs cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) librocksdbjni-osx-x86_64.jnilib librocksdbjni-osx-arm64.jnilib - cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/rocksdb/*.class org/rocksdb/util/*.class + cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 rocksdbjavastaticosx_ub: rocksdbjavastaticosx_archs cd java/target; lipo -create -output librocksdbjni-osx.jnilib librocksdbjni-osx-x86_64.jnilib librocksdbjni-osx-arm64.jnilib cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) librocksdbjni-osx.jnilib - cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/rocksdb/*.class org/rocksdb/util/*.class + cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 rocksdbjavastaticosx_archs: @@ -2327,7 +2327,7 @@ rocksdbjavastatic_javalib: rocksdbjava_jar: cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) $(ROCKSDBJNILIB) - cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/rocksdb/*.class org/rocksdb/util/*.class + cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 rocksdbjava_javadocs_jar: @@ -2346,14 +2346,14 @@ rocksdbjavastaticrelease: rocksdbjavastaticosx rocksdbjava_javadocs_jar rocksdbj cd java/crossbuild && (vagrant destroy -f || true) && vagrant up linux32 && vagrant halt linux32 && vagrant up linux64 && vagrant halt linux64 && vagrant up linux64-musl && vagrant halt linux64-musl cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR_ALL) HISTORY*.md cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) librocksdbjni-*.so librocksdbjni-*.jnilib - cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR_ALL) org/rocksdb/*.class org/rocksdb/util/*.class + cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR_ALL) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR_ALL) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR_ALL).sha1 rocksdbjavastaticreleasedocker: rocksdbjavastaticosx rocksdbjavastaticdockerx86 rocksdbjavastaticdockerx86_64 rocksdbjavastaticdockerx86musl rocksdbjavastaticdockerx86_64musl rocksdbjava_javadocs_jar rocksdbjava_sources_jar cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR_ALL) HISTORY*.md jar -uf java/target/$(ROCKSDB_JAR_ALL) HISTORY*.md cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) librocksdbjni-*.so librocksdbjni-*.jnilib librocksdbjni-win64.dll - cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR_ALL) org/rocksdb/*.class org/rocksdb/util/*.class + cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR_ALL) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR_ALL) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR_ALL).sha1 forstjavastaticreleasedocker: rocksdbjavastaticreleasedocker @@ -2467,10 +2467,10 @@ ifeq ($(JAVA_HOME),) endif $(AM_V_GEN)cd java; $(MAKE) javalib; $(AM_V_at)rm -f ./java/target/$(ROCKSDBJNILIB) - $(AM_V_at)$(CXX) $(CXXFLAGS) -I./java/. -I./java/rocksjni $(JAVA_INCLUDE) $(ROCKSDB_PLUGIN_JNI_CXX_INCLUDEFLAGS) -shared -fPIC -o ./java/target/$(ROCKSDBJNILIB) $(ALL_JNI_NATIVE_SOURCES) $(LIB_OBJECTS) $(JAVA_LDFLAGS) $(COVERAGEFLAGS) + $(AM_V_at)$(CXX) $(CXXFLAGS) -I./java/. -I./java/forstjni $(JAVA_INCLUDE) $(ROCKSDB_PLUGIN_JNI_CXX_INCLUDEFLAGS) -shared -fPIC -o ./java/target/$(ROCKSDBJNILIB) $(ALL_JNI_NATIVE_SOURCES) $(LIB_OBJECTS) $(JAVA_LDFLAGS) $(COVERAGEFLAGS) $(AM_V_at)cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md $(AM_V_at)cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) $(ROCKSDBJNILIB) - $(AM_V_at)cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/rocksdb/*.class org/rocksdb/util/*.class + $(AM_V_at)cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class $(AM_V_at)openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 jclean: diff --git a/db/db_basic_test.cc b/db/db_basic_test.cc index 0c8ae6033..0b0383ae0 100644 --- a/db/db_basic_test.cc +++ b/db/db_basic_test.cc @@ -4479,7 +4479,7 @@ TEST_F(DBBasicTest, FailOpenIfLoggerCreationFail) { SyncPoint::GetInstance()->DisableProcessing(); SyncPoint::GetInstance()->ClearAllCallBacks(); SyncPoint::GetInstance()->SetCallBack( - "rocksdb::CreateLoggerFromOptions:AfterGetPath", [&](void* arg) { + "forstdb::CreateLoggerFromOptions:AfterGetPath", [&](void* arg) { auto* s = reinterpret_cast(arg); assert(s); *s = Status::IOError("Injected"); diff --git a/db/db_secondary_test.cc b/db/db_secondary_test.cc index 987756906..8353790c3 100644 --- a/db/db_secondary_test.cc +++ b/db/db_secondary_test.cc @@ -130,7 +130,7 @@ TEST_F(DBSecondaryTest, FailOpenIfLoggerCreationFail) { SyncPoint::GetInstance()->DisableProcessing(); SyncPoint::GetInstance()->ClearAllCallBacks(); SyncPoint::GetInstance()->SetCallBack( - "rocksdb::CreateLoggerFromOptions:AfterGetPath", [&](void* arg) { + "forstdb::CreateLoggerFromOptions:AfterGetPath", [&](void* arg) { auto* s = reinterpret_cast(arg); assert(s); *s = Status::IOError("Injected"); diff --git a/include/rocksdb/rocksdb_namespace.h b/include/rocksdb/rocksdb_namespace.h index a339ec2aa..856300003 100644 --- a/include/rocksdb/rocksdb_namespace.h +++ b/include/rocksdb/rocksdb_namespace.h @@ -12,5 +12,5 @@ // Normal logic #ifndef ROCKSDB_NAMESPACE -#define ROCKSDB_NAMESPACE rocksdb +#define ROCKSDB_NAMESPACE forstdb #endif diff --git a/java/CMakeLists.txt b/java/CMakeLists.txt index c31083b6f..4c9a8ff8a 100644 --- a/java/CMakeLists.txt +++ b/java/CMakeLists.txt @@ -14,507 +14,507 @@ endif() set(CMAKE_JAVA_COMPILE_FLAGS -source 8) set(JNI_NATIVE_SOURCES - rocksjni/backup_engine_options.cc - rocksjni/backupenginejni.cc - rocksjni/cassandra_compactionfilterjni.cc - rocksjni/cassandra_value_operator.cc - rocksjni/checkpoint.cc - rocksjni/clock_cache.cc - rocksjni/cache.cc - rocksjni/columnfamilyhandle.cc - rocksjni/compaction_filter.cc - rocksjni/compaction_filter_factory.cc - rocksjni/compaction_filter_factory_jnicallback.cc - rocksjni/compaction_job_info.cc - rocksjni/compaction_job_stats.cc - rocksjni/compaction_options.cc - rocksjni/compaction_options_fifo.cc - rocksjni/compaction_options_universal.cc - rocksjni/compact_range_options.cc - rocksjni/comparator.cc - rocksjni/comparatorjnicallback.cc - rocksjni/compression_options.cc - rocksjni/concurrent_task_limiter.cc - rocksjni/config_options.cc - rocksjni/env.cc - rocksjni/env_flink.cc - rocksjni/env_flink_test_suite.cc - rocksjni/env_options.cc - rocksjni/event_listener.cc - rocksjni/event_listener_jnicallback.cc - rocksjni/export_import_files_metadatajni.cc - rocksjni/flink_compactionfilterjni.cc - rocksjni/filter.cc - rocksjni/import_column_family_options.cc - rocksjni/hyper_clock_cache.cc - rocksjni/ingest_external_file_options.cc - rocksjni/iterator.cc - rocksjni/jnicallback.cc - rocksjni/loggerjnicallback.cc - rocksjni/lru_cache.cc - rocksjni/memory_util.cc - rocksjni/memtablejni.cc - rocksjni/merge_operator.cc - rocksjni/native_comparator_wrapper_test.cc - rocksjni/optimistic_transaction_db.cc - rocksjni/optimistic_transaction_options.cc - rocksjni/options.cc - rocksjni/options_util.cc - rocksjni/persistent_cache.cc - rocksjni/jni_perf_context.cc - rocksjni/ratelimiterjni.cc - rocksjni/remove_emptyvalue_compactionfilterjni.cc - rocksjni/restorejni.cc - rocksjni/rocks_callback_object.cc - rocksjni/rocksdb_exception_test.cc - rocksjni/rocksjni.cc - rocksjni/slice.cc - rocksjni/snapshot.cc - rocksjni/sst_file_manager.cc - rocksjni/sst_file_writerjni.cc - rocksjni/sst_file_readerjni.cc - rocksjni/sst_file_reader_iterator.cc - rocksjni/sst_partitioner.cc - rocksjni/statistics.cc - rocksjni/statisticsjni.cc - rocksjni/table.cc - rocksjni/table_filter.cc - rocksjni/table_filter_jnicallback.cc - rocksjni/testable_event_listener.cc - rocksjni/thread_status.cc - rocksjni/trace_writer.cc - rocksjni/trace_writer_jnicallback.cc - rocksjni/transaction.cc - rocksjni/transaction_db.cc - rocksjni/transaction_db_options.cc - rocksjni/transaction_log.cc - rocksjni/transaction_notifier.cc - rocksjni/transaction_notifier_jnicallback.cc - rocksjni/transaction_options.cc - rocksjni/ttl.cc - rocksjni/wal_filter.cc - rocksjni/wal_filter_jnicallback.cc - rocksjni/write_batch.cc - rocksjni/writebatchhandlerjnicallback.cc - rocksjni/write_batch_test.cc - rocksjni/write_batch_with_index.cc - rocksjni/write_buffer_manager.cc + forstjni/backup_engine_options.cc + forstjni/backupenginejni.cc + forstjni/cassandra_compactionfilterjni.cc + forstjni/cassandra_value_operator.cc + forstjni/checkpoint.cc + forstjni/clock_cache.cc + forstjni/cache.cc + forstjni/columnfamilyhandle.cc + forstjni/compaction_filter.cc + forstjni/compaction_filter_factory.cc + forstjni/compaction_filter_factory_jnicallback.cc + forstjni/compaction_job_info.cc + forstjni/compaction_job_stats.cc + forstjni/compaction_options.cc + forstjni/compaction_options_fifo.cc + forstjni/compaction_options_universal.cc + forstjni/compact_range_options.cc + forstjni/comparator.cc + forstjni/comparatorjnicallback.cc + forstjni/compression_options.cc + forstjni/concurrent_task_limiter.cc + forstjni/config_options.cc + forstjni/env.cc + forstjni/env_flink.cc + forstjni/env_flink_test_suite.cc + forstjni/env_options.cc + forstjni/event_listener.cc + forstjni/event_listener_jnicallback.cc + forstjni/export_import_files_metadatajni.cc + forstjni/flink_compactionfilterjni.cc + forstjni/filter.cc + forstjni/import_column_family_options.cc + forstjni/hyper_clock_cache.cc + forstjni/ingest_external_file_options.cc + forstjni/iterator.cc + forstjni/jnicallback.cc + forstjni/loggerjnicallback.cc + forstjni/lru_cache.cc + forstjni/memory_util.cc + forstjni/memtablejni.cc + forstjni/merge_operator.cc + forstjni/native_comparator_wrapper_test.cc + forstjni/optimistic_transaction_db.cc + forstjni/optimistic_transaction_options.cc + forstjni/options.cc + forstjni/options_util.cc + forstjni/persistent_cache.cc + forstjni/jni_perf_context.cc + forstjni/ratelimiterjni.cc + forstjni/remove_emptyvalue_compactionfilterjni.cc + forstjni/restorejni.cc + forstjni/rocks_callback_object.cc + forstjni/rocksdb_exception_test.cc + forstjni/rocksjni.cc + forstjni/slice.cc + forstjni/snapshot.cc + forstjni/sst_file_manager.cc + forstjni/sst_file_writerjni.cc + forstjni/sst_file_readerjni.cc + forstjni/sst_file_reader_iterator.cc + forstjni/sst_partitioner.cc + forstjni/statistics.cc + forstjni/statisticsjni.cc + forstjni/table.cc + forstjni/table_filter.cc + forstjni/table_filter_jnicallback.cc + forstjni/testable_event_listener.cc + forstjni/thread_status.cc + forstjni/trace_writer.cc + forstjni/trace_writer_jnicallback.cc + forstjni/transaction.cc + forstjni/transaction_db.cc + forstjni/transaction_db_options.cc + forstjni/transaction_log.cc + forstjni/transaction_notifier.cc + forstjni/transaction_notifier_jnicallback.cc + forstjni/transaction_options.cc + forstjni/ttl.cc + forstjni/wal_filter.cc + forstjni/wal_filter_jnicallback.cc + forstjni/write_batch.cc + forstjni/writebatchhandlerjnicallback.cc + forstjni/write_batch_test.cc + forstjni/write_batch_with_index.cc + forstjni/write_buffer_manager.cc ) set(JAVA_MAIN_CLASSES - src/main/java/org/rocksdb/AbstractCompactionFilter.java - src/main/java/org/rocksdb/AbstractCompactionFilterFactory.java - src/main/java/org/rocksdb/AbstractComparator.java - src/main/java/org/rocksdb/AbstractEventListener.java - src/main/java/org/rocksdb/AbstractImmutableNativeReference.java - src/main/java/org/rocksdb/AbstractMutableOptions.java - src/main/java/org/rocksdb/AbstractNativeReference.java - src/main/java/org/rocksdb/AbstractRocksIterator.java - src/main/java/org/rocksdb/AbstractSlice.java - src/main/java/org/rocksdb/AbstractTableFilter.java - src/main/java/org/rocksdb/AbstractTraceWriter.java - src/main/java/org/rocksdb/AbstractTransactionNotifier.java - src/main/java/org/rocksdb/AbstractWalFilter.java - src/main/java/org/rocksdb/AbstractWriteBatch.java - src/main/java/org/rocksdb/AccessHint.java - src/main/java/org/rocksdb/AdvancedColumnFamilyOptionsInterface.java - src/main/java/org/rocksdb/AdvancedMutableColumnFamilyOptionsInterface.java - src/main/java/org/rocksdb/BackgroundErrorReason.java - src/main/java/org/rocksdb/BackupEngineOptions.java - src/main/java/org/rocksdb/BackupEngine.java - src/main/java/org/rocksdb/BackupInfo.java - src/main/java/org/rocksdb/BlockBasedTableConfig.java - src/main/java/org/rocksdb/BloomFilter.java - src/main/java/org/rocksdb/BuiltinComparator.java - src/main/java/org/rocksdb/ByteBufferGetStatus.java - src/main/java/org/rocksdb/Cache.java - src/main/java/org/rocksdb/CassandraCompactionFilter.java - src/main/java/org/rocksdb/CassandraValueMergeOperator.java - src/main/java/org/rocksdb/Checkpoint.java - src/main/java/org/rocksdb/ChecksumType.java - src/main/java/org/rocksdb/ClockCache.java - src/main/java/org/rocksdb/ColumnFamilyDescriptor.java - src/main/java/org/rocksdb/ColumnFamilyHandle.java - src/main/java/org/rocksdb/ColumnFamilyMetaData.java - src/main/java/org/rocksdb/ColumnFamilyOptionsInterface.java - src/main/java/org/rocksdb/ColumnFamilyOptions.java - src/main/java/org/rocksdb/CompactionJobInfo.java - src/main/java/org/rocksdb/CompactionJobStats.java - src/main/java/org/rocksdb/CompactionOptions.java - src/main/java/org/rocksdb/CompactionOptionsFIFO.java - src/main/java/org/rocksdb/CompactionOptionsUniversal.java - src/main/java/org/rocksdb/CompactionPriority.java - src/main/java/org/rocksdb/CompactionReason.java - src/main/java/org/rocksdb/CompactRangeOptions.java - src/main/java/org/rocksdb/CompactionStopStyle.java - src/main/java/org/rocksdb/CompactionStyle.java - src/main/java/org/rocksdb/ComparatorOptions.java - src/main/java/org/rocksdb/ComparatorType.java - src/main/java/org/rocksdb/CompressionOptions.java - src/main/java/org/rocksdb/CompressionType.java - src/main/java/org/rocksdb/ConfigOptions.java - src/main/java/org/rocksdb/DataBlockIndexType.java - src/main/java/org/rocksdb/DBOptionsInterface.java - src/main/java/org/rocksdb/DBOptions.java - src/main/java/org/rocksdb/DbPath.java - src/main/java/org/rocksdb/DirectSlice.java - src/main/java/org/rocksdb/EncodingType.java - src/main/java/org/rocksdb/Env.java - src/main/java/org/rocksdb/EnvFlinkTestSuite.java - src/main/java/org/rocksdb/EnvOptions.java - src/main/java/org/rocksdb/EventListener.java - src/main/java/org/rocksdb/Experimental.java - src/main/java/org/rocksdb/ExportImportFilesMetaData.java - src/main/java/org/rocksdb/ExternalFileIngestionInfo.java - src/main/java/org/rocksdb/Filter.java - src/main/java/org/rocksdb/FilterPolicyType.java - src/main/java/org/rocksdb/FileOperationInfo.java - src/main/java/org/rocksdb/FlinkCompactionFilter.java - src/main/java/org/rocksdb/FlinkEnv.java - src/main/java/org/rocksdb/FlushJobInfo.java - src/main/java/org/rocksdb/FlushReason.java - src/main/java/org/rocksdb/FlushOptions.java - src/main/java/org/rocksdb/GetStatus.java - src/main/java/org/rocksdb/HashLinkedListMemTableConfig.java - src/main/java/org/rocksdb/HashSkipListMemTableConfig.java - src/main/java/org/rocksdb/HistogramData.java - src/main/java/org/rocksdb/HistogramType.java - src/main/java/org/rocksdb/Holder.java - src/main/java/org/rocksdb/ImportColumnFamilyOptions.java - src/main/java/org/rocksdb/HyperClockCache.java - src/main/java/org/rocksdb/IndexShorteningMode.java - src/main/java/org/rocksdb/IndexType.java - src/main/java/org/rocksdb/InfoLogLevel.java - src/main/java/org/rocksdb/IngestExternalFileOptions.java - src/main/java/org/rocksdb/LevelMetaData.java - src/main/java/org/rocksdb/ConcurrentTaskLimiter.java - src/main/java/org/rocksdb/ConcurrentTaskLimiterImpl.java - src/main/java/org/rocksdb/KeyMayExist.java - src/main/java/org/rocksdb/LiveFileMetaData.java - src/main/java/org/rocksdb/LogFile.java - src/main/java/org/rocksdb/Logger.java - src/main/java/org/rocksdb/LRUCache.java - src/main/java/org/rocksdb/MemoryUsageType.java - src/main/java/org/rocksdb/MemoryUtil.java - src/main/java/org/rocksdb/MemTableConfig.java - src/main/java/org/rocksdb/MemTableInfo.java - src/main/java/org/rocksdb/MergeOperator.java - src/main/java/org/rocksdb/MutableColumnFamilyOptions.java - src/main/java/org/rocksdb/MutableColumnFamilyOptionsInterface.java - src/main/java/org/rocksdb/MutableDBOptions.java - src/main/java/org/rocksdb/MutableDBOptionsInterface.java - src/main/java/org/rocksdb/MutableOptionKey.java - src/main/java/org/rocksdb/MutableOptionValue.java - src/main/java/org/rocksdb/NativeComparatorWrapper.java - src/main/java/org/rocksdb/NativeLibraryLoader.java - src/main/java/org/rocksdb/OperationStage.java - src/main/java/org/rocksdb/OperationType.java - src/main/java/org/rocksdb/OptimisticTransactionDB.java - src/main/java/org/rocksdb/OptimisticTransactionOptions.java - src/main/java/org/rocksdb/Options.java - src/main/java/org/rocksdb/OptionString.java - src/main/java/org/rocksdb/OptionsUtil.java - src/main/java/org/rocksdb/PersistentCache.java - src/main/java/org/rocksdb/PerfContext.java - src/main/java/org/rocksdb/PerfLevel.java - src/main/java/org/rocksdb/PlainTableConfig.java - src/main/java/org/rocksdb/PrepopulateBlobCache.java - src/main/java/org/rocksdb/Priority.java - src/main/java/org/rocksdb/Range.java - src/main/java/org/rocksdb/RateLimiter.java - src/main/java/org/rocksdb/RateLimiterMode.java - src/main/java/org/rocksdb/ReadOptions.java - src/main/java/org/rocksdb/ReadTier.java - src/main/java/org/rocksdb/RemoveEmptyValueCompactionFilter.java - src/main/java/org/rocksdb/RestoreOptions.java - src/main/java/org/rocksdb/ReusedSynchronisationType.java - src/main/java/org/rocksdb/RocksCallbackObject.java - src/main/java/org/rocksdb/RocksDBException.java - src/main/java/org/rocksdb/RocksDB.java - src/main/java/org/rocksdb/RocksEnv.java - src/main/java/org/rocksdb/RocksIteratorInterface.java - src/main/java/org/rocksdb/RocksIterator.java - src/main/java/org/rocksdb/RocksMemEnv.java - src/main/java/org/rocksdb/RocksMutableObject.java - src/main/java/org/rocksdb/RocksObject.java - src/main/java/org/rocksdb/SanityLevel.java - src/main/java/org/rocksdb/SizeApproximationFlag.java - src/main/java/org/rocksdb/SkipListMemTableConfig.java - src/main/java/org/rocksdb/Slice.java - src/main/java/org/rocksdb/Snapshot.java - src/main/java/org/rocksdb/SstFileManager.java - src/main/java/org/rocksdb/SstFileMetaData.java - src/main/java/org/rocksdb/SstFileReader.java - src/main/java/org/rocksdb/SstFileReaderIterator.java - src/main/java/org/rocksdb/SstFileWriter.java - src/main/java/org/rocksdb/SstPartitionerFactory.java - src/main/java/org/rocksdb/SstPartitionerFixedPrefixFactory.java - src/main/java/org/rocksdb/StateType.java - src/main/java/org/rocksdb/StatisticsCollectorCallback.java - src/main/java/org/rocksdb/StatisticsCollector.java - src/main/java/org/rocksdb/Statistics.java - src/main/java/org/rocksdb/StatsCollectorInput.java - src/main/java/org/rocksdb/StatsLevel.java - src/main/java/org/rocksdb/Status.java - src/main/java/org/rocksdb/StringAppendOperator.java - src/main/java/org/rocksdb/TableFileCreationBriefInfo.java - src/main/java/org/rocksdb/TableFileCreationInfo.java - src/main/java/org/rocksdb/TableFileCreationReason.java - src/main/java/org/rocksdb/TableFileDeletionInfo.java - src/main/java/org/rocksdb/TableFilter.java - src/main/java/org/rocksdb/TableProperties.java - src/main/java/org/rocksdb/TableFormatConfig.java - src/main/java/org/rocksdb/ThreadType.java - src/main/java/org/rocksdb/ThreadStatus.java - src/main/java/org/rocksdb/TickerType.java - src/main/java/org/rocksdb/TimedEnv.java - src/main/java/org/rocksdb/TraceOptions.java - src/main/java/org/rocksdb/TraceWriter.java - src/main/java/org/rocksdb/TransactionalDB.java - src/main/java/org/rocksdb/TransactionalOptions.java - src/main/java/org/rocksdb/TransactionDB.java - src/main/java/org/rocksdb/TransactionDBOptions.java - src/main/java/org/rocksdb/Transaction.java - src/main/java/org/rocksdb/TransactionLogIterator.java - src/main/java/org/rocksdb/TransactionOptions.java - src/main/java/org/rocksdb/TtlDB.java - src/main/java/org/rocksdb/TxnDBWritePolicy.java - src/main/java/org/rocksdb/VectorMemTableConfig.java - src/main/java/org/rocksdb/WalFileType.java - src/main/java/org/rocksdb/WalFilter.java - src/main/java/org/rocksdb/WalProcessingOption.java - src/main/java/org/rocksdb/WALRecoveryMode.java - src/main/java/org/rocksdb/WBWIRocksIterator.java - src/main/java/org/rocksdb/WriteBatch.java - src/main/java/org/rocksdb/WriteBatchInterface.java - src/main/java/org/rocksdb/WriteBatchWithIndex.java - src/main/java/org/rocksdb/WriteOptions.java - src/main/java/org/rocksdb/WriteBufferManager.java - src/main/java/org/rocksdb/WriteStallCondition.java - src/main/java/org/rocksdb/WriteStallInfo.java - src/main/java/org/rocksdb/util/BufferUtil.java - src/main/java/org/rocksdb/util/ByteUtil.java - src/main/java/org/rocksdb/util/BytewiseComparator.java - src/main/java/org/rocksdb/util/Environment.java - src/main/java/org/rocksdb/util/IntComparator.java - src/main/java/org/rocksdb/util/ReverseBytewiseComparator.java - src/main/java/org/rocksdb/util/SizeUnit.java - src/main/java/org/rocksdb/UInt64AddOperator.java - src/test/java/org/rocksdb/NativeComparatorWrapperTest.java - src/test/java/org/rocksdb/RocksDBExceptionTest.java - src/test/java/org/rocksdb/test/TestableEventListener.java - src/test/java/org/rocksdb/WriteBatchTest.java - src/test/java/org/rocksdb/RocksNativeLibraryResource.java - src/test/java/org/rocksdb/util/CapturingWriteBatchHandler.java - src/test/java/org/rocksdb/util/WriteBatchGetter.java + src/main/java/org/forstdb/AbstractCompactionFilter.java + src/main/java/org/forstdb/AbstractCompactionFilterFactory.java + src/main/java/org/forstdb/AbstractComparator.java + src/main/java/org/forstdb/AbstractEventListener.java + src/main/java/org/forstdb/AbstractImmutableNativeReference.java + src/main/java/org/forstdb/AbstractMutableOptions.java + src/main/java/org/forstdb/AbstractNativeReference.java + src/main/java/org/forstdb/AbstractRocksIterator.java + src/main/java/org/forstdb/AbstractSlice.java + src/main/java/org/forstdb/AbstractTableFilter.java + src/main/java/org/forstdb/AbstractTraceWriter.java + src/main/java/org/forstdb/AbstractTransactionNotifier.java + src/main/java/org/forstdb/AbstractWalFilter.java + src/main/java/org/forstdb/AbstractWriteBatch.java + src/main/java/org/forstdb/AccessHint.java + src/main/java/org/forstdb/AdvancedColumnFamilyOptionsInterface.java + src/main/java/org/forstdb/AdvancedMutableColumnFamilyOptionsInterface.java + src/main/java/org/forstdb/BackgroundErrorReason.java + src/main/java/org/forstdb/BackupEngineOptions.java + src/main/java/org/forstdb/BackupEngine.java + src/main/java/org/forstdb/BackupInfo.java + src/main/java/org/forstdb/BlockBasedTableConfig.java + src/main/java/org/forstdb/BloomFilter.java + src/main/java/org/forstdb/BuiltinComparator.java + src/main/java/org/forstdb/ByteBufferGetStatus.java + src/main/java/org/forstdb/Cache.java + src/main/java/org/forstdb/CassandraCompactionFilter.java + src/main/java/org/forstdb/CassandraValueMergeOperator.java + src/main/java/org/forstdb/Checkpoint.java + src/main/java/org/forstdb/ChecksumType.java + src/main/java/org/forstdb/ClockCache.java + src/main/java/org/forstdb/ColumnFamilyDescriptor.java + src/main/java/org/forstdb/ColumnFamilyHandle.java + src/main/java/org/forstdb/ColumnFamilyMetaData.java + src/main/java/org/forstdb/ColumnFamilyOptionsInterface.java + src/main/java/org/forstdb/ColumnFamilyOptions.java + src/main/java/org/forstdb/CompactionJobInfo.java + src/main/java/org/forstdb/CompactionJobStats.java + src/main/java/org/forstdb/CompactionOptions.java + src/main/java/org/forstdb/CompactionOptionsFIFO.java + src/main/java/org/forstdb/CompactionOptionsUniversal.java + src/main/java/org/forstdb/CompactionPriority.java + src/main/java/org/forstdb/CompactionReason.java + src/main/java/org/forstdb/CompactRangeOptions.java + src/main/java/org/forstdb/CompactionStopStyle.java + src/main/java/org/forstdb/CompactionStyle.java + src/main/java/org/forstdb/ComparatorOptions.java + src/main/java/org/forstdb/ComparatorType.java + src/main/java/org/forstdb/CompressionOptions.java + src/main/java/org/forstdb/CompressionType.java + src/main/java/org/forstdb/ConfigOptions.java + src/main/java/org/forstdb/DataBlockIndexType.java + src/main/java/org/forstdb/DBOptionsInterface.java + src/main/java/org/forstdb/DBOptions.java + src/main/java/org/forstdb/DbPath.java + src/main/java/org/forstdb/DirectSlice.java + src/main/java/org/forstdb/EncodingType.java + src/main/java/org/forstdb/Env.java + src/main/java/org/forstdb/EnvFlinkTestSuite.java + src/main/java/org/forstdb/EnvOptions.java + src/main/java/org/forstdb/EventListener.java + src/main/java/org/forstdb/Experimental.java + src/main/java/org/forstdb/ExportImportFilesMetaData.java + src/main/java/org/forstdb/ExternalFileIngestionInfo.java + src/main/java/org/forstdb/Filter.java + src/main/java/org/forstdb/FilterPolicyType.java + src/main/java/org/forstdb/FileOperationInfo.java + src/main/java/org/forstdb/FlinkCompactionFilter.java + src/main/java/org/forstdb/FlinkEnv.java + src/main/java/org/forstdb/FlushJobInfo.java + src/main/java/org/forstdb/FlushReason.java + src/main/java/org/forstdb/FlushOptions.java + src/main/java/org/forstdb/GetStatus.java + src/main/java/org/forstdb/HashLinkedListMemTableConfig.java + src/main/java/org/forstdb/HashSkipListMemTableConfig.java + src/main/java/org/forstdb/HistogramData.java + src/main/java/org/forstdb/HistogramType.java + src/main/java/org/forstdb/Holder.java + src/main/java/org/forstdb/ImportColumnFamilyOptions.java + src/main/java/org/forstdb/HyperClockCache.java + src/main/java/org/forstdb/IndexShorteningMode.java + src/main/java/org/forstdb/IndexType.java + src/main/java/org/forstdb/InfoLogLevel.java + src/main/java/org/forstdb/IngestExternalFileOptions.java + src/main/java/org/forstdb/LevelMetaData.java + src/main/java/org/forstdb/ConcurrentTaskLimiter.java + src/main/java/org/forstdb/ConcurrentTaskLimiterImpl.java + src/main/java/org/forstdb/KeyMayExist.java + src/main/java/org/forstdb/LiveFileMetaData.java + src/main/java/org/forstdb/LogFile.java + src/main/java/org/forstdb/Logger.java + src/main/java/org/forstdb/LRUCache.java + src/main/java/org/forstdb/MemoryUsageType.java + src/main/java/org/forstdb/MemoryUtil.java + src/main/java/org/forstdb/MemTableConfig.java + src/main/java/org/forstdb/MemTableInfo.java + src/main/java/org/forstdb/MergeOperator.java + src/main/java/org/forstdb/MutableColumnFamilyOptions.java + src/main/java/org/forstdb/MutableColumnFamilyOptionsInterface.java + src/main/java/org/forstdb/MutableDBOptions.java + src/main/java/org/forstdb/MutableDBOptionsInterface.java + src/main/java/org/forstdb/MutableOptionKey.java + src/main/java/org/forstdb/MutableOptionValue.java + src/main/java/org/forstdb/NativeComparatorWrapper.java + src/main/java/org/forstdb/NativeLibraryLoader.java + src/main/java/org/forstdb/OperationStage.java + src/main/java/org/forstdb/OperationType.java + src/main/java/org/forstdb/OptimisticTransactionDB.java + src/main/java/org/forstdb/OptimisticTransactionOptions.java + src/main/java/org/forstdb/Options.java + src/main/java/org/forstdb/OptionString.java + src/main/java/org/forstdb/OptionsUtil.java + src/main/java/org/forstdb/PersistentCache.java + src/main/java/org/forstdb/PerfContext.java + src/main/java/org/forstdb/PerfLevel.java + src/main/java/org/forstdb/PlainTableConfig.java + src/main/java/org/forstdb/PrepopulateBlobCache.java + src/main/java/org/forstdb/Priority.java + src/main/java/org/forstdb/Range.java + src/main/java/org/forstdb/RateLimiter.java + src/main/java/org/forstdb/RateLimiterMode.java + src/main/java/org/forstdb/ReadOptions.java + src/main/java/org/forstdb/ReadTier.java + src/main/java/org/forstdb/RemoveEmptyValueCompactionFilter.java + src/main/java/org/forstdb/RestoreOptions.java + src/main/java/org/forstdb/ReusedSynchronisationType.java + src/main/java/org/forstdb/RocksCallbackObject.java + src/main/java/org/forstdb/RocksDBException.java + src/main/java/org/forstdb/RocksDB.java + src/main/java/org/forstdb/RocksEnv.java + src/main/java/org/forstdb/RocksIteratorInterface.java + src/main/java/org/forstdb/RocksIterator.java + src/main/java/org/forstdb/RocksMemEnv.java + src/main/java/org/forstdb/RocksMutableObject.java + src/main/java/org/forstdb/RocksObject.java + src/main/java/org/forstdb/SanityLevel.java + src/main/java/org/forstdb/SizeApproximationFlag.java + src/main/java/org/forstdb/SkipListMemTableConfig.java + src/main/java/org/forstdb/Slice.java + src/main/java/org/forstdb/Snapshot.java + src/main/java/org/forstdb/SstFileManager.java + src/main/java/org/forstdb/SstFileMetaData.java + src/main/java/org/forstdb/SstFileReader.java + src/main/java/org/forstdb/SstFileReaderIterator.java + src/main/java/org/forstdb/SstFileWriter.java + src/main/java/org/forstdb/SstPartitionerFactory.java + src/main/java/org/forstdb/SstPartitionerFixedPrefixFactory.java + src/main/java/org/forstdb/StateType.java + src/main/java/org/forstdb/StatisticsCollectorCallback.java + src/main/java/org/forstdb/StatisticsCollector.java + src/main/java/org/forstdb/Statistics.java + src/main/java/org/forstdb/StatsCollectorInput.java + src/main/java/org/forstdb/StatsLevel.java + src/main/java/org/forstdb/Status.java + src/main/java/org/forstdb/StringAppendOperator.java + src/main/java/org/forstdb/TableFileCreationBriefInfo.java + src/main/java/org/forstdb/TableFileCreationInfo.java + src/main/java/org/forstdb/TableFileCreationReason.java + src/main/java/org/forstdb/TableFileDeletionInfo.java + src/main/java/org/forstdb/TableFilter.java + src/main/java/org/forstdb/TableProperties.java + src/main/java/org/forstdb/TableFormatConfig.java + src/main/java/org/forstdb/ThreadType.java + src/main/java/org/forstdb/ThreadStatus.java + src/main/java/org/forstdb/TickerType.java + src/main/java/org/forstdb/TimedEnv.java + src/main/java/org/forstdb/TraceOptions.java + src/main/java/org/forstdb/TraceWriter.java + src/main/java/org/forstdb/TransactionalDB.java + src/main/java/org/forstdb/TransactionalOptions.java + src/main/java/org/forstdb/TransactionDB.java + src/main/java/org/forstdb/TransactionDBOptions.java + src/main/java/org/forstdb/Transaction.java + src/main/java/org/forstdb/TransactionLogIterator.java + src/main/java/org/forstdb/TransactionOptions.java + src/main/java/org/forstdb/TtlDB.java + src/main/java/org/forstdb/TxnDBWritePolicy.java + src/main/java/org/forstdb/VectorMemTableConfig.java + src/main/java/org/forstdb/WalFileType.java + src/main/java/org/forstdb/WalFilter.java + src/main/java/org/forstdb/WalProcessingOption.java + src/main/java/org/forstdb/WALRecoveryMode.java + src/main/java/org/forstdb/WBWIRocksIterator.java + src/main/java/org/forstdb/WriteBatch.java + src/main/java/org/forstdb/WriteBatchInterface.java + src/main/java/org/forstdb/WriteBatchWithIndex.java + src/main/java/org/forstdb/WriteOptions.java + src/main/java/org/forstdb/WriteBufferManager.java + src/main/java/org/forstdb/WriteStallCondition.java + src/main/java/org/forstdb/WriteStallInfo.java + src/main/java/org/forstdb/util/BufferUtil.java + src/main/java/org/forstdb/util/ByteUtil.java + src/main/java/org/forstdb/util/BytewiseComparator.java + src/main/java/org/forstdb/util/Environment.java + src/main/java/org/forstdb/util/IntComparator.java + src/main/java/org/forstdb/util/ReverseBytewiseComparator.java + src/main/java/org/forstdb/util/SizeUnit.java + src/main/java/org/forstdb/UInt64AddOperator.java + src/test/java/org/forstdb/NativeComparatorWrapperTest.java + src/test/java/org/forstdb/RocksDBExceptionTest.java + src/test/java/org/forstdb/test/TestableEventListener.java + src/test/java/org/forstdb/WriteBatchTest.java + src/test/java/org/forstdb/RocksNativeLibraryResource.java + src/test/java/org/forstdb/util/CapturingWriteBatchHandler.java + src/test/java/org/forstdb/util/WriteBatchGetter.java ) set(JAVA_TEST_CLASSES - src/test/java/org/rocksdb/ConcurrentTaskLimiterTest.java - src/test/java/org/rocksdb/EventListenerTest.java - src/test/java/org/rocksdb/CompactionOptionsTest.java - src/test/java/org/rocksdb/PlatformRandomHelper.java - src/test/java/org/rocksdb/IngestExternalFileOptionsTest.java - src/test/java/org/rocksdb/MutableDBOptionsTest.java - src/test/java/org/rocksdb/WriteOptionsTest.java - src/test/java/org/rocksdb/SstPartitionerTest.java - src/test/java/org/rocksdb/RocksMemEnvTest.java - src/test/java/org/rocksdb/CompactionOptionsUniversalTest.java - src/test/java/org/rocksdb/ClockCacheTest.java - src/test/java/org/rocksdb/BytewiseComparatorRegressionTest.java - src/test/java/org/rocksdb/SnapshotTest.java - src/test/java/org/rocksdb/CompactionJobStatsTest.java - src/test/java/org/rocksdb/MemTableTest.java - src/test/java/org/rocksdb/CompactionFilterFactoryTest.java - src/test/java/org/rocksdb/DefaultEnvTest.java - src/test/java/org/rocksdb/DBOptionsTest.java - src/test/java/org/rocksdb/RocksIteratorTest.java - src/test/java/org/rocksdb/SliceTest.java - src/test/java/org/rocksdb/MultiGetTest.java - src/test/java/org/rocksdb/ComparatorOptionsTest.java - src/test/java/org/rocksdb/NativeLibraryLoaderTest.java - src/test/java/org/rocksdb/StatisticsTest.java - src/test/java/org/rocksdb/WALRecoveryModeTest.java - src/test/java/org/rocksdb/TransactionLogIteratorTest.java - src/test/java/org/rocksdb/ReadOptionsTest.java - src/test/java/org/rocksdb/SecondaryDBTest.java - src/test/java/org/rocksdb/KeyMayExistTest.java - src/test/java/org/rocksdb/BlobOptionsTest.java - src/test/java/org/rocksdb/InfoLogLevelTest.java - src/test/java/org/rocksdb/CompactionPriorityTest.java - src/test/java/org/rocksdb/FlushOptionsTest.java - src/test/java/org/rocksdb/VerifyChecksumsTest.java - src/test/java/org/rocksdb/MultiColumnRegressionTest.java - src/test/java/org/rocksdb/FlushTest.java - src/test/java/org/rocksdb/HyperClockCacheTest.java - src/test/java/org/rocksdb/PutMultiplePartsTest.java - src/test/java/org/rocksdb/StatisticsCollectorTest.java - src/test/java/org/rocksdb/LRUCacheTest.java - src/test/java/org/rocksdb/ColumnFamilyOptionsTest.java - src/test/java/org/rocksdb/TransactionTest.java - src/test/java/org/rocksdb/CompactionOptionsFIFOTest.java - src/test/java/org/rocksdb/BackupEngineOptionsTest.java - src/test/java/org/rocksdb/CheckPointTest.java - src/test/java/org/rocksdb/PlainTableConfigTest.java - src/test/java/org/rocksdb/TransactionDBOptionsTest.java - src/test/java/org/rocksdb/ReadOnlyTest.java - src/test/java/org/rocksdb/EnvOptionsTest.java - src/test/java/org/rocksdb/test/RemoveEmptyValueCompactionFilterFactory.java - src/test/java/org/rocksdb/test/RemoveEmptyValueCompactionFilterFactory.java - src/test/java/org/rocksdb/test/TestableEventListener.java - src/test/java/org/rocksdb/test/RemoveEmptyValueCompactionFilterFactory.java - src/test/java/org/rocksdb/test/TestableEventListener.java - src/test/java/org/rocksdb/test/RocksJunitRunner.java - src/test/java/org/rocksdb/LoggerTest.java - src/test/java/org/rocksdb/FilterTest.java - src/test/java/org/rocksdb/ByteBufferUnsupportedOperationTest.java - src/test/java/org/rocksdb/util/IntComparatorTest.java - src/test/java/org/rocksdb/util/JNIComparatorTest.java - src/test/java/org/rocksdb/util/ByteBufferAllocator.java - src/test/java/org/rocksdb/util/SizeUnitTest.java - src/test/java/org/rocksdb/util/BytewiseComparatorTest.java - src/test/java/org/rocksdb/util/EnvironmentTest.java - src/test/java/org/rocksdb/util/BytewiseComparatorIntTest.java - src/test/java/org/rocksdb/util/DirectByteBufferAllocator.java - src/test/java/org/rocksdb/util/HeapByteBufferAllocator.java - src/test/java/org/rocksdb/util/TestUtil.java - src/test/java/org/rocksdb/util/ReverseBytewiseComparatorIntTest.java - src/test/java/org/rocksdb/Types.java - src/test/java/org/rocksdb/MixedOptionsTest.java - src/test/java/org/rocksdb/CompactRangeOptionsTest.java - src/test/java/org/rocksdb/SstFileWriterTest.java - src/test/java/org/rocksdb/WalFilterTest.java - src/test/java/org/rocksdb/AbstractTransactionTest.java - src/test/java/org/rocksdb/MergeTest.java - src/test/java/org/rocksdb/OptionsTest.java - src/test/java/org/rocksdb/WriteBatchThreadedTest.java - src/test/java/org/rocksdb/MultiGetManyKeysTest.java - src/test/java/org/rocksdb/TimedEnvTest.java - src/test/java/org/rocksdb/CompactionStopStyleTest.java - src/test/java/org/rocksdb/CompactionJobInfoTest.java - src/test/java/org/rocksdb/BlockBasedTableConfigTest.java - src/test/java/org/rocksdb/BuiltinComparatorTest.java - src/test/java/org/rocksdb/RateLimiterTest.java - src/test/java/org/rocksdb/TransactionOptionsTest.java - src/test/java/org/rocksdb/WriteBatchWithIndexTest.java - src/test/java/org/rocksdb/WriteBatchHandlerTest.java - src/test/java/org/rocksdb/OptimisticTransactionDBTest.java - src/test/java/org/rocksdb/OptionsUtilTest.java - src/test/java/org/rocksdb/OptimisticTransactionTest.java - src/test/java/org/rocksdb/MutableColumnFamilyOptionsTest.java - src/test/java/org/rocksdb/CompressionOptionsTest.java - src/test/java/org/rocksdb/ColumnFamilyTest.java - src/test/java/org/rocksdb/SstFileReaderTest.java - src/test/java/org/rocksdb/TransactionDBTest.java - src/test/java/org/rocksdb/RocksDBTest.java - src/test/java/org/rocksdb/MutableOptionsGetSetTest.java - src/test/java/org/rocksdb/OptimisticTransactionOptionsTest.java - src/test/java/org/rocksdb/SstFileManagerTest.java - src/test/java/org/rocksdb/BackupEngineTest.java - src/test/java/org/rocksdb/DirectSliceTest.java - src/test/java/org/rocksdb/StatsCallbackMock.java - src/test/java/org/rocksdb/CompressionTypesTest.java - src/test/java/org/rocksdb/MemoryUtilTest.java - src/test/java/org/rocksdb/TableFilterTest.java - src/test/java/org/rocksdb/TtlDBTest.java + src/test/java/org/forstdb/ConcurrentTaskLimiterTest.java + src/test/java/org/forstdb/EventListenerTest.java + src/test/java/org/forstdb/CompactionOptionsTest.java + src/test/java/org/forstdb/PlatformRandomHelper.java + src/test/java/org/forstdb/IngestExternalFileOptionsTest.java + src/test/java/org/forstdb/MutableDBOptionsTest.java + src/test/java/org/forstdb/WriteOptionsTest.java + src/test/java/org/forstdb/SstPartitionerTest.java + src/test/java/org/forstdb/RocksMemEnvTest.java + src/test/java/org/forstdb/CompactionOptionsUniversalTest.java + src/test/java/org/forstdb/ClockCacheTest.java + src/test/java/org/forstdb/BytewiseComparatorRegressionTest.java + src/test/java/org/forstdb/SnapshotTest.java + src/test/java/org/forstdb/CompactionJobStatsTest.java + src/test/java/org/forstdb/MemTableTest.java + src/test/java/org/forstdb/CompactionFilterFactoryTest.java + src/test/java/org/forstdb/DefaultEnvTest.java + src/test/java/org/forstdb/DBOptionsTest.java + src/test/java/org/forstdb/RocksIteratorTest.java + src/test/java/org/forstdb/SliceTest.java + src/test/java/org/forstdb/MultiGetTest.java + src/test/java/org/forstdb/ComparatorOptionsTest.java + src/test/java/org/forstdb/NativeLibraryLoaderTest.java + src/test/java/org/forstdb/StatisticsTest.java + src/test/java/org/forstdb/WALRecoveryModeTest.java + src/test/java/org/forstdb/TransactionLogIteratorTest.java + src/test/java/org/forstdb/ReadOptionsTest.java + src/test/java/org/forstdb/SecondaryDBTest.java + src/test/java/org/forstdb/KeyMayExistTest.java + src/test/java/org/forstdb/BlobOptionsTest.java + src/test/java/org/forstdb/InfoLogLevelTest.java + src/test/java/org/forstdb/CompactionPriorityTest.java + src/test/java/org/forstdb/FlushOptionsTest.java + src/test/java/org/forstdb/VerifyChecksumsTest.java + src/test/java/org/forstdb/MultiColumnRegressionTest.java + src/test/java/org/forstdb/FlushTest.java + src/test/java/org/forstdb/HyperClockCacheTest.java + src/test/java/org/forstdb/PutMultiplePartsTest.java + src/test/java/org/forstdb/StatisticsCollectorTest.java + src/test/java/org/forstdb/LRUCacheTest.java + src/test/java/org/forstdb/ColumnFamilyOptionsTest.java + src/test/java/org/forstdb/TransactionTest.java + src/test/java/org/forstdb/CompactionOptionsFIFOTest.java + src/test/java/org/forstdb/BackupEngineOptionsTest.java + src/test/java/org/forstdb/CheckPointTest.java + src/test/java/org/forstdb/PlainTableConfigTest.java + src/test/java/org/forstdb/TransactionDBOptionsTest.java + src/test/java/org/forstdb/ReadOnlyTest.java + src/test/java/org/forstdb/EnvOptionsTest.java + src/test/java/org/forstdb/test/RemoveEmptyValueCompactionFilterFactory.java + src/test/java/org/forstdb/test/RemoveEmptyValueCompactionFilterFactory.java + src/test/java/org/forstdb/test/TestableEventListener.java + src/test/java/org/forstdb/test/RemoveEmptyValueCompactionFilterFactory.java + src/test/java/org/forstdb/test/TestableEventListener.java + src/test/java/org/forstdb/test/RocksJunitRunner.java + src/test/java/org/forstdb/LoggerTest.java + src/test/java/org/forstdb/FilterTest.java + src/test/java/org/forstdb/ByteBufferUnsupportedOperationTest.java + src/test/java/org/forstdb/util/IntComparatorTest.java + src/test/java/org/forstdb/util/JNIComparatorTest.java + src/test/java/org/forstdb/util/ByteBufferAllocator.java + src/test/java/org/forstdb/util/SizeUnitTest.java + src/test/java/org/forstdb/util/BytewiseComparatorTest.java + src/test/java/org/forstdb/util/EnvironmentTest.java + src/test/java/org/forstdb/util/BytewiseComparatorIntTest.java + src/test/java/org/forstdb/util/DirectByteBufferAllocator.java + src/test/java/org/forstdb/util/HeapByteBufferAllocator.java + src/test/java/org/forstdb/util/TestUtil.java + src/test/java/org/forstdb/util/ReverseBytewiseComparatorIntTest.java + src/test/java/org/forstdb/Types.java + src/test/java/org/forstdb/MixedOptionsTest.java + src/test/java/org/forstdb/CompactRangeOptionsTest.java + src/test/java/org/forstdb/SstFileWriterTest.java + src/test/java/org/forstdb/WalFilterTest.java + src/test/java/org/forstdb/AbstractTransactionTest.java + src/test/java/org/forstdb/MergeTest.java + src/test/java/org/forstdb/OptionsTest.java + src/test/java/org/forstdb/WriteBatchThreadedTest.java + src/test/java/org/forstdb/MultiGetManyKeysTest.java + src/test/java/org/forstdb/TimedEnvTest.java + src/test/java/org/forstdb/CompactionStopStyleTest.java + src/test/java/org/forstdb/CompactionJobInfoTest.java + src/test/java/org/forstdb/BlockBasedTableConfigTest.java + src/test/java/org/forstdb/BuiltinComparatorTest.java + src/test/java/org/forstdb/RateLimiterTest.java + src/test/java/org/forstdb/TransactionOptionsTest.java + src/test/java/org/forstdb/WriteBatchWithIndexTest.java + src/test/java/org/forstdb/WriteBatchHandlerTest.java + src/test/java/org/forstdb/OptimisticTransactionDBTest.java + src/test/java/org/forstdb/OptionsUtilTest.java + src/test/java/org/forstdb/OptimisticTransactionTest.java + src/test/java/org/forstdb/MutableColumnFamilyOptionsTest.java + src/test/java/org/forstdb/CompressionOptionsTest.java + src/test/java/org/forstdb/ColumnFamilyTest.java + src/test/java/org/forstdb/SstFileReaderTest.java + src/test/java/org/forstdb/TransactionDBTest.java + src/test/java/org/forstdb/RocksDBTest.java + src/test/java/org/forstdb/MutableOptionsGetSetTest.java + src/test/java/org/forstdb/OptimisticTransactionOptionsTest.java + src/test/java/org/forstdb/SstFileManagerTest.java + src/test/java/org/forstdb/BackupEngineTest.java + src/test/java/org/forstdb/DirectSliceTest.java + src/test/java/org/forstdb/StatsCallbackMock.java + src/test/java/org/forstdb/CompressionTypesTest.java + src/test/java/org/forstdb/MemoryUtilTest.java + src/test/java/org/forstdb/TableFilterTest.java + src/test/java/org/forstdb/TtlDBTest.java ) set(JAVA_TEST_RUNNING_CLASSES - org.rocksdb.ConcurrentTaskLimiterTest - org.rocksdb.EventListenerTest - org.rocksdb.CompactionOptionsTest - org.rocksdb.IngestExternalFileOptionsTest - org.rocksdb.MutableDBOptionsTest - org.rocksdb.WriteOptionsTest - org.rocksdb.SstPartitionerTest - org.rocksdb.RocksMemEnvTest - org.rocksdb.CompactionOptionsUniversalTest - org.rocksdb.ClockCacheTest - # org.rocksdb.BytewiseComparatorRegressionTest - org.rocksdb.SnapshotTest - org.rocksdb.CompactionJobStatsTest - org.rocksdb.MemTableTest - org.rocksdb.CompactionFilterFactoryTest - # org.rocksdb.DefaultEnvTest - org.rocksdb.DBOptionsTest - org.rocksdb.WriteBatchTest - org.rocksdb.RocksIteratorTest - org.rocksdb.SliceTest - org.rocksdb.MultiGetTest - org.rocksdb.ComparatorOptionsTest - # org.rocksdb.NativeLibraryLoaderTest - org.rocksdb.StatisticsTest - org.rocksdb.WALRecoveryModeTest - org.rocksdb.TransactionLogIteratorTest - org.rocksdb.ReadOptionsTest - org.rocksdb.SecondaryDBTest - org.rocksdb.KeyMayExistTest - org.rocksdb.BlobOptionsTest - org.rocksdb.InfoLogLevelTest - org.rocksdb.CompactionPriorityTest - org.rocksdb.FlushOptionsTest - org.rocksdb.VerifyChecksumsTest - org.rocksdb.MultiColumnRegressionTest - org.rocksdb.FlushTest - org.rocksdb.HyperClockCacheTest - org.rocksdb.PutMultiplePartsTest - org.rocksdb.StatisticsCollectorTest - org.rocksdb.LRUCacheTest - org.rocksdb.ColumnFamilyOptionsTest - org.rocksdb.TransactionTest - org.rocksdb.CompactionOptionsFIFOTest - org.rocksdb.BackupEngineOptionsTest - org.rocksdb.CheckPointTest - org.rocksdb.PlainTableConfigTest - # org.rocksdb.TransactionDBOptionsTest - org.rocksdb.ReadOnlyTest - org.rocksdb.EnvOptionsTest - org.rocksdb.LoggerTest - org.rocksdb.FilterTest - # org.rocksdb.ByteBufferUnsupportedOperationTest - # org.rocksdb.util.IntComparatorTest - # org.rocksdb.util.JNIComparatorTest - org.rocksdb.util.SizeUnitTest - # org.rocksdb.util.BytewiseComparatorTest - org.rocksdb.util.EnvironmentTest - # org.rocksdb.util.BytewiseComparatorIntTest - # org.rocksdb.util.ReverseBytewiseComparatorIntTest - org.rocksdb.MixedOptionsTest - org.rocksdb.CompactRangeOptionsTest - # org.rocksdb.SstFileWriterTest - org.rocksdb.WalFilterTest - # org.rocksdb.AbstractTransactionTest - org.rocksdb.MergeTest - org.rocksdb.OptionsTest - org.rocksdb.WriteBatchThreadedTest - org.rocksdb.MultiGetManyKeysTest - org.rocksdb.TimedEnvTest - org.rocksdb.CompactionStopStyleTest - org.rocksdb.CompactionJobInfoTest - org.rocksdb.BlockBasedTableConfigTest - org.rocksdb.BuiltinComparatorTest - org.rocksdb.RateLimiterTest - # org.rocksdb.TransactionOptionsTest - org.rocksdb.WriteBatchWithIndexTest - org.rocksdb.WriteBatchHandlerTest - org.rocksdb.OptimisticTransactionDBTest - org.rocksdb.OptionsUtilTest - org.rocksdb.OptimisticTransactionTest - org.rocksdb.MutableColumnFamilyOptionsTest - org.rocksdb.CompressionOptionsTest - org.rocksdb.ColumnFamilyTest - org.rocksdb.SstFileReaderTest - org.rocksdb.TransactionDBTest - org.rocksdb.RocksDBTest - org.rocksdb.MutableOptionsGetSetTest - # org.rocksdb.OptimisticTransactionOptionsTest - org.rocksdb.SstFileManagerTest - org.rocksdb.BackupEngineTest - org.rocksdb.DirectSliceTest - org.rocksdb.CompressionTypesTest - org.rocksdb.MemoryUtilTest - org.rocksdb.TableFilterTest - org.rocksdb.TtlDBTest + org.forstdb.ConcurrentTaskLimiterTest + org.forstdb.EventListenerTest + org.forstdb.CompactionOptionsTest + org.forstdb.IngestExternalFileOptionsTest + org.forstdb.MutableDBOptionsTest + org.forstdb.WriteOptionsTest + org.forstdb.SstPartitionerTest + org.forstdb.RocksMemEnvTest + org.forstdb.CompactionOptionsUniversalTest + org.forstdb.ClockCacheTest + # org.forstdb.BytewiseComparatorRegressionTest + org.forstdb.SnapshotTest + org.forstdb.CompactionJobStatsTest + org.forstdb.MemTableTest + org.forstdb.CompactionFilterFactoryTest + # org.forstdb.DefaultEnvTest + org.forstdb.DBOptionsTest + org.forstdb.WriteBatchTest + org.forstdb.RocksIteratorTest + org.forstdb.SliceTest + org.forstdb.MultiGetTest + org.forstdb.ComparatorOptionsTest + # org.forstdb.NativeLibraryLoaderTest + org.forstdb.StatisticsTest + org.forstdb.WALRecoveryModeTest + org.forstdb.TransactionLogIteratorTest + org.forstdb.ReadOptionsTest + org.forstdb.SecondaryDBTest + org.forstdb.KeyMayExistTest + org.forstdb.BlobOptionsTest + org.forstdb.InfoLogLevelTest + org.forstdb.CompactionPriorityTest + org.forstdb.FlushOptionsTest + org.forstdb.VerifyChecksumsTest + org.forstdb.MultiColumnRegressionTest + org.forstdb.FlushTest + org.forstdb.HyperClockCacheTest + org.forstdb.PutMultiplePartsTest + org.forstdb.StatisticsCollectorTest + org.forstdb.LRUCacheTest + org.forstdb.ColumnFamilyOptionsTest + org.forstdb.TransactionTest + org.forstdb.CompactionOptionsFIFOTest + org.forstdb.BackupEngineOptionsTest + org.forstdb.CheckPointTest + org.forstdb.PlainTableConfigTest + # org.forstdb.TransactionDBOptionsTest + org.forstdb.ReadOnlyTest + org.forstdb.EnvOptionsTest + org.forstdb.LoggerTest + org.forstdb.FilterTest + # org.forstdb.ByteBufferUnsupportedOperationTest + # org.forstdb.util.IntComparatorTest + # org.forstdb.util.JNIComparatorTest + org.forstdb.util.SizeUnitTest + # org.forstdb.util.BytewiseComparatorTest + org.forstdb.util.EnvironmentTest + # org.forstdb.util.BytewiseComparatorIntTest + # org.forstdb.util.ReverseBytewiseComparatorIntTest + org.forstdb.MixedOptionsTest + org.forstdb.CompactRangeOptionsTest + # org.forstdb.SstFileWriterTest + org.forstdb.WalFilterTest + # org.forstdb.AbstractTransactionTest + org.forstdb.MergeTest + org.forstdb.OptionsTest + org.forstdb.WriteBatchThreadedTest + org.forstdb.MultiGetManyKeysTest + org.forstdb.TimedEnvTest + org.forstdb.CompactionStopStyleTest + org.forstdb.CompactionJobInfoTest + org.forstdb.BlockBasedTableConfigTest + org.forstdb.BuiltinComparatorTest + org.forstdb.RateLimiterTest + # org.forstdb.TransactionOptionsTest + org.forstdb.WriteBatchWithIndexTest + org.forstdb.WriteBatchHandlerTest + org.forstdb.OptimisticTransactionDBTest + org.forstdb.OptionsUtilTest + org.forstdb.OptimisticTransactionTest + org.forstdb.MutableColumnFamilyOptionsTest + org.forstdb.CompressionOptionsTest + org.forstdb.ColumnFamilyTest + org.forstdb.SstFileReaderTest + org.forstdb.TransactionDBTest + org.forstdb.RocksDBTest + org.forstdb.MutableOptionsGetSetTest + # org.forstdb.OptimisticTransactionOptionsTest + org.forstdb.SstFileManagerTest + org.forstdb.BackupEngineTest + org.forstdb.DirectSliceTest + org.forstdb.CompressionTypesTest + org.forstdb.MemoryUtilTest + org.forstdb.TableFilterTest + org.forstdb.TtlDBTest ) include(FindJava) @@ -653,111 +653,111 @@ if(${CMAKE_VERSION} VERSION_LESS "3.11.4") # Old CMake ONLY generate JNI headers, otherwise JNI is handled in add_jar step above message("Preparing JNI headers for old CMake (${CMAKE_VERSION})") set(NATIVE_JAVA_CLASSES - org.rocksdb.AbstractCompactionFilter - org.rocksdb.AbstractCompactionFilterFactory - org.rocksdb.AbstractComparator - org.rocksdb.AbstractEventListener - org.rocksdb.AbstractImmutableNativeReference - org.rocksdb.AbstractNativeReference - org.rocksdb.AbstractRocksIterator - org.rocksdb.AbstractSlice - org.rocksdb.AbstractTableFilter - org.rocksdb.AbstractTraceWriter - org.rocksdb.AbstractTransactionNotifier - org.rocksdb.AbstractWalFilter - org.rocksdb.BackupEngineOptions - org.rocksdb.BackupEngine - org.rocksdb.BlockBasedTableConfig - org.rocksdb.BloomFilter - org.rocksdb.CassandraCompactionFilter - org.rocksdb.CassandraValueMergeOperator - org.rocksdb.Checkpoint - org.rocksdb.ClockCache - org.rocksdb.Cache - org.rocksdb.ColumnFamilyHandle - org.rocksdb.ColumnFamilyOptions - org.rocksdb.CompactionJobInfo - org.rocksdb.CompactionJobStats - org.rocksdb.CompactionOptions - org.rocksdb.CompactionOptionsFIFO - org.rocksdb.CompactionOptionsUniversal - org.rocksdb.CompactRangeOptions - org.rocksdb.ComparatorOptions - org.rocksdb.CompressionOptions - org.rocksdb.ConcurrentTaskLimiterImpl - org.rocksdb.ConfigOptions - org.rocksdb.DBOptions - org.rocksdb.DirectSlice - org.rocksdb.Env - org.rocksdb.EnvFlinkTestSuite - org.rocksdb.EnvOptions - org.rocksdb.Filter - org.rocksdb.FlinkCompactionFilter - org.rocksdb.FlinkEnv - org.rocksdb.FlushOptions - org.rocksdb.HashLinkedListMemTableConfig - org.rocksdb.HashSkipListMemTableConfig - org.rocksdb.HyperClockCache - org.rocksdb.IngestExternalFileOptions - org.rocksdb.Logger - org.rocksdb.LRUCache - org.rocksdb.MemoryUtil - org.rocksdb.MemTableConfig - org.rocksdb.NativeComparatorWrapper - org.rocksdb.NativeLibraryLoader - org.rocksdb.OptimisticTransactionDB - org.rocksdb.OptimisticTransactionOptions - org.rocksdb.Options - org.rocksdb.OptionsUtil - org.rocksdb.PersistentCache - org.rocksdb.PlainTableConfig - org.rocksdb.RateLimiter - org.rocksdb.ReadOptions - org.rocksdb.RemoveEmptyValueCompactionFilter - org.rocksdb.RestoreOptions - org.rocksdb.RocksCallbackObject - org.rocksdb.RocksDB - org.rocksdb.RocksEnv - org.rocksdb.RocksIterator - org.rocksdb.RocksIteratorInterface - org.rocksdb.RocksMemEnv - org.rocksdb.RocksMutableObject - org.rocksdb.RocksObject - org.rocksdb.SkipListMemTableConfig - org.rocksdb.Slice - org.rocksdb.Snapshot - org.rocksdb.SstFileManager - org.rocksdb.SstFileWriter - org.rocksdb.SstFileReader - org.rocksdb.SstFileReaderIterator - org.rocksdb.SstPartitionerFactory - org.rocksdb.SstPartitionerFixedPrefixFactory - org.rocksdb.Statistics - org.rocksdb.StringAppendOperator - org.rocksdb.TableFormatConfig - org.rocksdb.ThreadStatus - org.rocksdb.TimedEnv - org.rocksdb.Transaction - org.rocksdb.TransactionDB - org.rocksdb.TransactionDBOptions - org.rocksdb.TransactionLogIterator - org.rocksdb.TransactionOptions - org.rocksdb.TtlDB - org.rocksdb.UInt64AddOperator - org.rocksdb.VectorMemTableConfig - org.rocksdb.WBWIRocksIterator - org.rocksdb.WriteBatch - org.rocksdb.WriteBatch.Handler - org.rocksdb.WriteBatchInterface - org.rocksdb.WriteBatchWithIndex - org.rocksdb.WriteOptions - org.rocksdb.NativeComparatorWrapperTest - org.rocksdb.RocksDBExceptionTest - org.rocksdb.SnapshotTest - org.rocksdb.WriteBatchTest - org.rocksdb.WriteBatchTestInternalHelper - org.rocksdb.WriteBufferManager - org.rocksdb.test.TestableEventListener + org.forstdb.AbstractCompactionFilter + org.forstdb.AbstractCompactionFilterFactory + org.forstdb.AbstractComparator + org.forstdb.AbstractEventListener + org.forstdb.AbstractImmutableNativeReference + org.forstdb.AbstractNativeReference + org.forstdb.AbstractRocksIterator + org.forstdb.AbstractSlice + org.forstdb.AbstractTableFilter + org.forstdb.AbstractTraceWriter + org.forstdb.AbstractTransactionNotifier + org.forstdb.AbstractWalFilter + org.forstdb.BackupEngineOptions + org.forstdb.BackupEngine + org.forstdb.BlockBasedTableConfig + org.forstdb.BloomFilter + org.forstdb.CassandraCompactionFilter + org.forstdb.CassandraValueMergeOperator + org.forstdb.Checkpoint + org.forstdb.ClockCache + org.forstdb.Cache + org.forstdb.ColumnFamilyHandle + org.forstdb.ColumnFamilyOptions + org.forstdb.CompactionJobInfo + org.forstdb.CompactionJobStats + org.forstdb.CompactionOptions + org.forstdb.CompactionOptionsFIFO + org.forstdb.CompactionOptionsUniversal + org.forstdb.CompactRangeOptions + org.forstdb.ComparatorOptions + org.forstdb.CompressionOptions + org.forstdb.ConcurrentTaskLimiterImpl + org.forstdb.ConfigOptions + org.forstdb.DBOptions + org.forstdb.DirectSlice + org.forstdb.Env + org.forstdb.EnvFlinkTestSuite + org.forstdb.EnvOptions + org.forstdb.Filter + org.forstdb.FlinkCompactionFilter + org.forstdb.FlinkEnv + org.forstdb.FlushOptions + org.forstdb.HashLinkedListMemTableConfig + org.forstdb.HashSkipListMemTableConfig + org.forstdb.HyperClockCache + org.forstdb.IngestExternalFileOptions + org.forstdb.Logger + org.forstdb.LRUCache + org.forstdb.MemoryUtil + org.forstdb.MemTableConfig + org.forstdb.NativeComparatorWrapper + org.forstdb.NativeLibraryLoader + org.forstdb.OptimisticTransactionDB + org.forstdb.OptimisticTransactionOptions + org.forstdb.Options + org.forstdb.OptionsUtil + org.forstdb.PersistentCache + org.forstdb.PlainTableConfig + org.forstdb.RateLimiter + org.forstdb.ReadOptions + org.forstdb.RemoveEmptyValueCompactionFilter + org.forstdb.RestoreOptions + org.forstdb.RocksCallbackObject + org.forstdb.RocksDB + org.forstdb.RocksEnv + org.forstdb.RocksIterator + org.forstdb.RocksIteratorInterface + org.forstdb.RocksMemEnv + org.forstdb.RocksMutableObject + org.forstdb.RocksObject + org.forstdb.SkipListMemTableConfig + org.forstdb.Slice + org.forstdb.Snapshot + org.forstdb.SstFileManager + org.forstdb.SstFileWriter + org.forstdb.SstFileReader + org.forstdb.SstFileReaderIterator + org.forstdb.SstPartitionerFactory + org.forstdb.SstPartitionerFixedPrefixFactory + org.forstdb.Statistics + org.forstdb.StringAppendOperator + org.forstdb.TableFormatConfig + org.forstdb.ThreadStatus + org.forstdb.TimedEnv + org.forstdb.Transaction + org.forstdb.TransactionDB + org.forstdb.TransactionDBOptions + org.forstdb.TransactionLogIterator + org.forstdb.TransactionOptions + org.forstdb.TtlDB + org.forstdb.UInt64AddOperator + org.forstdb.VectorMemTableConfig + org.forstdb.WBWIRocksIterator + org.forstdb.WriteBatch + org.forstdb.WriteBatch.Handler + org.forstdb.WriteBatchInterface + org.forstdb.WriteBatchWithIndex + org.forstdb.WriteOptions + org.forstdb.NativeComparatorWrapperTest + org.forstdb.RocksDBExceptionTest + org.forstdb.SnapshotTest + org.forstdb.WriteBatchTest + org.forstdb.WriteBatchTestInternalHelper + org.forstdb.WriteBufferManager + org.forstdb.test.TestableEventListener ) create_javah( @@ -802,12 +802,12 @@ foreach (CLAZZ ${JAVA_TEST_RUNNING_CLASSES}) if(${CMAKE_SYSTEM_NAME} MATCHES "Windows") add_test( NAME jtest_${CLAZZ} - COMMAND ${Java_JAVA_EXECUTABLE} ${JVMARGS} -ea -Xcheck:jni -Djava.library.path=${PROJECT_BINARY_DIR}/java/${CMAKE_BUILD_TYPE} -classpath ${JAVA_RUN_TESTCLASSPATH}$${ROCKSDBJNI_CLASSES_TEST_JAR_FILE} org.rocksdb.test.RocksJunitRunner ${CLAZZ} + COMMAND ${Java_JAVA_EXECUTABLE} ${JVMARGS} -ea -Xcheck:jni -Djava.library.path=${PROJECT_BINARY_DIR}/java/${CMAKE_BUILD_TYPE} -classpath ${JAVA_RUN_TESTCLASSPATH}$${ROCKSDBJNI_CLASSES_TEST_JAR_FILE} org.forstdb.test.RocksJunitRunner ${CLAZZ} ) else() add_test( NAME jtest_${CLAZZ} - COMMAND ${Java_JAVA_EXECUTABLE} ${JVMARGS} -ea -Xcheck:jni -Djava.library.path=${PROJECT_BINARY_DIR}/java -classpath ${JAVA_RUN_TESTCLASSPATH}:${ROCKSDBJNI_CLASSES_TEST_JAR_FILE} org.rocksdb.test.RocksJunitRunner ${CLAZZ} + COMMAND ${Java_JAVA_EXECUTABLE} ${JVMARGS} -ea -Xcheck:jni -Djava.library.path=${PROJECT_BINARY_DIR}/java -classpath ${JAVA_RUN_TESTCLASSPATH}:${ROCKSDBJNI_CLASSES_TEST_JAR_FILE} org.forstdb.test.RocksJunitRunner ${CLAZZ} ) endif() endforeach(CLAZZ) \ No newline at end of file diff --git a/java/Makefile b/java/Makefile index aae28e0cd..7a6915cf0 100644 --- a/java/Makefile +++ b/java/Makefile @@ -1,103 +1,103 @@ NATIVE_JAVA_CLASSES = \ - org.rocksdb.AbstractCompactionFilter\ - org.rocksdb.AbstractCompactionFilterFactory\ - org.rocksdb.AbstractComparator\ - org.rocksdb.AbstractEventListener\ - org.rocksdb.AbstractSlice\ - org.rocksdb.AbstractTableFilter\ - org.rocksdb.AbstractTraceWriter\ - org.rocksdb.AbstractTransactionNotifier\ - org.rocksdb.AbstractWalFilter\ - org.rocksdb.BackupEngine\ - org.rocksdb.BackupEngineOptions\ - org.rocksdb.BlockBasedTableConfig\ - org.rocksdb.BloomFilter\ - org.rocksdb.Checkpoint\ - org.rocksdb.ClockCache\ - org.rocksdb.Cache\ - org.rocksdb.CassandraCompactionFilter\ - org.rocksdb.CassandraValueMergeOperator\ - org.rocksdb.ColumnFamilyHandle\ - org.rocksdb.ColumnFamilyOptions\ - org.rocksdb.CompactionJobInfo\ - org.rocksdb.CompactionJobStats\ - org.rocksdb.CompactionOptions\ - org.rocksdb.CompactionOptionsFIFO\ - org.rocksdb.CompactionOptionsUniversal\ - org.rocksdb.CompactRangeOptions\ - org.rocksdb.ComparatorOptions\ - org.rocksdb.CompressionOptions\ - org.rocksdb.ConfigOptions\ - org.rocksdb.DBOptions\ - org.rocksdb.DirectSlice\ - org.rocksdb.Env\ - org.rocksdb.EnvOptions\ - org.rocksdb.FlinkCompactionFilter\ - org.rocksdb.FlushOptions\ - org.rocksdb.Filter\ - org.rocksdb.IngestExternalFileOptions\ - org.rocksdb.HashLinkedListMemTableConfig\ - org.rocksdb.HashSkipListMemTableConfig\ - org.rocksdb.ConcurrentTaskLimiter\ - org.rocksdb.ConcurrentTaskLimiterImpl\ - org.rocksdb.KeyMayExist\ - org.rocksdb.Logger\ - org.rocksdb.LRUCache\ - org.rocksdb.MemoryUsageType\ - org.rocksdb.MemoryUtil\ - org.rocksdb.MergeOperator\ - org.rocksdb.NativeComparatorWrapper\ - org.rocksdb.OptimisticTransactionDB\ - org.rocksdb.OptimisticTransactionOptions\ - org.rocksdb.Options\ - org.rocksdb.OptionsUtil\ - org.rocksdb.PersistentCache\ - org.rocksdb.PerfContext\ - org.rocksdb.PerfLevel\ - org.rocksdb.PlainTableConfig\ - org.rocksdb.RateLimiter\ - org.rocksdb.ReadOptions\ - org.rocksdb.RemoveEmptyValueCompactionFilter\ - org.rocksdb.RestoreOptions\ - org.rocksdb.RocksCallbackObject\ - org.rocksdb.RocksDB\ - org.rocksdb.RocksEnv\ - org.rocksdb.RocksIterator\ - org.rocksdb.RocksMemEnv\ - org.rocksdb.SkipListMemTableConfig\ - org.rocksdb.Slice\ - org.rocksdb.SstFileManager\ - org.rocksdb.SstFileWriter\ - org.rocksdb.SstFileReader\ - org.rocksdb.SstFileReaderIterator\ - org.rocksdb.SstPartitionerFactory\ - org.rocksdb.SstPartitionerFixedPrefixFactory\ - org.rocksdb.Statistics\ - org.rocksdb.ThreadStatus\ - org.rocksdb.TimedEnv\ - org.rocksdb.Transaction\ - org.rocksdb.TransactionDB\ - org.rocksdb.TransactionDBOptions\ - org.rocksdb.TransactionOptions\ - org.rocksdb.TransactionLogIterator\ - org.rocksdb.TtlDB\ - org.rocksdb.VectorMemTableConfig\ - org.rocksdb.Snapshot\ - org.rocksdb.StringAppendOperator\ - org.rocksdb.UInt64AddOperator\ - org.rocksdb.WriteBatch\ - org.rocksdb.WriteBatch.Handler\ - org.rocksdb.WriteOptions\ - org.rocksdb.WriteBatchWithIndex\ - org.rocksdb.WriteBufferManager\ - org.rocksdb.WBWIRocksIterator + org.forstdb.AbstractCompactionFilter\ + org.forstdb.AbstractCompactionFilterFactory\ + org.forstdb.AbstractComparator\ + org.forstdb.AbstractEventListener\ + org.forstdb.AbstractSlice\ + org.forstdb.AbstractTableFilter\ + org.forstdb.AbstractTraceWriter\ + org.forstdb.AbstractTransactionNotifier\ + org.forstdb.AbstractWalFilter\ + org.forstdb.BackupEngine\ + org.forstdb.BackupEngineOptions\ + org.forstdb.BlockBasedTableConfig\ + org.forstdb.BloomFilter\ + org.forstdb.Checkpoint\ + org.forstdb.ClockCache\ + org.forstdb.Cache\ + org.forstdb.CassandraCompactionFilter\ + org.forstdb.CassandraValueMergeOperator\ + org.forstdb.ColumnFamilyHandle\ + org.forstdb.ColumnFamilyOptions\ + org.forstdb.CompactionJobInfo\ + org.forstdb.CompactionJobStats\ + org.forstdb.CompactionOptions\ + org.forstdb.CompactionOptionsFIFO\ + org.forstdb.CompactionOptionsUniversal\ + org.forstdb.CompactRangeOptions\ + org.forstdb.ComparatorOptions\ + org.forstdb.CompressionOptions\ + org.forstdb.ConfigOptions\ + org.forstdb.DBOptions\ + org.forstdb.DirectSlice\ + org.forstdb.Env\ + org.forstdb.EnvOptions\ + org.forstdb.FlinkCompactionFilter\ + org.forstdb.FlushOptions\ + org.forstdb.Filter\ + org.forstdb.IngestExternalFileOptions\ + org.forstdb.HashLinkedListMemTableConfig\ + org.forstdb.HashSkipListMemTableConfig\ + org.forstdb.ConcurrentTaskLimiter\ + org.forstdb.ConcurrentTaskLimiterImpl\ + org.forstdb.KeyMayExist\ + org.forstdb.Logger\ + org.forstdb.LRUCache\ + org.forstdb.MemoryUsageType\ + org.forstdb.MemoryUtil\ + org.forstdb.MergeOperator\ + org.forstdb.NativeComparatorWrapper\ + org.forstdb.OptimisticTransactionDB\ + org.forstdb.OptimisticTransactionOptions\ + org.forstdb.Options\ + org.forstdb.OptionsUtil\ + org.forstdb.PersistentCache\ + org.forstdb.PerfContext\ + org.forstdb.PerfLevel\ + org.forstdb.PlainTableConfig\ + org.forstdb.RateLimiter\ + org.forstdb.ReadOptions\ + org.forstdb.RemoveEmptyValueCompactionFilter\ + org.forstdb.RestoreOptions\ + org.forstdb.RocksCallbackObject\ + org.forstdb.RocksDB\ + org.forstdb.RocksEnv\ + org.forstdb.RocksIterator\ + org.forstdb.RocksMemEnv\ + org.forstdb.SkipListMemTableConfig\ + org.forstdb.Slice\ + org.forstdb.SstFileManager\ + org.forstdb.SstFileWriter\ + org.forstdb.SstFileReader\ + org.forstdb.SstFileReaderIterator\ + org.forstdb.SstPartitionerFactory\ + org.forstdb.SstPartitionerFixedPrefixFactory\ + org.forstdb.Statistics\ + org.forstdb.ThreadStatus\ + org.forstdb.TimedEnv\ + org.forstdb.Transaction\ + org.forstdb.TransactionDB\ + org.forstdb.TransactionDBOptions\ + org.forstdb.TransactionOptions\ + org.forstdb.TransactionLogIterator\ + org.forstdb.TtlDB\ + org.forstdb.VectorMemTableConfig\ + org.forstdb.Snapshot\ + org.forstdb.StringAppendOperator\ + org.forstdb.UInt64AddOperator\ + org.forstdb.WriteBatch\ + org.forstdb.WriteBatch.Handler\ + org.forstdb.WriteOptions\ + org.forstdb.WriteBatchWithIndex\ + org.forstdb.WriteBufferManager\ + org.forstdb.WBWIRocksIterator NATIVE_JAVA_TEST_CLASSES = \ - org.rocksdb.RocksDBExceptionTest\ - org.rocksdb.test.TestableEventListener\ - org.rocksdb.NativeComparatorWrapperTest.NativeStringComparatorWrapper\ - org.rocksdb.WriteBatchTest\ - org.rocksdb.WriteBatchTestInternalHelper + org.forstdb.RocksDBExceptionTest\ + org.forstdb.test.TestableEventListener\ + org.forstdb.NativeComparatorWrapperTest.NativeStringComparatorWrapper\ + org.forstdb.WriteBatchTest\ + org.forstdb.WriteBatchTestInternalHelper ROCKSDB_MAJOR = $(shell grep -E "ROCKSDB_MAJOR.[0-9]" ../include/rocksdb/version.h | cut -d ' ' -f 3) ROCKSDB_MINOR = $(shell grep -E "ROCKSDB_MINOR.[0-9]" ../include/rocksdb/version.h | cut -d ' ' -f 3) @@ -108,109 +108,109 @@ ARCH := $(shell getconf LONG_BIT) SHA256_CMD ?= sha256sum JAVA_TESTS = \ - org.rocksdb.BackupEngineOptionsTest\ - org.rocksdb.BackupEngineTest\ - org.rocksdb.BlobOptionsTest\ - org.rocksdb.BlockBasedTableConfigTest\ - org.rocksdb.BuiltinComparatorTest\ - org.rocksdb.ByteBufferUnsupportedOperationTest\ - org.rocksdb.BytewiseComparatorRegressionTest\ - org.rocksdb.util.BytewiseComparatorTest\ - org.rocksdb.util.BytewiseComparatorIntTest\ - org.rocksdb.CheckPointTest\ - org.rocksdb.ClockCacheTest\ - org.rocksdb.ColumnFamilyOptionsTest\ - org.rocksdb.ColumnFamilyTest\ - org.rocksdb.CompactionFilterFactoryTest\ - org.rocksdb.CompactionJobInfoTest\ - org.rocksdb.CompactionJobStatsTest\ - org.rocksdb.CompactionOptionsTest\ - org.rocksdb.CompactionOptionsFIFOTest\ - org.rocksdb.CompactionOptionsUniversalTest\ - org.rocksdb.CompactionPriorityTest\ - org.rocksdb.CompactionStopStyleTest\ - org.rocksdb.ComparatorOptionsTest\ - org.rocksdb.CompressionOptionsTest\ - org.rocksdb.CompressionTypesTest\ - org.rocksdb.DBOptionsTest\ - org.rocksdb.DirectSliceTest\ - org.rocksdb.util.EnvironmentTest\ - org.rocksdb.EnvOptionsTest\ - org.rocksdb.EventListenerTest\ - org.rocksdb.IngestExternalFileOptionsTest\ - org.rocksdb.util.IntComparatorTest\ - org.rocksdb.util.JNIComparatorTest\ - org.rocksdb.FilterTest\ - org.rocksdb.FlushTest\ - org.rocksdb.ImportColumnFamilyTest\ - org.rocksdb.InfoLogLevelTest\ - org.rocksdb.KeyExistsTest \ - org.rocksdb.KeyMayExistTest\ - org.rocksdb.ConcurrentTaskLimiterTest\ - org.rocksdb.LoggerTest\ - org.rocksdb.LRUCacheTest\ - org.rocksdb.MemoryUtilTest\ - org.rocksdb.MemTableTest\ - org.rocksdb.MergeCFVariantsTest\ - org.rocksdb.MergeTest\ - org.rocksdb.MergeVariantsTest\ - org.rocksdb.MultiColumnRegressionTest \ - org.rocksdb.MultiGetManyKeysTest\ - org.rocksdb.MultiGetTest\ - org.rocksdb.MixedOptionsTest\ - org.rocksdb.MutableColumnFamilyOptionsTest\ - org.rocksdb.MutableDBOptionsTest\ - org.rocksdb.MutableOptionsGetSetTest \ - org.rocksdb.NativeComparatorWrapperTest\ - org.rocksdb.NativeLibraryLoaderTest\ - org.rocksdb.OptimisticTransactionTest\ - org.rocksdb.OptimisticTransactionDBTest\ - org.rocksdb.OptimisticTransactionOptionsTest\ - org.rocksdb.OptionsUtilTest\ - org.rocksdb.OptionsTest\ - org.rocksdb.PerfLevelTest \ - org.rocksdb.PerfContextTest \ - org.rocksdb.PutCFVariantsTest\ - org.rocksdb.PutVariantsTest\ - org.rocksdb.PlainTableConfigTest\ - org.rocksdb.RateLimiterTest\ - org.rocksdb.ReadOnlyTest\ - org.rocksdb.ReadOptionsTest\ - org.rocksdb.util.ReverseBytewiseComparatorIntTest\ - org.rocksdb.RocksDBTest\ - org.rocksdb.RocksDBExceptionTest\ - org.rocksdb.DefaultEnvTest\ - org.rocksdb.RocksIteratorTest\ - org.rocksdb.RocksMemEnvTest\ - org.rocksdb.util.SizeUnitTest\ - org.rocksdb.SecondaryDBTest\ - org.rocksdb.SliceTest\ - org.rocksdb.SnapshotTest\ - org.rocksdb.SstFileManagerTest\ - org.rocksdb.SstFileWriterTest\ - org.rocksdb.SstFileReaderTest\ - org.rocksdb.SstPartitionerTest\ - org.rocksdb.TableFilterTest\ - org.rocksdb.TimedEnvTest\ - org.rocksdb.TransactionTest\ - org.rocksdb.TransactionDBTest\ - org.rocksdb.TransactionOptionsTest\ - org.rocksdb.TransactionDBOptionsTest\ - org.rocksdb.TransactionLogIteratorTest\ - org.rocksdb.TtlDBTest\ - org.rocksdb.StatisticsTest\ - org.rocksdb.StatisticsCollectorTest\ - org.rocksdb.VerifyChecksumsTest\ - org.rocksdb.WalFilterTest\ - org.rocksdb.WALRecoveryModeTest\ - org.rocksdb.WriteBatchHandlerTest\ - org.rocksdb.WriteBatchTest\ - org.rocksdb.WriteBatchThreadedTest\ - org.rocksdb.WriteOptionsTest\ - org.rocksdb.WriteBatchWithIndexTest + org.forstdb.BackupEngineOptionsTest\ + org.forstdb.BackupEngineTest\ + org.forstdb.BlobOptionsTest\ + org.forstdb.BlockBasedTableConfigTest\ + org.forstdb.BuiltinComparatorTest\ + org.forstdb.ByteBufferUnsupportedOperationTest\ + org.forstdb.BytewiseComparatorRegressionTest\ + org.forstdb.util.BytewiseComparatorTest\ + org.forstdb.util.BytewiseComparatorIntTest\ + org.forstdb.CheckPointTest\ + org.forstdb.ClockCacheTest\ + org.forstdb.ColumnFamilyOptionsTest\ + org.forstdb.ColumnFamilyTest\ + org.forstdb.CompactionFilterFactoryTest\ + org.forstdb.CompactionJobInfoTest\ + org.forstdb.CompactionJobStatsTest\ + org.forstdb.CompactionOptionsTest\ + org.forstdb.CompactionOptionsFIFOTest\ + org.forstdb.CompactionOptionsUniversalTest\ + org.forstdb.CompactionPriorityTest\ + org.forstdb.CompactionStopStyleTest\ + org.forstdb.ComparatorOptionsTest\ + org.forstdb.CompressionOptionsTest\ + org.forstdb.CompressionTypesTest\ + org.forstdb.DBOptionsTest\ + org.forstdb.DirectSliceTest\ + org.forstdb.util.EnvironmentTest\ + org.forstdb.EnvOptionsTest\ + org.forstdb.EventListenerTest\ + org.forstdb.IngestExternalFileOptionsTest\ + org.forstdb.util.IntComparatorTest\ + org.forstdb.util.JNIComparatorTest\ + org.forstdb.FilterTest\ + org.forstdb.FlushTest\ + org.forstdb.ImportColumnFamilyTest\ + org.forstdb.InfoLogLevelTest\ + org.forstdb.KeyExistsTest \ + org.forstdb.KeyMayExistTest\ + org.forstdb.ConcurrentTaskLimiterTest\ + org.forstdb.LoggerTest\ + org.forstdb.LRUCacheTest\ + org.forstdb.MemoryUtilTest\ + org.forstdb.MemTableTest\ + org.forstdb.MergeCFVariantsTest\ + org.forstdb.MergeTest\ + org.forstdb.MergeVariantsTest\ + org.forstdb.MultiColumnRegressionTest \ + org.forstdb.MultiGetManyKeysTest\ + org.forstdb.MultiGetTest\ + org.forstdb.MixedOptionsTest\ + org.forstdb.MutableColumnFamilyOptionsTest\ + org.forstdb.MutableDBOptionsTest\ + org.forstdb.MutableOptionsGetSetTest \ + org.forstdb.NativeComparatorWrapperTest\ + org.forstdb.NativeLibraryLoaderTest\ + org.forstdb.OptimisticTransactionTest\ + org.forstdb.OptimisticTransactionDBTest\ + org.forstdb.OptimisticTransactionOptionsTest\ + org.forstdb.OptionsUtilTest\ + org.forstdb.OptionsTest\ + org.forstdb.PerfLevelTest \ + org.forstdb.PerfContextTest \ + org.forstdb.PutCFVariantsTest\ + org.forstdb.PutVariantsTest\ + org.forstdb.PlainTableConfigTest\ + org.forstdb.RateLimiterTest\ + org.forstdb.ReadOnlyTest\ + org.forstdb.ReadOptionsTest\ + org.forstdb.util.ReverseBytewiseComparatorIntTest\ + org.forstdb.RocksDBTest\ + org.forstdb.RocksDBExceptionTest\ + org.forstdb.DefaultEnvTest\ + org.forstdb.RocksIteratorTest\ + org.forstdb.RocksMemEnvTest\ + org.forstdb.util.SizeUnitTest\ + org.forstdb.SecondaryDBTest\ + org.forstdb.SliceTest\ + org.forstdb.SnapshotTest\ + org.forstdb.SstFileManagerTest\ + org.forstdb.SstFileWriterTest\ + org.forstdb.SstFileReaderTest\ + org.forstdb.SstPartitionerTest\ + org.forstdb.TableFilterTest\ + org.forstdb.TimedEnvTest\ + org.forstdb.TransactionTest\ + org.forstdb.TransactionDBTest\ + org.forstdb.TransactionOptionsTest\ + org.forstdb.TransactionDBOptionsTest\ + org.forstdb.TransactionLogIteratorTest\ + org.forstdb.TtlDBTest\ + org.forstdb.StatisticsTest\ + org.forstdb.StatisticsCollectorTest\ + org.forstdb.VerifyChecksumsTest\ + org.forstdb.WalFilterTest\ + org.forstdb.WALRecoveryModeTest\ + org.forstdb.WriteBatchHandlerTest\ + org.forstdb.WriteBatchTest\ + org.forstdb.WriteBatchThreadedTest\ + org.forstdb.WriteOptionsTest\ + org.forstdb.WriteBatchWithIndexTest FLINK_TESTS = \ - org.rocksdb.flink.FlinkEnvTest + org.forstdb.flink.FlinkEnvTest MAIN_SRC = src/main/java TEST_SRC = src/test/java @@ -302,11 +302,11 @@ include $(ROCKSDB_PLUGIN_MKS) # Add paths to Java sources in plugins ROCKSDB_PLUGIN_JAVA_ROOTS = $(foreach plugin, $(ROCKSDB_PLUGINS), $(PLUGIN_PATH)/$(plugin)/java) -PLUGIN_SOURCES = $(foreach root, $(ROCKSDB_PLUGIN_JAVA_ROOTS), $(foreach pkg, org/rocksdb/util org/rocksdb, $(root)/$(MAIN_SRC)/$(pkg)/*.java)) -CORE_SOURCES = $(foreach pkg, org/rocksdb/util org/rocksdb, $(MAIN_SRC)/$(pkg)/*.java) +PLUGIN_SOURCES = $(foreach root, $(ROCKSDB_PLUGIN_JAVA_ROOTS), $(foreach pkg, org/forstdb/util org/forstdb, $(root)/$(MAIN_SRC)/$(pkg)/*.java)) +CORE_SOURCES = $(foreach pkg, org/forstdb/util org/forstdb, $(MAIN_SRC)/$(pkg)/*.java) SOURCES = $(wildcard $(CORE_SOURCES) $(PLUGIN_SOURCES)) -PLUGIN_TEST_SOURCES = $(foreach root, $(ROCKSDB_PLUGIN_JAVA_ROOTS), $(foreach pkg, org/rocksdb/test org/rocksdb/util org/rocksdb, $(root)/$(TEST_SRC)/$(pkg)/*.java)) -CORE_TEST_SOURCES = $(foreach pkg, org/rocksdb/test org/rocksdb/util org/rocksdb/flink org/rocksdb, $(TEST_SRC)/$(pkg)/*.java) +PLUGIN_TEST_SOURCES = $(foreach root, $(ROCKSDB_PLUGIN_JAVA_ROOTS), $(foreach pkg, org/forstdb/test org/forstdb/util org/forstdb, $(root)/$(TEST_SRC)/$(pkg)/*.java)) +CORE_TEST_SOURCES = $(foreach pkg, org/forstdb/test org/forstdb/util org/forstdb/flink org/forstdb, $(TEST_SRC)/$(pkg)/*.java) TEST_SOURCES = $(wildcard $(CORE_TEST_SOURCES) $(PLUGIN_TEST_SOURCES)) MOCK_FLINK_TEST_SOURCES = $(foreach pkg, org/apache/flink/core/fs org/apache/flink/state/forst/fs, flinktestmock/src/main/java/$(pkg)/*.java) @@ -458,15 +458,15 @@ test: java mock_flink_fs java_test $(MAKE) run_test run_test: - $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp "$(MAIN_CLASSES):$(TEST_CLASSES):$(JAVA_TESTCLASSPATH):target/*" org.rocksdb.test.RocksJunitRunner $(ALL_JAVA_TESTS) - $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp "$(MAIN_CLASSES):$(TEST_CLASSES):$(JAVA_TESTCLASSPATH):target/*" org.rocksdb.test.RocksJunitRunner org.rocksdb.StatisticsTest + $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp "$(MAIN_CLASSES):$(TEST_CLASSES):$(JAVA_TESTCLASSPATH):target/*" org.forstdb.test.RocksJunitRunner $(ALL_JAVA_TESTS) + $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp "$(MAIN_CLASSES):$(TEST_CLASSES):$(JAVA_TESTCLASSPATH):target/*" org.forstdb.test.RocksJunitRunner org.forstdb.StatisticsTest run_plugin_test: - $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp "$(MAIN_CLASSES):$(TEST_CLASSES):$(JAVA_TESTCLASSPATH):target/*" org.rocksdb.test.RocksJunitRunner $(ROCKSDB_PLUGIN_JAVA_TESTS) + $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp "$(MAIN_CLASSES):$(TEST_CLASSES):$(JAVA_TESTCLASSPATH):target/*" org.forstdb.test.RocksJunitRunner $(ROCKSDB_PLUGIN_JAVA_TESTS) db_bench: java $(AM_V_GEN)mkdir -p $(BENCHMARK_MAIN_CLASSES) - $(AM_V_at)$(JAVAC_CMD) $(JAVAC_ARGS) -cp $(MAIN_CLASSES) -d $(BENCHMARK_MAIN_CLASSES) $(BENCHMARK_MAIN_SRC)/org/rocksdb/benchmark/*.java + $(AM_V_at)$(JAVAC_CMD) $(JAVAC_ARGS) -cp $(MAIN_CLASSES) -d $(BENCHMARK_MAIN_CLASSES) $(BENCHMARK_MAIN_SRC)/org/forstdb/benchmark/*.java pmd: $(MAVEN_CMD) pmd:pmd pmd:cpd pmd:check @@ -479,4 +479,4 @@ flink_test: java java_test mock_flink_fs $(MAKE) run_flink_test run_flink_test: - $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp "$(MAIN_CLASSES):$(TEST_CLASSES):$(JAVA_TESTCLASSPATH):target/*" org.rocksdb.test.RocksJunitRunner $(FLINK_TESTS) + $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp "$(MAIN_CLASSES):$(TEST_CLASSES):$(JAVA_TESTCLASSPATH):target/*" org.forstdb.test.RocksJunitRunner $(FLINK_TESTS) diff --git a/java/benchmark/src/main/java/org/rocksdb/benchmark/DbBenchmark.java b/java/benchmark/src/main/java/org/rocksdb/benchmark/DbBenchmark.java index 070f0fe75..4b8372f51 100644 --- a/java/benchmark/src/main/java/org/rocksdb/benchmark/DbBenchmark.java +++ b/java/benchmark/src/main/java/org/rocksdb/benchmark/DbBenchmark.java @@ -19,7 +19,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.rocksdb.benchmark; +package org.forstdb.benchmark; import java.io.IOException; import java.lang.Runnable; @@ -43,9 +43,9 @@ import java.util.concurrent.ExecutorService; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; -import org.rocksdb.*; -import org.rocksdb.RocksMemEnv; -import org.rocksdb.util.SizeUnit; +import org.forstdb.*; +import org.forstdb.RocksMemEnv; +import org.forstdb.util.SizeUnit; class Stats { int id_; diff --git a/java/rocksjni/backup_engine_options.cc b/java/forstjni/backup_engine_options.cc similarity index 77% rename from java/rocksjni/backup_engine_options.cc rename to java/forstjni/backup_engine_options.cc index 25bfb6720..589a711be 100644 --- a/java/rocksjni/backup_engine_options.cc +++ b/java/forstjni/backup_engine_options.cc @@ -14,20 +14,20 @@ #include #include -#include "include/org_rocksdb_BackupEngineOptions.h" +#include "include/org_forstdb_BackupEngineOptions.h" #include "rocksdb/utilities/backup_engine.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /////////////////////////////////////////////////////////////////////////// // BackupDBOptions /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: newBackupEngineOptions * Signature: (Ljava/lang/String;)J */ -jlong Java_org_rocksdb_BackupEngineOptions_newBackupEngineOptions( +jlong Java_org_forstdb_BackupEngineOptions_newBackupEngineOptions( JNIEnv* env, jclass /*jcls*/, jstring jpath) { const char* cpath = env->GetStringUTFChars(jpath, nullptr); if (cpath == nullptr) { @@ -40,11 +40,11 @@ jlong Java_org_rocksdb_BackupEngineOptions_newBackupEngineOptions( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: backupDir * Signature: (J)Ljava/lang/String; */ -jstring Java_org_rocksdb_BackupEngineOptions_backupDir(JNIEnv* env, +jstring Java_org_forstdb_BackupEngineOptions_backupDir(JNIEnv* env, jobject /*jopt*/, jlong jhandle) { auto* bopt = @@ -53,11 +53,11 @@ jstring Java_org_rocksdb_BackupEngineOptions_backupDir(JNIEnv* env, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setBackupEnv * Signature: (JJ)V */ -void Java_org_rocksdb_BackupEngineOptions_setBackupEnv( +void Java_org_forstdb_BackupEngineOptions_setBackupEnv( JNIEnv* /*env*/, jobject /*jopt*/, jlong jhandle, jlong jrocks_env_handle) { auto* bopt = reinterpret_cast(jhandle); @@ -67,11 +67,11 @@ void Java_org_rocksdb_BackupEngineOptions_setBackupEnv( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setShareTableFiles * Signature: (JZ)V */ -void Java_org_rocksdb_BackupEngineOptions_setShareTableFiles(JNIEnv* /*env*/, +void Java_org_forstdb_BackupEngineOptions_setShareTableFiles(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jboolean flag) { @@ -81,11 +81,11 @@ void Java_org_rocksdb_BackupEngineOptions_setShareTableFiles(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: shareTableFiles * Signature: (J)Z */ -jboolean Java_org_rocksdb_BackupEngineOptions_shareTableFiles(JNIEnv* /*env*/, +jboolean Java_org_forstdb_BackupEngineOptions_shareTableFiles(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* bopt = @@ -94,11 +94,11 @@ jboolean Java_org_rocksdb_BackupEngineOptions_shareTableFiles(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setInfoLog * Signature: (JJ)V */ -void Java_org_rocksdb_BackupEngineOptions_setInfoLog(JNIEnv* /*env*/, +void Java_org_forstdb_BackupEngineOptions_setInfoLog(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong /*jlogger_handle*/) { @@ -111,11 +111,11 @@ void Java_org_rocksdb_BackupEngineOptions_setInfoLog(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setSync * Signature: (JZ)V */ -void Java_org_rocksdb_BackupEngineOptions_setSync(JNIEnv* /*env*/, +void Java_org_forstdb_BackupEngineOptions_setSync(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jboolean flag) { @@ -125,11 +125,11 @@ void Java_org_rocksdb_BackupEngineOptions_setSync(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: sync * Signature: (J)Z */ -jboolean Java_org_rocksdb_BackupEngineOptions_sync(JNIEnv* /*env*/, +jboolean Java_org_forstdb_BackupEngineOptions_sync(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* bopt = @@ -138,11 +138,11 @@ jboolean Java_org_rocksdb_BackupEngineOptions_sync(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setDestroyOldData * Signature: (JZ)V */ -void Java_org_rocksdb_BackupEngineOptions_setDestroyOldData(JNIEnv* /*env*/, +void Java_org_forstdb_BackupEngineOptions_setDestroyOldData(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jboolean flag) { @@ -152,11 +152,11 @@ void Java_org_rocksdb_BackupEngineOptions_setDestroyOldData(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: destroyOldData * Signature: (J)Z */ -jboolean Java_org_rocksdb_BackupEngineOptions_destroyOldData(JNIEnv* /*env*/, +jboolean Java_org_forstdb_BackupEngineOptions_destroyOldData(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* bopt = @@ -165,11 +165,11 @@ jboolean Java_org_rocksdb_BackupEngineOptions_destroyOldData(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setBackupLogFiles * Signature: (JZ)V */ -void Java_org_rocksdb_BackupEngineOptions_setBackupLogFiles(JNIEnv* /*env*/, +void Java_org_forstdb_BackupEngineOptions_setBackupLogFiles(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jboolean flag) { @@ -179,11 +179,11 @@ void Java_org_rocksdb_BackupEngineOptions_setBackupLogFiles(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: backupLogFiles * Signature: (J)Z */ -jboolean Java_org_rocksdb_BackupEngineOptions_backupLogFiles(JNIEnv* /*env*/, +jboolean Java_org_forstdb_BackupEngineOptions_backupLogFiles(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* bopt = @@ -192,11 +192,11 @@ jboolean Java_org_rocksdb_BackupEngineOptions_backupLogFiles(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setBackupRateLimit * Signature: (JJ)V */ -void Java_org_rocksdb_BackupEngineOptions_setBackupRateLimit( +void Java_org_forstdb_BackupEngineOptions_setBackupRateLimit( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jbackup_rate_limit) { auto* bopt = @@ -205,11 +205,11 @@ void Java_org_rocksdb_BackupEngineOptions_setBackupRateLimit( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: backupRateLimit * Signature: (J)J */ -jlong Java_org_rocksdb_BackupEngineOptions_backupRateLimit(JNIEnv* /*env*/, +jlong Java_org_forstdb_BackupEngineOptions_backupRateLimit(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* bopt = @@ -218,11 +218,11 @@ jlong Java_org_rocksdb_BackupEngineOptions_backupRateLimit(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setBackupRateLimiter * Signature: (JJ)V */ -void Java_org_rocksdb_BackupEngineOptions_setBackupRateLimiter( +void Java_org_forstdb_BackupEngineOptions_setBackupRateLimiter( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jrate_limiter_handle) { auto* bopt = @@ -234,11 +234,11 @@ void Java_org_rocksdb_BackupEngineOptions_setBackupRateLimiter( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setRestoreRateLimit * Signature: (JJ)V */ -void Java_org_rocksdb_BackupEngineOptions_setRestoreRateLimit( +void Java_org_forstdb_BackupEngineOptions_setRestoreRateLimit( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jrestore_rate_limit) { auto* bopt = @@ -247,11 +247,11 @@ void Java_org_rocksdb_BackupEngineOptions_setRestoreRateLimit( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: restoreRateLimit * Signature: (J)J */ -jlong Java_org_rocksdb_BackupEngineOptions_restoreRateLimit(JNIEnv* /*env*/, +jlong Java_org_forstdb_BackupEngineOptions_restoreRateLimit(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* bopt = @@ -260,11 +260,11 @@ jlong Java_org_rocksdb_BackupEngineOptions_restoreRateLimit(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setRestoreRateLimiter * Signature: (JJ)V */ -void Java_org_rocksdb_BackupEngineOptions_setRestoreRateLimiter( +void Java_org_forstdb_BackupEngineOptions_setRestoreRateLimiter( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jrate_limiter_handle) { auto* bopt = @@ -276,11 +276,11 @@ void Java_org_rocksdb_BackupEngineOptions_setRestoreRateLimiter( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setShareFilesWithChecksum * Signature: (JZ)V */ -void Java_org_rocksdb_BackupEngineOptions_setShareFilesWithChecksum( +void Java_org_forstdb_BackupEngineOptions_setShareFilesWithChecksum( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jboolean flag) { auto* bopt = reinterpret_cast(jhandle); @@ -288,11 +288,11 @@ void Java_org_rocksdb_BackupEngineOptions_setShareFilesWithChecksum( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: shareFilesWithChecksum * Signature: (J)Z */ -jboolean Java_org_rocksdb_BackupEngineOptions_shareFilesWithChecksum( +jboolean Java_org_forstdb_BackupEngineOptions_shareFilesWithChecksum( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* bopt = reinterpret_cast(jhandle); @@ -300,11 +300,11 @@ jboolean Java_org_rocksdb_BackupEngineOptions_shareFilesWithChecksum( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setMaxBackgroundOperations * Signature: (JI)V */ -void Java_org_rocksdb_BackupEngineOptions_setMaxBackgroundOperations( +void Java_org_forstdb_BackupEngineOptions_setMaxBackgroundOperations( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jint max_background_operations) { auto* bopt = @@ -313,11 +313,11 @@ void Java_org_rocksdb_BackupEngineOptions_setMaxBackgroundOperations( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: maxBackgroundOperations * Signature: (J)I */ -jint Java_org_rocksdb_BackupEngineOptions_maxBackgroundOperations( +jint Java_org_forstdb_BackupEngineOptions_maxBackgroundOperations( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* bopt = reinterpret_cast(jhandle); @@ -325,11 +325,11 @@ jint Java_org_rocksdb_BackupEngineOptions_maxBackgroundOperations( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: setCallbackTriggerIntervalSize * Signature: (JJ)V */ -void Java_org_rocksdb_BackupEngineOptions_setCallbackTriggerIntervalSize( +void Java_org_forstdb_BackupEngineOptions_setCallbackTriggerIntervalSize( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jcallback_trigger_interval_size) { auto* bopt = @@ -339,11 +339,11 @@ void Java_org_rocksdb_BackupEngineOptions_setCallbackTriggerIntervalSize( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: callbackTriggerIntervalSize * Signature: (J)J */ -jlong Java_org_rocksdb_BackupEngineOptions_callbackTriggerIntervalSize( +jlong Java_org_forstdb_BackupEngineOptions_callbackTriggerIntervalSize( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* bopt = reinterpret_cast(jhandle); @@ -351,11 +351,11 @@ jlong Java_org_rocksdb_BackupEngineOptions_callbackTriggerIntervalSize( } /* - * Class: org_rocksdb_BackupEngineOptions + * Class: org_forstdb_BackupEngineOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_BackupEngineOptions_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_BackupEngineOptions_disposeInternal(JNIEnv* /*env*/, jobject /*jopt*/, jlong jhandle) { auto* bopt = diff --git a/java/rocksjni/backupenginejni.cc b/java/forstjni/backupenginejni.cc similarity index 86% rename from java/rocksjni/backupenginejni.cc rename to java/forstjni/backupenginejni.cc index 1ba7ea286..2a1876b4c 100644 --- a/java/rocksjni/backupenginejni.cc +++ b/java/forstjni/backupenginejni.cc @@ -10,17 +10,17 @@ #include -#include "include/org_rocksdb_BackupEngine.h" +#include "include/org_forstdb_BackupEngine.h" #include "rocksdb/utilities/backup_engine.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_BackupEngine + * Class: org_forstdb_BackupEngine * Method: open * Signature: (JJ)J */ -jlong Java_org_rocksdb_BackupEngine_open(JNIEnv* env, jclass /*jcls*/, +jlong Java_org_forstdb_BackupEngine_open(JNIEnv* env, jclass /*jcls*/, jlong env_handle, jlong backup_engine_options_handle) { auto* rocks_env = reinterpret_cast(env_handle); @@ -40,11 +40,11 @@ jlong Java_org_rocksdb_BackupEngine_open(JNIEnv* env, jclass /*jcls*/, } /* - * Class: org_rocksdb_BackupEngine + * Class: org_forstdb_BackupEngine * Method: createNewBackup * Signature: (JJZ)V */ -void Java_org_rocksdb_BackupEngine_createNewBackup( +void Java_org_forstdb_BackupEngine_createNewBackup( JNIEnv* env, jobject /*jbe*/, jlong jbe_handle, jlong db_handle, jboolean jflush_before_backup) { auto* db = reinterpret_cast(db_handle); @@ -61,11 +61,11 @@ void Java_org_rocksdb_BackupEngine_createNewBackup( } /* - * Class: org_rocksdb_BackupEngine + * Class: org_forstdb_BackupEngine * Method: createNewBackupWithMetadata * Signature: (JJLjava/lang/String;Z)V */ -void Java_org_rocksdb_BackupEngine_createNewBackupWithMetadata( +void Java_org_forstdb_BackupEngine_createNewBackupWithMetadata( JNIEnv* env, jobject /*jbe*/, jlong jbe_handle, jlong db_handle, jstring japp_metadata, jboolean jflush_before_backup) { auto* db = reinterpret_cast(db_handle); @@ -92,11 +92,11 @@ void Java_org_rocksdb_BackupEngine_createNewBackupWithMetadata( } /* - * Class: org_rocksdb_BackupEngine + * Class: org_forstdb_BackupEngine * Method: getBackupInfo * Signature: (J)Ljava/util/List; */ -jobject Java_org_rocksdb_BackupEngine_getBackupInfo(JNIEnv* env, +jobject Java_org_forstdb_BackupEngine_getBackupInfo(JNIEnv* env, jobject /*jbe*/, jlong jbe_handle) { auto* backup_engine = @@ -107,11 +107,11 @@ jobject Java_org_rocksdb_BackupEngine_getBackupInfo(JNIEnv* env, } /* - * Class: org_rocksdb_BackupEngine + * Class: org_forstdb_BackupEngine * Method: getCorruptedBackups * Signature: (J)[I */ -jintArray Java_org_rocksdb_BackupEngine_getCorruptedBackups(JNIEnv* env, +jintArray Java_org_forstdb_BackupEngine_getCorruptedBackups(JNIEnv* env, jobject /*jbe*/, jlong jbe_handle) { auto* backup_engine = @@ -135,11 +135,11 @@ jintArray Java_org_rocksdb_BackupEngine_getCorruptedBackups(JNIEnv* env, } /* - * Class: org_rocksdb_BackupEngine + * Class: org_forstdb_BackupEngine * Method: garbageCollect * Signature: (J)V */ -void Java_org_rocksdb_BackupEngine_garbageCollect(JNIEnv* env, jobject /*jbe*/, +void Java_org_forstdb_BackupEngine_garbageCollect(JNIEnv* env, jobject /*jbe*/, jlong jbe_handle) { auto* backup_engine = reinterpret_cast(jbe_handle); @@ -153,11 +153,11 @@ void Java_org_rocksdb_BackupEngine_garbageCollect(JNIEnv* env, jobject /*jbe*/, } /* - * Class: org_rocksdb_BackupEngine + * Class: org_forstdb_BackupEngine * Method: purgeOldBackups * Signature: (JI)V */ -void Java_org_rocksdb_BackupEngine_purgeOldBackups(JNIEnv* env, jobject /*jbe*/, +void Java_org_forstdb_BackupEngine_purgeOldBackups(JNIEnv* env, jobject /*jbe*/, jlong jbe_handle, jint jnum_backups_to_keep) { auto* backup_engine = @@ -173,11 +173,11 @@ void Java_org_rocksdb_BackupEngine_purgeOldBackups(JNIEnv* env, jobject /*jbe*/, } /* - * Class: org_rocksdb_BackupEngine + * Class: org_forstdb_BackupEngine * Method: deleteBackup * Signature: (JI)V */ -void Java_org_rocksdb_BackupEngine_deleteBackup(JNIEnv* env, jobject /*jbe*/, +void Java_org_forstdb_BackupEngine_deleteBackup(JNIEnv* env, jobject /*jbe*/, jlong jbe_handle, jint jbackup_id) { auto* backup_engine = @@ -193,11 +193,11 @@ void Java_org_rocksdb_BackupEngine_deleteBackup(JNIEnv* env, jobject /*jbe*/, } /* - * Class: org_rocksdb_BackupEngine + * Class: org_forstdb_BackupEngine * Method: restoreDbFromBackup * Signature: (JILjava/lang/String;Ljava/lang/String;J)V */ -void Java_org_rocksdb_BackupEngine_restoreDbFromBackup( +void Java_org_forstdb_BackupEngine_restoreDbFromBackup( JNIEnv* env, jobject /*jbe*/, jlong jbe_handle, jint jbackup_id, jstring jdb_dir, jstring jwal_dir, jlong jrestore_options_handle) { auto* backup_engine = @@ -230,11 +230,11 @@ void Java_org_rocksdb_BackupEngine_restoreDbFromBackup( } /* - * Class: org_rocksdb_BackupEngine + * Class: org_forstdb_BackupEngine * Method: restoreDbFromLatestBackup * Signature: (JLjava/lang/String;Ljava/lang/String;J)V */ -void Java_org_rocksdb_BackupEngine_restoreDbFromLatestBackup( +void Java_org_forstdb_BackupEngine_restoreDbFromLatestBackup( JNIEnv* env, jobject /*jbe*/, jlong jbe_handle, jstring jdb_dir, jstring jwal_dir, jlong jrestore_options_handle) { auto* backup_engine = @@ -266,11 +266,11 @@ void Java_org_rocksdb_BackupEngine_restoreDbFromLatestBackup( } /* - * Class: org_rocksdb_BackupEngine + * Class: org_forstdb_BackupEngine * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_BackupEngine_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_BackupEngine_disposeInternal(JNIEnv* /*env*/, jobject /*jbe*/, jlong jbe_handle) { auto* be = reinterpret_cast(jbe_handle); diff --git a/java/rocksjni/cache.cc b/java/forstjni/cache.cc similarity index 78% rename from java/rocksjni/cache.cc rename to java/forstjni/cache.cc index 5ca1d5175..a1c863d35 100644 --- a/java/rocksjni/cache.cc +++ b/java/forstjni/cache.cc @@ -8,26 +8,26 @@ #include -#include "include/org_rocksdb_Cache.h" +#include "include/org_forstdb_Cache.h" #include "rocksdb/advanced_cache.h" /* - * Class: org_rocksdb_Cache + * Class: org_forstdb_Cache * Method: getUsage * Signature: (J)J */ -jlong Java_org_rocksdb_Cache_getUsage(JNIEnv*, jclass, jlong jhandle) { +jlong Java_org_forstdb_Cache_getUsage(JNIEnv*, jclass, jlong jhandle) { auto* sptr_cache = reinterpret_cast*>(jhandle); return static_cast(sptr_cache->get()->GetUsage()); } /* - * Class: org_rocksdb_Cache + * Class: org_forstdb_Cache * Method: getPinnedUsage * Signature: (J)J */ -jlong Java_org_rocksdb_Cache_getPinnedUsage(JNIEnv*, jclass, jlong jhandle) { +jlong Java_org_forstdb_Cache_getPinnedUsage(JNIEnv*, jclass, jlong jhandle) { auto* sptr_cache = reinterpret_cast*>(jhandle); return static_cast(sptr_cache->get()->GetPinnedUsage()); diff --git a/java/rocksjni/cassandra_compactionfilterjni.cc b/java/forstjni/cassandra_compactionfilterjni.cc similarity index 78% rename from java/rocksjni/cassandra_compactionfilterjni.cc rename to java/forstjni/cassandra_compactionfilterjni.cc index 25817aeca..805f31051 100644 --- a/java/rocksjni/cassandra_compactionfilterjni.cc +++ b/java/forstjni/cassandra_compactionfilterjni.cc @@ -5,16 +5,16 @@ #include -#include "include/org_rocksdb_CassandraCompactionFilter.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "include/org_forstdb_CassandraCompactionFilter.h" +#include "forstjni/cplusplus_to_java_convert.h" #include "utilities/cassandra/cassandra_compaction_filter.h" /* - * Class: org_rocksdb_CassandraCompactionFilter + * Class: org_forstdb_CassandraCompactionFilter * Method: createNewCassandraCompactionFilter0 * Signature: (ZI)J */ -jlong Java_org_rocksdb_CassandraCompactionFilter_createNewCassandraCompactionFilter0( +jlong Java_org_forstdb_CassandraCompactionFilter_createNewCassandraCompactionFilter0( JNIEnv* /*env*/, jclass /*jcls*/, jboolean purge_ttl_on_expiration, jint gc_grace_period_in_seconds) { auto* compaction_filter = diff --git a/java/rocksjni/cassandra_value_operator.cc b/java/forstjni/cassandra_value_operator.cc similarity index 77% rename from java/rocksjni/cassandra_value_operator.cc rename to java/forstjni/cassandra_value_operator.cc index 6de28c1b1..46f4caae5 100644 --- a/java/rocksjni/cassandra_value_operator.cc +++ b/java/forstjni/cassandra_value_operator.cc @@ -10,7 +10,7 @@ #include #include -#include "include/org_rocksdb_CassandraValueMergeOperator.h" +#include "include/org_forstdb_CassandraValueMergeOperator.h" #include "rocksdb/db.h" #include "rocksdb/memtablerep.h" #include "rocksdb/merge_operator.h" @@ -18,16 +18,16 @@ #include "rocksdb/slice_transform.h" #include "rocksdb/statistics.h" #include "rocksdb/table.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" #include "utilities/cassandra/merge_operator.h" /* - * Class: org_rocksdb_CassandraValueMergeOperator + * Class: org_forstdb_CassandraValueMergeOperator * Method: newSharedCassandraValueMergeOperator * Signature: (II)J */ -jlong Java_org_rocksdb_CassandraValueMergeOperator_newSharedCassandraValueMergeOperator( +jlong Java_org_forstdb_CassandraValueMergeOperator_newSharedCassandraValueMergeOperator( JNIEnv* /*env*/, jclass /*jclazz*/, jint gcGracePeriodInSeconds, jint operands_limit) { auto* op = new std::shared_ptr( @@ -37,11 +37,11 @@ jlong Java_org_rocksdb_CassandraValueMergeOperator_newSharedCassandraValueMergeO } /* - * Class: org_rocksdb_CassandraValueMergeOperator + * Class: org_forstdb_CassandraValueMergeOperator * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_CassandraValueMergeOperator_disposeInternal( +void Java_org_forstdb_CassandraValueMergeOperator_disposeInternal( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* op = reinterpret_cast*>( diff --git a/java/rocksjni/checkpoint.cc b/java/forstjni/checkpoint.cc similarity index 85% rename from java/rocksjni/checkpoint.cc rename to java/forstjni/checkpoint.cc index cef5f3ca8..dd689b5aa 100644 --- a/java/rocksjni/checkpoint.cc +++ b/java/forstjni/checkpoint.cc @@ -14,16 +14,16 @@ #include -#include "include/org_rocksdb_Checkpoint.h" +#include "include/org_forstdb_Checkpoint.h" #include "rocksdb/db.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_Checkpoint + * Class: org_forstdb_Checkpoint * Method: newCheckpoint * Signature: (J)J */ -jlong Java_org_rocksdb_Checkpoint_newCheckpoint(JNIEnv* /*env*/, +jlong Java_org_forstdb_Checkpoint_newCheckpoint(JNIEnv* /*env*/, jclass /*jclazz*/, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -33,11 +33,11 @@ jlong Java_org_rocksdb_Checkpoint_newCheckpoint(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Checkpoint + * Class: org_forstdb_Checkpoint * Method: dispose * Signature: (J)V */ -void Java_org_rocksdb_Checkpoint_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_Checkpoint_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* checkpoint = reinterpret_cast(jhandle); @@ -46,11 +46,11 @@ void Java_org_rocksdb_Checkpoint_disposeInternal(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Checkpoint + * Class: org_forstdb_Checkpoint * Method: createCheckpoint * Signature: (JLjava/lang/String;)V */ -void Java_org_rocksdb_Checkpoint_createCheckpoint(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_Checkpoint_createCheckpoint(JNIEnv* env, jobject /*jobj*/, jlong jcheckpoint_handle, jstring jcheckpoint_path) { const char* checkpoint_path = env->GetStringUTFChars(jcheckpoint_path, 0); @@ -71,11 +71,11 @@ void Java_org_rocksdb_Checkpoint_createCheckpoint(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_Checkpoint + * Class: org_forstdb_Checkpoint * Method: exportColumnFamily * Signature: (JJLjava/lang/String;)Lorg/rocksdb/ExportImportFilesMetaData; */ -jlong Java_org_rocksdb_Checkpoint_exportColumnFamily( +jlong Java_org_forstdb_Checkpoint_exportColumnFamily( JNIEnv* env, jobject /*jobj*/, jlong jcheckpoint_handle, jlong jcolumn_family_handle, jstring jexport_path) { const char* export_path = env->GetStringUTFChars(jexport_path, 0); diff --git a/java/rocksjni/clock_cache.cc b/java/forstjni/clock_cache.cc similarity index 81% rename from java/rocksjni/clock_cache.cc rename to java/forstjni/clock_cache.cc index e04991aa9..e5778d15e 100644 --- a/java/rocksjni/clock_cache.cc +++ b/java/forstjni/clock_cache.cc @@ -10,15 +10,15 @@ #include -#include "include/org_rocksdb_ClockCache.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "include/org_forstdb_ClockCache.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_ClockCache + * Class: org_forstdb_ClockCache * Method: newClockCache * Signature: (JIZ)J */ -jlong Java_org_rocksdb_ClockCache_newClockCache( +jlong Java_org_forstdb_ClockCache_newClockCache( JNIEnv* /*env*/, jclass /*jcls*/, jlong jcapacity, jint jnum_shard_bits, jboolean jstrict_capacity_limit) { auto* sptr_clock_cache = new std::shared_ptr( @@ -29,11 +29,11 @@ jlong Java_org_rocksdb_ClockCache_newClockCache( } /* - * Class: org_rocksdb_ClockCache + * Class: org_forstdb_ClockCache * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_ClockCache_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_ClockCache_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* sptr_clock_cache = diff --git a/java/rocksjni/columnfamilyhandle.cc b/java/forstjni/columnfamilyhandle.cc similarity index 80% rename from java/rocksjni/columnfamilyhandle.cc rename to java/forstjni/columnfamilyhandle.cc index 4140580f0..abca5ff5f 100644 --- a/java/rocksjni/columnfamilyhandle.cc +++ b/java/forstjni/columnfamilyhandle.cc @@ -10,15 +10,15 @@ #include #include -#include "include/org_rocksdb_ColumnFamilyHandle.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_ColumnFamilyHandle.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_ColumnFamilyHandle + * Class: org_forstdb_ColumnFamilyHandle * Method: getName * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_ColumnFamilyHandle_getName(JNIEnv* env, +jbyteArray Java_org_forstdb_ColumnFamilyHandle_getName(JNIEnv* env, jobject /*jobj*/, jlong jhandle) { auto* cfh = reinterpret_cast(jhandle); @@ -27,11 +27,11 @@ jbyteArray Java_org_rocksdb_ColumnFamilyHandle_getName(JNIEnv* env, } /* - * Class: org_rocksdb_ColumnFamilyHandle + * Class: org_forstdb_ColumnFamilyHandle * Method: getID * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyHandle_getID(JNIEnv* /*env*/, +jint Java_org_forstdb_ColumnFamilyHandle_getID(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* cfh = reinterpret_cast(jhandle); @@ -40,11 +40,11 @@ jint Java_org_rocksdb_ColumnFamilyHandle_getID(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_ColumnFamilyHandle + * Class: org_forstdb_ColumnFamilyHandle * Method: getDescriptor * Signature: (J)Lorg/rocksdb/ColumnFamilyDescriptor; */ -jobject Java_org_rocksdb_ColumnFamilyHandle_getDescriptor(JNIEnv* env, +jobject Java_org_forstdb_ColumnFamilyHandle_getDescriptor(JNIEnv* env, jobject /*jobj*/, jlong jhandle) { auto* cfh = reinterpret_cast(jhandle); @@ -59,11 +59,11 @@ jobject Java_org_rocksdb_ColumnFamilyHandle_getDescriptor(JNIEnv* env, } /* - * Class: org_rocksdb_ColumnFamilyHandle + * Class: org_forstdb_ColumnFamilyHandle * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_ColumnFamilyHandle_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_ColumnFamilyHandle_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* cfh = reinterpret_cast(jhandle); diff --git a/java/rocksjni/compact_range_options.cc b/java/forstjni/compact_range_options.cc similarity index 70% rename from java/rocksjni/compact_range_options.cc rename to java/forstjni/compact_range_options.cc index d07263ab6..89d8a9156 100644 --- a/java/rocksjni/compact_range_options.cc +++ b/java/forstjni/compact_range_options.cc @@ -8,10 +8,10 @@ #include -#include "include/org_rocksdb_CompactRangeOptions.h" +#include "include/org_forstdb_CompactRangeOptions.h" #include "rocksdb/options.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" #include "util/coding.h" /** @@ -23,7 +23,7 @@ * maintain the lifetime of these parameters (`full_history_ts_low`, `canceled`) * by including their values in this class. */ -class Java_org_rocksdb_CompactRangeOptions { +class Java_org_forstdb_CompactRangeOptions { public: ROCKSDB_NAMESPACE::CompactRangeOptions compactRangeOptions; @@ -64,229 +64,229 @@ class Java_org_rocksdb_CompactRangeOptions { }; /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: newCompactRangeOptions * Signature: ()J */ -jlong Java_org_rocksdb_CompactRangeOptions_newCompactRangeOptions( +jlong Java_org_forstdb_CompactRangeOptions_newCompactRangeOptions( JNIEnv* /*env*/, jclass /*jclazz*/) { - auto* options = new Java_org_rocksdb_CompactRangeOptions(); + auto* options = new Java_org_forstdb_CompactRangeOptions(); return GET_CPLUSPLUS_POINTER(&options->compactRangeOptions); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: exclusiveManualCompaction * Signature: (J)Z */ -jboolean Java_org_rocksdb_CompactRangeOptions_exclusiveManualCompaction( +jboolean Java_org_forstdb_CompactRangeOptions_exclusiveManualCompaction( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); return static_cast( options->compactRangeOptions.exclusive_manual_compaction); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: setExclusiveManualCompaction * Signature: (JZ)V */ -void Java_org_rocksdb_CompactRangeOptions_setExclusiveManualCompaction( +void Java_org_forstdb_CompactRangeOptions_setExclusiveManualCompaction( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jboolean exclusive_manual_compaction) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); options->compactRangeOptions.exclusive_manual_compaction = static_cast(exclusive_manual_compaction); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: bottommostLevelCompaction * Signature: (J)I */ -jint Java_org_rocksdb_CompactRangeOptions_bottommostLevelCompaction( +jint Java_org_forstdb_CompactRangeOptions_bottommostLevelCompaction( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); return ROCKSDB_NAMESPACE::BottommostLevelCompactionJni:: toJavaBottommostLevelCompaction( options->compactRangeOptions.bottommost_level_compaction); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: setBottommostLevelCompaction * Signature: (JI)V */ -void Java_org_rocksdb_CompactRangeOptions_setBottommostLevelCompaction( +void Java_org_forstdb_CompactRangeOptions_setBottommostLevelCompaction( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jint bottommost_level_compaction) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); options->compactRangeOptions.bottommost_level_compaction = ROCKSDB_NAMESPACE::BottommostLevelCompactionJni:: toCppBottommostLevelCompaction(bottommost_level_compaction); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: changeLevel * Signature: (J)Z */ -jboolean Java_org_rocksdb_CompactRangeOptions_changeLevel(JNIEnv* /*env*/, +jboolean Java_org_forstdb_CompactRangeOptions_changeLevel(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); return static_cast(options->compactRangeOptions.change_level); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: setChangeLevel * Signature: (JZ)V */ -void Java_org_rocksdb_CompactRangeOptions_setChangeLevel( +void Java_org_forstdb_CompactRangeOptions_setChangeLevel( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jboolean change_level) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); options->compactRangeOptions.change_level = static_cast(change_level); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: targetLevel * Signature: (J)I */ -jint Java_org_rocksdb_CompactRangeOptions_targetLevel(JNIEnv* /*env*/, +jint Java_org_forstdb_CompactRangeOptions_targetLevel(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); return static_cast(options->compactRangeOptions.target_level); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: setTargetLevel * Signature: (JI)V */ -void Java_org_rocksdb_CompactRangeOptions_setTargetLevel(JNIEnv* /*env*/, +void Java_org_forstdb_CompactRangeOptions_setTargetLevel(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jint target_level) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); options->compactRangeOptions.target_level = static_cast(target_level); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: targetPathId * Signature: (J)I */ -jint Java_org_rocksdb_CompactRangeOptions_targetPathId(JNIEnv* /*env*/, +jint Java_org_forstdb_CompactRangeOptions_targetPathId(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); return static_cast(options->compactRangeOptions.target_path_id); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: setTargetPathId * Signature: (JI)V */ -void Java_org_rocksdb_CompactRangeOptions_setTargetPathId(JNIEnv* /*env*/, +void Java_org_forstdb_CompactRangeOptions_setTargetPathId(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jint target_path_id) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); options->compactRangeOptions.target_path_id = static_cast(target_path_id); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: allowWriteStall * Signature: (J)Z */ -jboolean Java_org_rocksdb_CompactRangeOptions_allowWriteStall(JNIEnv* /*env*/, +jboolean Java_org_forstdb_CompactRangeOptions_allowWriteStall(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); return static_cast(options->compactRangeOptions.allow_write_stall); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: setAllowWriteStall * Signature: (JZ)V */ -void Java_org_rocksdb_CompactRangeOptions_setAllowWriteStall( +void Java_org_forstdb_CompactRangeOptions_setAllowWriteStall( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jboolean allow_write_stall) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); options->compactRangeOptions.allow_write_stall = static_cast(allow_write_stall); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: maxSubcompactions * Signature: (J)I */ -jint Java_org_rocksdb_CompactRangeOptions_maxSubcompactions(JNIEnv* /*env*/, +jint Java_org_forstdb_CompactRangeOptions_maxSubcompactions(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); return static_cast(options->compactRangeOptions.max_subcompactions); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: setMaxSubcompactions * Signature: (JI)V */ -void Java_org_rocksdb_CompactRangeOptions_setMaxSubcompactions( +void Java_org_forstdb_CompactRangeOptions_setMaxSubcompactions( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jint max_subcompactions) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); options->compactRangeOptions.max_subcompactions = static_cast(max_subcompactions); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: setFullHistoryTSLow * Signature: (JJJ)V */ -void Java_org_rocksdb_CompactRangeOptions_setFullHistoryTSLow(JNIEnv*, jobject, +void Java_org_forstdb_CompactRangeOptions_setFullHistoryTSLow(JNIEnv*, jobject, jlong jhandle, jlong start, jlong range) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); options->set_full_history_ts_low(start, range); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: fullHistoryTSLow * Signature: (J)Lorg/rocksdb/CompactRangeOptions/Timestamp; */ -jobject Java_org_rocksdb_CompactRangeOptions_fullHistoryTSLow(JNIEnv* env, +jobject Java_org_forstdb_CompactRangeOptions_fullHistoryTSLow(JNIEnv* env, jobject, jlong jhandle) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); uint64_t start; uint64_t range; jobject result = nullptr; @@ -300,39 +300,39 @@ jobject Java_org_rocksdb_CompactRangeOptions_fullHistoryTSLow(JNIEnv* env, } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: setCanceled * Signature: (JZ)V */ -void Java_org_rocksdb_CompactRangeOptions_setCanceled(JNIEnv*, jobject, +void Java_org_forstdb_CompactRangeOptions_setCanceled(JNIEnv*, jobject, jlong jhandle, jboolean jcanceled) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); options->set_canceled(jcanceled); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: canceled * Signature: (J)Z */ -jboolean Java_org_rocksdb_CompactRangeOptions_canceled(JNIEnv*, jobject, +jboolean Java_org_forstdb_CompactRangeOptions_canceled(JNIEnv*, jobject, jlong jhandle) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); return options->get_canceled(); } /* - * Class: org_rocksdb_CompactRangeOptions + * Class: org_forstdb_CompactRangeOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_CompactRangeOptions_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_CompactRangeOptions_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* options = - reinterpret_cast(jhandle); + reinterpret_cast(jhandle); delete options; } diff --git a/java/rocksjni/compaction_filter.cc b/java/forstjni/compaction_filter.cc similarity index 83% rename from java/rocksjni/compaction_filter.cc rename to java/forstjni/compaction_filter.cc index ea04996ac..f45234896 100644 --- a/java/rocksjni/compaction_filter.cc +++ b/java/forstjni/compaction_filter.cc @@ -10,16 +10,16 @@ #include -#include "include/org_rocksdb_AbstractCompactionFilter.h" +#include "include/org_forstdb_AbstractCompactionFilter.h" // /* - * Class: org_rocksdb_AbstractCompactionFilter + * Class: org_forstdb_AbstractCompactionFilter * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_AbstractCompactionFilter_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_AbstractCompactionFilter_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { auto* cf = reinterpret_cast(handle); diff --git a/java/rocksjni/compaction_filter_factory.cc b/java/forstjni/compaction_filter_factory.cc similarity index 71% rename from java/rocksjni/compaction_filter_factory.cc rename to java/forstjni/compaction_filter_factory.cc index 16fbdbbdd..5f68420c3 100644 --- a/java/rocksjni/compaction_filter_factory.cc +++ b/java/forstjni/compaction_filter_factory.cc @@ -10,16 +10,16 @@ #include -#include "include/org_rocksdb_AbstractCompactionFilterFactory.h" -#include "rocksjni/compaction_filter_factory_jnicallback.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "include/org_forstdb_AbstractCompactionFilterFactory.h" +#include "forstjni/compaction_filter_factory_jnicallback.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_AbstractCompactionFilterFactory + * Class: org_forstdb_AbstractCompactionFilterFactory * Method: createNewCompactionFilterFactory0 * Signature: ()J */ -jlong Java_org_rocksdb_AbstractCompactionFilterFactory_createNewCompactionFilterFactory0( +jlong Java_org_forstdb_AbstractCompactionFilterFactory_createNewCompactionFilterFactory0( JNIEnv* env, jobject jobj) { auto* cff = new ROCKSDB_NAMESPACE::CompactionFilterFactoryJniCallback(env, jobj); @@ -29,11 +29,11 @@ jlong Java_org_rocksdb_AbstractCompactionFilterFactory_createNewCompactionFilter } /* - * Class: org_rocksdb_AbstractCompactionFilterFactory + * Class: org_forstdb_AbstractCompactionFilterFactory * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_AbstractCompactionFilterFactory_disposeInternal( +void Java_org_forstdb_AbstractCompactionFilterFactory_disposeInternal( JNIEnv*, jobject, jlong jhandle) { auto* ptr_sptr_cff = reinterpret_cast< std::shared_ptr*>( diff --git a/java/rocksjni/compaction_filter_factory_jnicallback.cc b/java/forstjni/compaction_filter_factory_jnicallback.cc similarity index 96% rename from java/rocksjni/compaction_filter_factory_jnicallback.cc rename to java/forstjni/compaction_filter_factory_jnicallback.cc index 14285526f..ccf08eb0b 100644 --- a/java/rocksjni/compaction_filter_factory_jnicallback.cc +++ b/java/forstjni/compaction_filter_factory_jnicallback.cc @@ -6,9 +6,9 @@ // This file implements the callback "bridge" between Java and C++ for // ROCKSDB_NAMESPACE::CompactionFilterFactory. -#include "rocksjni/compaction_filter_factory_jnicallback.h" +#include "forstjni/compaction_filter_factory_jnicallback.h" -#include "rocksjni/portal.h" +#include "forstjni/portal.h" namespace ROCKSDB_NAMESPACE { CompactionFilterFactoryJniCallback::CompactionFilterFactoryJniCallback( diff --git a/java/rocksjni/compaction_filter_factory_jnicallback.h b/java/forstjni/compaction_filter_factory_jnicallback.h similarity index 97% rename from java/rocksjni/compaction_filter_factory_jnicallback.h rename to java/forstjni/compaction_filter_factory_jnicallback.h index 2f26f8dbe..c8f1e718b 100644 --- a/java/rocksjni/compaction_filter_factory_jnicallback.h +++ b/java/forstjni/compaction_filter_factory_jnicallback.h @@ -14,7 +14,7 @@ #include #include "rocksdb/compaction_filter.h" -#include "rocksjni/jnicallback.h" +#include "forstjni/jnicallback.h" namespace ROCKSDB_NAMESPACE { diff --git a/java/rocksjni/compaction_job_info.cc b/java/forstjni/compaction_job_info.cc similarity index 79% rename from java/rocksjni/compaction_job_info.cc rename to java/forstjni/compaction_job_info.cc index fb292f59c..b6bef26e1 100644 --- a/java/rocksjni/compaction_job_info.cc +++ b/java/forstjni/compaction_job_info.cc @@ -8,27 +8,27 @@ #include -#include "include/org_rocksdb_CompactionJobInfo.h" +#include "include/org_forstdb_CompactionJobInfo.h" #include "rocksdb/listener.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: newCompactionJobInfo * Signature: ()J */ -jlong Java_org_rocksdb_CompactionJobInfo_newCompactionJobInfo(JNIEnv*, jclass) { +jlong Java_org_forstdb_CompactionJobInfo_newCompactionJobInfo(JNIEnv*, jclass) { auto* compact_job_info = new ROCKSDB_NAMESPACE::CompactionJobInfo(); return GET_CPLUSPLUS_POINTER(compact_job_info); } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_CompactionJobInfo_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_CompactionJobInfo_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); @@ -36,11 +36,11 @@ void Java_org_rocksdb_CompactionJobInfo_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: columnFamilyName * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_CompactionJobInfo_columnFamilyName(JNIEnv* env, +jbyteArray Java_org_forstdb_CompactionJobInfo_columnFamilyName(JNIEnv* env, jclass, jlong jhandle) { auto* compact_job_info = @@ -49,11 +49,11 @@ jbyteArray Java_org_rocksdb_CompactionJobInfo_columnFamilyName(JNIEnv* env, } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: status * Signature: (J)Lorg/rocksdb/Status; */ -jobject Java_org_rocksdb_CompactionJobInfo_status(JNIEnv* env, jclass, +jobject Java_org_forstdb_CompactionJobInfo_status(JNIEnv* env, jclass, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); @@ -61,11 +61,11 @@ jobject Java_org_rocksdb_CompactionJobInfo_status(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: threadId * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobInfo_threadId(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobInfo_threadId(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); @@ -73,22 +73,22 @@ jlong Java_org_rocksdb_CompactionJobInfo_threadId(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: jobId * Signature: (J)I */ -jint Java_org_rocksdb_CompactionJobInfo_jobId(JNIEnv*, jclass, jlong jhandle) { +jint Java_org_forstdb_CompactionJobInfo_jobId(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); return static_cast(compact_job_info->job_id); } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: baseInputLevel * Signature: (J)I */ -jint Java_org_rocksdb_CompactionJobInfo_baseInputLevel(JNIEnv*, jclass, +jint Java_org_forstdb_CompactionJobInfo_baseInputLevel(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); @@ -96,11 +96,11 @@ jint Java_org_rocksdb_CompactionJobInfo_baseInputLevel(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: outputLevel * Signature: (J)I */ -jint Java_org_rocksdb_CompactionJobInfo_outputLevel(JNIEnv*, jclass, +jint Java_org_forstdb_CompactionJobInfo_outputLevel(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); @@ -108,11 +108,11 @@ jint Java_org_rocksdb_CompactionJobInfo_outputLevel(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: inputFiles * Signature: (J)[Ljava/lang/String; */ -jobjectArray Java_org_rocksdb_CompactionJobInfo_inputFiles(JNIEnv* env, jclass, +jobjectArray Java_org_forstdb_CompactionJobInfo_inputFiles(JNIEnv* env, jclass, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); @@ -121,11 +121,11 @@ jobjectArray Java_org_rocksdb_CompactionJobInfo_inputFiles(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: outputFiles * Signature: (J)[Ljava/lang/String; */ -jobjectArray Java_org_rocksdb_CompactionJobInfo_outputFiles(JNIEnv* env, jclass, +jobjectArray Java_org_forstdb_CompactionJobInfo_outputFiles(JNIEnv* env, jclass, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); @@ -134,11 +134,11 @@ jobjectArray Java_org_rocksdb_CompactionJobInfo_outputFiles(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: tableProperties * Signature: (J)Ljava/util/Map; */ -jobject Java_org_rocksdb_CompactionJobInfo_tableProperties(JNIEnv* env, jclass, +jobject Java_org_forstdb_CompactionJobInfo_tableProperties(JNIEnv* env, jclass, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); @@ -191,11 +191,11 @@ jobject Java_org_rocksdb_CompactionJobInfo_tableProperties(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: compactionReason * Signature: (J)B */ -jbyte Java_org_rocksdb_CompactionJobInfo_compactionReason(JNIEnv*, jclass, +jbyte Java_org_forstdb_CompactionJobInfo_compactionReason(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); @@ -204,11 +204,11 @@ jbyte Java_org_rocksdb_CompactionJobInfo_compactionReason(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: compression * Signature: (J)B */ -jbyte Java_org_rocksdb_CompactionJobInfo_compression(JNIEnv*, jclass, +jbyte Java_org_forstdb_CompactionJobInfo_compression(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); @@ -217,11 +217,11 @@ jbyte Java_org_rocksdb_CompactionJobInfo_compression(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobInfo + * Class: org_forstdb_CompactionJobInfo * Method: stats * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobInfo_stats(JNIEnv*, jclass, jlong jhandle) { +jlong Java_org_forstdb_CompactionJobInfo_stats(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_info = reinterpret_cast(jhandle); auto* stats = new ROCKSDB_NAMESPACE::CompactionJobStats(); diff --git a/java/rocksjni/compaction_job_stats.cc b/java/forstjni/compaction_job_stats.cc similarity index 74% rename from java/rocksjni/compaction_job_stats.cc rename to java/forstjni/compaction_job_stats.cc index a2599c132..ca009e4af 100644 --- a/java/rocksjni/compaction_job_stats.cc +++ b/java/forstjni/compaction_job_stats.cc @@ -10,27 +10,27 @@ #include -#include "include/org_rocksdb_CompactionJobStats.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_CompactionJobStats.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: newCompactionJobStats * Signature: ()J */ -jlong Java_org_rocksdb_CompactionJobStats_newCompactionJobStats(JNIEnv*, +jlong Java_org_forstdb_CompactionJobStats_newCompactionJobStats(JNIEnv*, jclass) { auto* compact_job_stats = new ROCKSDB_NAMESPACE::CompactionJobStats(); return GET_CPLUSPLUS_POINTER(compact_job_stats); } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_CompactionJobStats_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_CompactionJobStats_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -38,22 +38,22 @@ void Java_org_rocksdb_CompactionJobStats_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: reset * Signature: (J)V */ -void Java_org_rocksdb_CompactionJobStats_reset(JNIEnv*, jclass, jlong jhandle) { +void Java_org_forstdb_CompactionJobStats_reset(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); compact_job_stats->Reset(); } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: add * Signature: (JJ)V */ -void Java_org_rocksdb_CompactionJobStats_add(JNIEnv*, jclass, jlong jhandle, +void Java_org_forstdb_CompactionJobStats_add(JNIEnv*, jclass, jlong jhandle, jlong jother_handle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -63,11 +63,11 @@ void Java_org_rocksdb_CompactionJobStats_add(JNIEnv*, jclass, jlong jhandle, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: elapsedMicros * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_elapsedMicros(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_elapsedMicros(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -75,11 +75,11 @@ jlong Java_org_rocksdb_CompactionJobStats_elapsedMicros(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: numInputRecords * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_numInputRecords(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_numInputRecords(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -87,11 +87,11 @@ jlong Java_org_rocksdb_CompactionJobStats_numInputRecords(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: numInputFiles * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_numInputFiles(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_numInputFiles(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -99,11 +99,11 @@ jlong Java_org_rocksdb_CompactionJobStats_numInputFiles(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: numInputFilesAtOutputLevel * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_numInputFilesAtOutputLevel( +jlong Java_org_forstdb_CompactionJobStats_numInputFilesAtOutputLevel( JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -111,11 +111,11 @@ jlong Java_org_rocksdb_CompactionJobStats_numInputFilesAtOutputLevel( } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: numOutputRecords * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_numOutputRecords(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_numOutputRecords(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -123,11 +123,11 @@ jlong Java_org_rocksdb_CompactionJobStats_numOutputRecords(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: numOutputFiles * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_numOutputFiles(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_numOutputFiles(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -135,11 +135,11 @@ jlong Java_org_rocksdb_CompactionJobStats_numOutputFiles(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: isManualCompaction * Signature: (J)Z */ -jboolean Java_org_rocksdb_CompactionJobStats_isManualCompaction(JNIEnv*, jclass, +jboolean Java_org_forstdb_CompactionJobStats_isManualCompaction(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -151,11 +151,11 @@ jboolean Java_org_rocksdb_CompactionJobStats_isManualCompaction(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: totalInputBytes * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_totalInputBytes(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_totalInputBytes(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -163,11 +163,11 @@ jlong Java_org_rocksdb_CompactionJobStats_totalInputBytes(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: totalOutputBytes * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_totalOutputBytes(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_totalOutputBytes(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -175,11 +175,11 @@ jlong Java_org_rocksdb_CompactionJobStats_totalOutputBytes(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: numRecordsReplaced * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_numRecordsReplaced(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_numRecordsReplaced(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -187,11 +187,11 @@ jlong Java_org_rocksdb_CompactionJobStats_numRecordsReplaced(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: totalInputRawKeyBytes * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_totalInputRawKeyBytes(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_totalInputRawKeyBytes(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -199,11 +199,11 @@ jlong Java_org_rocksdb_CompactionJobStats_totalInputRawKeyBytes(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: totalInputRawValueBytes * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_totalInputRawValueBytes( +jlong Java_org_forstdb_CompactionJobStats_totalInputRawValueBytes( JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -211,11 +211,11 @@ jlong Java_org_rocksdb_CompactionJobStats_totalInputRawValueBytes( } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: numInputDeletionRecords * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_numInputDeletionRecords( +jlong Java_org_forstdb_CompactionJobStats_numInputDeletionRecords( JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -223,11 +223,11 @@ jlong Java_org_rocksdb_CompactionJobStats_numInputDeletionRecords( } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: numExpiredDeletionRecords * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_numExpiredDeletionRecords( +jlong Java_org_forstdb_CompactionJobStats_numExpiredDeletionRecords( JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -235,11 +235,11 @@ jlong Java_org_rocksdb_CompactionJobStats_numExpiredDeletionRecords( } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: numCorruptKeys * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_numCorruptKeys(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_numCorruptKeys(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -247,11 +247,11 @@ jlong Java_org_rocksdb_CompactionJobStats_numCorruptKeys(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: fileWriteNanos * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_fileWriteNanos(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_fileWriteNanos(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -259,11 +259,11 @@ jlong Java_org_rocksdb_CompactionJobStats_fileWriteNanos(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: fileRangeSyncNanos * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_fileRangeSyncNanos(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_fileRangeSyncNanos(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -271,11 +271,11 @@ jlong Java_org_rocksdb_CompactionJobStats_fileRangeSyncNanos(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: fileFsyncNanos * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_fileFsyncNanos(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_fileFsyncNanos(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -283,11 +283,11 @@ jlong Java_org_rocksdb_CompactionJobStats_fileFsyncNanos(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: filePrepareWriteNanos * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_filePrepareWriteNanos(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_filePrepareWriteNanos(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -295,11 +295,11 @@ jlong Java_org_rocksdb_CompactionJobStats_filePrepareWriteNanos(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: smallestOutputKeyPrefix * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_CompactionJobStats_smallestOutputKeyPrefix( +jbyteArray Java_org_forstdb_CompactionJobStats_smallestOutputKeyPrefix( JNIEnv* env, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -308,11 +308,11 @@ jbyteArray Java_org_rocksdb_CompactionJobStats_smallestOutputKeyPrefix( } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: largestOutputKeyPrefix * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_CompactionJobStats_largestOutputKeyPrefix( +jbyteArray Java_org_forstdb_CompactionJobStats_largestOutputKeyPrefix( JNIEnv* env, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -321,11 +321,11 @@ jbyteArray Java_org_rocksdb_CompactionJobStats_largestOutputKeyPrefix( } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: numSingleDelFallthru * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_numSingleDelFallthru(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_numSingleDelFallthru(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); @@ -333,11 +333,11 @@ jlong Java_org_rocksdb_CompactionJobStats_numSingleDelFallthru(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionJobStats + * Class: org_forstdb_CompactionJobStats * Method: numSingleDelMismatch * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionJobStats_numSingleDelMismatch(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionJobStats_numSingleDelMismatch(JNIEnv*, jclass, jlong jhandle) { auto* compact_job_stats = reinterpret_cast(jhandle); diff --git a/java/rocksjni/compaction_options.cc b/java/forstjni/compaction_options.cc similarity index 74% rename from java/rocksjni/compaction_options.cc rename to java/forstjni/compaction_options.cc index bbbde0313..0cf3e92df 100644 --- a/java/rocksjni/compaction_options.cc +++ b/java/forstjni/compaction_options.cc @@ -8,27 +8,27 @@ #include -#include "include/org_rocksdb_CompactionOptions.h" +#include "include/org_forstdb_CompactionOptions.h" #include "rocksdb/options.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_CompactionOptions + * Class: org_forstdb_CompactionOptions * Method: newCompactionOptions * Signature: ()J */ -jlong Java_org_rocksdb_CompactionOptions_newCompactionOptions(JNIEnv*, jclass) { +jlong Java_org_forstdb_CompactionOptions_newCompactionOptions(JNIEnv*, jclass) { auto* compact_opts = new ROCKSDB_NAMESPACE::CompactionOptions(); return GET_CPLUSPLUS_POINTER(compact_opts); } /* - * Class: org_rocksdb_CompactionOptions + * Class: org_forstdb_CompactionOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_CompactionOptions_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_CompactionOptions_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* compact_opts = reinterpret_cast(jhandle); @@ -36,11 +36,11 @@ void Java_org_rocksdb_CompactionOptions_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompactionOptions + * Class: org_forstdb_CompactionOptions * Method: compression * Signature: (J)B */ -jbyte Java_org_rocksdb_CompactionOptions_compression(JNIEnv*, jclass, +jbyte Java_org_forstdb_CompactionOptions_compression(JNIEnv*, jclass, jlong jhandle) { auto* compact_opts = reinterpret_cast(jhandle); @@ -49,11 +49,11 @@ jbyte Java_org_rocksdb_CompactionOptions_compression(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionOptions + * Class: org_forstdb_CompactionOptions * Method: setCompression * Signature: (JB)V */ -void Java_org_rocksdb_CompactionOptions_setCompression( +void Java_org_forstdb_CompactionOptions_setCompression( JNIEnv*, jclass, jlong jhandle, jbyte jcompression_type_value) { auto* compact_opts = reinterpret_cast(jhandle); @@ -63,11 +63,11 @@ void Java_org_rocksdb_CompactionOptions_setCompression( } /* - * Class: org_rocksdb_CompactionOptions + * Class: org_forstdb_CompactionOptions * Method: outputFileSizeLimit * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionOptions_outputFileSizeLimit(JNIEnv*, jclass, +jlong Java_org_forstdb_CompactionOptions_outputFileSizeLimit(JNIEnv*, jclass, jlong jhandle) { auto* compact_opts = reinterpret_cast(jhandle); @@ -75,11 +75,11 @@ jlong Java_org_rocksdb_CompactionOptions_outputFileSizeLimit(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionOptions + * Class: org_forstdb_CompactionOptions * Method: setOutputFileSizeLimit * Signature: (JJ)V */ -void Java_org_rocksdb_CompactionOptions_setOutputFileSizeLimit( +void Java_org_forstdb_CompactionOptions_setOutputFileSizeLimit( JNIEnv*, jclass, jlong jhandle, jlong joutput_file_size_limit) { auto* compact_opts = reinterpret_cast(jhandle); @@ -88,11 +88,11 @@ void Java_org_rocksdb_CompactionOptions_setOutputFileSizeLimit( } /* - * Class: org_rocksdb_CompactionOptions + * Class: org_forstdb_CompactionOptions * Method: maxSubcompactions * Signature: (J)I */ -jint Java_org_rocksdb_CompactionOptions_maxSubcompactions(JNIEnv*, jclass, +jint Java_org_forstdb_CompactionOptions_maxSubcompactions(JNIEnv*, jclass, jlong jhandle) { auto* compact_opts = reinterpret_cast(jhandle); @@ -100,11 +100,11 @@ jint Java_org_rocksdb_CompactionOptions_maxSubcompactions(JNIEnv*, jclass, } /* - * Class: org_rocksdb_CompactionOptions + * Class: org_forstdb_CompactionOptions * Method: setMaxSubcompactions * Signature: (JI)V */ -void Java_org_rocksdb_CompactionOptions_setMaxSubcompactions( +void Java_org_forstdb_CompactionOptions_setMaxSubcompactions( JNIEnv*, jclass, jlong jhandle, jint jmax_subcompactions) { auto* compact_opts = reinterpret_cast(jhandle); diff --git a/java/rocksjni/compaction_options_fifo.cc b/java/forstjni/compaction_options_fifo.cc similarity index 73% rename from java/rocksjni/compaction_options_fifo.cc rename to java/forstjni/compaction_options_fifo.cc index f6a47fec5..3a4bf5c25 100644 --- a/java/rocksjni/compaction_options_fifo.cc +++ b/java/forstjni/compaction_options_fifo.cc @@ -8,27 +8,27 @@ #include -#include "include/org_rocksdb_CompactionOptionsFIFO.h" +#include "include/org_forstdb_CompactionOptionsFIFO.h" #include "rocksdb/advanced_options.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_CompactionOptionsFIFO + * Class: org_forstdb_CompactionOptionsFIFO * Method: newCompactionOptionsFIFO * Signature: ()J */ -jlong Java_org_rocksdb_CompactionOptionsFIFO_newCompactionOptionsFIFO(JNIEnv*, +jlong Java_org_forstdb_CompactionOptionsFIFO_newCompactionOptionsFIFO(JNIEnv*, jclass) { const auto* opt = new ROCKSDB_NAMESPACE::CompactionOptionsFIFO(); return GET_CPLUSPLUS_POINTER(opt); } /* - * Class: org_rocksdb_CompactionOptionsFIFO + * Class: org_forstdb_CompactionOptionsFIFO * Method: setMaxTableFilesSize * Signature: (JJ)V */ -void Java_org_rocksdb_CompactionOptionsFIFO_setMaxTableFilesSize( +void Java_org_forstdb_CompactionOptionsFIFO_setMaxTableFilesSize( JNIEnv*, jobject, jlong jhandle, jlong jmax_table_files_size) { auto* opt = reinterpret_cast(jhandle); @@ -36,11 +36,11 @@ void Java_org_rocksdb_CompactionOptionsFIFO_setMaxTableFilesSize( } /* - * Class: org_rocksdb_CompactionOptionsFIFO + * Class: org_forstdb_CompactionOptionsFIFO * Method: maxTableFilesSize * Signature: (J)J */ -jlong Java_org_rocksdb_CompactionOptionsFIFO_maxTableFilesSize(JNIEnv*, jobject, +jlong Java_org_forstdb_CompactionOptionsFIFO_maxTableFilesSize(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); @@ -48,11 +48,11 @@ jlong Java_org_rocksdb_CompactionOptionsFIFO_maxTableFilesSize(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompactionOptionsFIFO + * Class: org_forstdb_CompactionOptionsFIFO * Method: setAllowCompaction * Signature: (JZ)V */ -void Java_org_rocksdb_CompactionOptionsFIFO_setAllowCompaction( +void Java_org_forstdb_CompactionOptionsFIFO_setAllowCompaction( JNIEnv*, jobject, jlong jhandle, jboolean allow_compaction) { auto* opt = reinterpret_cast(jhandle); @@ -60,11 +60,11 @@ void Java_org_rocksdb_CompactionOptionsFIFO_setAllowCompaction( } /* - * Class: org_rocksdb_CompactionOptionsFIFO + * Class: org_forstdb_CompactionOptionsFIFO * Method: allowCompaction * Signature: (J)Z */ -jboolean Java_org_rocksdb_CompactionOptionsFIFO_allowCompaction(JNIEnv*, +jboolean Java_org_forstdb_CompactionOptionsFIFO_allowCompaction(JNIEnv*, jobject, jlong jhandle) { auto* opt = @@ -73,11 +73,11 @@ jboolean Java_org_rocksdb_CompactionOptionsFIFO_allowCompaction(JNIEnv*, } /* - * Class: org_rocksdb_CompactionOptionsFIFO + * Class: org_forstdb_CompactionOptionsFIFO * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_CompactionOptionsFIFO_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_CompactionOptionsFIFO_disposeInternal(JNIEnv*, jobject, jlong jhandle) { delete reinterpret_cast(jhandle); } diff --git a/java/rocksjni/compaction_options_universal.cc b/java/forstjni/compaction_options_universal.cc similarity index 71% rename from java/rocksjni/compaction_options_universal.cc rename to java/forstjni/compaction_options_universal.cc index 9fc6f3158..c2fb1d6d4 100644 --- a/java/rocksjni/compaction_options_universal.cc +++ b/java/forstjni/compaction_options_universal.cc @@ -8,28 +8,28 @@ #include -#include "include/org_rocksdb_CompactionOptionsUniversal.h" +#include "include/org_forstdb_CompactionOptionsUniversal.h" #include "rocksdb/advanced_options.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: newCompactionOptionsUniversal * Signature: ()J */ -jlong Java_org_rocksdb_CompactionOptionsUniversal_newCompactionOptionsUniversal( +jlong Java_org_forstdb_CompactionOptionsUniversal_newCompactionOptionsUniversal( JNIEnv*, jclass) { const auto* opt = new ROCKSDB_NAMESPACE::CompactionOptionsUniversal(); return GET_CPLUSPLUS_POINTER(opt); } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: setSizeRatio * Signature: (JI)V */ -void Java_org_rocksdb_CompactionOptionsUniversal_setSizeRatio( +void Java_org_forstdb_CompactionOptionsUniversal_setSizeRatio( JNIEnv*, jobject, jlong jhandle, jint jsize_ratio) { auto* opt = reinterpret_cast(jhandle); @@ -37,11 +37,11 @@ void Java_org_rocksdb_CompactionOptionsUniversal_setSizeRatio( } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: sizeRatio * Signature: (J)I */ -jint Java_org_rocksdb_CompactionOptionsUniversal_sizeRatio(JNIEnv*, jobject, +jint Java_org_forstdb_CompactionOptionsUniversal_sizeRatio(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); @@ -49,11 +49,11 @@ jint Java_org_rocksdb_CompactionOptionsUniversal_sizeRatio(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: setMinMergeWidth * Signature: (JI)V */ -void Java_org_rocksdb_CompactionOptionsUniversal_setMinMergeWidth( +void Java_org_forstdb_CompactionOptionsUniversal_setMinMergeWidth( JNIEnv*, jobject, jlong jhandle, jint jmin_merge_width) { auto* opt = reinterpret_cast(jhandle); @@ -61,11 +61,11 @@ void Java_org_rocksdb_CompactionOptionsUniversal_setMinMergeWidth( } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: minMergeWidth * Signature: (J)I */ -jint Java_org_rocksdb_CompactionOptionsUniversal_minMergeWidth(JNIEnv*, jobject, +jint Java_org_forstdb_CompactionOptionsUniversal_minMergeWidth(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); @@ -73,11 +73,11 @@ jint Java_org_rocksdb_CompactionOptionsUniversal_minMergeWidth(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: setMaxMergeWidth * Signature: (JI)V */ -void Java_org_rocksdb_CompactionOptionsUniversal_setMaxMergeWidth( +void Java_org_forstdb_CompactionOptionsUniversal_setMaxMergeWidth( JNIEnv*, jobject, jlong jhandle, jint jmax_merge_width) { auto* opt = reinterpret_cast(jhandle); @@ -85,11 +85,11 @@ void Java_org_rocksdb_CompactionOptionsUniversal_setMaxMergeWidth( } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: maxMergeWidth * Signature: (J)I */ -jint Java_org_rocksdb_CompactionOptionsUniversal_maxMergeWidth(JNIEnv*, jobject, +jint Java_org_forstdb_CompactionOptionsUniversal_maxMergeWidth(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); @@ -97,11 +97,11 @@ jint Java_org_rocksdb_CompactionOptionsUniversal_maxMergeWidth(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: setMaxSizeAmplificationPercent * Signature: (JI)V */ -void Java_org_rocksdb_CompactionOptionsUniversal_setMaxSizeAmplificationPercent( +void Java_org_forstdb_CompactionOptionsUniversal_setMaxSizeAmplificationPercent( JNIEnv*, jobject, jlong jhandle, jint jmax_size_amplification_percent) { auto* opt = reinterpret_cast(jhandle); @@ -110,11 +110,11 @@ void Java_org_rocksdb_CompactionOptionsUniversal_setMaxSizeAmplificationPercent( } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: maxSizeAmplificationPercent * Signature: (J)I */ -jint Java_org_rocksdb_CompactionOptionsUniversal_maxSizeAmplificationPercent( +jint Java_org_forstdb_CompactionOptionsUniversal_maxSizeAmplificationPercent( JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); @@ -122,11 +122,11 @@ jint Java_org_rocksdb_CompactionOptionsUniversal_maxSizeAmplificationPercent( } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: setCompressionSizePercent * Signature: (JI)V */ -void Java_org_rocksdb_CompactionOptionsUniversal_setCompressionSizePercent( +void Java_org_forstdb_CompactionOptionsUniversal_setCompressionSizePercent( JNIEnv*, jobject, jlong jhandle, jint jcompression_size_percent) { auto* opt = reinterpret_cast(jhandle); @@ -135,11 +135,11 @@ void Java_org_rocksdb_CompactionOptionsUniversal_setCompressionSizePercent( } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: compressionSizePercent * Signature: (J)I */ -jint Java_org_rocksdb_CompactionOptionsUniversal_compressionSizePercent( +jint Java_org_forstdb_CompactionOptionsUniversal_compressionSizePercent( JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); @@ -147,11 +147,11 @@ jint Java_org_rocksdb_CompactionOptionsUniversal_compressionSizePercent( } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: setStopStyle * Signature: (JB)V */ -void Java_org_rocksdb_CompactionOptionsUniversal_setStopStyle( +void Java_org_forstdb_CompactionOptionsUniversal_setStopStyle( JNIEnv*, jobject, jlong jhandle, jbyte jstop_style_value) { auto* opt = reinterpret_cast(jhandle); @@ -161,11 +161,11 @@ void Java_org_rocksdb_CompactionOptionsUniversal_setStopStyle( } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: stopStyle * Signature: (J)B */ -jbyte Java_org_rocksdb_CompactionOptionsUniversal_stopStyle(JNIEnv*, jobject, +jbyte Java_org_forstdb_CompactionOptionsUniversal_stopStyle(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); @@ -174,11 +174,11 @@ jbyte Java_org_rocksdb_CompactionOptionsUniversal_stopStyle(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: setAllowTrivialMove * Signature: (JZ)V */ -void Java_org_rocksdb_CompactionOptionsUniversal_setAllowTrivialMove( +void Java_org_forstdb_CompactionOptionsUniversal_setAllowTrivialMove( JNIEnv*, jobject, jlong jhandle, jboolean jallow_trivial_move) { auto* opt = reinterpret_cast(jhandle); @@ -186,11 +186,11 @@ void Java_org_rocksdb_CompactionOptionsUniversal_setAllowTrivialMove( } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: allowTrivialMove * Signature: (J)Z */ -jboolean Java_org_rocksdb_CompactionOptionsUniversal_allowTrivialMove( +jboolean Java_org_forstdb_CompactionOptionsUniversal_allowTrivialMove( JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); @@ -198,11 +198,11 @@ jboolean Java_org_rocksdb_CompactionOptionsUniversal_allowTrivialMove( } /* - * Class: org_rocksdb_CompactionOptionsUniversal + * Class: org_forstdb_CompactionOptionsUniversal * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_CompactionOptionsUniversal_disposeInternal( +void Java_org_forstdb_CompactionOptionsUniversal_disposeInternal( JNIEnv*, jobject, jlong jhandle) { delete reinterpret_cast( jhandle); diff --git a/java/rocksjni/comparator.cc b/java/forstjni/comparator.cc similarity index 71% rename from java/rocksjni/comparator.cc rename to java/forstjni/comparator.cc index 11279c4ce..0e69990cf 100644 --- a/java/rocksjni/comparator.cc +++ b/java/forstjni/comparator.cc @@ -13,18 +13,18 @@ #include #include -#include "include/org_rocksdb_AbstractComparator.h" -#include "include/org_rocksdb_NativeComparatorWrapper.h" -#include "rocksjni/comparatorjnicallback.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_AbstractComparator.h" +#include "include/org_forstdb_NativeComparatorWrapper.h" +#include "forstjni/comparatorjnicallback.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_AbstractComparator + * Class: org_forstdb_AbstractComparator * Method: createNewComparator * Signature: (J)J */ -jlong Java_org_rocksdb_AbstractComparator_createNewComparator( +jlong Java_org_forstdb_AbstractComparator_createNewComparator( JNIEnv* env, jobject jcomparator, jlong copt_handle) { auto* copt = reinterpret_cast( @@ -35,11 +35,11 @@ jlong Java_org_rocksdb_AbstractComparator_createNewComparator( } /* - * Class: org_rocksdb_AbstractComparator + * Class: org_forstdb_AbstractComparator * Method: usingDirectBuffers * Signature: (J)Z */ -jboolean Java_org_rocksdb_AbstractComparator_usingDirectBuffers(JNIEnv*, +jboolean Java_org_forstdb_AbstractComparator_usingDirectBuffers(JNIEnv*, jobject, jlong jhandle) { auto* c = @@ -48,11 +48,11 @@ jboolean Java_org_rocksdb_AbstractComparator_usingDirectBuffers(JNIEnv*, } /* - * Class: org_rocksdb_NativeComparatorWrapper + * Class: org_forstdb_NativeComparatorWrapper * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_NativeComparatorWrapper_disposeInternal( +void Java_org_forstdb_NativeComparatorWrapper_disposeInternal( JNIEnv* /*env*/, jobject /*jobj*/, jlong jcomparator_handle) { auto* comparator = reinterpret_cast(jcomparator_handle); diff --git a/java/rocksjni/comparatorjnicallback.cc b/java/forstjni/comparatorjnicallback.cc similarity index 99% rename from java/rocksjni/comparatorjnicallback.cc rename to java/forstjni/comparatorjnicallback.cc index d354b40b8..775399223 100644 --- a/java/rocksjni/comparatorjnicallback.cc +++ b/java/forstjni/comparatorjnicallback.cc @@ -6,9 +6,9 @@ // This file implements the callback "bridge" between Java and C++ for // ROCKSDB_NAMESPACE::Comparator. -#include "rocksjni/comparatorjnicallback.h" +#include "forstjni/comparatorjnicallback.h" -#include "rocksjni/portal.h" +#include "forstjni/portal.h" namespace ROCKSDB_NAMESPACE { ComparatorJniCallback::ComparatorJniCallback( diff --git a/java/rocksjni/comparatorjnicallback.h b/java/forstjni/comparatorjnicallback.h similarity index 99% rename from java/rocksjni/comparatorjnicallback.h rename to java/forstjni/comparatorjnicallback.h index 034c0d5d7..671d2a3a8 100644 --- a/java/rocksjni/comparatorjnicallback.h +++ b/java/forstjni/comparatorjnicallback.h @@ -17,7 +17,7 @@ #include "port/port.h" #include "rocksdb/comparator.h" #include "rocksdb/slice.h" -#include "rocksjni/jnicallback.h" +#include "forstjni/jnicallback.h" #include "util/thread_local.h" namespace ROCKSDB_NAMESPACE { diff --git a/java/rocksjni/compression_options.cc b/java/forstjni/compression_options.cc similarity index 73% rename from java/rocksjni/compression_options.cc rename to java/forstjni/compression_options.cc index 53f240560..702dcb8de 100644 --- a/java/rocksjni/compression_options.cc +++ b/java/forstjni/compression_options.cc @@ -8,27 +8,27 @@ #include -#include "include/org_rocksdb_CompressionOptions.h" +#include "include/org_forstdb_CompressionOptions.h" #include "rocksdb/advanced_options.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: newCompressionOptions * Signature: ()J */ -jlong Java_org_rocksdb_CompressionOptions_newCompressionOptions(JNIEnv*, +jlong Java_org_forstdb_CompressionOptions_newCompressionOptions(JNIEnv*, jclass) { const auto* opt = new ROCKSDB_NAMESPACE::CompressionOptions(); return GET_CPLUSPLUS_POINTER(opt); } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: setWindowBits * Signature: (JI)V */ -void Java_org_rocksdb_CompressionOptions_setWindowBits(JNIEnv*, jobject, +void Java_org_forstdb_CompressionOptions_setWindowBits(JNIEnv*, jobject, jlong jhandle, jint jwindow_bits) { auto* opt = reinterpret_cast(jhandle); @@ -36,44 +36,44 @@ void Java_org_rocksdb_CompressionOptions_setWindowBits(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: windowBits * Signature: (J)I */ -jint Java_org_rocksdb_CompressionOptions_windowBits(JNIEnv*, jobject, +jint Java_org_forstdb_CompressionOptions_windowBits(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->window_bits); } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: setLevel * Signature: (JI)V */ -void Java_org_rocksdb_CompressionOptions_setLevel(JNIEnv*, jobject, +void Java_org_forstdb_CompressionOptions_setLevel(JNIEnv*, jobject, jlong jhandle, jint jlevel) { auto* opt = reinterpret_cast(jhandle); opt->level = static_cast(jlevel); } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: level * Signature: (J)I */ -jint Java_org_rocksdb_CompressionOptions_level(JNIEnv*, jobject, +jint Java_org_forstdb_CompressionOptions_level(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->level); } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: setStrategy * Signature: (JI)V */ -void Java_org_rocksdb_CompressionOptions_setStrategy(JNIEnv*, jobject, +void Java_org_forstdb_CompressionOptions_setStrategy(JNIEnv*, jobject, jlong jhandle, jint jstrategy) { auto* opt = reinterpret_cast(jhandle); @@ -81,22 +81,22 @@ void Java_org_rocksdb_CompressionOptions_setStrategy(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: strategy * Signature: (J)I */ -jint Java_org_rocksdb_CompressionOptions_strategy(JNIEnv*, jobject, +jint Java_org_forstdb_CompressionOptions_strategy(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->strategy); } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: setMaxDictBytes * Signature: (JI)V */ -void Java_org_rocksdb_CompressionOptions_setMaxDictBytes(JNIEnv*, jobject, +void Java_org_forstdb_CompressionOptions_setMaxDictBytes(JNIEnv*, jobject, jlong jhandle, jint jmax_dict_bytes) { auto* opt = reinterpret_cast(jhandle); @@ -104,77 +104,77 @@ void Java_org_rocksdb_CompressionOptions_setMaxDictBytes(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: maxDictBytes * Signature: (J)I */ -jint Java_org_rocksdb_CompressionOptions_maxDictBytes(JNIEnv*, jobject, +jint Java_org_forstdb_CompressionOptions_maxDictBytes(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->max_dict_bytes); } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: setZstdMaxTrainBytes * Signature: (JI)V */ -void Java_org_rocksdb_CompressionOptions_setZstdMaxTrainBytes( +void Java_org_forstdb_CompressionOptions_setZstdMaxTrainBytes( JNIEnv*, jobject, jlong jhandle, jint jzstd_max_train_bytes) { auto* opt = reinterpret_cast(jhandle); opt->zstd_max_train_bytes = static_cast(jzstd_max_train_bytes); } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: zstdMaxTrainBytes * Signature: (J)I */ -jint Java_org_rocksdb_CompressionOptions_zstdMaxTrainBytes(JNIEnv*, jobject, +jint Java_org_forstdb_CompressionOptions_zstdMaxTrainBytes(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->zstd_max_train_bytes); } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: setMaxDictBufferBytes * Signature: (JJ)V */ -void Java_org_rocksdb_CompressionOptions_setMaxDictBufferBytes( +void Java_org_forstdb_CompressionOptions_setMaxDictBufferBytes( JNIEnv*, jobject, jlong jhandle, jlong jmax_dict_buffer_bytes) { auto* opt = reinterpret_cast(jhandle); opt->max_dict_buffer_bytes = static_cast(jmax_dict_buffer_bytes); } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: maxDictBufferBytes * Signature: (J)J */ -jlong Java_org_rocksdb_CompressionOptions_maxDictBufferBytes(JNIEnv*, jobject, +jlong Java_org_forstdb_CompressionOptions_maxDictBufferBytes(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->max_dict_buffer_bytes); } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: setZstdMaxTrainBytes * Signature: (JZ)V */ -void Java_org_rocksdb_CompressionOptions_setUseZstdDictTrainer( +void Java_org_forstdb_CompressionOptions_setUseZstdDictTrainer( JNIEnv*, jobject, jlong jhandle, jboolean juse_zstd_dict_trainer) { auto* opt = reinterpret_cast(jhandle); opt->use_zstd_dict_trainer = juse_zstd_dict_trainer == JNI_TRUE; } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: zstdMaxTrainBytes * Signature: (J)Z */ -jboolean Java_org_rocksdb_CompressionOptions_useZstdDictTrainer(JNIEnv*, +jboolean Java_org_forstdb_CompressionOptions_useZstdDictTrainer(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); @@ -182,11 +182,11 @@ jboolean Java_org_rocksdb_CompressionOptions_useZstdDictTrainer(JNIEnv*, } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: setEnabled * Signature: (JZ)V */ -void Java_org_rocksdb_CompressionOptions_setEnabled(JNIEnv*, jobject, +void Java_org_forstdb_CompressionOptions_setEnabled(JNIEnv*, jobject, jlong jhandle, jboolean jenabled) { auto* opt = reinterpret_cast(jhandle); @@ -194,21 +194,21 @@ void Java_org_rocksdb_CompressionOptions_setEnabled(JNIEnv*, jobject, } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: enabled * Signature: (J)Z */ -jboolean Java_org_rocksdb_CompressionOptions_enabled(JNIEnv*, jobject, +jboolean Java_org_forstdb_CompressionOptions_enabled(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->enabled); } /* - * Class: org_rocksdb_CompressionOptions + * Class: org_forstdb_CompressionOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_CompressionOptions_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_CompressionOptions_disposeInternal(JNIEnv*, jobject, jlong jhandle) { delete reinterpret_cast(jhandle); } diff --git a/java/rocksjni/concurrent_task_limiter.cc b/java/forstjni/concurrent_task_limiter.cc similarity index 75% rename from java/rocksjni/concurrent_task_limiter.cc rename to java/forstjni/concurrent_task_limiter.cc index 0b0b2d271..0c9b08c27 100644 --- a/java/rocksjni/concurrent_task_limiter.cc +++ b/java/forstjni/concurrent_task_limiter.cc @@ -11,16 +11,16 @@ #include #include -#include "include/org_rocksdb_ConcurrentTaskLimiterImpl.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_ConcurrentTaskLimiterImpl.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_ConcurrentTaskLimiterImpl + * Class: org_forstdb_ConcurrentTaskLimiterImpl * Method: newConcurrentTaskLimiterImpl0 * Signature: (Ljava/lang/String;I)J */ -jlong Java_org_rocksdb_ConcurrentTaskLimiterImpl_newConcurrentTaskLimiterImpl0( +jlong Java_org_forstdb_ConcurrentTaskLimiterImpl_newConcurrentTaskLimiterImpl0( JNIEnv* env, jclass, jstring jname, jint limit) { jboolean has_exception = JNI_FALSE; std::string name = @@ -36,11 +36,11 @@ jlong Java_org_rocksdb_ConcurrentTaskLimiterImpl_newConcurrentTaskLimiterImpl0( } /* - * Class: org_rocksdb_ConcurrentTaskLimiterImpl + * Class: org_forstdb_ConcurrentTaskLimiterImpl * Method: name * Signature: (J)Ljava/lang/String; */ -jstring Java_org_rocksdb_ConcurrentTaskLimiterImpl_name(JNIEnv* env, jclass, +jstring Java_org_forstdb_ConcurrentTaskLimiterImpl_name(JNIEnv* env, jclass, jlong handle) { const auto& limiter = *reinterpret_cast< std::shared_ptr*>(handle); @@ -48,11 +48,11 @@ jstring Java_org_rocksdb_ConcurrentTaskLimiterImpl_name(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_ConcurrentTaskLimiterImpl + * Class: org_forstdb_ConcurrentTaskLimiterImpl * Method: setMaxOutstandingTask * Signature: (JI)V */ -void Java_org_rocksdb_ConcurrentTaskLimiterImpl_setMaxOutstandingTask( +void Java_org_forstdb_ConcurrentTaskLimiterImpl_setMaxOutstandingTask( JNIEnv*, jclass, jlong handle, jint max_outstanding_task) { const auto& limiter = *reinterpret_cast< std::shared_ptr*>(handle); @@ -60,11 +60,11 @@ void Java_org_rocksdb_ConcurrentTaskLimiterImpl_setMaxOutstandingTask( } /* - * Class: org_rocksdb_ConcurrentTaskLimiterImpl + * Class: org_forstdb_ConcurrentTaskLimiterImpl * Method: resetMaxOutstandingTask * Signature: (J)V */ -void Java_org_rocksdb_ConcurrentTaskLimiterImpl_resetMaxOutstandingTask( +void Java_org_forstdb_ConcurrentTaskLimiterImpl_resetMaxOutstandingTask( JNIEnv*, jclass, jlong handle) { const auto& limiter = *reinterpret_cast< std::shared_ptr*>(handle); @@ -72,11 +72,11 @@ void Java_org_rocksdb_ConcurrentTaskLimiterImpl_resetMaxOutstandingTask( } /* - * Class: org_rocksdb_ConcurrentTaskLimiterImpl + * Class: org_forstdb_ConcurrentTaskLimiterImpl * Method: outstandingTask * Signature: (J)I */ -jint Java_org_rocksdb_ConcurrentTaskLimiterImpl_outstandingTask(JNIEnv*, jclass, +jint Java_org_forstdb_ConcurrentTaskLimiterImpl_outstandingTask(JNIEnv*, jclass, jlong handle) { const auto& limiter = *reinterpret_cast< std::shared_ptr*>(handle); @@ -84,11 +84,11 @@ jint Java_org_rocksdb_ConcurrentTaskLimiterImpl_outstandingTask(JNIEnv*, jclass, } /* - * Class: org_rocksdb_ConcurrentTaskLimiterImpl + * Class: org_forstdb_ConcurrentTaskLimiterImpl * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_ConcurrentTaskLimiterImpl_disposeInternal(JNIEnv*, +void Java_org_forstdb_ConcurrentTaskLimiterImpl_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* ptr = reinterpret_cast< diff --git a/java/rocksjni/config_options.cc b/java/forstjni/config_options.cc similarity index 76% rename from java/rocksjni/config_options.cc rename to java/forstjni/config_options.cc index 55a9cbb66..dd11ab813 100644 --- a/java/rocksjni/config_options.cc +++ b/java/forstjni/config_options.cc @@ -9,17 +9,17 @@ #include -#include "include/org_rocksdb_ConfigOptions.h" +#include "include/org_forstdb_ConfigOptions.h" #include "rocksdb/convenience.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_ConfigOptions + * Class: org_forstdb_ConfigOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_ConfigOptions_disposeInternal(JNIEnv *, jobject, +void Java_org_forstdb_ConfigOptions_disposeInternal(JNIEnv *, jobject, jlong jhandle) { auto *co = reinterpret_cast(jhandle); assert(co != nullptr); @@ -27,21 +27,21 @@ void Java_org_rocksdb_ConfigOptions_disposeInternal(JNIEnv *, jobject, } /* - * Class: org_rocksdb_ConfigOptions + * Class: org_forstdb_ConfigOptions * Method: newConfigOptions * Signature: ()J */ -jlong Java_org_rocksdb_ConfigOptions_newConfigOptions(JNIEnv *, jclass) { +jlong Java_org_forstdb_ConfigOptions_newConfigOptions(JNIEnv *, jclass) { auto *cfg_opt = new ROCKSDB_NAMESPACE::ConfigOptions(); return GET_CPLUSPLUS_POINTER(cfg_opt); } /* - * Class: org_rocksdb_ConfigOptions + * Class: org_forstdb_ConfigOptions * Method: setEnv * Signature: (JJ;)V */ -void Java_org_rocksdb_ConfigOptions_setEnv(JNIEnv *, jclass, jlong handle, +void Java_org_forstdb_ConfigOptions_setEnv(JNIEnv *, jclass, jlong handle, jlong rocksdb_env_handle) { auto *cfg_opt = reinterpret_cast(handle); auto *rocksdb_env = @@ -50,11 +50,11 @@ void Java_org_rocksdb_ConfigOptions_setEnv(JNIEnv *, jclass, jlong handle, } /* - * Class: org_rocksdb_ConfigOptions + * Class: org_forstdb_ConfigOptions * Method: setDelimiter * Signature: (JLjava/lang/String;)V */ -void Java_org_rocksdb_ConfigOptions_setDelimiter(JNIEnv *env, jclass, +void Java_org_forstdb_ConfigOptions_setDelimiter(JNIEnv *env, jclass, jlong handle, jstring s) { auto *cfg_opt = reinterpret_cast(handle); const char *delim = env->GetStringUTFChars(s, nullptr); @@ -67,11 +67,11 @@ void Java_org_rocksdb_ConfigOptions_setDelimiter(JNIEnv *env, jclass, } /* - * Class: org_rocksdb_ConfigOptions + * Class: org_forstdb_ConfigOptions * Method: setIgnoreUnknownOptions * Signature: (JZ)V */ -void Java_org_rocksdb_ConfigOptions_setIgnoreUnknownOptions(JNIEnv *, jclass, +void Java_org_forstdb_ConfigOptions_setIgnoreUnknownOptions(JNIEnv *, jclass, jlong handle, jboolean b) { auto *cfg_opt = reinterpret_cast(handle); @@ -79,11 +79,11 @@ void Java_org_rocksdb_ConfigOptions_setIgnoreUnknownOptions(JNIEnv *, jclass, } /* - * Class: org_rocksdb_ConfigOptions + * Class: org_forstdb_ConfigOptions * Method: setInputStringsEscaped * Signature: (JZ)V */ -void Java_org_rocksdb_ConfigOptions_setInputStringsEscaped(JNIEnv *, jclass, +void Java_org_forstdb_ConfigOptions_setInputStringsEscaped(JNIEnv *, jclass, jlong handle, jboolean b) { auto *cfg_opt = reinterpret_cast(handle); @@ -91,11 +91,11 @@ void Java_org_rocksdb_ConfigOptions_setInputStringsEscaped(JNIEnv *, jclass, } /* - * Class: org_rocksdb_ConfigOptions + * Class: org_forstdb_ConfigOptions * Method: setSanityLevel * Signature: (JI)V */ -void Java_org_rocksdb_ConfigOptions_setSanityLevel(JNIEnv *, jclass, +void Java_org_forstdb_ConfigOptions_setSanityLevel(JNIEnv *, jclass, jlong handle, jbyte level) { auto *cfg_opt = reinterpret_cast(handle); cfg_opt->sanity_level = diff --git a/java/rocksjni/cplusplus_to_java_convert.h b/java/forstjni/cplusplus_to_java_convert.h similarity index 100% rename from java/rocksjni/cplusplus_to_java_convert.h rename to java/forstjni/cplusplus_to_java_convert.h diff --git a/java/rocksjni/env.cc b/java/forstjni/env.cc similarity index 78% rename from java/rocksjni/env.cc rename to java/forstjni/env.cc index bb739fe2b..bde4ed574 100644 --- a/java/rocksjni/env.cc +++ b/java/forstjni/env.cc @@ -12,28 +12,28 @@ #include -#include "include/org_rocksdb_Env.h" -#include "include/org_rocksdb_RocksEnv.h" -#include "include/org_rocksdb_RocksMemEnv.h" -#include "include/org_rocksdb_TimedEnv.h" +#include "include/org_forstdb_Env.h" +#include "include/org_forstdb_RocksEnv.h" +#include "include/org_forstdb_RocksMemEnv.h" +#include "include/org_forstdb_TimedEnv.h" #include "portal.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_Env + * Class: org_forstdb_Env * Method: getDefaultEnvInternal * Signature: ()J */ -jlong Java_org_rocksdb_Env_getDefaultEnvInternal(JNIEnv*, jclass) { +jlong Java_org_forstdb_Env_getDefaultEnvInternal(JNIEnv*, jclass) { return GET_CPLUSPLUS_POINTER(ROCKSDB_NAMESPACE::Env::Default()); } /* - * Class: org_rocksdb_RocksEnv + * Class: org_forstdb_RocksEnv * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_RocksEnv_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_RocksEnv_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* e = reinterpret_cast(jhandle); assert(e != nullptr); @@ -41,11 +41,11 @@ void Java_org_rocksdb_RocksEnv_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Env + * Class: org_forstdb_Env * Method: setBackgroundThreads * Signature: (JIB)V */ -void Java_org_rocksdb_Env_setBackgroundThreads(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Env_setBackgroundThreads(JNIEnv*, jobject, jlong jhandle, jint jnum, jbyte jpriority_value) { auto* rocks_env = reinterpret_cast(jhandle); @@ -55,11 +55,11 @@ void Java_org_rocksdb_Env_setBackgroundThreads(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Env + * Class: org_forstdb_Env * Method: getBackgroundThreads * Signature: (JB)I */ -jint Java_org_rocksdb_Env_getBackgroundThreads(JNIEnv*, jobject, jlong jhandle, +jint Java_org_forstdb_Env_getBackgroundThreads(JNIEnv*, jobject, jlong jhandle, jbyte jpriority_value) { auto* rocks_env = reinterpret_cast(jhandle); const int num = rocks_env->GetBackgroundThreads( @@ -68,11 +68,11 @@ jint Java_org_rocksdb_Env_getBackgroundThreads(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Env + * Class: org_forstdb_Env * Method: getThreadPoolQueueLen * Signature: (JB)I */ -jint Java_org_rocksdb_Env_getThreadPoolQueueLen(JNIEnv*, jobject, jlong jhandle, +jint Java_org_forstdb_Env_getThreadPoolQueueLen(JNIEnv*, jobject, jlong jhandle, jbyte jpriority_value) { auto* rocks_env = reinterpret_cast(jhandle); const int queue_len = rocks_env->GetThreadPoolQueueLen( @@ -81,11 +81,11 @@ jint Java_org_rocksdb_Env_getThreadPoolQueueLen(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Env + * Class: org_forstdb_Env * Method: incBackgroundThreadsIfNeeded * Signature: (JIB)V */ -void Java_org_rocksdb_Env_incBackgroundThreadsIfNeeded(JNIEnv*, jobject, +void Java_org_forstdb_Env_incBackgroundThreadsIfNeeded(JNIEnv*, jobject, jlong jhandle, jint jnum, jbyte jpriority_value) { auto* rocks_env = reinterpret_cast(jhandle); @@ -95,11 +95,11 @@ void Java_org_rocksdb_Env_incBackgroundThreadsIfNeeded(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Env + * Class: org_forstdb_Env * Method: lowerThreadPoolIOPriority * Signature: (JB)V */ -void Java_org_rocksdb_Env_lowerThreadPoolIOPriority(JNIEnv*, jobject, +void Java_org_forstdb_Env_lowerThreadPoolIOPriority(JNIEnv*, jobject, jlong jhandle, jbyte jpriority_value) { auto* rocks_env = reinterpret_cast(jhandle); @@ -108,11 +108,11 @@ void Java_org_rocksdb_Env_lowerThreadPoolIOPriority(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Env + * Class: org_forstdb_Env * Method: lowerThreadPoolCPUPriority * Signature: (JB)V */ -void Java_org_rocksdb_Env_lowerThreadPoolCPUPriority(JNIEnv*, jobject, +void Java_org_forstdb_Env_lowerThreadPoolCPUPriority(JNIEnv*, jobject, jlong jhandle, jbyte jpriority_value) { auto* rocks_env = reinterpret_cast(jhandle); @@ -121,11 +121,11 @@ void Java_org_rocksdb_Env_lowerThreadPoolCPUPriority(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Env + * Class: org_forstdb_Env * Method: getThreadList * Signature: (J)[Lorg/rocksdb/ThreadStatus; */ -jobjectArray Java_org_rocksdb_Env_getThreadList(JNIEnv* env, jobject, +jobjectArray Java_org_forstdb_Env_getThreadList(JNIEnv* env, jobject, jlong jhandle) { auto* rocks_env = reinterpret_cast(jhandle); std::vector thread_status; @@ -159,22 +159,22 @@ jobjectArray Java_org_rocksdb_Env_getThreadList(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksMemEnv + * Class: org_forstdb_RocksMemEnv * Method: createMemEnv * Signature: (J)J */ -jlong Java_org_rocksdb_RocksMemEnv_createMemEnv(JNIEnv*, jclass, +jlong Java_org_forstdb_RocksMemEnv_createMemEnv(JNIEnv*, jclass, jlong jbase_env_handle) { auto* base_env = reinterpret_cast(jbase_env_handle); return GET_CPLUSPLUS_POINTER(ROCKSDB_NAMESPACE::NewMemEnv(base_env)); } /* - * Class: org_rocksdb_RocksMemEnv + * Class: org_forstdb_RocksMemEnv * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_RocksMemEnv_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_RocksMemEnv_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* e = reinterpret_cast(jhandle); assert(e != nullptr); @@ -182,22 +182,22 @@ void Java_org_rocksdb_RocksMemEnv_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_TimedEnv + * Class: org_forstdb_TimedEnv * Method: createTimedEnv * Signature: (J)J */ -jlong Java_org_rocksdb_TimedEnv_createTimedEnv(JNIEnv*, jclass, +jlong Java_org_forstdb_TimedEnv_createTimedEnv(JNIEnv*, jclass, jlong jbase_env_handle) { auto* base_env = reinterpret_cast(jbase_env_handle); return GET_CPLUSPLUS_POINTER(ROCKSDB_NAMESPACE::NewTimedEnv(base_env)); } /* - * Class: org_rocksdb_TimedEnv + * Class: org_forstdb_TimedEnv * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_TimedEnv_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_TimedEnv_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* e = reinterpret_cast(jhandle); assert(e != nullptr); diff --git a/java/rocksjni/env_flink.cc b/java/forstjni/env_flink.cc similarity index 87% rename from java/rocksjni/env_flink.cc rename to java/forstjni/env_flink.cc index f6d4b44ca..c3fee7690 100644 --- a/java/rocksjni/env_flink.cc +++ b/java/forstjni/env_flink.cc @@ -20,17 +20,17 @@ #include -#include +#include "include/org_forstdb_FlinkEnv.h" -#include "java/rocksjni/portal.h" +#include "java/forstjni/portal.h" #include "rocksdb/env.h" /* - * Class: org_rocksdb_FlinkEnv + * Class: org_forstdb_FlinkEnv * Method: createFlinkEnv * Signature: (Ljava/lang/String;)J */ -jlong Java_org_rocksdb_FlinkEnv_createFlinkEnv(JNIEnv* env, jclass, +jlong Java_org_forstdb_FlinkEnv_createFlinkEnv(JNIEnv* env, jclass, jstring base_path) { jboolean has_exception = JNI_FALSE; auto path = @@ -51,11 +51,11 @@ jlong Java_org_rocksdb_FlinkEnv_createFlinkEnv(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_FlinkEnv + * Class: org_forstdb_FlinkEnv * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_FlinkEnv_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_FlinkEnv_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* handle = reinterpret_cast(jhandle); assert(handle != nullptr); diff --git a/java/rocksjni/env_flink_test_suite.cc b/java/forstjni/env_flink_test_suite.cc similarity index 84% rename from java/rocksjni/env_flink_test_suite.cc rename to java/forstjni/env_flink_test_suite.cc index 5e66ca746..529f95018 100644 --- a/java/rocksjni/env_flink_test_suite.cc +++ b/java/forstjni/env_flink_test_suite.cc @@ -20,15 +20,15 @@ #include -#include "include/org_rocksdb_EnvFlinkTestSuite.h" -#include "java/rocksjni/portal.h" +#include "include/org_forstdb_EnvFlinkTestSuite.h" +#include "java/forstjni/portal.h" /* - * Class: org_rocksdb_EnvFlinkTestSuite + * Class: org_forstdb_EnvFlinkTestSuite * Method: buildNativeObject * Signature: (Ljava/lang/String;)J */ -jlong Java_org_rocksdb_EnvFlinkTestSuite_buildNativeObject(JNIEnv* env, jobject, +jlong Java_org_forstdb_EnvFlinkTestSuite_buildNativeObject(JNIEnv* env, jobject, jstring basePath) { jboolean has_exception = JNI_FALSE; auto path = @@ -43,11 +43,11 @@ jlong Java_org_rocksdb_EnvFlinkTestSuite_buildNativeObject(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_EnvFlinkTestSuite + * Class: org_forstdb_EnvFlinkTestSuite * Method: runAllTestSuites * Signature: (J)V */ -JNIEXPORT void JNICALL Java_org_rocksdb_EnvFlinkTestSuite_runAllTestSuites( +JNIEXPORT void JNICALL Java_org_forstdb_EnvFlinkTestSuite_runAllTestSuites( JNIEnv* jniEnv, jobject, jlong objectHandle) { auto env_flink_test_suites = reinterpret_cast(objectHandle); @@ -61,11 +61,11 @@ JNIEXPORT void JNICALL Java_org_rocksdb_EnvFlinkTestSuite_runAllTestSuites( } /* - * Class: org_rocksdb_EnvFlinkTestSuite + * Class: org_forstdb_EnvFlinkTestSuite * Method: disposeInternal * Signature: (J)V */ -JNIEXPORT void JNICALL Java_org_rocksdb_EnvFlinkTestSuite_disposeInternal( +JNIEXPORT void JNICALL Java_org_forstdb_EnvFlinkTestSuite_disposeInternal( JNIEnv*, jobject, jlong objectHandle) { auto test_suites = reinterpret_cast(objectHandle); diff --git a/java/rocksjni/env_options.cc b/java/forstjni/env_options.cc similarity index 72% rename from java/rocksjni/env_options.cc rename to java/forstjni/env_options.cc index 3237e2775..a0d6b1158 100644 --- a/java/rocksjni/env_options.cc +++ b/java/forstjni/env_options.cc @@ -9,9 +9,9 @@ #include -#include "include/org_rocksdb_EnvOptions.h" +#include "include/org_forstdb_EnvOptions.h" #include "rocksdb/env.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" #define ENV_OPTIONS_SET_BOOL(_jhandle, _opt) \ reinterpret_cast(_jhandle)->_opt = \ @@ -29,21 +29,21 @@ reinterpret_cast(_jhandle)->_opt /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: newEnvOptions * Signature: ()J */ -jlong Java_org_rocksdb_EnvOptions_newEnvOptions__(JNIEnv *, jclass) { +jlong Java_org_forstdb_EnvOptions_newEnvOptions__(JNIEnv *, jclass) { auto *env_opt = new ROCKSDB_NAMESPACE::EnvOptions(); return GET_CPLUSPLUS_POINTER(env_opt); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: newEnvOptions * Signature: (J)J */ -jlong Java_org_rocksdb_EnvOptions_newEnvOptions__J(JNIEnv *, jclass, +jlong Java_org_forstdb_EnvOptions_newEnvOptions__J(JNIEnv *, jclass, jlong jdboptions_handle) { auto *db_options = reinterpret_cast(jdboptions_handle); @@ -52,11 +52,11 @@ jlong Java_org_rocksdb_EnvOptions_newEnvOptions__J(JNIEnv *, jclass, } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_EnvOptions_disposeInternal(JNIEnv *, jobject, +void Java_org_forstdb_EnvOptions_disposeInternal(JNIEnv *, jobject, jlong jhandle) { auto *eo = reinterpret_cast(jhandle); assert(eo != nullptr); @@ -64,237 +64,237 @@ void Java_org_rocksdb_EnvOptions_disposeInternal(JNIEnv *, jobject, } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setUseMmapReads * Signature: (JZ)V */ -void Java_org_rocksdb_EnvOptions_setUseMmapReads(JNIEnv *, jobject, +void Java_org_forstdb_EnvOptions_setUseMmapReads(JNIEnv *, jobject, jlong jhandle, jboolean use_mmap_reads) { ENV_OPTIONS_SET_BOOL(jhandle, use_mmap_reads); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: useMmapReads * Signature: (J)Z */ -jboolean Java_org_rocksdb_EnvOptions_useMmapReads(JNIEnv *, jobject, +jboolean Java_org_forstdb_EnvOptions_useMmapReads(JNIEnv *, jobject, jlong jhandle) { return ENV_OPTIONS_GET(jhandle, use_mmap_reads); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setUseMmapWrites * Signature: (JZ)V */ -void Java_org_rocksdb_EnvOptions_setUseMmapWrites(JNIEnv *, jobject, +void Java_org_forstdb_EnvOptions_setUseMmapWrites(JNIEnv *, jobject, jlong jhandle, jboolean use_mmap_writes) { ENV_OPTIONS_SET_BOOL(jhandle, use_mmap_writes); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: useMmapWrites * Signature: (J)Z */ -jboolean Java_org_rocksdb_EnvOptions_useMmapWrites(JNIEnv *, jobject, +jboolean Java_org_forstdb_EnvOptions_useMmapWrites(JNIEnv *, jobject, jlong jhandle) { return ENV_OPTIONS_GET(jhandle, use_mmap_writes); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setUseDirectReads * Signature: (JZ)V */ -void Java_org_rocksdb_EnvOptions_setUseDirectReads(JNIEnv *, jobject, +void Java_org_forstdb_EnvOptions_setUseDirectReads(JNIEnv *, jobject, jlong jhandle, jboolean use_direct_reads) { ENV_OPTIONS_SET_BOOL(jhandle, use_direct_reads); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: useDirectReads * Signature: (J)Z */ -jboolean Java_org_rocksdb_EnvOptions_useDirectReads(JNIEnv *, jobject, +jboolean Java_org_forstdb_EnvOptions_useDirectReads(JNIEnv *, jobject, jlong jhandle) { return ENV_OPTIONS_GET(jhandle, use_direct_reads); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setUseDirectWrites * Signature: (JZ)V */ -void Java_org_rocksdb_EnvOptions_setUseDirectWrites( +void Java_org_forstdb_EnvOptions_setUseDirectWrites( JNIEnv *, jobject, jlong jhandle, jboolean use_direct_writes) { ENV_OPTIONS_SET_BOOL(jhandle, use_direct_writes); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: useDirectWrites * Signature: (J)Z */ -jboolean Java_org_rocksdb_EnvOptions_useDirectWrites(JNIEnv *, jobject, +jboolean Java_org_forstdb_EnvOptions_useDirectWrites(JNIEnv *, jobject, jlong jhandle) { return ENV_OPTIONS_GET(jhandle, use_direct_writes); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setAllowFallocate * Signature: (JZ)V */ -void Java_org_rocksdb_EnvOptions_setAllowFallocate(JNIEnv *, jobject, +void Java_org_forstdb_EnvOptions_setAllowFallocate(JNIEnv *, jobject, jlong jhandle, jboolean allow_fallocate) { ENV_OPTIONS_SET_BOOL(jhandle, allow_fallocate); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: allowFallocate * Signature: (J)Z */ -jboolean Java_org_rocksdb_EnvOptions_allowFallocate(JNIEnv *, jobject, +jboolean Java_org_forstdb_EnvOptions_allowFallocate(JNIEnv *, jobject, jlong jhandle) { return ENV_OPTIONS_GET(jhandle, allow_fallocate); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setSetFdCloexec * Signature: (JZ)V */ -void Java_org_rocksdb_EnvOptions_setSetFdCloexec(JNIEnv *, jobject, +void Java_org_forstdb_EnvOptions_setSetFdCloexec(JNIEnv *, jobject, jlong jhandle, jboolean set_fd_cloexec) { ENV_OPTIONS_SET_BOOL(jhandle, set_fd_cloexec); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setFdCloexec * Signature: (J)Z */ -jboolean Java_org_rocksdb_EnvOptions_setFdCloexec(JNIEnv *, jobject, +jboolean Java_org_forstdb_EnvOptions_setFdCloexec(JNIEnv *, jobject, jlong jhandle) { return ENV_OPTIONS_GET(jhandle, set_fd_cloexec); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setBytesPerSync * Signature: (JJ)V */ -void Java_org_rocksdb_EnvOptions_setBytesPerSync(JNIEnv *, jobject, +void Java_org_forstdb_EnvOptions_setBytesPerSync(JNIEnv *, jobject, jlong jhandle, jlong bytes_per_sync) { ENV_OPTIONS_SET_UINT64_T(jhandle, bytes_per_sync); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: bytesPerSync * Signature: (J)J */ -jlong Java_org_rocksdb_EnvOptions_bytesPerSync(JNIEnv *, jobject, +jlong Java_org_forstdb_EnvOptions_bytesPerSync(JNIEnv *, jobject, jlong jhandle) { return ENV_OPTIONS_GET(jhandle, bytes_per_sync); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setFallocateWithKeepSize * Signature: (JZ)V */ -void Java_org_rocksdb_EnvOptions_setFallocateWithKeepSize( +void Java_org_forstdb_EnvOptions_setFallocateWithKeepSize( JNIEnv *, jobject, jlong jhandle, jboolean fallocate_with_keep_size) { ENV_OPTIONS_SET_BOOL(jhandle, fallocate_with_keep_size); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: fallocateWithKeepSize * Signature: (J)Z */ -jboolean Java_org_rocksdb_EnvOptions_fallocateWithKeepSize(JNIEnv *, jobject, +jboolean Java_org_forstdb_EnvOptions_fallocateWithKeepSize(JNIEnv *, jobject, jlong jhandle) { return ENV_OPTIONS_GET(jhandle, fallocate_with_keep_size); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setCompactionReadaheadSize * Signature: (JJ)V */ -void Java_org_rocksdb_EnvOptions_setCompactionReadaheadSize( +void Java_org_forstdb_EnvOptions_setCompactionReadaheadSize( JNIEnv *, jobject, jlong jhandle, jlong compaction_readahead_size) { ENV_OPTIONS_SET_SIZE_T(jhandle, compaction_readahead_size); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: compactionReadaheadSize * Signature: (J)J */ -jlong Java_org_rocksdb_EnvOptions_compactionReadaheadSize(JNIEnv *, jobject, +jlong Java_org_forstdb_EnvOptions_compactionReadaheadSize(JNIEnv *, jobject, jlong jhandle) { return ENV_OPTIONS_GET(jhandle, compaction_readahead_size); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setRandomAccessMaxBufferSize * Signature: (JJ)V */ -void Java_org_rocksdb_EnvOptions_setRandomAccessMaxBufferSize( +void Java_org_forstdb_EnvOptions_setRandomAccessMaxBufferSize( JNIEnv *, jobject, jlong jhandle, jlong random_access_max_buffer_size) { ENV_OPTIONS_SET_SIZE_T(jhandle, random_access_max_buffer_size); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: randomAccessMaxBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_EnvOptions_randomAccessMaxBufferSize(JNIEnv *, jobject, +jlong Java_org_forstdb_EnvOptions_randomAccessMaxBufferSize(JNIEnv *, jobject, jlong jhandle) { return ENV_OPTIONS_GET(jhandle, random_access_max_buffer_size); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setWritableFileMaxBufferSize * Signature: (JJ)V */ -void Java_org_rocksdb_EnvOptions_setWritableFileMaxBufferSize( +void Java_org_forstdb_EnvOptions_setWritableFileMaxBufferSize( JNIEnv *, jobject, jlong jhandle, jlong writable_file_max_buffer_size) { ENV_OPTIONS_SET_SIZE_T(jhandle, writable_file_max_buffer_size); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: writableFileMaxBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_EnvOptions_writableFileMaxBufferSize(JNIEnv *, jobject, +jlong Java_org_forstdb_EnvOptions_writableFileMaxBufferSize(JNIEnv *, jobject, jlong jhandle) { return ENV_OPTIONS_GET(jhandle, writable_file_max_buffer_size); } /* - * Class: org_rocksdb_EnvOptions + * Class: org_forstdb_EnvOptions * Method: setRateLimiter * Signature: (JJ)V */ -void Java_org_rocksdb_EnvOptions_setRateLimiter(JNIEnv *, jobject, +void Java_org_forstdb_EnvOptions_setRateLimiter(JNIEnv *, jobject, jlong jhandle, jlong rl_handle) { auto *sptr_rate_limiter = diff --git a/java/rocksjni/event_listener.cc b/java/forstjni/event_listener.cc similarity index 74% rename from java/rocksjni/event_listener.cc rename to java/forstjni/event_listener.cc index 965932c9c..2f73b8b01 100644 --- a/java/rocksjni/event_listener.cc +++ b/java/forstjni/event_listener.cc @@ -10,17 +10,17 @@ #include -#include "include/org_rocksdb_AbstractEventListener.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/event_listener_jnicallback.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_AbstractEventListener.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/event_listener_jnicallback.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_AbstractEventListener + * Class: org_forstdb_AbstractEventListener * Method: createNewEventListener * Signature: (J)J */ -jlong Java_org_rocksdb_AbstractEventListener_createNewEventListener( +jlong Java_org_forstdb_AbstractEventListener_createNewEventListener( JNIEnv* env, jobject jobj, jlong jenabled_event_callback_values) { auto enabled_event_callbacks = ROCKSDB_NAMESPACE::EnabledEventCallbackJni::toCppEnabledEventCallbacks( @@ -33,11 +33,11 @@ jlong Java_org_rocksdb_AbstractEventListener_createNewEventListener( } /* - * Class: org_rocksdb_AbstractEventListener + * Class: org_forstdb_AbstractEventListener * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_AbstractEventListener_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_AbstractEventListener_disposeInternal(JNIEnv*, jobject, jlong jhandle) { delete reinterpret_cast*>( jhandle); diff --git a/java/rocksjni/event_listener_jnicallback.cc b/java/forstjni/event_listener_jnicallback.cc similarity index 99% rename from java/rocksjni/event_listener_jnicallback.cc rename to java/forstjni/event_listener_jnicallback.cc index 342d938b4..deb8d65de 100644 --- a/java/rocksjni/event_listener_jnicallback.cc +++ b/java/forstjni/event_listener_jnicallback.cc @@ -6,9 +6,9 @@ // This file implements the callback "bridge" between Java and C++ for // ROCKSDB_NAMESPACE::EventListener. -#include "rocksjni/event_listener_jnicallback.h" +#include "forstjni/event_listener_jnicallback.h" -#include "rocksjni/portal.h" +#include "forstjni/portal.h" namespace ROCKSDB_NAMESPACE { EventListenerJniCallback::EventListenerJniCallback( diff --git a/java/rocksjni/event_listener_jnicallback.h b/java/forstjni/event_listener_jnicallback.h similarity index 99% rename from java/rocksjni/event_listener_jnicallback.h rename to java/forstjni/event_listener_jnicallback.h index f4a235a23..564210d37 100644 --- a/java/rocksjni/event_listener_jnicallback.h +++ b/java/forstjni/event_listener_jnicallback.h @@ -15,7 +15,7 @@ #include #include "rocksdb/listener.h" -#include "rocksjni/jnicallback.h" +#include "forstjni/jnicallback.h" namespace ROCKSDB_NAMESPACE { diff --git a/java/rocksjni/export_import_files_metadatajni.cc b/java/forstjni/export_import_files_metadatajni.cc similarity index 67% rename from java/rocksjni/export_import_files_metadatajni.cc rename to java/forstjni/export_import_files_metadatajni.cc index 213977ac2..547b49b4c 100644 --- a/java/rocksjni/export_import_files_metadatajni.cc +++ b/java/forstjni/export_import_files_metadatajni.cc @@ -4,16 +4,16 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -#include "include/org_rocksdb_ExportImportFilesMetaData.h" -#include "include/org_rocksdb_LiveFileMetaData.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_ExportImportFilesMetaData.h" +#include "include/org_forstdb_LiveFileMetaData.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_ExportImportFilesMetaData + * Class: org_forstdb_ExportImportFilesMetaData * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_ExportImportFilesMetaData_disposeInternal( +void Java_org_forstdb_ExportImportFilesMetaData_disposeInternal( JNIEnv* /*env*/, jobject /*jopt*/, jlong jhandle) { auto* metadata = reinterpret_cast(jhandle); diff --git a/java/rocksjni/filter.cc b/java/forstjni/filter.cc similarity index 76% rename from java/rocksjni/filter.cc rename to java/forstjni/filter.cc index ed22016d2..d07584dfc 100644 --- a/java/rocksjni/filter.cc +++ b/java/forstjni/filter.cc @@ -12,18 +12,18 @@ #include -#include "include/org_rocksdb_BloomFilter.h" -#include "include/org_rocksdb_Filter.h" +#include "include/org_forstdb_BloomFilter.h" +#include "include/org_forstdb_Filter.h" #include "rocksdb/filter_policy.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_BloomFilter + * Class: org_forstdb_BloomFilter * Method: createBloomFilter * Signature: (DZ)J */ -jlong Java_org_rocksdb_BloomFilter_createNewBloomFilter(JNIEnv* /*env*/, +jlong Java_org_forstdb_BloomFilter_createNewBloomFilter(JNIEnv* /*env*/, jclass /*jcls*/, jdouble bits_per_key) { auto* sptr_filter = @@ -33,11 +33,11 @@ jlong Java_org_rocksdb_BloomFilter_createNewBloomFilter(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Filter + * Class: org_forstdb_Filter * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_Filter_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_Filter_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* handle = reinterpret_cast*>( diff --git a/java/rocksjni/flink_compactionfilterjni.cc b/java/forstjni/flink_compactionfilterjni.cc similarity index 94% rename from java/rocksjni/flink_compactionfilterjni.cc rename to java/forstjni/flink_compactionfilterjni.cc index cd3e88027..793c56698 100644 --- a/java/rocksjni/flink_compactionfilterjni.cc +++ b/java/forstjni/flink_compactionfilterjni.cc @@ -6,10 +6,10 @@ #include #include -#include "include/org_rocksdb_FlinkCompactionFilter.h" +#include "include/org_forstdb_FlinkCompactionFilter.h" #include "loggerjnicallback.h" #include "portal.h" -#include "rocksjni/jnicallback.h" +#include "forstjni/jnicallback.h" #include "utilities/flink/flink_compaction_filter.h" class JniCallbackBase : public ROCKSDB_NAMESPACE::JniCallback { @@ -159,11 +159,11 @@ static ROCKSDB_NAMESPACE::flink::FlinkCompactionFilter:: } /*x - * Class: org_rocksdb_FlinkCompactionFilter + * Class: org_forstdb_FlinkCompactionFilter * Method: createNewFlinkCompactionFilterConfigHolder * Signature: ()J */ -jlong Java_org_rocksdb_FlinkCompactionFilter_createNewFlinkCompactionFilterConfigHolder( +jlong Java_org_forstdb_FlinkCompactionFilter_createNewFlinkCompactionFilterConfigHolder( JNIEnv* /* env */, jclass /* jcls */) { return reinterpret_cast( new std::shared_ptr< @@ -172,11 +172,11 @@ jlong Java_org_rocksdb_FlinkCompactionFilter_createNewFlinkCompactionFilterConfi } /* - * Class: org_rocksdb_FlinkCompactionFilter + * Class: org_forstdb_FlinkCompactionFilter * Method: disposeFlinkCompactionFilterConfigHolder * Signature: (J)V */ -void Java_org_rocksdb_FlinkCompactionFilter_disposeFlinkCompactionFilterConfigHolder( +void Java_org_forstdb_FlinkCompactionFilter_disposeFlinkCompactionFilterConfigHolder( JNIEnv* /* env */, jclass /* jcls */, jlong handle) { auto* config_holder = reinterpret_cast*>(handle); @@ -184,11 +184,11 @@ void Java_org_rocksdb_FlinkCompactionFilter_disposeFlinkCompactionFilterConfigHo } /* - * Class: org_rocksdb_FlinkCompactionFilter + * Class: org_forstdb_FlinkCompactionFilter * Method: createNewFlinkCompactionFilter0 * Signature: (JJJ)J */ -jlong Java_org_rocksdb_FlinkCompactionFilter_createNewFlinkCompactionFilter0( +jlong Java_org_forstdb_FlinkCompactionFilter_createNewFlinkCompactionFilter0( JNIEnv* env, jclass /* jcls */, jlong config_holder_handle, jobject jtime_provider, jlong logger_handle) { auto config_holder = @@ -212,11 +212,11 @@ jlong Java_org_rocksdb_FlinkCompactionFilter_createNewFlinkCompactionFilter0( } /* - * Class: org_rocksdb_FlinkCompactionFilter + * Class: org_forstdb_FlinkCompactionFilter * Method: configureFlinkCompactionFilter * Signature: (JIIJJILorg/rocksdb/FlinkCompactionFilter$ListElementFilter;)Z */ -jboolean Java_org_rocksdb_FlinkCompactionFilter_configureFlinkCompactionFilter( +jboolean Java_org_forstdb_FlinkCompactionFilter_configureFlinkCompactionFilter( JNIEnv* env, jclass /* jcls */, jlong handle, jint ji_state_type, jint ji_timestamp_offset, jlong jl_ttl_milli, jlong jquery_time_after_num_entries, jint ji_list_elem_len, diff --git a/java/rocksjni/hyper_clock_cache.cc b/java/forstjni/hyper_clock_cache.cc similarity index 78% rename from java/rocksjni/hyper_clock_cache.cc rename to java/forstjni/hyper_clock_cache.cc index 782f123a5..9fdab09f7 100644 --- a/java/rocksjni/hyper_clock_cache.cc +++ b/java/forstjni/hyper_clock_cache.cc @@ -9,15 +9,15 @@ #include #include "cache/clock_cache.h" -#include "include/org_rocksdb_HyperClockCache.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "include/org_forstdb_HyperClockCache.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_HyperClockCache + * Class: org_forstdb_HyperClockCache * Method: newHyperClockCache * Signature: (JJIZ)J */ -jlong Java_org_rocksdb_HyperClockCache_newHyperClockCache( +jlong Java_org_forstdb_HyperClockCache_newHyperClockCache( JNIEnv*, jclass, jlong capacity, jlong estimatedEntryCharge, jint numShardBits, jboolean strictCapacityLimit) { ROCKSDB_NAMESPACE::HyperClockCacheOptions cacheOptions = @@ -30,11 +30,11 @@ jlong Java_org_rocksdb_HyperClockCache_newHyperClockCache( } /* - * Class: org_rocksdb_HyperClockCache + * Class: org_forstdb_HyperClockCache * Method: disposeInternalJni * Signature: (J)V */ -void Java_org_rocksdb_HyperClockCache_disposeInternalJni(JNIEnv*, jclass, +void Java_org_forstdb_HyperClockCache_disposeInternalJni(JNIEnv*, jclass, jlong jhandle) { auto* hyper_clock_cache = reinterpret_cast*>(jhandle); diff --git a/java/rocksjni/import_column_family_options.cc b/java/forstjni/import_column_family_options.cc similarity index 71% rename from java/rocksjni/import_column_family_options.cc rename to java/forstjni/import_column_family_options.cc index 1a9bded51..3f642871e 100644 --- a/java/rocksjni/import_column_family_options.cc +++ b/java/forstjni/import_column_family_options.cc @@ -6,16 +6,16 @@ #include -#include "include/org_rocksdb_ImportColumnFamilyOptions.h" +#include "include/org_forstdb_ImportColumnFamilyOptions.h" #include "rocksdb/options.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_ImportColumnFamilyOptions + * Class: org_forstdb_ImportColumnFamilyOptions * Method: newImportColumnFamilyOptions * Signature: ()J */ -jlong Java_org_rocksdb_ImportColumnFamilyOptions_newImportColumnFamilyOptions( +jlong Java_org_forstdb_ImportColumnFamilyOptions_newImportColumnFamilyOptions( JNIEnv *, jclass) { ROCKSDB_NAMESPACE::ImportColumnFamilyOptions *opts = new ROCKSDB_NAMESPACE::ImportColumnFamilyOptions(); @@ -23,11 +23,11 @@ jlong Java_org_rocksdb_ImportColumnFamilyOptions_newImportColumnFamilyOptions( } /* - * Class: org_rocksdb_ImportColumnFamilyOptions + * Class: org_forstdb_ImportColumnFamilyOptions * Method: setMoveFiles * Signature: (JZ)V */ -void Java_org_rocksdb_ImportColumnFamilyOptions_setMoveFiles( +void Java_org_forstdb_ImportColumnFamilyOptions_setMoveFiles( JNIEnv *, jobject, jlong jhandle, jboolean jmove_files) { auto *options = reinterpret_cast(jhandle); @@ -35,11 +35,11 @@ void Java_org_rocksdb_ImportColumnFamilyOptions_setMoveFiles( } /* - * Class: org_rocksdb_ImportColumnFamilyOptions + * Class: org_forstdb_ImportColumnFamilyOptions * Method: moveFiles * Signature: (J)Z */ -jboolean Java_org_rocksdb_ImportColumnFamilyOptions_moveFiles(JNIEnv *, jobject, +jboolean Java_org_forstdb_ImportColumnFamilyOptions_moveFiles(JNIEnv *, jobject, jlong jhandle) { auto *options = reinterpret_cast(jhandle); @@ -47,11 +47,11 @@ jboolean Java_org_rocksdb_ImportColumnFamilyOptions_moveFiles(JNIEnv *, jobject, } /* - * Class: org_rocksdb_ImportColumnFamilyOptions + * Class: org_forstdb_ImportColumnFamilyOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_ImportColumnFamilyOptions_disposeInternal(JNIEnv *, +void Java_org_forstdb_ImportColumnFamilyOptions_disposeInternal(JNIEnv *, jobject, jlong jhandle) { delete reinterpret_cast( diff --git a/java/rocksjni/ingest_external_file_options.cc b/java/forstjni/ingest_external_file_options.cc similarity index 73% rename from java/rocksjni/ingest_external_file_options.cc rename to java/forstjni/ingest_external_file_options.cc index 052cf3325..8b87c33ab 100644 --- a/java/rocksjni/ingest_external_file_options.cc +++ b/java/forstjni/ingest_external_file_options.cc @@ -8,27 +8,27 @@ #include -#include "include/org_rocksdb_IngestExternalFileOptions.h" +#include "include/org_forstdb_IngestExternalFileOptions.h" #include "rocksdb/options.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: newIngestExternalFileOptions * Signature: ()J */ -jlong Java_org_rocksdb_IngestExternalFileOptions_newIngestExternalFileOptions__( +jlong Java_org_forstdb_IngestExternalFileOptions_newIngestExternalFileOptions__( JNIEnv*, jclass) { auto* options = new ROCKSDB_NAMESPACE::IngestExternalFileOptions(); return GET_CPLUSPLUS_POINTER(options); } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: newIngestExternalFileOptions * Signature: (ZZZZ)J */ -jlong Java_org_rocksdb_IngestExternalFileOptions_newIngestExternalFileOptions__ZZZZ( +jlong Java_org_forstdb_IngestExternalFileOptions_newIngestExternalFileOptions__ZZZZ( JNIEnv*, jclass, jboolean jmove_files, jboolean jsnapshot_consistency, jboolean jallow_global_seqno, jboolean jallow_blocking_flush) { auto* options = new ROCKSDB_NAMESPACE::IngestExternalFileOptions(); @@ -40,11 +40,11 @@ jlong Java_org_rocksdb_IngestExternalFileOptions_newIngestExternalFileOptions__Z } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: moveFiles * Signature: (J)Z */ -jboolean Java_org_rocksdb_IngestExternalFileOptions_moveFiles(JNIEnv*, jobject, +jboolean Java_org_forstdb_IngestExternalFileOptions_moveFiles(JNIEnv*, jobject, jlong jhandle) { auto* options = reinterpret_cast(jhandle); @@ -52,11 +52,11 @@ jboolean Java_org_rocksdb_IngestExternalFileOptions_moveFiles(JNIEnv*, jobject, } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: setMoveFiles * Signature: (JZ)V */ -void Java_org_rocksdb_IngestExternalFileOptions_setMoveFiles( +void Java_org_forstdb_IngestExternalFileOptions_setMoveFiles( JNIEnv*, jobject, jlong jhandle, jboolean jmove_files) { auto* options = reinterpret_cast(jhandle); @@ -64,11 +64,11 @@ void Java_org_rocksdb_IngestExternalFileOptions_setMoveFiles( } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: snapshotConsistency * Signature: (J)Z */ -jboolean Java_org_rocksdb_IngestExternalFileOptions_snapshotConsistency( +jboolean Java_org_forstdb_IngestExternalFileOptions_snapshotConsistency( JNIEnv*, jobject, jlong jhandle) { auto* options = reinterpret_cast(jhandle); @@ -76,11 +76,11 @@ jboolean Java_org_rocksdb_IngestExternalFileOptions_snapshotConsistency( } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: setSnapshotConsistency * Signature: (JZ)V */ -void Java_org_rocksdb_IngestExternalFileOptions_setSnapshotConsistency( +void Java_org_forstdb_IngestExternalFileOptions_setSnapshotConsistency( JNIEnv*, jobject, jlong jhandle, jboolean jsnapshot_consistency) { auto* options = reinterpret_cast(jhandle); @@ -88,11 +88,11 @@ void Java_org_rocksdb_IngestExternalFileOptions_setSnapshotConsistency( } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: allowGlobalSeqNo * Signature: (J)Z */ -jboolean Java_org_rocksdb_IngestExternalFileOptions_allowGlobalSeqNo( +jboolean Java_org_forstdb_IngestExternalFileOptions_allowGlobalSeqNo( JNIEnv*, jobject, jlong jhandle) { auto* options = reinterpret_cast(jhandle); @@ -100,11 +100,11 @@ jboolean Java_org_rocksdb_IngestExternalFileOptions_allowGlobalSeqNo( } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: setAllowGlobalSeqNo * Signature: (JZ)V */ -void Java_org_rocksdb_IngestExternalFileOptions_setAllowGlobalSeqNo( +void Java_org_forstdb_IngestExternalFileOptions_setAllowGlobalSeqNo( JNIEnv*, jobject, jlong jhandle, jboolean jallow_global_seqno) { auto* options = reinterpret_cast(jhandle); @@ -112,11 +112,11 @@ void Java_org_rocksdb_IngestExternalFileOptions_setAllowGlobalSeqNo( } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: allowBlockingFlush * Signature: (J)Z */ -jboolean Java_org_rocksdb_IngestExternalFileOptions_allowBlockingFlush( +jboolean Java_org_forstdb_IngestExternalFileOptions_allowBlockingFlush( JNIEnv*, jobject, jlong jhandle) { auto* options = reinterpret_cast(jhandle); @@ -124,11 +124,11 @@ jboolean Java_org_rocksdb_IngestExternalFileOptions_allowBlockingFlush( } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: setAllowBlockingFlush * Signature: (JZ)V */ -void Java_org_rocksdb_IngestExternalFileOptions_setAllowBlockingFlush( +void Java_org_forstdb_IngestExternalFileOptions_setAllowBlockingFlush( JNIEnv*, jobject, jlong jhandle, jboolean jallow_blocking_flush) { auto* options = reinterpret_cast(jhandle); @@ -136,11 +136,11 @@ void Java_org_rocksdb_IngestExternalFileOptions_setAllowBlockingFlush( } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: ingestBehind * Signature: (J)Z */ -jboolean Java_org_rocksdb_IngestExternalFileOptions_ingestBehind( +jboolean Java_org_forstdb_IngestExternalFileOptions_ingestBehind( JNIEnv*, jobject, jlong jhandle) { auto* options = reinterpret_cast(jhandle); @@ -148,11 +148,11 @@ jboolean Java_org_rocksdb_IngestExternalFileOptions_ingestBehind( } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: setIngestBehind * Signature: (JZ)V */ -void Java_org_rocksdb_IngestExternalFileOptions_setIngestBehind( +void Java_org_forstdb_IngestExternalFileOptions_setIngestBehind( JNIEnv*, jobject, jlong jhandle, jboolean jingest_behind) { auto* options = reinterpret_cast(jhandle); @@ -160,12 +160,12 @@ void Java_org_rocksdb_IngestExternalFileOptions_setIngestBehind( } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: writeGlobalSeqno * Signature: (J)Z */ JNIEXPORT jboolean JNICALL -Java_org_rocksdb_IngestExternalFileOptions_writeGlobalSeqno(JNIEnv*, jobject, +Java_org_forstdb_IngestExternalFileOptions_writeGlobalSeqno(JNIEnv*, jobject, jlong jhandle) { auto* options = reinterpret_cast(jhandle); @@ -173,12 +173,12 @@ Java_org_rocksdb_IngestExternalFileOptions_writeGlobalSeqno(JNIEnv*, jobject, } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: setWriteGlobalSeqno * Signature: (JZ)V */ JNIEXPORT void JNICALL -Java_org_rocksdb_IngestExternalFileOptions_setWriteGlobalSeqno( +Java_org_forstdb_IngestExternalFileOptions_setWriteGlobalSeqno( JNIEnv*, jobject, jlong jhandle, jboolean jwrite_global_seqno) { auto* options = reinterpret_cast(jhandle); @@ -186,11 +186,11 @@ Java_org_rocksdb_IngestExternalFileOptions_setWriteGlobalSeqno( } /* - * Class: org_rocksdb_IngestExternalFileOptions + * Class: org_forstdb_IngestExternalFileOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_IngestExternalFileOptions_disposeInternal(JNIEnv*, +void Java_org_forstdb_IngestExternalFileOptions_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* options = diff --git a/java/rocksjni/iterator.cc b/java/forstjni/iterator.cc similarity index 82% rename from java/rocksjni/iterator.cc rename to java/forstjni/iterator.cc index 3ddb9778b..c202e5b41 100644 --- a/java/rocksjni/iterator.cc +++ b/java/forstjni/iterator.cc @@ -14,15 +14,15 @@ #include -#include "include/org_rocksdb_RocksIterator.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_RocksIterator.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_RocksIterator_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_RocksIterator_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); @@ -31,64 +31,64 @@ void Java_org_rocksdb_RocksIterator_disposeInternal(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: isValid0 * Signature: (J)Z */ -jboolean Java_org_rocksdb_RocksIterator_isValid0(JNIEnv* /*env*/, +jboolean Java_org_forstdb_RocksIterator_isValid0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { return reinterpret_cast(handle)->Valid(); } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: seekToFirst0 * Signature: (J)V */ -void Java_org_rocksdb_RocksIterator_seekToFirst0(JNIEnv* /*env*/, +void Java_org_forstdb_RocksIterator_seekToFirst0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->SeekToFirst(); } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: seekToLast0 * Signature: (J)V */ -void Java_org_rocksdb_RocksIterator_seekToLast0(JNIEnv* /*env*/, +void Java_org_forstdb_RocksIterator_seekToLast0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->SeekToLast(); } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: next0 * Signature: (J)V */ -void Java_org_rocksdb_RocksIterator_next0(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_RocksIterator_next0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->Next(); } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: prev0 * Signature: (J)V */ -void Java_org_rocksdb_RocksIterator_prev0(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_RocksIterator_prev0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->Prev(); } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: refresh0 * Signature: (J)V */ -void Java_org_rocksdb_RocksIterator_refresh0(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_RocksIterator_refresh0(JNIEnv* env, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); ROCKSDB_NAMESPACE::Status s = it->Refresh(); @@ -101,11 +101,11 @@ void Java_org_rocksdb_RocksIterator_refresh0(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: seek0 * Signature: (J[BI)V */ -void Java_org_rocksdb_RocksIterator_seek0(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_RocksIterator_seek0(JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, jint jtarget_len) { auto* it = reinterpret_cast(handle); @@ -120,11 +120,11 @@ void Java_org_rocksdb_RocksIterator_seek0(JNIEnv* env, jobject /*jobj*/, * the Java wrapper extracts the byte[] and passes it here. * In this case, the buffer offset of the key may be non-zero. * - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: seek0 * Signature: (J[BII)V */ -void Java_org_rocksdb_RocksIterator_seekByteArray0( +void Java_org_forstdb_RocksIterator_seekByteArray0( JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, jint jtarget_off, jint jtarget_len) { auto* it = reinterpret_cast(handle); @@ -136,11 +136,11 @@ void Java_org_rocksdb_RocksIterator_seekByteArray0( } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: seekDirect0 * Signature: (JLjava/nio/ByteBuffer;II)V */ -void Java_org_rocksdb_RocksIterator_seekDirect0(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_RocksIterator_seekDirect0(JNIEnv* env, jobject /*jobj*/, jlong handle, jobject jtarget, jint jtarget_off, jint jtarget_len) { @@ -153,11 +153,11 @@ void Java_org_rocksdb_RocksIterator_seekDirect0(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: seekForPrevDirect0 * Signature: (JLjava/nio/ByteBuffer;II)V */ -void Java_org_rocksdb_RocksIterator_seekForPrevDirect0( +void Java_org_forstdb_RocksIterator_seekForPrevDirect0( JNIEnv* env, jobject /*jobj*/, jlong handle, jobject jtarget, jint jtarget_off, jint jtarget_len) { auto* it = reinterpret_cast(handle); @@ -169,11 +169,11 @@ void Java_org_rocksdb_RocksIterator_seekForPrevDirect0( } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: seekForPrev0 * Signature: (J[BI)V */ -void Java_org_rocksdb_RocksIterator_seekForPrev0(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_RocksIterator_seekForPrev0(JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, jint jtarget_len) { @@ -189,11 +189,11 @@ void Java_org_rocksdb_RocksIterator_seekForPrev0(JNIEnv* env, jobject /*jobj*/, * the Java wrapper extracts the byte[] and passes it here. * In this case, the buffer offset of the key may be non-zero. * - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: seek0 * Signature: (J[BII)V */ -void Java_org_rocksdb_RocksIterator_seekForPrevByteArray0( +void Java_org_forstdb_RocksIterator_seekForPrevByteArray0( JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, jint jtarget_off, jint jtarget_len) { auto* it = reinterpret_cast(handle); @@ -205,11 +205,11 @@ void Java_org_rocksdb_RocksIterator_seekForPrevByteArray0( } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: status0 * Signature: (J)V */ -void Java_org_rocksdb_RocksIterator_status0(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_RocksIterator_status0(JNIEnv* env, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); ROCKSDB_NAMESPACE::Status s = it->status(); @@ -222,11 +222,11 @@ void Java_org_rocksdb_RocksIterator_status0(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: key0 * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_RocksIterator_key0(JNIEnv* env, jobject /*jobj*/, +jbyteArray Java_org_forstdb_RocksIterator_key0(JNIEnv* env, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); ROCKSDB_NAMESPACE::Slice key_slice = it->key(); @@ -243,11 +243,11 @@ jbyteArray Java_org_rocksdb_RocksIterator_key0(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: keyDirect0 * Signature: (JLjava/nio/ByteBuffer;II)I */ -jint Java_org_rocksdb_RocksIterator_keyDirect0(JNIEnv* env, jobject /*jobj*/, +jint Java_org_forstdb_RocksIterator_keyDirect0(JNIEnv* env, jobject /*jobj*/, jlong handle, jobject jtarget, jint jtarget_off, jint jtarget_len) { @@ -261,11 +261,11 @@ jint Java_org_rocksdb_RocksIterator_keyDirect0(JNIEnv* env, jobject /*jobj*/, * This method supports fetching into indirect byte buffers; * the Java wrapper extracts the byte[] and passes it here. * - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: keyByteArray0 * Signature: (J[BII)I */ -jint Java_org_rocksdb_RocksIterator_keyByteArray0(JNIEnv* env, jobject /*jobj*/, +jint Java_org_forstdb_RocksIterator_keyByteArray0(JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jkey, jint jkey_off, jint jkey_len) { @@ -281,11 +281,11 @@ jint Java_org_rocksdb_RocksIterator_keyByteArray0(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: value0 * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_RocksIterator_value0(JNIEnv* env, jobject /*jobj*/, +jbyteArray Java_org_forstdb_RocksIterator_value0(JNIEnv* env, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); ROCKSDB_NAMESPACE::Slice value_slice = it->value(); @@ -303,11 +303,11 @@ jbyteArray Java_org_rocksdb_RocksIterator_value0(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: valueDirect0 * Signature: (JLjava/nio/ByteBuffer;II)I */ -jint Java_org_rocksdb_RocksIterator_valueDirect0(JNIEnv* env, jobject /*jobj*/, +jint Java_org_forstdb_RocksIterator_valueDirect0(JNIEnv* env, jobject /*jobj*/, jlong handle, jobject jtarget, jint jtarget_off, jint jtarget_len) { @@ -321,11 +321,11 @@ jint Java_org_rocksdb_RocksIterator_valueDirect0(JNIEnv* env, jobject /*jobj*/, * This method supports fetching into indirect byte buffers; * the Java wrapper extracts the byte[] and passes it here. * - * Class: org_rocksdb_RocksIterator + * Class: org_forstdb_RocksIterator * Method: valueByteArray0 * Signature: (J[BII)I */ -jint Java_org_rocksdb_RocksIterator_valueByteArray0( +jint Java_org_forstdb_RocksIterator_valueByteArray0( JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jvalue_target, jint jvalue_off, jint jvalue_len) { auto* it = reinterpret_cast(handle); diff --git a/java/rocksjni/jni_perf_context.cc b/java/forstjni/jni_perf_context.cc similarity index 75% rename from java/rocksjni/jni_perf_context.cc rename to java/forstjni/jni_perf_context.cc index e0124fdaa..813a3aed7 100644 --- a/java/rocksjni/jni_perf_context.cc +++ b/java/forstjni/jni_perf_context.cc @@ -5,22 +5,22 @@ #include -#include "include/org_rocksdb_PerfContext.h" +#include "include/org_forstdb_PerfContext.h" #include "rocksdb/db.h" #include "rocksdb/perf_context.h" -void Java_org_rocksdb_PerfContext_reset(JNIEnv*, jobject, jlong jpc_handle) { +void Java_org_forstdb_PerfContext_reset(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); perf_context->Reset(); } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getUserKeyComparisonCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getUserKeyComparisonCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getUserKeyComparisonCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -28,11 +28,11 @@ jlong Java_org_rocksdb_PerfContext_getUserKeyComparisonCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlockCacheHitCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlockCacheHitCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlockCacheHitCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -40,11 +40,11 @@ jlong Java_org_rocksdb_PerfContext_getBlockCacheHitCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlockReadCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlockReadCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlockReadCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -52,11 +52,11 @@ jlong Java_org_rocksdb_PerfContext_getBlockReadCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlockCacheIndexHitCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlockCacheIndexHitCount( +jlong Java_org_forstdb_PerfContext_getBlockCacheIndexHitCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -64,11 +64,11 @@ jlong Java_org_rocksdb_PerfContext_getBlockCacheIndexHitCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlockCacheStandaloneHandleCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlockCacheStandaloneHandleCount( +jlong Java_org_forstdb_PerfContext_getBlockCacheStandaloneHandleCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -76,11 +76,11 @@ jlong Java_org_rocksdb_PerfContext_getBlockCacheStandaloneHandleCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlockCacheRealHandleCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlockCacheRealHandleCount( +jlong Java_org_forstdb_PerfContext_getBlockCacheRealHandleCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -88,11 +88,11 @@ jlong Java_org_rocksdb_PerfContext_getBlockCacheRealHandleCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getIndexBlockReadCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getIndexBlockReadCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getIndexBlockReadCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -100,11 +100,11 @@ jlong Java_org_rocksdb_PerfContext_getIndexBlockReadCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlockCacheFilterHitCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlockCacheFilterHitCount( +jlong Java_org_forstdb_PerfContext_getBlockCacheFilterHitCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -112,11 +112,11 @@ jlong Java_org_rocksdb_PerfContext_getBlockCacheFilterHitCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getFilterBlockReadCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getFilterBlockReadCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getFilterBlockReadCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -124,11 +124,11 @@ jlong Java_org_rocksdb_PerfContext_getFilterBlockReadCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getCompressionDictBlockReadCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getCompressionDictBlockReadCount( +jlong Java_org_forstdb_PerfContext_getCompressionDictBlockReadCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -136,11 +136,11 @@ jlong Java_org_rocksdb_PerfContext_getCompressionDictBlockReadCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlockReadByte * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlockReadByte(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlockReadByte(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -148,18 +148,18 @@ jlong Java_org_rocksdb_PerfContext_getBlockReadByte(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlockReadTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlockReadTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlockReadTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); return perf_context->block_read_time; } -jlong Java_org_rocksdb_PerfContext_getBlockReadCpuTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlockReadCpuTime(JNIEnv*, jobject, jlong jpc_handler) { // reinterpret_cast(jcf_handle); ROCKSDB_NAMESPACE::PerfContext* perf_context = @@ -168,11 +168,11 @@ jlong Java_org_rocksdb_PerfContext_getBlockReadCpuTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getSecondaryCacheHitCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getSecondaryCacheHitCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getSecondaryCacheHitCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -180,11 +180,11 @@ jlong Java_org_rocksdb_PerfContext_getSecondaryCacheHitCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getCompressedSecCacheInsertRealCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getCompressedSecCacheInsertRealCount( +jlong Java_org_forstdb_PerfContext_getCompressedSecCacheInsertRealCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -192,11 +192,11 @@ jlong Java_org_rocksdb_PerfContext_getCompressedSecCacheInsertRealCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getCompressedSecCacheInsertDummyCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getCompressedSecCacheInsertDummyCount( +jlong Java_org_forstdb_PerfContext_getCompressedSecCacheInsertDummyCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -204,11 +204,11 @@ jlong Java_org_rocksdb_PerfContext_getCompressedSecCacheInsertDummyCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getCompressedSecCacheUncompressedBytes * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getCompressedSecCacheUncompressedBytes( +jlong Java_org_forstdb_PerfContext_getCompressedSecCacheUncompressedBytes( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -216,11 +216,11 @@ jlong Java_org_rocksdb_PerfContext_getCompressedSecCacheUncompressedBytes( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getCompressedSecCacheCompressedBytes * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getCompressedSecCacheCompressedBytes( +jlong Java_org_forstdb_PerfContext_getCompressedSecCacheCompressedBytes( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -228,11 +228,11 @@ jlong Java_org_rocksdb_PerfContext_getCompressedSecCacheCompressedBytes( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlockChecksumTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlockChecksumTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlockChecksumTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -240,11 +240,11 @@ jlong Java_org_rocksdb_PerfContext_getBlockChecksumTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlockDecompressTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlockDecompressTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlockDecompressTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -252,11 +252,11 @@ jlong Java_org_rocksdb_PerfContext_getBlockDecompressTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getReadBytes * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getReadBytes(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getReadBytes(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -264,11 +264,11 @@ jlong Java_org_rocksdb_PerfContext_getReadBytes(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getMultigetReadBytes * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getMultigetReadBytes(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getMultigetReadBytes(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -276,11 +276,11 @@ jlong Java_org_rocksdb_PerfContext_getMultigetReadBytes(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getIterReadBytes * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getIterReadBytes(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getIterReadBytes(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -288,11 +288,11 @@ jlong Java_org_rocksdb_PerfContext_getIterReadBytes(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlobCacheHitCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlobCacheHitCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlobCacheHitCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -300,11 +300,11 @@ jlong Java_org_rocksdb_PerfContext_getBlobCacheHitCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlobReadCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlobReadCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlobReadCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -312,11 +312,11 @@ jlong Java_org_rocksdb_PerfContext_getBlobReadCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlobReadByte * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlobReadByte(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlobReadByte(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -324,11 +324,11 @@ jlong Java_org_rocksdb_PerfContext_getBlobReadByte(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlobReadTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlobReadTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlobReadTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -336,11 +336,11 @@ jlong Java_org_rocksdb_PerfContext_getBlobReadTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlobChecksumTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlobChecksumTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlobChecksumTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -348,11 +348,11 @@ jlong Java_org_rocksdb_PerfContext_getBlobChecksumTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlobDecompressTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlobDecompressTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlobDecompressTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -360,11 +360,11 @@ jlong Java_org_rocksdb_PerfContext_getBlobDecompressTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getInternal_key_skipped_count * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getInternalKeySkippedCount( +jlong Java_org_forstdb_PerfContext_getInternalKeySkippedCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -372,11 +372,11 @@ jlong Java_org_rocksdb_PerfContext_getInternalKeySkippedCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getInternalDeleteSkippedCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getInternalDeleteSkippedCount( +jlong Java_org_forstdb_PerfContext_getInternalDeleteSkippedCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -384,11 +384,11 @@ jlong Java_org_rocksdb_PerfContext_getInternalDeleteSkippedCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getInternalRecentSkippedCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getInternalRecentSkippedCount( +jlong Java_org_forstdb_PerfContext_getInternalRecentSkippedCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -396,11 +396,11 @@ jlong Java_org_rocksdb_PerfContext_getInternalRecentSkippedCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getInternalMergeCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getInternalMergeCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getInternalMergeCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -408,11 +408,11 @@ jlong Java_org_rocksdb_PerfContext_getInternalMergeCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getInternalMergePointLookupCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getInternalMergePointLookupCount( +jlong Java_org_forstdb_PerfContext_getInternalMergePointLookupCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -420,11 +420,11 @@ jlong Java_org_rocksdb_PerfContext_getInternalMergePointLookupCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getInternalRangeDelReseekCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getInternalRangeDelReseekCount( +jlong Java_org_forstdb_PerfContext_getInternalRangeDelReseekCount( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -432,11 +432,11 @@ jlong Java_org_rocksdb_PerfContext_getInternalRangeDelReseekCount( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getSnapshotTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getSnapshotTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getSnapshotTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -444,11 +444,11 @@ jlong Java_org_rocksdb_PerfContext_getSnapshotTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getFromMemtableTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getFromMemtableTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getFromMemtableTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -456,11 +456,11 @@ jlong Java_org_rocksdb_PerfContext_getFromMemtableTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getFromMemtableCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getFromMemtableCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getFromMemtableCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -468,11 +468,11 @@ jlong Java_org_rocksdb_PerfContext_getFromMemtableCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getPostProcessTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getPostProcessTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getPostProcessTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -480,11 +480,11 @@ jlong Java_org_rocksdb_PerfContext_getPostProcessTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getFromOutputFilesTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getFromOutputFilesTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getFromOutputFilesTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -492,11 +492,11 @@ jlong Java_org_rocksdb_PerfContext_getFromOutputFilesTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getSeekOnMemtableTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getSeekOnMemtableTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getSeekOnMemtableTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -504,11 +504,11 @@ jlong Java_org_rocksdb_PerfContext_getSeekOnMemtableTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getSeekOnMemtableCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getSeekOnMemtableCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getSeekOnMemtableCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -516,11 +516,11 @@ jlong Java_org_rocksdb_PerfContext_getSeekOnMemtableCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getNextOnMemtableCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getNextOnMemtableCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getNextOnMemtableCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -528,11 +528,11 @@ jlong Java_org_rocksdb_PerfContext_getNextOnMemtableCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getPrevOnMemtableCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getPrevOnMemtableCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getPrevOnMemtableCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -540,11 +540,11 @@ jlong Java_org_rocksdb_PerfContext_getPrevOnMemtableCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getSeekChildSeekTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getSeekChildSeekTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getSeekChildSeekTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -552,11 +552,11 @@ jlong Java_org_rocksdb_PerfContext_getSeekChildSeekTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getSeekChildSeekCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getSeekChildSeekCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getSeekChildSeekCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -564,11 +564,11 @@ jlong Java_org_rocksdb_PerfContext_getSeekChildSeekCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getSeekMinHeapTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getSeekMinHeapTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getSeekMinHeapTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -576,11 +576,11 @@ jlong Java_org_rocksdb_PerfContext_getSeekMinHeapTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getSeekMaxHeapTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getSeekMaxHeapTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getSeekMaxHeapTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -588,11 +588,11 @@ jlong Java_org_rocksdb_PerfContext_getSeekMaxHeapTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getSeekInternalSeekTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getSeekInternalSeekTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getSeekInternalSeekTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -600,11 +600,11 @@ jlong Java_org_rocksdb_PerfContext_getSeekInternalSeekTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getFindNextUserEntryTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getFindNextUserEntryTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getFindNextUserEntryTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -612,11 +612,11 @@ jlong Java_org_rocksdb_PerfContext_getFindNextUserEntryTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getWriteWalTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getWriteWalTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getWriteWalTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -624,11 +624,11 @@ jlong Java_org_rocksdb_PerfContext_getWriteWalTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getWriteMemtableTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getWriteMemtableTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getWriteMemtableTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -636,11 +636,11 @@ jlong Java_org_rocksdb_PerfContext_getWriteMemtableTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getWriteDelayTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getWriteDelayTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getWriteDelayTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -648,11 +648,11 @@ jlong Java_org_rocksdb_PerfContext_getWriteDelayTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getWriteSchedulingFlushesCompactionsTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getWriteSchedulingFlushesCompactionsTime( +jlong Java_org_forstdb_PerfContext_getWriteSchedulingFlushesCompactionsTime( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -660,11 +660,11 @@ jlong Java_org_rocksdb_PerfContext_getWriteSchedulingFlushesCompactionsTime( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getWritePreAndPostProcessTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getWritePreAndPostProcessTime( +jlong Java_org_forstdb_PerfContext_getWritePreAndPostProcessTime( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -672,11 +672,11 @@ jlong Java_org_rocksdb_PerfContext_getWritePreAndPostProcessTime( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getWriteThreadWaitNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getWriteThreadWaitNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getWriteThreadWaitNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -684,11 +684,11 @@ jlong Java_org_rocksdb_PerfContext_getWriteThreadWaitNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getDbMutexLockNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getDbMutexLockNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getDbMutexLockNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -696,11 +696,11 @@ jlong Java_org_rocksdb_PerfContext_getDbMutexLockNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getDbConditionWaitNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getDbConditionWaitNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getDbConditionWaitNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -708,11 +708,11 @@ jlong Java_org_rocksdb_PerfContext_getDbConditionWaitNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getMergeOperatorTimeNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getMergeOperatorTimeNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getMergeOperatorTimeNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -720,11 +720,11 @@ jlong Java_org_rocksdb_PerfContext_getMergeOperatorTimeNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getReadIndexBlockNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getReadIndexBlockNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getReadIndexBlockNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -732,11 +732,11 @@ jlong Java_org_rocksdb_PerfContext_getReadIndexBlockNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getReadFilterBlockNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getReadFilterBlockNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getReadFilterBlockNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -744,11 +744,11 @@ jlong Java_org_rocksdb_PerfContext_getReadFilterBlockNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getNewTableBlockIterNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getNewTableBlockIterNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getNewTableBlockIterNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -756,11 +756,11 @@ jlong Java_org_rocksdb_PerfContext_getNewTableBlockIterNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getNewTableIteratorNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getNewTableIteratorNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getNewTableIteratorNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -768,11 +768,11 @@ jlong Java_org_rocksdb_PerfContext_getNewTableIteratorNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBlockSeekNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBlockSeekNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBlockSeekNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -780,11 +780,11 @@ jlong Java_org_rocksdb_PerfContext_getBlockSeekNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getFindTableNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getFindTableNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getFindTableNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -792,11 +792,11 @@ jlong Java_org_rocksdb_PerfContext_getFindTableNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBloomMemtableHitCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBloomMemtableHitCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBloomMemtableHitCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -804,11 +804,11 @@ jlong Java_org_rocksdb_PerfContext_getBloomMemtableHitCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBloomMemtableMissCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBloomMemtableMissCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBloomMemtableMissCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -816,11 +816,11 @@ jlong Java_org_rocksdb_PerfContext_getBloomMemtableMissCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBloomSstHitCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBloomSstHitCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBloomSstHitCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -828,11 +828,11 @@ jlong Java_org_rocksdb_PerfContext_getBloomSstHitCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getBloomSstMissCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getBloomSstMissCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getBloomSstMissCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -840,11 +840,11 @@ jlong Java_org_rocksdb_PerfContext_getBloomSstMissCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getKeyLockWaitTime * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getKeyLockWaitTime(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getKeyLockWaitTime(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -852,11 +852,11 @@ jlong Java_org_rocksdb_PerfContext_getKeyLockWaitTime(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getKeyLockWaitCount * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getKeyLockWaitCount(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getKeyLockWaitCount(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -864,11 +864,11 @@ jlong Java_org_rocksdb_PerfContext_getKeyLockWaitCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvNewSequentialFileNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvNewSequentialFileNanos( +jlong Java_org_forstdb_PerfContext_getEnvNewSequentialFileNanos( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -876,11 +876,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvNewSequentialFileNanos( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvNewRandomAccessFileNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvNewRandomAccessFileNanos( +jlong Java_org_forstdb_PerfContext_getEnvNewRandomAccessFileNanos( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -888,11 +888,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvNewRandomAccessFileNanos( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvNewWritableFileNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvNewWritableFileNanos( +jlong Java_org_forstdb_PerfContext_getEnvNewWritableFileNanos( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -900,11 +900,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvNewWritableFileNanos( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvReuseWritableFileNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvReuseWritableFileNanos( +jlong Java_org_forstdb_PerfContext_getEnvReuseWritableFileNanos( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -912,11 +912,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvReuseWritableFileNanos( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvNewRandomRwFileNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvNewRandomRwFileNanos( +jlong Java_org_forstdb_PerfContext_getEnvNewRandomRwFileNanos( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -924,11 +924,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvNewRandomRwFileNanos( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvNewDirectoryNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvNewDirectoryNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvNewDirectoryNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -936,11 +936,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvNewDirectoryNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvFileExistsNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvFileExistsNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvFileExistsNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -948,11 +948,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvFileExistsNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvGetChildrenNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvGetChildrenNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvGetChildrenNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -960,11 +960,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvGetChildrenNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvGetChildrenFileAttributesNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvGetChildrenFileAttributesNanos( +jlong Java_org_forstdb_PerfContext_getEnvGetChildrenFileAttributesNanos( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -972,11 +972,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvGetChildrenFileAttributesNanos( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvDeleteFileNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvDeleteFileNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvDeleteFileNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -984,11 +984,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvDeleteFileNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvCreateDirNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvCreateDirNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvCreateDirNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -996,11 +996,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvCreateDirNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvCreateDirIfMissingNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvCreateDirIfMissingNanos( +jlong Java_org_forstdb_PerfContext_getEnvCreateDirIfMissingNanos( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1008,11 +1008,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvCreateDirIfMissingNanos( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvDeleteDirNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvDeleteDirNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvDeleteDirNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1020,11 +1020,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvDeleteDirNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvGetFileSizeNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvGetFileSizeNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvGetFileSizeNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1032,11 +1032,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvGetFileSizeNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvGetFileModificationTimeNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvGetFileModificationTimeNanos( +jlong Java_org_forstdb_PerfContext_getEnvGetFileModificationTimeNanos( JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1044,11 +1044,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvGetFileModificationTimeNanos( } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvRenameFileNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvRenameFileNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvRenameFileNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1056,11 +1056,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvRenameFileNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvLinkFileNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvLinkFileNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvLinkFileNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1068,11 +1068,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvLinkFileNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvLockFileNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvLockFileNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvLockFileNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1080,11 +1080,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvLockFileNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvUnlockFileNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvUnlockFileNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvUnlockFileNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1092,11 +1092,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvUnlockFileNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEnvNewLoggerNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEnvNewLoggerNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEnvNewLoggerNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1104,11 +1104,11 @@ jlong Java_org_rocksdb_PerfContext_getEnvNewLoggerNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getCpuNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getGetCpuNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getGetCpuNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1116,11 +1116,11 @@ jlong Java_org_rocksdb_PerfContext_getGetCpuNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getIterNextCpuNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getIterNextCpuNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getIterNextCpuNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1128,11 +1128,11 @@ jlong Java_org_rocksdb_PerfContext_getIterNextCpuNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getIterPrevCpuNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getIterPrevCpuNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getIterPrevCpuNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1140,11 +1140,11 @@ jlong Java_org_rocksdb_PerfContext_getIterPrevCpuNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getIterSeekCpuNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getIterSeekCpuNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getIterSeekCpuNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1152,11 +1152,11 @@ jlong Java_org_rocksdb_PerfContext_getIterSeekCpuNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getEncryptDataNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getEncryptDataNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getEncryptDataNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1164,11 +1164,11 @@ jlong Java_org_rocksdb_PerfContext_getEncryptDataNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getDecryptDataNanos * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getDecryptDataNanos(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getDecryptDataNanos(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); @@ -1176,11 +1176,11 @@ jlong Java_org_rocksdb_PerfContext_getDecryptDataNanos(JNIEnv*, jobject, } /* - * Class: org_rocksdb_PerfContext + * Class: org_forstdb_PerfContext * Method: getNumberAsyncSeek * Signature: (J)J */ -jlong Java_org_rocksdb_PerfContext_getNumberAsyncSeek(JNIEnv*, jobject, +jlong Java_org_forstdb_PerfContext_getNumberAsyncSeek(JNIEnv*, jobject, jlong jpc_handle) { ROCKSDB_NAMESPACE::PerfContext* perf_context = reinterpret_cast(jpc_handle); diff --git a/java/rocksjni/jnicallback.cc b/java/forstjni/jnicallback.cc similarity index 96% rename from java/rocksjni/jnicallback.cc rename to java/forstjni/jnicallback.cc index f2742cd88..51fe1f04c 100644 --- a/java/rocksjni/jnicallback.cc +++ b/java/forstjni/jnicallback.cc @@ -6,11 +6,11 @@ // This file implements the callback "bridge" between Java and C++ for // JNI Callbacks from C++ to sub-classes or org.rocksdb.RocksCallbackObject -#include "rocksjni/jnicallback.h" +#include "forstjni/jnicallback.h" #include -#include "rocksjni/portal.h" +#include "forstjni/portal.h" namespace ROCKSDB_NAMESPACE { JniCallback::JniCallback(JNIEnv* env, jobject jcallback_obj) { diff --git a/java/rocksjni/jnicallback.h b/java/forstjni/jnicallback.h similarity index 100% rename from java/rocksjni/jnicallback.h rename to java/forstjni/jnicallback.h diff --git a/java/rocksjni/kv_helper.h b/java/forstjni/kv_helper.h similarity index 99% rename from java/rocksjni/kv_helper.h rename to java/forstjni/kv_helper.h index 0eb2c6eb0..4caffa16c 100644 --- a/java/rocksjni/kv_helper.h +++ b/java/forstjni/kv_helper.h @@ -18,7 +18,7 @@ #include "rocksdb/rocksdb_namespace.h" #include "rocksdb/slice.h" #include "rocksdb/status.h" -#include "rocksjni/portal.h" +#include "forstjni/portal.h" namespace ROCKSDB_NAMESPACE { diff --git a/java/rocksjni/loggerjnicallback.cc b/java/forstjni/loggerjnicallback.cc similarity index 92% rename from java/rocksjni/loggerjnicallback.cc rename to java/forstjni/loggerjnicallback.cc index aa9f95cd4..82724e945 100644 --- a/java/rocksjni/loggerjnicallback.cc +++ b/java/forstjni/loggerjnicallback.cc @@ -6,14 +6,14 @@ // This file implements the callback "bridge" between Java and C++ for // ROCKSDB_NAMESPACE::Logger. -#include "rocksjni/loggerjnicallback.h" +#include "forstjni/loggerjnicallback.h" #include #include -#include "include/org_rocksdb_Logger.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_Logger.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" namespace ROCKSDB_NAMESPACE { @@ -223,11 +223,11 @@ LoggerJniCallback::~LoggerJniCallback() { } // namespace ROCKSDB_NAMESPACE /* - * Class: org_rocksdb_Logger + * Class: org_forstdb_Logger * Method: createNewLoggerOptions * Signature: (J)J */ -jlong Java_org_rocksdb_Logger_createNewLoggerOptions(JNIEnv* env, jobject jobj, +jlong Java_org_forstdb_Logger_createNewLoggerOptions(JNIEnv* env, jobject jobj, jlong joptions) { auto* sptr_logger = new std::shared_ptr( new ROCKSDB_NAMESPACE::LoggerJniCallback(env, jobj)); @@ -240,11 +240,11 @@ jlong Java_org_rocksdb_Logger_createNewLoggerOptions(JNIEnv* env, jobject jobj, } /* - * Class: org_rocksdb_Logger + * Class: org_forstdb_Logger * Method: createNewLoggerDbOptions * Signature: (J)J */ -jlong Java_org_rocksdb_Logger_createNewLoggerDbOptions(JNIEnv* env, +jlong Java_org_forstdb_Logger_createNewLoggerDbOptions(JNIEnv* env, jobject jobj, jlong jdb_options) { auto* sptr_logger = new std::shared_ptr( @@ -259,11 +259,11 @@ jlong Java_org_rocksdb_Logger_createNewLoggerDbOptions(JNIEnv* env, } /* - * Class: org_rocksdb_Logger + * Class: org_forstdb_Logger * Method: setInfoLogLevel * Signature: (JB)V */ -void Java_org_rocksdb_Logger_setInfoLogLevel(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_Logger_setInfoLogLevel(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jbyte jlog_level) { auto* handle = reinterpret_cast*>( @@ -273,11 +273,11 @@ void Java_org_rocksdb_Logger_setInfoLogLevel(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_Logger + * Class: org_forstdb_Logger * Method: infoLogLevel * Signature: (J)B */ -jbyte Java_org_rocksdb_Logger_infoLogLevel(JNIEnv* /*env*/, jobject /*jobj*/, +jbyte Java_org_forstdb_Logger_infoLogLevel(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* handle = reinterpret_cast*>( @@ -286,11 +286,11 @@ jbyte Java_org_rocksdb_Logger_infoLogLevel(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_Logger + * Class: org_forstdb_Logger * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_Logger_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_Logger_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* handle = reinterpret_cast*>( diff --git a/java/rocksjni/loggerjnicallback.h b/java/forstjni/loggerjnicallback.h similarity index 97% rename from java/rocksjni/loggerjnicallback.h rename to java/forstjni/loggerjnicallback.h index 57774988c..ec1393aa3 100644 --- a/java/rocksjni/loggerjnicallback.h +++ b/java/forstjni/loggerjnicallback.h @@ -16,7 +16,7 @@ #include "port/port.h" #include "rocksdb/env.h" -#include "rocksjni/jnicallback.h" +#include "forstjni/jnicallback.h" namespace ROCKSDB_NAMESPACE { diff --git a/java/rocksjni/lru_cache.cc b/java/forstjni/lru_cache.cc similarity index 78% rename from java/rocksjni/lru_cache.cc rename to java/forstjni/lru_cache.cc index 56dffa2f0..cc2bb1851 100644 --- a/java/rocksjni/lru_cache.cc +++ b/java/forstjni/lru_cache.cc @@ -10,15 +10,15 @@ #include -#include "include/org_rocksdb_LRUCache.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "include/org_forstdb_LRUCache.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_LRUCache + * Class: org_forstdb_LRUCache * Method: newLRUCache * Signature: (JIZD)J */ -jlong Java_org_rocksdb_LRUCache_newLRUCache(JNIEnv* /*env*/, jclass /*jcls*/, +jlong Java_org_forstdb_LRUCache_newLRUCache(JNIEnv* /*env*/, jclass /*jcls*/, jlong jcapacity, jint jnum_shard_bits, jboolean jstrict_capacity_limit, @@ -29,18 +29,18 @@ jlong Java_org_rocksdb_LRUCache_newLRUCache(JNIEnv* /*env*/, jclass /*jcls*/, static_cast(jcapacity), static_cast(jnum_shard_bits), static_cast(jstrict_capacity_limit), static_cast(jhigh_pri_pool_ratio), - nullptr /* memory_allocator */, rocksdb::kDefaultToAdaptiveMutex, - rocksdb::kDefaultCacheMetadataChargePolicy, + nullptr /* memory_allocator */, ROCKSDB_NAMESPACE::kDefaultToAdaptiveMutex, + ROCKSDB_NAMESPACE::kDefaultCacheMetadataChargePolicy, static_cast(jlow_pri_pool_ratio))); return GET_CPLUSPLUS_POINTER(sptr_lru_cache); } /* - * Class: org_rocksdb_LRUCache + * Class: org_forstdb_LRUCache * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_LRUCache_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_LRUCache_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* sptr_lru_cache = diff --git a/java/rocksjni/memory_util.cc b/java/forstjni/memory_util.cc similarity index 95% rename from java/rocksjni/memory_util.cc rename to java/forstjni/memory_util.cc index c87c4f403..9a40b6d75 100644 --- a/java/rocksjni/memory_util.cc +++ b/java/forstjni/memory_util.cc @@ -12,15 +12,15 @@ #include #include -#include "include/org_rocksdb_MemoryUtil.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_MemoryUtil.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_MemoryUtil + * Class: org_forstdb_MemoryUtil * Method: getApproximateMemoryUsageByType * Signature: ([J[J)Ljava/util/Map; */ -jobject Java_org_rocksdb_MemoryUtil_getApproximateMemoryUsageByType( +jobject Java_org_forstdb_MemoryUtil_getApproximateMemoryUsageByType( JNIEnv *env, jclass, jlongArray jdb_handles, jlongArray jcache_handles) { jboolean has_exception = JNI_FALSE; std::vector dbs = diff --git a/java/rocksjni/memtablejni.cc b/java/forstjni/memtablejni.cc similarity index 79% rename from java/rocksjni/memtablejni.cc rename to java/forstjni/memtablejni.cc index a4d02f354..59473c7c1 100644 --- a/java/rocksjni/memtablejni.cc +++ b/java/forstjni/memtablejni.cc @@ -5,20 +5,20 @@ // // This file implements the "bridge" between Java and C++ for MemTables. -#include "include/org_rocksdb_HashLinkedListMemTableConfig.h" -#include "include/org_rocksdb_HashSkipListMemTableConfig.h" -#include "include/org_rocksdb_SkipListMemTableConfig.h" -#include "include/org_rocksdb_VectorMemTableConfig.h" +#include "include/org_forstdb_HashLinkedListMemTableConfig.h" +#include "include/org_forstdb_HashSkipListMemTableConfig.h" +#include "include/org_forstdb_SkipListMemTableConfig.h" +#include "include/org_forstdb_VectorMemTableConfig.h" #include "rocksdb/memtablerep.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_HashSkipListMemTableConfig + * Class: org_forstdb_HashSkipListMemTableConfig * Method: newMemTableFactoryHandle * Signature: (JII)J */ -jlong Java_org_rocksdb_HashSkipListMemTableConfig_newMemTableFactoryHandle( +jlong Java_org_forstdb_HashSkipListMemTableConfig_newMemTableFactoryHandle( JNIEnv* env, jobject /*jobj*/, jlong jbucket_count, jint jheight, jint jbranching_factor) { ROCKSDB_NAMESPACE::Status s = @@ -33,11 +33,11 @@ jlong Java_org_rocksdb_HashSkipListMemTableConfig_newMemTableFactoryHandle( } /* - * Class: org_rocksdb_HashLinkedListMemTableConfig + * Class: org_forstdb_HashLinkedListMemTableConfig * Method: newMemTableFactoryHandle * Signature: (JJIZI)J */ -jlong Java_org_rocksdb_HashLinkedListMemTableConfig_newMemTableFactoryHandle( +jlong Java_org_forstdb_HashLinkedListMemTableConfig_newMemTableFactoryHandle( JNIEnv* env, jobject /*jobj*/, jlong jbucket_count, jlong jhuge_page_tlb_size, jint jbucket_entries_logging_threshold, jboolean jif_log_bucket_dist_when_flash, jint jthreshold_use_skiplist) { @@ -60,11 +60,11 @@ jlong Java_org_rocksdb_HashLinkedListMemTableConfig_newMemTableFactoryHandle( } /* - * Class: org_rocksdb_VectorMemTableConfig + * Class: org_forstdb_VectorMemTableConfig * Method: newMemTableFactoryHandle * Signature: (J)J */ -jlong Java_org_rocksdb_VectorMemTableConfig_newMemTableFactoryHandle( +jlong Java_org_forstdb_VectorMemTableConfig_newMemTableFactoryHandle( JNIEnv* env, jobject /*jobj*/, jlong jreserved_size) { ROCKSDB_NAMESPACE::Status s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(jreserved_size); @@ -77,11 +77,11 @@ jlong Java_org_rocksdb_VectorMemTableConfig_newMemTableFactoryHandle( } /* - * Class: org_rocksdb_SkipListMemTableConfig + * Class: org_forstdb_SkipListMemTableConfig * Method: newMemTableFactoryHandle0 * Signature: (J)J */ -jlong Java_org_rocksdb_SkipListMemTableConfig_newMemTableFactoryHandle0( +jlong Java_org_forstdb_SkipListMemTableConfig_newMemTableFactoryHandle0( JNIEnv* env, jobject /*jobj*/, jlong jlookahead) { ROCKSDB_NAMESPACE::Status s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(jlookahead); diff --git a/java/rocksjni/merge_operator.cc b/java/forstjni/merge_operator.cc similarity index 80% rename from java/rocksjni/merge_operator.cc rename to java/forstjni/merge_operator.cc index ce3c5df56..e5da11fb9 100644 --- a/java/rocksjni/merge_operator.cc +++ b/java/forstjni/merge_operator.cc @@ -16,24 +16,24 @@ #include #include -#include "include/org_rocksdb_StringAppendOperator.h" -#include "include/org_rocksdb_UInt64AddOperator.h" +#include "include/org_forstdb_StringAppendOperator.h" +#include "include/org_forstdb_UInt64AddOperator.h" #include "rocksdb/db.h" #include "rocksdb/memtablerep.h" #include "rocksdb/options.h" #include "rocksdb/slice_transform.h" #include "rocksdb/statistics.h" #include "rocksdb/table.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" #include "utilities/merge_operators.h" /* - * Class: org_rocksdb_StringAppendOperator + * Class: org_forstdb_StringAppendOperator * Method: newSharedStringAppendOperator * Signature: (C)J */ -jlong Java_org_rocksdb_StringAppendOperator_newSharedStringAppendOperator__C( +jlong Java_org_forstdb_StringAppendOperator_newSharedStringAppendOperator__C( JNIEnv* /*env*/, jclass /*jclazz*/, jchar jdelim) { auto* sptr_string_append_op = new std::shared_ptr( @@ -42,7 +42,7 @@ jlong Java_org_rocksdb_StringAppendOperator_newSharedStringAppendOperator__C( return GET_CPLUSPLUS_POINTER(sptr_string_append_op); } -jlong Java_org_rocksdb_StringAppendOperator_newSharedStringAppendOperator__Ljava_lang_String_2( +jlong Java_org_forstdb_StringAppendOperator_newSharedStringAppendOperator__Ljava_lang_String_2( JNIEnv* env, jclass /*jclass*/, jstring jdelim) { jboolean has_exception = JNI_FALSE; auto delim = @@ -57,11 +57,11 @@ jlong Java_org_rocksdb_StringAppendOperator_newSharedStringAppendOperator__Ljava } /* - * Class: org_rocksdb_StringAppendOperator + * Class: org_forstdb_StringAppendOperator * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_StringAppendOperator_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_StringAppendOperator_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* sptr_string_append_op = @@ -71,11 +71,11 @@ void Java_org_rocksdb_StringAppendOperator_disposeInternal(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_UInt64AddOperator + * Class: org_forstdb_UInt64AddOperator * Method: newSharedUInt64AddOperator * Signature: ()J */ -jlong Java_org_rocksdb_UInt64AddOperator_newSharedUInt64AddOperator( +jlong Java_org_forstdb_UInt64AddOperator_newSharedUInt64AddOperator( JNIEnv* /*env*/, jclass /*jclazz*/) { auto* sptr_uint64_add_op = new std::shared_ptr( @@ -84,11 +84,11 @@ jlong Java_org_rocksdb_UInt64AddOperator_newSharedUInt64AddOperator( } /* - * Class: org_rocksdb_UInt64AddOperator + * Class: org_forstdb_UInt64AddOperator * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_UInt64AddOperator_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_UInt64AddOperator_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* sptr_uint64_add_op = diff --git a/java/rocksjni/native_comparator_wrapper_test.cc b/java/forstjni/native_comparator_wrapper_test.cc similarity index 83% rename from java/rocksjni/native_comparator_wrapper_test.cc rename to java/forstjni/native_comparator_wrapper_test.cc index ac33ca22d..708d6fd4c 100644 --- a/java/rocksjni/native_comparator_wrapper_test.cc +++ b/java/forstjni/native_comparator_wrapper_test.cc @@ -7,10 +7,10 @@ #include -#include "include/org_rocksdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper.h" +#include "include/org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper.h" #include "rocksdb/comparator.h" #include "rocksdb/slice.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" namespace ROCKSDB_NAMESPACE { @@ -33,11 +33,11 @@ class NativeComparatorWrapperTestStringComparator : public Comparator { } // namespace ROCKSDB_NAMESPACE /* - * Class: org_rocksdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper + * Class: org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper * Method: newStringComparator * Signature: ()J */ -jlong Java_org_rocksdb_NativeComparatorWrapperTest_00024NativeStringComparatorWrapper_newStringComparator( +jlong Java_org_forstdb_NativeComparatorWrapperTest_00024NativeStringComparatorWrapper_newStringComparator( JNIEnv* /*env*/, jobject /*jobj*/) { auto* comparator = new ROCKSDB_NAMESPACE::NativeComparatorWrapperTestStringComparator(); diff --git a/java/rocksjni/optimistic_transaction_db.cc b/java/forstjni/optimistic_transaction_db.cc similarity index 88% rename from java/rocksjni/optimistic_transaction_db.cc rename to java/forstjni/optimistic_transaction_db.cc index 238224f58..0e6fcf1c7 100644 --- a/java/rocksjni/optimistic_transaction_db.cc +++ b/java/forstjni/optimistic_transaction_db.cc @@ -10,18 +10,18 @@ #include -#include "include/org_rocksdb_OptimisticTransactionDB.h" +#include "include/org_forstdb_OptimisticTransactionDB.h" #include "rocksdb/options.h" #include "rocksdb/utilities/transaction.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_OptimisticTransactionDB + * Class: org_forstdb_OptimisticTransactionDB * Method: open * Signature: (JLjava/lang/String;)J */ -jlong Java_org_rocksdb_OptimisticTransactionDB_open__JLjava_lang_String_2( +jlong Java_org_forstdb_OptimisticTransactionDB_open__JLjava_lang_String_2( JNIEnv* env, jclass, jlong joptions_handle, jstring jdb_path) { const char* db_path = env->GetStringUTFChars(jdb_path, nullptr); if (db_path == nullptr) { @@ -46,12 +46,12 @@ jlong Java_org_rocksdb_OptimisticTransactionDB_open__JLjava_lang_String_2( } /* - * Class: org_rocksdb_OptimisticTransactionDB + * Class: org_forstdb_OptimisticTransactionDB * Method: open * Signature: (JLjava/lang/String;[[B[J)[J */ jlongArray -Java_org_rocksdb_OptimisticTransactionDB_open__JLjava_lang_String_2_3_3B_3J( +Java_org_forstdb_OptimisticTransactionDB_open__JLjava_lang_String_2_3_3B_3J( JNIEnv* env, jclass, jlong jdb_options_handle, jstring jdb_path, jobjectArray jcolumn_names, jlongArray jcolumn_options_handles) { const char* db_path = env->GetStringUTFChars(jdb_path, nullptr); @@ -141,11 +141,11 @@ Java_org_rocksdb_OptimisticTransactionDB_open__JLjava_lang_String_2_3_3B_3J( } /* - * Class: org_rocksdb_OptimisticTransactionDB + * Class: org_forstdb_OptimisticTransactionDB * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_OptimisticTransactionDB_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_OptimisticTransactionDB_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* optimistic_txn_db = reinterpret_cast(jhandle); @@ -154,11 +154,11 @@ void Java_org_rocksdb_OptimisticTransactionDB_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_OptimisticTransactionDB + * Class: org_forstdb_OptimisticTransactionDB * Method: closeDatabase * Signature: (J)V */ -void Java_org_rocksdb_OptimisticTransactionDB_closeDatabase(JNIEnv* env, jclass, +void Java_org_forstdb_OptimisticTransactionDB_closeDatabase(JNIEnv* env, jclass, jlong jhandle) { auto* optimistic_txn_db = reinterpret_cast(jhandle); @@ -168,11 +168,11 @@ void Java_org_rocksdb_OptimisticTransactionDB_closeDatabase(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_OptimisticTransactionDB + * Class: org_forstdb_OptimisticTransactionDB * Method: beginTransaction * Signature: (JJ)J */ -jlong Java_org_rocksdb_OptimisticTransactionDB_beginTransaction__JJ( +jlong Java_org_forstdb_OptimisticTransactionDB_beginTransaction__JJ( JNIEnv*, jobject, jlong jhandle, jlong jwrite_options_handle) { auto* optimistic_txn_db = reinterpret_cast(jhandle); @@ -184,11 +184,11 @@ jlong Java_org_rocksdb_OptimisticTransactionDB_beginTransaction__JJ( } /* - * Class: org_rocksdb_OptimisticTransactionDB + * Class: org_forstdb_OptimisticTransactionDB * Method: beginTransaction * Signature: (JJJ)J */ -jlong Java_org_rocksdb_OptimisticTransactionDB_beginTransaction__JJJ( +jlong Java_org_forstdb_OptimisticTransactionDB_beginTransaction__JJJ( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jwrite_options_handle, jlong joptimistic_txn_options_handle) { auto* optimistic_txn_db = @@ -204,11 +204,11 @@ jlong Java_org_rocksdb_OptimisticTransactionDB_beginTransaction__JJJ( } /* - * Class: org_rocksdb_OptimisticTransactionDB + * Class: org_forstdb_OptimisticTransactionDB * Method: beginTransaction_withOld * Signature: (JJJ)J */ -jlong Java_org_rocksdb_OptimisticTransactionDB_beginTransaction_1withOld__JJJ( +jlong Java_org_forstdb_OptimisticTransactionDB_beginTransaction_1withOld__JJJ( JNIEnv*, jobject, jlong jhandle, jlong jwrite_options_handle, jlong jold_txn_handle) { auto* optimistic_txn_db = @@ -230,11 +230,11 @@ jlong Java_org_rocksdb_OptimisticTransactionDB_beginTransaction_1withOld__JJJ( } /* - * Class: org_rocksdb_OptimisticTransactionDB + * Class: org_forstdb_OptimisticTransactionDB * Method: beginTransaction_withOld * Signature: (JJJJ)J */ -jlong Java_org_rocksdb_OptimisticTransactionDB_beginTransaction_1withOld__JJJJ( +jlong Java_org_forstdb_OptimisticTransactionDB_beginTransaction_1withOld__JJJJ( JNIEnv*, jobject, jlong jhandle, jlong jwrite_options_handle, jlong joptimistic_txn_options_handle, jlong jold_txn_handle) { auto* optimistic_txn_db = @@ -258,11 +258,11 @@ jlong Java_org_rocksdb_OptimisticTransactionDB_beginTransaction_1withOld__JJJJ( } /* - * Class: org_rocksdb_OptimisticTransactionDB + * Class: org_forstdb_OptimisticTransactionDB * Method: getBaseDB * Signature: (J)J */ -jlong Java_org_rocksdb_OptimisticTransactionDB_getBaseDB(JNIEnv*, jobject, +jlong Java_org_forstdb_OptimisticTransactionDB_getBaseDB(JNIEnv*, jobject, jlong jhandle) { auto* optimistic_txn_db = reinterpret_cast(jhandle); diff --git a/java/rocksjni/optimistic_transaction_options.cc b/java/forstjni/optimistic_transaction_options.cc similarity index 72% rename from java/rocksjni/optimistic_transaction_options.cc rename to java/forstjni/optimistic_transaction_options.cc index 501c6c4fb..feb5e0238 100644 --- a/java/rocksjni/optimistic_transaction_options.cc +++ b/java/forstjni/optimistic_transaction_options.cc @@ -8,17 +8,17 @@ #include -#include "include/org_rocksdb_OptimisticTransactionOptions.h" +#include "include/org_forstdb_OptimisticTransactionOptions.h" #include "rocksdb/comparator.h" #include "rocksdb/utilities/optimistic_transaction_db.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_OptimisticTransactionOptions + * Class: org_forstdb_OptimisticTransactionOptions * Method: newOptimisticTransactionOptions * Signature: ()J */ -jlong Java_org_rocksdb_OptimisticTransactionOptions_newOptimisticTransactionOptions( +jlong Java_org_forstdb_OptimisticTransactionOptions_newOptimisticTransactionOptions( JNIEnv* /*env*/, jclass /*jcls*/) { ROCKSDB_NAMESPACE::OptimisticTransactionOptions* opts = new ROCKSDB_NAMESPACE::OptimisticTransactionOptions(); @@ -26,11 +26,11 @@ jlong Java_org_rocksdb_OptimisticTransactionOptions_newOptimisticTransactionOpti } /* - * Class: org_rocksdb_OptimisticTransactionOptions + * Class: org_forstdb_OptimisticTransactionOptions * Method: isSetSnapshot * Signature: (J)Z */ -jboolean Java_org_rocksdb_OptimisticTransactionOptions_isSetSnapshot( +jboolean Java_org_forstdb_OptimisticTransactionOptions_isSetSnapshot( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = reinterpret_cast( @@ -39,11 +39,11 @@ jboolean Java_org_rocksdb_OptimisticTransactionOptions_isSetSnapshot( } /* - * Class: org_rocksdb_OptimisticTransactionOptions + * Class: org_forstdb_OptimisticTransactionOptions * Method: setSetSnapshot * Signature: (JZ)V */ -void Java_org_rocksdb_OptimisticTransactionOptions_setSetSnapshot( +void Java_org_forstdb_OptimisticTransactionOptions_setSetSnapshot( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jboolean jset_snapshot) { auto* opts = reinterpret_cast( @@ -52,11 +52,11 @@ void Java_org_rocksdb_OptimisticTransactionOptions_setSetSnapshot( } /* - * Class: org_rocksdb_OptimisticTransactionOptions + * Class: org_forstdb_OptimisticTransactionOptions * Method: setComparator * Signature: (JJ)V */ -void Java_org_rocksdb_OptimisticTransactionOptions_setComparator( +void Java_org_forstdb_OptimisticTransactionOptions_setComparator( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jcomparator_handle) { auto* opts = @@ -67,11 +67,11 @@ void Java_org_rocksdb_OptimisticTransactionOptions_setComparator( } /* - * Class: org_rocksdb_OptimisticTransactionOptions + * Class: org_forstdb_OptimisticTransactionOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_OptimisticTransactionOptions_disposeInternal( +void Java_org_forstdb_OptimisticTransactionOptions_disposeInternal( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { delete reinterpret_cast( jhandle); diff --git a/java/rocksjni/options.cc b/java/forstjni/options.cc similarity index 76% rename from java/rocksjni/options.cc rename to java/forstjni/options.cc index 0d84901c9..bc61f470d 100644 --- a/java/rocksjni/options.cc +++ b/java/forstjni/options.cc @@ -15,13 +15,13 @@ #include #include -#include "include/org_rocksdb_ColumnFamilyOptions.h" -#include "include/org_rocksdb_ComparatorOptions.h" -#include "include/org_rocksdb_DBOptions.h" -#include "include/org_rocksdb_FlushOptions.h" -#include "include/org_rocksdb_Options.h" -#include "include/org_rocksdb_ReadOptions.h" -#include "include/org_rocksdb_WriteOptions.h" +#include "include/org_forstdb_ColumnFamilyOptions.h" +#include "include/org_forstdb_ComparatorOptions.h" +#include "include/org_forstdb_DBOptions.h" +#include "include/org_forstdb_FlushOptions.h" +#include "include/org_forstdb_Options.h" +#include "include/org_forstdb_ReadOptions.h" +#include "include/org_forstdb_WriteOptions.h" #include "rocksdb/comparator.h" #include "rocksdb/convenience.h" #include "rocksdb/db.h" @@ -32,29 +32,29 @@ #include "rocksdb/sst_partitioner.h" #include "rocksdb/statistics.h" #include "rocksdb/table.h" -#include "rocksjni/comparatorjnicallback.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" -#include "rocksjni/statisticsjni.h" -#include "rocksjni/table_filter_jnicallback.h" +#include "forstjni/comparatorjnicallback.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" +#include "forstjni/statisticsjni.h" +#include "forstjni/table_filter_jnicallback.h" #include "utilities/merge_operators.h" /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: newOptions * Signature: ()J */ -jlong Java_org_rocksdb_Options_newOptions__(JNIEnv*, jclass) { +jlong Java_org_forstdb_Options_newOptions__(JNIEnv*, jclass) { auto* op = new ROCKSDB_NAMESPACE::Options(); return GET_CPLUSPLUS_POINTER(op); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: newOptions * Signature: (JJ)J */ -jlong Java_org_rocksdb_Options_newOptions__JJ(JNIEnv*, jclass, jlong jdboptions, +jlong Java_org_forstdb_Options_newOptions__JJ(JNIEnv*, jclass, jlong jdboptions, jlong jcfoptions) { auto* dbOpt = reinterpret_cast(jdboptions); @@ -65,33 +65,33 @@ jlong Java_org_rocksdb_Options_newOptions__JJ(JNIEnv*, jclass, jlong jdboptions, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: copyOptions * Signature: (J)J */ -jlong Java_org_rocksdb_Options_copyOptions(JNIEnv*, jclass, jlong jhandle) { +jlong Java_org_forstdb_Options_copyOptions(JNIEnv*, jclass, jlong jhandle) { auto new_opt = new ROCKSDB_NAMESPACE::Options( *(reinterpret_cast(jhandle))); return GET_CPLUSPLUS_POINTER(new_opt); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_Options_disposeInternal(JNIEnv*, jobject, jlong handle) { +void Java_org_forstdb_Options_disposeInternal(JNIEnv*, jobject, jlong handle) { auto* op = reinterpret_cast(handle); assert(op != nullptr); delete op; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setIncreaseParallelism * Signature: (JI)V */ -void Java_org_rocksdb_Options_setIncreaseParallelism(JNIEnv*, jobject, +void Java_org_forstdb_Options_setIncreaseParallelism(JNIEnv*, jobject, jlong jhandle, jint totalThreads) { reinterpret_cast(jhandle)->IncreaseParallelism( @@ -99,33 +99,33 @@ void Java_org_rocksdb_Options_setIncreaseParallelism(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCreateIfMissing * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setCreateIfMissing(JNIEnv*, jobject, +void Java_org_forstdb_Options_setCreateIfMissing(JNIEnv*, jobject, jlong jhandle, jboolean flag) { reinterpret_cast(jhandle)->create_if_missing = flag; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: createIfMissing * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_createIfMissing(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_createIfMissing(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->create_if_missing; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCreateMissingColumnFamilies * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setCreateMissingColumnFamilies(JNIEnv*, jobject, +void Java_org_forstdb_Options_setCreateMissingColumnFamilies(JNIEnv*, jobject, jlong jhandle, jboolean flag) { reinterpret_cast(jhandle) @@ -133,22 +133,22 @@ void Java_org_rocksdb_Options_setCreateMissingColumnFamilies(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: createMissingColumnFamilies * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_createMissingColumnFamilies(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_createMissingColumnFamilies(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->create_missing_column_families; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setComparatorHandle * Signature: (JI)V */ -void Java_org_rocksdb_Options_setComparatorHandle__JI(JNIEnv*, jobject, +void Java_org_forstdb_Options_setComparatorHandle__JI(JNIEnv*, jobject, jlong jhandle, jint builtinComparator) { switch (builtinComparator) { @@ -164,11 +164,11 @@ void Java_org_rocksdb_Options_setComparatorHandle__JI(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setComparatorHandle * Signature: (JJB)V */ -void Java_org_rocksdb_Options_setComparatorHandle__JJB(JNIEnv*, jobject, +void Java_org_forstdb_Options_setComparatorHandle__JJB(JNIEnv*, jobject, jlong jopt_handle, jlong jcomparator_handle, jbyte jcomparator_type) { @@ -191,11 +191,11 @@ void Java_org_rocksdb_Options_setComparatorHandle__JJB(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMergeOperatorName * Signature: (JJjava/lang/String)V */ -void Java_org_rocksdb_Options_setMergeOperatorName(JNIEnv* env, jobject, +void Java_org_forstdb_Options_setMergeOperatorName(JNIEnv* env, jobject, jlong jhandle, jstring jop_name) { const char* op_name = env->GetStringUTFChars(jop_name, nullptr); @@ -212,11 +212,11 @@ void Java_org_rocksdb_Options_setMergeOperatorName(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMergeOperator * Signature: (JJjava/lang/String)V */ -void Java_org_rocksdb_Options_setMergeOperator(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setMergeOperator(JNIEnv*, jobject, jlong jhandle, jlong mergeOperatorHandle) { reinterpret_cast(jhandle)->merge_operator = *(reinterpret_cast*>( @@ -224,11 +224,11 @@ void Java_org_rocksdb_Options_setMergeOperator(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCompactionFilterHandle * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setCompactionFilterHandle( +void Java_org_forstdb_Options_setCompactionFilterHandle( JNIEnv*, jobject, jlong jopt_handle, jlong jcompactionfilter_handle) { reinterpret_cast(jopt_handle) ->compaction_filter = @@ -237,11 +237,11 @@ void Java_org_rocksdb_Options_setCompactionFilterHandle( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCompactionFilterFactoryHandle * Signature: (JJ)V */ -void JNICALL Java_org_rocksdb_Options_setCompactionFilterFactoryHandle( +void JNICALL Java_org_forstdb_Options_setCompactionFilterFactoryHandle( JNIEnv*, jobject, jlong jopt_handle, jlong jcompactionfilterfactory_handle) { auto* cff_factory = reinterpret_cast< @@ -252,11 +252,11 @@ void JNICALL Java_org_rocksdb_Options_setCompactionFilterFactoryHandle( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWriteBufferSize * Signature: (JJ)I */ -void Java_org_rocksdb_Options_setWriteBufferSize(JNIEnv* env, jobject, +void Java_org_forstdb_Options_setWriteBufferSize(JNIEnv* env, jobject, jlong jhandle, jlong jwrite_buffer_size) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( @@ -270,11 +270,11 @@ void Java_org_rocksdb_Options_setWriteBufferSize(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWriteBufferManager * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setWriteBufferManager( +void Java_org_forstdb_Options_setWriteBufferManager( JNIEnv*, jobject, jlong joptions_handle, jlong jwrite_buffer_manager_handle) { auto* write_buffer_manager = @@ -285,33 +285,33 @@ void Java_org_rocksdb_Options_setWriteBufferManager( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: writeBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_writeBufferSize(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_writeBufferSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->write_buffer_size; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxWriteBufferNumber * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMaxWriteBufferNumber( +void Java_org_forstdb_Options_setMaxWriteBufferNumber( JNIEnv*, jobject, jlong jhandle, jint jmax_write_buffer_number) { reinterpret_cast(jhandle) ->max_write_buffer_number = jmax_write_buffer_number; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setStatistics * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setStatistics(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setStatistics(JNIEnv*, jobject, jlong jhandle, jlong jstatistics_handle) { auto* opt = reinterpret_cast(jhandle); auto* pSptr = @@ -321,11 +321,11 @@ void Java_org_rocksdb_Options_setStatistics(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: statistics * Signature: (J)J */ -jlong Java_org_rocksdb_Options_statistics(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_Options_statistics(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); std::shared_ptr sptr = opt->statistics; if (sptr == nullptr) { @@ -338,77 +338,77 @@ jlong Java_org_rocksdb_Options_statistics(JNIEnv*, jobject, jlong jhandle) { } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxWriteBufferNumber * Signature: (J)I */ -jint Java_org_rocksdb_Options_maxWriteBufferNumber(JNIEnv*, jobject, +jint Java_org_forstdb_Options_maxWriteBufferNumber(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_write_buffer_number; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: errorIfExists * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_errorIfExists(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_errorIfExists(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->error_if_exists; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setErrorIfExists * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setErrorIfExists(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setErrorIfExists(JNIEnv*, jobject, jlong jhandle, jboolean error_if_exists) { reinterpret_cast(jhandle)->error_if_exists = static_cast(error_if_exists); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: paranoidChecks * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_paranoidChecks(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_paranoidChecks(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->paranoid_checks; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setParanoidChecks * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setParanoidChecks(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setParanoidChecks(JNIEnv*, jobject, jlong jhandle, jboolean paranoid_checks) { reinterpret_cast(jhandle)->paranoid_checks = static_cast(paranoid_checks); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setEnv * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setEnv(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setEnv(JNIEnv*, jobject, jlong jhandle, jlong jenv) { reinterpret_cast(jhandle)->env = reinterpret_cast(jenv); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxTotalWalSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setMaxTotalWalSize(JNIEnv*, jobject, +void Java_org_forstdb_Options_setMaxTotalWalSize(JNIEnv*, jobject, jlong jhandle, jlong jmax_total_wal_size) { reinterpret_cast(jhandle)->max_total_wal_size = @@ -416,84 +416,84 @@ void Java_org_rocksdb_Options_setMaxTotalWalSize(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxTotalWalSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_maxTotalWalSize(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_maxTotalWalSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_total_wal_size; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxOpenFiles * Signature: (J)I */ -jint Java_org_rocksdb_Options_maxOpenFiles(JNIEnv*, jobject, jlong jhandle) { +jint Java_org_forstdb_Options_maxOpenFiles(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->max_open_files; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxOpenFiles * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMaxOpenFiles(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setMaxOpenFiles(JNIEnv*, jobject, jlong jhandle, jint max_open_files) { reinterpret_cast(jhandle)->max_open_files = static_cast(max_open_files); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxFileOpeningThreads * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMaxFileOpeningThreads( +void Java_org_forstdb_Options_setMaxFileOpeningThreads( JNIEnv*, jobject, jlong jhandle, jint jmax_file_opening_threads) { reinterpret_cast(jhandle) ->max_file_opening_threads = static_cast(jmax_file_opening_threads); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxFileOpeningThreads * Signature: (J)I */ -jint Java_org_rocksdb_Options_maxFileOpeningThreads(JNIEnv*, jobject, +jint Java_org_forstdb_Options_maxFileOpeningThreads(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->max_file_opening_threads); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: useFsync * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_useFsync(JNIEnv*, jobject, jlong jhandle) { +jboolean Java_org_forstdb_Options_useFsync(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->use_fsync; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setUseFsync * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setUseFsync(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setUseFsync(JNIEnv*, jobject, jlong jhandle, jboolean use_fsync) { reinterpret_cast(jhandle)->use_fsync = static_cast(use_fsync); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setDbPaths * Signature: (J[Ljava/lang/String;[J)V */ -void Java_org_rocksdb_Options_setDbPaths(JNIEnv* env, jobject, jlong jhandle, +void Java_org_forstdb_Options_setDbPaths(JNIEnv* env, jobject, jlong jhandle, jobjectArray jpaths, jlongArray jtarget_sizes) { std::vector db_paths; @@ -535,21 +535,21 @@ void Java_org_rocksdb_Options_setDbPaths(JNIEnv* env, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: dbPathsLen * Signature: (J)J */ -jlong Java_org_rocksdb_Options_dbPathsLen(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_Options_dbPathsLen(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->db_paths.size()); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: dbPaths * Signature: (J[Ljava/lang/String;[J)V */ -void Java_org_rocksdb_Options_dbPaths(JNIEnv* env, jobject, jlong jhandle, +void Java_org_forstdb_Options_dbPaths(JNIEnv* env, jobject, jlong jhandle, jobjectArray jpaths, jlongArray jtarget_sizes) { jboolean is_copy; @@ -586,22 +586,22 @@ void Java_org_rocksdb_Options_dbPaths(JNIEnv* env, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: dbLogDir * Signature: (J)Ljava/lang/String */ -jstring Java_org_rocksdb_Options_dbLogDir(JNIEnv* env, jobject, jlong jhandle) { +jstring Java_org_forstdb_Options_dbLogDir(JNIEnv* env, jobject, jlong jhandle) { return env->NewStringUTF( reinterpret_cast(jhandle) ->db_log_dir.c_str()); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setDbLogDir * Signature: (JLjava/lang/String)V */ -void Java_org_rocksdb_Options_setDbLogDir(JNIEnv* env, jobject, jlong jhandle, +void Java_org_forstdb_Options_setDbLogDir(JNIEnv* env, jobject, jlong jhandle, jstring jdb_log_dir) { const char* log_dir = env->GetStringUTFChars(jdb_log_dir, nullptr); if (log_dir == nullptr) { @@ -614,21 +614,21 @@ void Java_org_rocksdb_Options_setDbLogDir(JNIEnv* env, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: walDir * Signature: (J)Ljava/lang/String */ -jstring Java_org_rocksdb_Options_walDir(JNIEnv* env, jobject, jlong jhandle) { +jstring Java_org_forstdb_Options_walDir(JNIEnv* env, jobject, jlong jhandle) { return env->NewStringUTF( reinterpret_cast(jhandle)->wal_dir.c_str()); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWalDir * Signature: (JLjava/lang/String)V */ -void Java_org_rocksdb_Options_setWalDir(JNIEnv* env, jobject, jlong jhandle, +void Java_org_forstdb_Options_setWalDir(JNIEnv* env, jobject, jlong jhandle, jstring jwal_dir) { const char* wal_dir = env->GetStringUTFChars(jwal_dir, nullptr); if (wal_dir == nullptr) { @@ -641,22 +641,22 @@ void Java_org_rocksdb_Options_setWalDir(JNIEnv* env, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: deleteObsoleteFilesPeriodMicros * Signature: (J)J */ -jlong Java_org_rocksdb_Options_deleteObsoleteFilesPeriodMicros(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_deleteObsoleteFilesPeriodMicros(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->delete_obsolete_files_period_micros; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setDeleteObsoleteFilesPeriodMicros * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setDeleteObsoleteFilesPeriodMicros(JNIEnv*, +void Java_org_forstdb_Options_setDeleteObsoleteFilesPeriodMicros(JNIEnv*, jobject, jlong jhandle, jlong micros) { @@ -665,22 +665,22 @@ void Java_org_rocksdb_Options_setDeleteObsoleteFilesPeriodMicros(JNIEnv*, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxBackgroundCompactions * Signature: (J)I */ -jint Java_org_rocksdb_Options_maxBackgroundCompactions(JNIEnv*, jobject, +jint Java_org_forstdb_Options_maxBackgroundCompactions(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_background_compactions; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxBackgroundCompactions * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMaxBackgroundCompactions(JNIEnv*, jobject, +void Java_org_forstdb_Options_setMaxBackgroundCompactions(JNIEnv*, jobject, jlong jhandle, jint max) { reinterpret_cast(jhandle) @@ -688,66 +688,66 @@ void Java_org_rocksdb_Options_setMaxBackgroundCompactions(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxSubcompactions * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMaxSubcompactions(JNIEnv*, jobject, +void Java_org_forstdb_Options_setMaxSubcompactions(JNIEnv*, jobject, jlong jhandle, jint max) { reinterpret_cast(jhandle)->max_subcompactions = static_cast(max); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxSubcompactions * Signature: (J)I */ -jint Java_org_rocksdb_Options_maxSubcompactions(JNIEnv*, jobject, +jint Java_org_forstdb_Options_maxSubcompactions(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_subcompactions; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxBackgroundFlushes * Signature: (J)I */ -jint Java_org_rocksdb_Options_maxBackgroundFlushes(JNIEnv*, jobject, +jint Java_org_forstdb_Options_maxBackgroundFlushes(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_background_flushes; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxBackgroundFlushes * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMaxBackgroundFlushes( +void Java_org_forstdb_Options_setMaxBackgroundFlushes( JNIEnv*, jobject, jlong jhandle, jint max_background_flushes) { reinterpret_cast(jhandle) ->max_background_flushes = static_cast(max_background_flushes); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxBackgroundJobs * Signature: (J)I */ -jint Java_org_rocksdb_Options_maxBackgroundJobs(JNIEnv*, jobject, +jint Java_org_forstdb_Options_maxBackgroundJobs(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_background_jobs; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxBackgroundJobs * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMaxBackgroundJobs(JNIEnv*, jobject, +void Java_org_forstdb_Options_setMaxBackgroundJobs(JNIEnv*, jobject, jlong jhandle, jint max_background_jobs) { reinterpret_cast(jhandle)->max_background_jobs = @@ -755,21 +755,21 @@ void Java_org_rocksdb_Options_setMaxBackgroundJobs(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxLogFileSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_maxLogFileSize(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_Options_maxLogFileSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_log_file_size; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxLogFileSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setMaxLogFileSize(JNIEnv* env, jobject, +void Java_org_forstdb_Options_setMaxLogFileSize(JNIEnv* env, jobject, jlong jhandle, jlong max_log_file_size) { auto s = @@ -783,22 +783,22 @@ void Java_org_rocksdb_Options_setMaxLogFileSize(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: logFileTimeToRoll * Signature: (J)J */ -jlong Java_org_rocksdb_Options_logFileTimeToRoll(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_logFileTimeToRoll(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->log_file_time_to_roll; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setLogFileTimeToRoll * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setLogFileTimeToRoll( +void Java_org_forstdb_Options_setLogFileTimeToRoll( JNIEnv* env, jobject, jlong jhandle, jlong log_file_time_to_roll) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( log_file_time_to_roll); @@ -811,21 +811,21 @@ void Java_org_rocksdb_Options_setLogFileTimeToRoll( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: keepLogFileNum * Signature: (J)J */ -jlong Java_org_rocksdb_Options_keepLogFileNum(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_Options_keepLogFileNum(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->keep_log_file_num; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setKeepLogFileNum * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setKeepLogFileNum(JNIEnv* env, jobject, +void Java_org_forstdb_Options_setKeepLogFileNum(JNIEnv* env, jobject, jlong jhandle, jlong keep_log_file_num) { auto s = @@ -839,22 +839,22 @@ void Java_org_rocksdb_Options_setKeepLogFileNum(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: recycleLogFileNum * Signature: (J)J */ -jlong Java_org_rocksdb_Options_recycleLogFileNum(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_recycleLogFileNum(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->recycle_log_file_num; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setRecycleLogFileNum * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setRecycleLogFileNum(JNIEnv* env, jobject, +void Java_org_forstdb_Options_setRecycleLogFileNum(JNIEnv* env, jobject, jlong jhandle, jlong recycle_log_file_num) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( @@ -868,11 +868,11 @@ void Java_org_rocksdb_Options_setRecycleLogFileNum(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxManifestFileSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_maxManifestFileSize(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_maxManifestFileSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_manifest_file_size; @@ -882,7 +882,7 @@ jlong Java_org_rocksdb_Options_maxManifestFileSize(JNIEnv*, jobject, * Method: memTableFactoryName * Signature: (J)Ljava/lang/String */ -jstring Java_org_rocksdb_Options_memTableFactoryName(JNIEnv* env, jobject, +jstring Java_org_forstdb_Options_memTableFactoryName(JNIEnv* env, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); ROCKSDB_NAMESPACE::MemTableRepFactory* tf = opt->memtable_factory.get(); @@ -950,11 +950,11 @@ rocksdb_convert_cf_paths_from_java_helper(JNIEnv* env, jobjectArray path_array, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCfPaths * Signature: (J[Ljava/lang/String;[J)V */ -void Java_org_rocksdb_Options_setCfPaths(JNIEnv* env, jclass, jlong jhandle, +void Java_org_forstdb_Options_setCfPaths(JNIEnv* env, jclass, jlong jhandle, jobjectArray path_array, jlongArray size_array) { auto* options = reinterpret_cast(jhandle); @@ -968,11 +968,11 @@ void Java_org_rocksdb_Options_setCfPaths(JNIEnv* env, jclass, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: cfPathsLen * Signature: (J)J */ -jlong Java_org_rocksdb_Options_cfPathsLen(JNIEnv*, jclass, jlong jhandle) { +jlong Java_org_forstdb_Options_cfPathsLen(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->cf_paths.size()); } @@ -1017,11 +1017,11 @@ static void rocksdb_convert_cf_paths_to_java_helper(JNIEnv* env, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: cfPaths * Signature: (J[Ljava/lang/String;[J)V */ -void Java_org_rocksdb_Options_cfPaths(JNIEnv* env, jclass, jlong jhandle, +void Java_org_forstdb_Options_cfPaths(JNIEnv* env, jclass, jlong jhandle, jobjectArray jpaths, jlongArray jtarget_sizes) { rocksdb_convert_cf_paths_to_java_helper( @@ -1029,11 +1029,11 @@ void Java_org_rocksdb_Options_cfPaths(JNIEnv* env, jclass, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxManifestFileSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setMaxManifestFileSize( +void Java_org_forstdb_Options_setMaxManifestFileSize( JNIEnv*, jobject, jlong jhandle, jlong max_manifest_file_size) { reinterpret_cast(jhandle) ->max_manifest_file_size = static_cast(max_manifest_file_size); @@ -1043,7 +1043,7 @@ void Java_org_rocksdb_Options_setMaxManifestFileSize( * Method: setMemTableFactory * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setMemTableFactory(JNIEnv*, jobject, +void Java_org_forstdb_Options_setMemTableFactory(JNIEnv*, jobject, jlong jhandle, jlong jfactory_handle) { reinterpret_cast(jhandle) @@ -1053,11 +1053,11 @@ void Java_org_rocksdb_Options_setMemTableFactory(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setRateLimiter * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setRateLimiter(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setRateLimiter(JNIEnv*, jobject, jlong jhandle, jlong jrate_limiter_handle) { std::shared_ptr* pRateLimiter = reinterpret_cast*>( @@ -1067,11 +1067,11 @@ void Java_org_rocksdb_Options_setRateLimiter(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setSstFileManager * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setSstFileManager( +void Java_org_forstdb_Options_setSstFileManager( JNIEnv*, jobject, jlong jhandle, jlong jsst_file_manager_handle) { auto* sptr_sst_file_manager = reinterpret_cast*>( @@ -1081,11 +1081,11 @@ void Java_org_rocksdb_Options_setSstFileManager( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setLogger * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setLogger(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setLogger(JNIEnv*, jobject, jlong jhandle, jlong jlogger_handle) { std::shared_ptr* pLogger = reinterpret_cast*>( @@ -1094,43 +1094,43 @@ void Java_org_rocksdb_Options_setLogger(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setInfoLogLevel * Signature: (JB)V */ -void Java_org_rocksdb_Options_setInfoLogLevel(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setInfoLogLevel(JNIEnv*, jobject, jlong jhandle, jbyte jlog_level) { reinterpret_cast(jhandle)->info_log_level = static_cast(jlog_level); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: infoLogLevel * Signature: (J)B */ -jbyte Java_org_rocksdb_Options_infoLogLevel(JNIEnv*, jobject, jlong jhandle) { +jbyte Java_org_forstdb_Options_infoLogLevel(JNIEnv*, jobject, jlong jhandle) { return static_cast( reinterpret_cast(jhandle)->info_log_level); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: tableCacheNumshardbits * Signature: (J)I */ -jint Java_org_rocksdb_Options_tableCacheNumshardbits(JNIEnv*, jobject, +jint Java_org_forstdb_Options_tableCacheNumshardbits(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->table_cache_numshardbits; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setTableCacheNumshardbits * Signature: (JI)V */ -void Java_org_rocksdb_Options_setTableCacheNumshardbits( +void Java_org_forstdb_Options_setTableCacheNumshardbits( JNIEnv*, jobject, jlong jhandle, jint table_cache_numshardbits) { reinterpret_cast(jhandle) ->table_cache_numshardbits = static_cast(table_cache_numshardbits); @@ -1140,7 +1140,7 @@ void Java_org_rocksdb_Options_setTableCacheNumshardbits( * Method: useFixedLengthPrefixExtractor * Signature: (JI)V */ -void Java_org_rocksdb_Options_useFixedLengthPrefixExtractor( +void Java_org_forstdb_Options_useFixedLengthPrefixExtractor( JNIEnv*, jobject, jlong jhandle, jint jprefix_length) { reinterpret_cast(jhandle) ->prefix_extractor.reset(ROCKSDB_NAMESPACE::NewFixedPrefixTransform( @@ -1151,7 +1151,7 @@ void Java_org_rocksdb_Options_useFixedLengthPrefixExtractor( * Method: useCappedPrefixExtractor * Signature: (JI)V */ -void Java_org_rocksdb_Options_useCappedPrefixExtractor(JNIEnv*, jobject, +void Java_org_forstdb_Options_useCappedPrefixExtractor(JNIEnv*, jobject, jlong jhandle, jint jprefix_length) { reinterpret_cast(jhandle) @@ -1160,53 +1160,53 @@ void Java_org_rocksdb_Options_useCappedPrefixExtractor(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: walTtlSeconds * Signature: (J)J */ -jlong Java_org_rocksdb_Options_walTtlSeconds(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_Options_walTtlSeconds(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->WAL_ttl_seconds; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWalTtlSeconds * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setWalTtlSeconds(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setWalTtlSeconds(JNIEnv*, jobject, jlong jhandle, jlong WAL_ttl_seconds) { reinterpret_cast(jhandle)->WAL_ttl_seconds = static_cast(WAL_ttl_seconds); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: walTtlSeconds * Signature: (J)J */ -jlong Java_org_rocksdb_Options_walSizeLimitMB(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_Options_walSizeLimitMB(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->WAL_size_limit_MB; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWalSizeLimitMB * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setWalSizeLimitMB(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setWalSizeLimitMB(JNIEnv*, jobject, jlong jhandle, jlong WAL_size_limit_MB) { reinterpret_cast(jhandle)->WAL_size_limit_MB = static_cast(WAL_size_limit_MB); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxWriteBatchGroupSizeBytes * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setMaxWriteBatchGroupSizeBytes( +void Java_org_forstdb_Options_setMaxWriteBatchGroupSizeBytes( JNIEnv*, jclass, jlong jhandle, jlong jmax_write_batch_group_size_bytes) { auto* opt = reinterpret_cast(jhandle); opt->max_write_batch_group_size_bytes = @@ -1214,33 +1214,33 @@ void Java_org_rocksdb_Options_setMaxWriteBatchGroupSizeBytes( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxWriteBatchGroupSizeBytes * Signature: (J)J */ -jlong Java_org_rocksdb_Options_maxWriteBatchGroupSizeBytes(JNIEnv*, jclass, +jlong Java_org_forstdb_Options_maxWriteBatchGroupSizeBytes(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->max_write_batch_group_size_bytes); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: manifestPreallocationSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_manifestPreallocationSize(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_manifestPreallocationSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->manifest_preallocation_size; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setManifestPreallocationSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setManifestPreallocationSize( +void Java_org_forstdb_Options_setManifestPreallocationSize( JNIEnv* env, jobject, jlong jhandle, jlong preallocation_size) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( preallocation_size); @@ -1256,7 +1256,7 @@ void Java_org_rocksdb_Options_setManifestPreallocationSize( * Method: setTableFactory * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setTableFactory(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setTableFactory(JNIEnv*, jobject, jlong jhandle, jlong jtable_factory_handle) { auto* options = reinterpret_cast(jhandle); auto* table_factory = @@ -1268,7 +1268,7 @@ void Java_org_rocksdb_Options_setTableFactory(JNIEnv*, jobject, jlong jhandle, * Method: setSstPartitionerFactory * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setSstPartitionerFactory(JNIEnv*, jobject, +void Java_org_forstdb_Options_setSstPartitionerFactory(JNIEnv*, jobject, jlong jhandle, jlong factory_handle) { auto* options = reinterpret_cast(jhandle); @@ -1279,11 +1279,11 @@ void Java_org_rocksdb_Options_setSstPartitionerFactory(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCompactionThreadLimiter * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setCompactionThreadLimiter( +void Java_org_forstdb_Options_setCompactionThreadLimiter( JNIEnv*, jclass, jlong jhandle, jlong jlimiter_handle) { auto* options = reinterpret_cast(jhandle); auto* limiter = reinterpret_cast< @@ -1293,44 +1293,44 @@ void Java_org_rocksdb_Options_setCompactionThreadLimiter( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: allowMmapReads * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_allowMmapReads(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_allowMmapReads(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->allow_mmap_reads; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAllowMmapReads * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setAllowMmapReads(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setAllowMmapReads(JNIEnv*, jobject, jlong jhandle, jboolean allow_mmap_reads) { reinterpret_cast(jhandle)->allow_mmap_reads = static_cast(allow_mmap_reads); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: allowMmapWrites * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_allowMmapWrites(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_allowMmapWrites(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->allow_mmap_writes; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAllowMmapWrites * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setAllowMmapWrites(JNIEnv*, jobject, +void Java_org_forstdb_Options_setAllowMmapWrites(JNIEnv*, jobject, jlong jhandle, jboolean allow_mmap_writes) { reinterpret_cast(jhandle)->allow_mmap_writes = @@ -1338,44 +1338,44 @@ void Java_org_rocksdb_Options_setAllowMmapWrites(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: useDirectReads * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_useDirectReads(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_useDirectReads(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->use_direct_reads; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setUseDirectReads * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setUseDirectReads(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setUseDirectReads(JNIEnv*, jobject, jlong jhandle, jboolean use_direct_reads) { reinterpret_cast(jhandle)->use_direct_reads = static_cast(use_direct_reads); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: useDirectIoForFlushAndCompaction * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_useDirectIoForFlushAndCompaction( +jboolean Java_org_forstdb_Options_useDirectIoForFlushAndCompaction( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->use_direct_io_for_flush_and_compaction; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setUseDirectIoForFlushAndCompaction * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setUseDirectIoForFlushAndCompaction( +void Java_org_forstdb_Options_setUseDirectIoForFlushAndCompaction( JNIEnv*, jobject, jlong jhandle, jboolean use_direct_io_for_flush_and_compaction) { reinterpret_cast(jhandle) @@ -1384,44 +1384,44 @@ void Java_org_rocksdb_Options_setUseDirectIoForFlushAndCompaction( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAllowFAllocate * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setAllowFAllocate(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setAllowFAllocate(JNIEnv*, jobject, jlong jhandle, jboolean jallow_fallocate) { reinterpret_cast(jhandle)->allow_fallocate = static_cast(jallow_fallocate); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: allowFAllocate * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_allowFAllocate(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_allowFAllocate(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->allow_fallocate); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: isFdCloseOnExec * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_isFdCloseOnExec(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_isFdCloseOnExec(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->is_fd_close_on_exec; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setIsFdCloseOnExec * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setIsFdCloseOnExec(JNIEnv*, jobject, +void Java_org_forstdb_Options_setIsFdCloseOnExec(JNIEnv*, jobject, jlong jhandle, jboolean is_fd_close_on_exec) { reinterpret_cast(jhandle)->is_fd_close_on_exec = @@ -1429,22 +1429,22 @@ void Java_org_rocksdb_Options_setIsFdCloseOnExec(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: statsDumpPeriodSec * Signature: (J)I */ -jint Java_org_rocksdb_Options_statsDumpPeriodSec(JNIEnv*, jobject, +jint Java_org_forstdb_Options_statsDumpPeriodSec(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->stats_dump_period_sec; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setStatsDumpPeriodSec * Signature: (JI)V */ -void Java_org_rocksdb_Options_setStatsDumpPeriodSec( +void Java_org_forstdb_Options_setStatsDumpPeriodSec( JNIEnv*, jobject, jlong jhandle, jint jstats_dump_period_sec) { reinterpret_cast(jhandle) ->stats_dump_period_sec = @@ -1452,22 +1452,22 @@ void Java_org_rocksdb_Options_setStatsDumpPeriodSec( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: statsPersistPeriodSec * Signature: (J)I */ -jint Java_org_rocksdb_Options_statsPersistPeriodSec(JNIEnv*, jobject, +jint Java_org_forstdb_Options_statsPersistPeriodSec(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->stats_persist_period_sec; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setStatsPersistPeriodSec * Signature: (JI)V */ -void Java_org_rocksdb_Options_setStatsPersistPeriodSec( +void Java_org_forstdb_Options_setStatsPersistPeriodSec( JNIEnv*, jobject, jlong jhandle, jint jstats_persist_period_sec) { reinterpret_cast(jhandle) ->stats_persist_period_sec = @@ -1475,22 +1475,22 @@ void Java_org_rocksdb_Options_setStatsPersistPeriodSec( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: statsHistoryBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_statsHistoryBufferSize(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_statsHistoryBufferSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->stats_history_buffer_size; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setStatsHistoryBufferSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setStatsHistoryBufferSize( +void Java_org_forstdb_Options_setStatsHistoryBufferSize( JNIEnv*, jobject, jlong jhandle, jlong jstats_history_buffer_size) { reinterpret_cast(jhandle) ->stats_history_buffer_size = @@ -1498,55 +1498,55 @@ void Java_org_rocksdb_Options_setStatsHistoryBufferSize( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: adviseRandomOnOpen * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_adviseRandomOnOpen(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_adviseRandomOnOpen(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->advise_random_on_open; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAdviseRandomOnOpen * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setAdviseRandomOnOpen( +void Java_org_forstdb_Options_setAdviseRandomOnOpen( JNIEnv*, jobject, jlong jhandle, jboolean advise_random_on_open) { reinterpret_cast(jhandle) ->advise_random_on_open = static_cast(advise_random_on_open); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setDbWriteBufferSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setDbWriteBufferSize( +void Java_org_forstdb_Options_setDbWriteBufferSize( JNIEnv*, jobject, jlong jhandle, jlong jdb_write_buffer_size) { auto* opt = reinterpret_cast(jhandle); opt->db_write_buffer_size = static_cast(jdb_write_buffer_size); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: dbWriteBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_dbWriteBufferSize(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_dbWriteBufferSize(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->db_write_buffer_size); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAccessHintOnCompactionStart * Signature: (JB)V */ -void Java_org_rocksdb_Options_setAccessHintOnCompactionStart( +void Java_org_forstdb_Options_setAccessHintOnCompactionStart( JNIEnv*, jobject, jlong jhandle, jbyte jaccess_hint_value) { auto* opt = reinterpret_cast(jhandle); opt->access_hint_on_compaction_start = @@ -1554,11 +1554,11 @@ void Java_org_rocksdb_Options_setAccessHintOnCompactionStart( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: accessHintOnCompactionStart * Signature: (J)B */ -jbyte Java_org_rocksdb_Options_accessHintOnCompactionStart(JNIEnv*, jobject, +jbyte Java_org_forstdb_Options_accessHintOnCompactionStart(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return ROCKSDB_NAMESPACE::AccessHintJni::toJavaAccessHint( @@ -1566,11 +1566,11 @@ jbyte Java_org_rocksdb_Options_accessHintOnCompactionStart(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCompactionReadaheadSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setCompactionReadaheadSize( +void Java_org_forstdb_Options_setCompactionReadaheadSize( JNIEnv*, jobject, jlong jhandle, jlong jcompaction_readahead_size) { auto* opt = reinterpret_cast(jhandle); opt->compaction_readahead_size = @@ -1578,22 +1578,22 @@ void Java_org_rocksdb_Options_setCompactionReadaheadSize( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: compactionReadaheadSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_compactionReadaheadSize(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_compactionReadaheadSize(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->compaction_readahead_size); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setRandomAccessMaxBufferSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setRandomAccessMaxBufferSize( +void Java_org_forstdb_Options_setRandomAccessMaxBufferSize( JNIEnv*, jobject, jlong jhandle, jlong jrandom_access_max_buffer_size) { auto* opt = reinterpret_cast(jhandle); opt->random_access_max_buffer_size = @@ -1601,22 +1601,22 @@ void Java_org_rocksdb_Options_setRandomAccessMaxBufferSize( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: randomAccessMaxBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_randomAccessMaxBufferSize(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_randomAccessMaxBufferSize(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->random_access_max_buffer_size); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWritableFileMaxBufferSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setWritableFileMaxBufferSize( +void Java_org_forstdb_Options_setWritableFileMaxBufferSize( JNIEnv*, jobject, jlong jhandle, jlong jwritable_file_max_buffer_size) { auto* opt = reinterpret_cast(jhandle); opt->writable_file_max_buffer_size = @@ -1624,33 +1624,33 @@ void Java_org_rocksdb_Options_setWritableFileMaxBufferSize( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: writableFileMaxBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_writableFileMaxBufferSize(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_writableFileMaxBufferSize(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->writable_file_max_buffer_size); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: useAdaptiveMutex * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_useAdaptiveMutex(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_useAdaptiveMutex(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->use_adaptive_mutex; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setUseAdaptiveMutex * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setUseAdaptiveMutex(JNIEnv*, jobject, +void Java_org_forstdb_Options_setUseAdaptiveMutex(JNIEnv*, jobject, jlong jhandle, jboolean use_adaptive_mutex) { reinterpret_cast(jhandle)->use_adaptive_mutex = @@ -1658,31 +1658,31 @@ void Java_org_rocksdb_Options_setUseAdaptiveMutex(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: bytesPerSync * Signature: (J)J */ -jlong Java_org_rocksdb_Options_bytesPerSync(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_Options_bytesPerSync(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->bytes_per_sync; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBytesPerSync * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setBytesPerSync(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setBytesPerSync(JNIEnv*, jobject, jlong jhandle, jlong bytes_per_sync) { reinterpret_cast(jhandle)->bytes_per_sync = static_cast(bytes_per_sync); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWalBytesPerSync * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setWalBytesPerSync(JNIEnv*, jobject, +void Java_org_forstdb_Options_setWalBytesPerSync(JNIEnv*, jobject, jlong jhandle, jlong jwal_bytes_per_sync) { reinterpret_cast(jhandle)->wal_bytes_per_sync = @@ -1690,33 +1690,33 @@ void Java_org_rocksdb_Options_setWalBytesPerSync(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: walBytesPerSync * Signature: (J)J */ -jlong Java_org_rocksdb_Options_walBytesPerSync(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_walBytesPerSync(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->wal_bytes_per_sync); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setStrictBytesPerSync * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setStrictBytesPerSync( +void Java_org_forstdb_Options_setStrictBytesPerSync( JNIEnv*, jobject, jlong jhandle, jboolean jstrict_bytes_per_sync) { reinterpret_cast(jhandle) ->strict_bytes_per_sync = jstrict_bytes_per_sync == JNI_TRUE; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: strictBytesPerSync * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_strictBytesPerSync(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_strictBytesPerSync(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->strict_bytes_per_sync); @@ -1746,11 +1746,11 @@ static void rocksdb_set_event_listeners_helper( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setEventListeners * Signature: (J[J)V */ -void Java_org_rocksdb_Options_setEventListeners(JNIEnv* env, jclass, +void Java_org_forstdb_Options_setEventListeners(JNIEnv* env, jclass, jlong jhandle, jlongArray jlistener_array) { auto* opt = reinterpret_cast(jhandle); @@ -1782,44 +1782,44 @@ static jobjectArray rocksdb_get_event_listeners_helper( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: eventListeners * Signature: (J)[Lorg/rocksdb/AbstractEventListener; */ -jobjectArray Java_org_rocksdb_Options_eventListeners(JNIEnv* env, jclass, +jobjectArray Java_org_forstdb_Options_eventListeners(JNIEnv* env, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return rocksdb_get_event_listeners_helper(env, opt->listeners); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setEnableThreadTracking * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setEnableThreadTracking( +void Java_org_forstdb_Options_setEnableThreadTracking( JNIEnv*, jobject, jlong jhandle, jboolean jenable_thread_tracking) { auto* opt = reinterpret_cast(jhandle); opt->enable_thread_tracking = static_cast(jenable_thread_tracking); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: enableThreadTracking * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_enableThreadTracking(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_enableThreadTracking(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->enable_thread_tracking); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setDelayedWriteRate * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setDelayedWriteRate(JNIEnv*, jobject, +void Java_org_forstdb_Options_setDelayedWriteRate(JNIEnv*, jobject, jlong jhandle, jlong jdelayed_write_rate) { auto* opt = reinterpret_cast(jhandle); @@ -1827,66 +1827,66 @@ void Java_org_rocksdb_Options_setDelayedWriteRate(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: delayedWriteRate * Signature: (J)J */ -jlong Java_org_rocksdb_Options_delayedWriteRate(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_delayedWriteRate(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->delayed_write_rate); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setEnablePipelinedWrite * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setEnablePipelinedWrite( +void Java_org_forstdb_Options_setEnablePipelinedWrite( JNIEnv*, jobject, jlong jhandle, jboolean jenable_pipelined_write) { auto* opt = reinterpret_cast(jhandle); opt->enable_pipelined_write = jenable_pipelined_write == JNI_TRUE; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: enablePipelinedWrite * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_enablePipelinedWrite(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_enablePipelinedWrite(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->enable_pipelined_write); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setUnorderedWrite * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setUnorderedWrite(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setUnorderedWrite(JNIEnv*, jobject, jlong jhandle, jboolean unordered_write) { reinterpret_cast(jhandle)->unordered_write = static_cast(unordered_write); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: unorderedWrite * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_unorderedWrite(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_unorderedWrite(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->unordered_write; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAllowConcurrentMemtableWrite * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setAllowConcurrentMemtableWrite(JNIEnv*, jobject, +void Java_org_forstdb_Options_setAllowConcurrentMemtableWrite(JNIEnv*, jobject, jlong jhandle, jboolean allow) { reinterpret_cast(jhandle) @@ -1894,44 +1894,44 @@ void Java_org_rocksdb_Options_setAllowConcurrentMemtableWrite(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: allowConcurrentMemtableWrite * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_allowConcurrentMemtableWrite(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_allowConcurrentMemtableWrite(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->allow_concurrent_memtable_write; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setEnableWriteThreadAdaptiveYield * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setEnableWriteThreadAdaptiveYield( +void Java_org_forstdb_Options_setEnableWriteThreadAdaptiveYield( JNIEnv*, jobject, jlong jhandle, jboolean yield) { reinterpret_cast(jhandle) ->enable_write_thread_adaptive_yield = static_cast(yield); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: enableWriteThreadAdaptiveYield * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_enableWriteThreadAdaptiveYield( +jboolean Java_org_forstdb_Options_enableWriteThreadAdaptiveYield( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->enable_write_thread_adaptive_yield; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWriteThreadMaxYieldUsec * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setWriteThreadMaxYieldUsec(JNIEnv*, jobject, +void Java_org_forstdb_Options_setWriteThreadMaxYieldUsec(JNIEnv*, jobject, jlong jhandle, jlong max) { reinterpret_cast(jhandle) @@ -1939,22 +1939,22 @@ void Java_org_rocksdb_Options_setWriteThreadMaxYieldUsec(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: writeThreadMaxYieldUsec * Signature: (J)J */ -jlong Java_org_rocksdb_Options_writeThreadMaxYieldUsec(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_writeThreadMaxYieldUsec(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->write_thread_max_yield_usec; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWriteThreadSlowYieldUsec * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setWriteThreadSlowYieldUsec(JNIEnv*, jobject, +void Java_org_forstdb_Options_setWriteThreadSlowYieldUsec(JNIEnv*, jobject, jlong jhandle, jlong slow) { reinterpret_cast(jhandle) @@ -1962,22 +1962,22 @@ void Java_org_rocksdb_Options_setWriteThreadSlowYieldUsec(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: writeThreadSlowYieldUsec * Signature: (J)J */ -jlong Java_org_rocksdb_Options_writeThreadSlowYieldUsec(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_writeThreadSlowYieldUsec(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->write_thread_slow_yield_usec; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setSkipStatsUpdateOnDbOpen * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setSkipStatsUpdateOnDbOpen( +void Java_org_forstdb_Options_setSkipStatsUpdateOnDbOpen( JNIEnv*, jobject, jlong jhandle, jboolean jskip_stats_update_on_db_open) { auto* opt = reinterpret_cast(jhandle); opt->skip_stats_update_on_db_open = @@ -1985,22 +1985,22 @@ void Java_org_rocksdb_Options_setSkipStatsUpdateOnDbOpen( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: skipStatsUpdateOnDbOpen * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_skipStatsUpdateOnDbOpen(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_skipStatsUpdateOnDbOpen(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->skip_stats_update_on_db_open); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setSkipCheckingSstFileSizesOnDbOpen * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setSkipCheckingSstFileSizesOnDbOpen( +void Java_org_forstdb_Options_setSkipCheckingSstFileSizesOnDbOpen( JNIEnv*, jclass, jlong jhandle, jboolean jskip_checking_sst_file_sizes_on_db_open) { auto* opt = reinterpret_cast(jhandle); @@ -2009,22 +2009,22 @@ void Java_org_rocksdb_Options_setSkipCheckingSstFileSizesOnDbOpen( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: skipCheckingSstFileSizesOnDbOpen * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_skipCheckingSstFileSizesOnDbOpen( +jboolean Java_org_forstdb_Options_skipCheckingSstFileSizesOnDbOpen( JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->skip_checking_sst_file_sizes_on_db_open); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWalRecoveryMode * Signature: (JB)V */ -void Java_org_rocksdb_Options_setWalRecoveryMode( +void Java_org_forstdb_Options_setWalRecoveryMode( JNIEnv*, jobject, jlong jhandle, jbyte jwal_recovery_mode_value) { auto* opt = reinterpret_cast(jhandle); opt->wal_recovery_mode = @@ -2033,11 +2033,11 @@ void Java_org_rocksdb_Options_setWalRecoveryMode( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: walRecoveryMode * Signature: (J)B */ -jbyte Java_org_rocksdb_Options_walRecoveryMode(JNIEnv*, jobject, +jbyte Java_org_forstdb_Options_walRecoveryMode(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return ROCKSDB_NAMESPACE::WALRecoveryModeJni::toJavaWALRecoveryMode( @@ -2045,32 +2045,32 @@ jbyte Java_org_rocksdb_Options_walRecoveryMode(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAllow2pc * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setAllow2pc(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setAllow2pc(JNIEnv*, jobject, jlong jhandle, jboolean jallow_2pc) { auto* opt = reinterpret_cast(jhandle); opt->allow_2pc = static_cast(jallow_2pc); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: allow2pc * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_allow2pc(JNIEnv*, jobject, jlong jhandle) { +jboolean Java_org_forstdb_Options_allow2pc(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->allow_2pc); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setRowCache * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setRowCache(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setRowCache(JNIEnv*, jobject, jlong jhandle, jlong jrow_cache_handle) { auto* opt = reinterpret_cast(jhandle); auto* row_cache = @@ -2080,11 +2080,11 @@ void Java_org_rocksdb_Options_setRowCache(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWalFilter * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setWalFilter(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setWalFilter(JNIEnv*, jobject, jlong jhandle, jlong jwal_filter_handle) { auto* opt = reinterpret_cast(jhandle); auto* wal_filter = reinterpret_cast( @@ -2093,11 +2093,11 @@ void Java_org_rocksdb_Options_setWalFilter(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setFailIfOptionsFileError * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setFailIfOptionsFileError( +void Java_org_forstdb_Options_setFailIfOptionsFileError( JNIEnv*, jobject, jlong jhandle, jboolean jfail_if_options_file_error) { auto* opt = reinterpret_cast(jhandle); opt->fail_if_options_file_error = @@ -2105,22 +2105,22 @@ void Java_org_rocksdb_Options_setFailIfOptionsFileError( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: failIfOptionsFileError * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_failIfOptionsFileError(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_failIfOptionsFileError(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->fail_if_options_file_error); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setDumpMallocStats * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setDumpMallocStats(JNIEnv*, jobject, +void Java_org_forstdb_Options_setDumpMallocStats(JNIEnv*, jobject, jlong jhandle, jboolean jdump_malloc_stats) { auto* opt = reinterpret_cast(jhandle); @@ -2128,22 +2128,22 @@ void Java_org_rocksdb_Options_setDumpMallocStats(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: dumpMallocStats * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_dumpMallocStats(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_dumpMallocStats(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->dump_malloc_stats); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAvoidFlushDuringRecovery * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setAvoidFlushDuringRecovery( +void Java_org_forstdb_Options_setAvoidFlushDuringRecovery( JNIEnv*, jobject, jlong jhandle, jboolean javoid_flush_during_recovery) { auto* opt = reinterpret_cast(jhandle); opt->avoid_flush_during_recovery = @@ -2151,88 +2151,88 @@ void Java_org_rocksdb_Options_setAvoidFlushDuringRecovery( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: avoidFlushDuringRecovery * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_avoidFlushDuringRecovery(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_avoidFlushDuringRecovery(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->avoid_flush_during_recovery); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAvoidUnnecessaryBlockingIO * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setAvoidUnnecessaryBlockingIO( +void Java_org_forstdb_Options_setAvoidUnnecessaryBlockingIO( JNIEnv*, jclass, jlong jhandle, jboolean avoid_blocking_io) { auto* opt = reinterpret_cast(jhandle); opt->avoid_unnecessary_blocking_io = static_cast(avoid_blocking_io); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: avoidUnnecessaryBlockingIO * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_avoidUnnecessaryBlockingIO(JNIEnv*, jclass, +jboolean Java_org_forstdb_Options_avoidUnnecessaryBlockingIO(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->avoid_unnecessary_blocking_io); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setPersistStatsToDisk * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setPersistStatsToDisk( +void Java_org_forstdb_Options_setPersistStatsToDisk( JNIEnv*, jclass, jlong jhandle, jboolean persist_stats_to_disk) { auto* opt = reinterpret_cast(jhandle); opt->persist_stats_to_disk = static_cast(persist_stats_to_disk); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: persistStatsToDisk * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_persistStatsToDisk(JNIEnv*, jclass, +jboolean Java_org_forstdb_Options_persistStatsToDisk(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->persist_stats_to_disk); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setWriteDbidToManifest * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setWriteDbidToManifest( +void Java_org_forstdb_Options_setWriteDbidToManifest( JNIEnv*, jclass, jlong jhandle, jboolean jwrite_dbid_to_manifest) { auto* opt = reinterpret_cast(jhandle); opt->write_dbid_to_manifest = static_cast(jwrite_dbid_to_manifest); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: writeDbidToManifest * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_writeDbidToManifest(JNIEnv*, jclass, +jboolean Java_org_forstdb_Options_writeDbidToManifest(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->write_dbid_to_manifest); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setLogReadaheadSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setLogReadaheadSize(JNIEnv*, jclass, +void Java_org_forstdb_Options_setLogReadaheadSize(JNIEnv*, jclass, jlong jhandle, jlong jlog_readahead_size) { auto* opt = reinterpret_cast(jhandle); @@ -2240,66 +2240,66 @@ void Java_org_rocksdb_Options_setLogReadaheadSize(JNIEnv*, jclass, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: logReasaheadSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_logReadaheadSize(JNIEnv*, jclass, +jlong Java_org_forstdb_Options_logReadaheadSize(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->log_readahead_size); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBestEffortsRecovery * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setBestEffortsRecovery( +void Java_org_forstdb_Options_setBestEffortsRecovery( JNIEnv*, jclass, jlong jhandle, jboolean jbest_efforts_recovery) { auto* opt = reinterpret_cast(jhandle); opt->best_efforts_recovery = static_cast(jbest_efforts_recovery); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: bestEffortsRecovery * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_bestEffortsRecovery(JNIEnv*, jclass, +jboolean Java_org_forstdb_Options_bestEffortsRecovery(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->best_efforts_recovery); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxBgErrorResumeCount * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMaxBgErrorResumeCount( +void Java_org_forstdb_Options_setMaxBgErrorResumeCount( JNIEnv*, jclass, jlong jhandle, jint jmax_bgerror_resume_count) { auto* opt = reinterpret_cast(jhandle); opt->max_bgerror_resume_count = static_cast(jmax_bgerror_resume_count); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxBgerrorResumeCount * Signature: (J)I */ -jint Java_org_rocksdb_Options_maxBgerrorResumeCount(JNIEnv*, jclass, +jint Java_org_forstdb_Options_maxBgerrorResumeCount(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->max_bgerror_resume_count); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBgerrorResumeRetryInterval * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setBgerrorResumeRetryInterval( +void Java_org_forstdb_Options_setBgerrorResumeRetryInterval( JNIEnv*, jclass, jlong jhandle, jlong jbgerror_resume_retry_interval) { auto* opt = reinterpret_cast(jhandle); opt->bgerror_resume_retry_interval = @@ -2307,22 +2307,22 @@ void Java_org_rocksdb_Options_setBgerrorResumeRetryInterval( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: bgerrorResumeRetryInterval * Signature: (J)J */ -jlong Java_org_rocksdb_Options_bgerrorResumeRetryInterval(JNIEnv*, jclass, +jlong Java_org_forstdb_Options_bgerrorResumeRetryInterval(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->bgerror_resume_retry_interval); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAvoidFlushDuringShutdown * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setAvoidFlushDuringShutdown( +void Java_org_forstdb_Options_setAvoidFlushDuringShutdown( JNIEnv*, jobject, jlong jhandle, jboolean javoid_flush_during_shutdown) { auto* opt = reinterpret_cast(jhandle); opt->avoid_flush_during_shutdown = @@ -2330,99 +2330,99 @@ void Java_org_rocksdb_Options_setAvoidFlushDuringShutdown( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: avoidFlushDuringShutdown * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_avoidFlushDuringShutdown(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_avoidFlushDuringShutdown(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->avoid_flush_during_shutdown); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAllowIngestBehind * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setAllowIngestBehind( +void Java_org_forstdb_Options_setAllowIngestBehind( JNIEnv*, jobject, jlong jhandle, jboolean jallow_ingest_behind) { auto* opt = reinterpret_cast(jhandle); opt->allow_ingest_behind = jallow_ingest_behind == JNI_TRUE; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: allowIngestBehind * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_allowIngestBehind(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_allowIngestBehind(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->allow_ingest_behind); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setTwoWriteQueues * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setTwoWriteQueues(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setTwoWriteQueues(JNIEnv*, jobject, jlong jhandle, jboolean jtwo_write_queues) { auto* opt = reinterpret_cast(jhandle); opt->two_write_queues = jtwo_write_queues == JNI_TRUE; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: twoWriteQueues * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_twoWriteQueues(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_twoWriteQueues(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->two_write_queues); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setManualWalFlush * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setManualWalFlush(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setManualWalFlush(JNIEnv*, jobject, jlong jhandle, jboolean jmanual_wal_flush) { auto* opt = reinterpret_cast(jhandle); opt->manual_wal_flush = jmanual_wal_flush == JNI_TRUE; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: manualWalFlush * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_manualWalFlush(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_manualWalFlush(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->manual_wal_flush); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setAtomicFlush * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setAtomicFlush(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setAtomicFlush(JNIEnv*, jobject, jlong jhandle, jboolean jatomic_flush) { auto* opt = reinterpret_cast(jhandle); opt->atomic_flush = jatomic_flush == JNI_TRUE; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: atomicFlush * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_atomicFlush(JNIEnv*, jobject, jlong jhandle) { +jboolean Java_org_forstdb_Options_atomicFlush(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->atomic_flush); } @@ -2431,7 +2431,7 @@ jboolean Java_org_rocksdb_Options_atomicFlush(JNIEnv*, jobject, jlong jhandle) { * Method: tableFactoryName * Signature: (J)Ljava/lang/String */ -jstring Java_org_rocksdb_Options_tableFactoryName(JNIEnv* env, jobject, +jstring Java_org_forstdb_Options_tableFactoryName(JNIEnv* env, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); ROCKSDB_NAMESPACE::TableFactory* tf = opt->table_factory.get(); @@ -2444,44 +2444,44 @@ jstring Java_org_rocksdb_Options_tableFactoryName(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: minWriteBufferNumberToMerge * Signature: (J)I */ -jint Java_org_rocksdb_Options_minWriteBufferNumberToMerge(JNIEnv*, jobject, +jint Java_org_forstdb_Options_minWriteBufferNumberToMerge(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->min_write_buffer_number_to_merge; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMinWriteBufferNumberToMerge * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMinWriteBufferNumberToMerge( +void Java_org_forstdb_Options_setMinWriteBufferNumberToMerge( JNIEnv*, jobject, jlong jhandle, jint jmin_write_buffer_number_to_merge) { reinterpret_cast(jhandle) ->min_write_buffer_number_to_merge = static_cast(jmin_write_buffer_number_to_merge); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxWriteBufferNumberToMaintain * Signature: (J)I */ -jint Java_org_rocksdb_Options_maxWriteBufferNumberToMaintain(JNIEnv*, jobject, +jint Java_org_forstdb_Options_maxWriteBufferNumberToMaintain(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_write_buffer_number_to_maintain; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxWriteBufferNumberToMaintain * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMaxWriteBufferNumberToMaintain( +void Java_org_forstdb_Options_setMaxWriteBufferNumberToMaintain( JNIEnv*, jobject, jlong jhandle, jint jmax_write_buffer_number_to_maintain) { reinterpret_cast(jhandle) @@ -2490,11 +2490,11 @@ void Java_org_rocksdb_Options_setMaxWriteBufferNumberToMaintain( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCompressionType * Signature: (JB)V */ -void Java_org_rocksdb_Options_setCompressionType( +void Java_org_forstdb_Options_setCompressionType( JNIEnv*, jobject, jlong jhandle, jbyte jcompression_type_value) { auto* opts = reinterpret_cast(jhandle); opts->compression = @@ -2503,11 +2503,11 @@ void Java_org_rocksdb_Options_setCompressionType( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: compressionType * Signature: (J)B */ -jbyte Java_org_rocksdb_Options_compressionType(JNIEnv*, jobject, +jbyte Java_org_forstdb_Options_compressionType(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return ROCKSDB_NAMESPACE::CompressionTypeJni::toJavaCompressionType( @@ -2594,11 +2594,11 @@ jbyteArray rocksdb_compression_list_helper( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCompressionPerLevel * Signature: (J[B)V */ -void Java_org_rocksdb_Options_setCompressionPerLevel( +void Java_org_forstdb_Options_setCompressionPerLevel( JNIEnv* env, jobject, jlong jhandle, jbyteArray jcompressionLevels) { auto uptr_compression_levels = rocksdb_compression_vector_helper(env, jcompressionLevels); @@ -2611,22 +2611,22 @@ void Java_org_rocksdb_Options_setCompressionPerLevel( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: compressionPerLevel * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_Options_compressionPerLevel(JNIEnv* env, jobject, +jbyteArray Java_org_forstdb_Options_compressionPerLevel(JNIEnv* env, jobject, jlong jhandle) { auto* options = reinterpret_cast(jhandle); return rocksdb_compression_list_helper(env, options->compression_per_level); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBottommostCompressionType * Signature: (JB)V */ -void Java_org_rocksdb_Options_setBottommostCompressionType( +void Java_org_forstdb_Options_setBottommostCompressionType( JNIEnv*, jobject, jlong jhandle, jbyte jcompression_type_value) { auto* options = reinterpret_cast(jhandle); options->bottommost_compression = @@ -2635,11 +2635,11 @@ void Java_org_rocksdb_Options_setBottommostCompressionType( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: bottommostCompressionType * Signature: (J)B */ -jbyte Java_org_rocksdb_Options_bottommostCompressionType(JNIEnv*, jobject, +jbyte Java_org_forstdb_Options_bottommostCompressionType(JNIEnv*, jobject, jlong jhandle) { auto* options = reinterpret_cast(jhandle); return ROCKSDB_NAMESPACE::CompressionTypeJni::toJavaCompressionType( @@ -2647,11 +2647,11 @@ jbyte Java_org_rocksdb_Options_bottommostCompressionType(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBottommostCompressionOptions * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setBottommostCompressionOptions( +void Java_org_forstdb_Options_setBottommostCompressionOptions( JNIEnv*, jobject, jlong jhandle, jlong jbottommost_compression_options_handle) { auto* options = reinterpret_cast(jhandle); @@ -2662,11 +2662,11 @@ void Java_org_rocksdb_Options_setBottommostCompressionOptions( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCompressionOptions * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setCompressionOptions( +void Java_org_forstdb_Options_setCompressionOptions( JNIEnv*, jobject, jlong jhandle, jlong jcompression_options_handle) { auto* options = reinterpret_cast(jhandle); auto* compression_options = @@ -2676,11 +2676,11 @@ void Java_org_rocksdb_Options_setCompressionOptions( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCompactionStyle * Signature: (JB)V */ -void Java_org_rocksdb_Options_setCompactionStyle(JNIEnv*, jobject, +void Java_org_forstdb_Options_setCompactionStyle(JNIEnv*, jobject, jlong jhandle, jbyte jcompaction_style) { auto* options = reinterpret_cast(jhandle); @@ -2690,11 +2690,11 @@ void Java_org_rocksdb_Options_setCompactionStyle(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: compactionStyle * Signature: (J)B */ -jbyte Java_org_rocksdb_Options_compactionStyle(JNIEnv*, jobject, +jbyte Java_org_forstdb_Options_compactionStyle(JNIEnv*, jobject, jlong jhandle) { auto* options = reinterpret_cast(jhandle); return ROCKSDB_NAMESPACE::CompactionStyleJni::toJavaCompactionStyle( @@ -2702,11 +2702,11 @@ jbyte Java_org_rocksdb_Options_compactionStyle(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxTableFilesSizeFIFO * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setMaxTableFilesSizeFIFO( +void Java_org_forstdb_Options_setMaxTableFilesSizeFIFO( JNIEnv*, jobject, jlong jhandle, jlong jmax_table_files_size) { reinterpret_cast(jhandle) ->compaction_options_fifo.max_table_files_size = @@ -2714,42 +2714,42 @@ void Java_org_rocksdb_Options_setMaxTableFilesSizeFIFO( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxTableFilesSizeFIFO * Signature: (J)J */ -jlong Java_org_rocksdb_Options_maxTableFilesSizeFIFO(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_maxTableFilesSizeFIFO(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->compaction_options_fifo.max_table_files_size; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: numLevels * Signature: (J)I */ -jint Java_org_rocksdb_Options_numLevels(JNIEnv*, jobject, jlong jhandle) { +jint Java_org_forstdb_Options_numLevels(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->num_levels; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setNumLevels * Signature: (JI)V */ -void Java_org_rocksdb_Options_setNumLevels(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setNumLevels(JNIEnv*, jobject, jlong jhandle, jint jnum_levels) { reinterpret_cast(jhandle)->num_levels = static_cast(jnum_levels); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: levelZeroFileNumCompactionTrigger * Signature: (J)I */ -jint Java_org_rocksdb_Options_levelZeroFileNumCompactionTrigger(JNIEnv*, +jint Java_org_forstdb_Options_levelZeroFileNumCompactionTrigger(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) @@ -2757,11 +2757,11 @@ jint Java_org_rocksdb_Options_levelZeroFileNumCompactionTrigger(JNIEnv*, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setLevelZeroFileNumCompactionTrigger * Signature: (JI)V */ -void Java_org_rocksdb_Options_setLevelZeroFileNumCompactionTrigger( +void Java_org_forstdb_Options_setLevelZeroFileNumCompactionTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_file_num_compaction_trigger) { reinterpret_cast(jhandle) ->level0_file_num_compaction_trigger = @@ -2769,22 +2769,22 @@ void Java_org_rocksdb_Options_setLevelZeroFileNumCompactionTrigger( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: levelZeroSlowdownWritesTrigger * Signature: (J)I */ -jint Java_org_rocksdb_Options_levelZeroSlowdownWritesTrigger(JNIEnv*, jobject, +jint Java_org_forstdb_Options_levelZeroSlowdownWritesTrigger(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level0_slowdown_writes_trigger; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setLevelSlowdownWritesTrigger * Signature: (JI)V */ -void Java_org_rocksdb_Options_setLevelZeroSlowdownWritesTrigger( +void Java_org_forstdb_Options_setLevelZeroSlowdownWritesTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_slowdown_writes_trigger) { reinterpret_cast(jhandle) ->level0_slowdown_writes_trigger = @@ -2792,22 +2792,22 @@ void Java_org_rocksdb_Options_setLevelZeroSlowdownWritesTrigger( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: levelZeroStopWritesTrigger * Signature: (J)I */ -jint Java_org_rocksdb_Options_levelZeroStopWritesTrigger(JNIEnv*, jobject, +jint Java_org_forstdb_Options_levelZeroStopWritesTrigger(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level0_stop_writes_trigger; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setLevelStopWritesTrigger * Signature: (JI)V */ -void Java_org_rocksdb_Options_setLevelZeroStopWritesTrigger( +void Java_org_forstdb_Options_setLevelZeroStopWritesTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_stop_writes_trigger) { reinterpret_cast(jhandle) ->level0_stop_writes_trigger = @@ -2815,44 +2815,44 @@ void Java_org_rocksdb_Options_setLevelZeroStopWritesTrigger( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: targetFileSizeBase * Signature: (J)J */ -jlong Java_org_rocksdb_Options_targetFileSizeBase(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_targetFileSizeBase(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->target_file_size_base; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setTargetFileSizeBase * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setTargetFileSizeBase( +void Java_org_forstdb_Options_setTargetFileSizeBase( JNIEnv*, jobject, jlong jhandle, jlong jtarget_file_size_base) { reinterpret_cast(jhandle) ->target_file_size_base = static_cast(jtarget_file_size_base); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: targetFileSizeMultiplier * Signature: (J)I */ -jint Java_org_rocksdb_Options_targetFileSizeMultiplier(JNIEnv*, jobject, +jint Java_org_forstdb_Options_targetFileSizeMultiplier(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->target_file_size_multiplier; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setTargetFileSizeMultiplier * Signature: (JI)V */ -void Java_org_rocksdb_Options_setTargetFileSizeMultiplier( +void Java_org_forstdb_Options_setTargetFileSizeMultiplier( JNIEnv*, jobject, jlong jhandle, jint jtarget_file_size_multiplier) { reinterpret_cast(jhandle) ->target_file_size_multiplier = @@ -2860,22 +2860,22 @@ void Java_org_rocksdb_Options_setTargetFileSizeMultiplier( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxBytesForLevelBase * Signature: (J)J */ -jlong Java_org_rocksdb_Options_maxBytesForLevelBase(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_maxBytesForLevelBase(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_bytes_for_level_base; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxBytesForLevelBase * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setMaxBytesForLevelBase( +void Java_org_forstdb_Options_setMaxBytesForLevelBase( JNIEnv*, jobject, jlong jhandle, jlong jmax_bytes_for_level_base) { reinterpret_cast(jhandle) ->max_bytes_for_level_base = @@ -2883,44 +2883,44 @@ void Java_org_rocksdb_Options_setMaxBytesForLevelBase( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: levelCompactionDynamicLevelBytes * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_levelCompactionDynamicLevelBytes( +jboolean Java_org_forstdb_Options_levelCompactionDynamicLevelBytes( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level_compaction_dynamic_level_bytes; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setLevelCompactionDynamicLevelBytes * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setLevelCompactionDynamicLevelBytes( +void Java_org_forstdb_Options_setLevelCompactionDynamicLevelBytes( JNIEnv*, jobject, jlong jhandle, jboolean jenable_dynamic_level_bytes) { reinterpret_cast(jhandle) ->level_compaction_dynamic_level_bytes = (jenable_dynamic_level_bytes); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxBytesForLevelMultiplier * Signature: (J)D */ -jdouble Java_org_rocksdb_Options_maxBytesForLevelMultiplier(JNIEnv*, jobject, +jdouble Java_org_forstdb_Options_maxBytesForLevelMultiplier(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_bytes_for_level_multiplier; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxBytesForLevelMultiplier * Signature: (JD)V */ -void Java_org_rocksdb_Options_setMaxBytesForLevelMultiplier( +void Java_org_forstdb_Options_setMaxBytesForLevelMultiplier( JNIEnv*, jobject, jlong jhandle, jdouble jmax_bytes_for_level_multiplier) { reinterpret_cast(jhandle) ->max_bytes_for_level_multiplier = @@ -2928,11 +2928,11 @@ void Java_org_rocksdb_Options_setMaxBytesForLevelMultiplier( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxCompactionBytes * Signature: (J)I */ -jlong Java_org_rocksdb_Options_maxCompactionBytes(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_maxCompactionBytes(JNIEnv*, jobject, jlong jhandle) { return static_cast( reinterpret_cast(jhandle) @@ -2940,32 +2940,32 @@ jlong Java_org_rocksdb_Options_maxCompactionBytes(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxCompactionBytes * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMaxCompactionBytes( +void Java_org_forstdb_Options_setMaxCompactionBytes( JNIEnv*, jobject, jlong jhandle, jlong jmax_compaction_bytes) { reinterpret_cast(jhandle)->max_compaction_bytes = static_cast(jmax_compaction_bytes); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: arenaBlockSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_arenaBlockSize(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_Options_arenaBlockSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->arena_block_size; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setArenaBlockSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setArenaBlockSize(JNIEnv* env, jobject, +void Java_org_forstdb_Options_setArenaBlockSize(JNIEnv* env, jobject, jlong jhandle, jlong jarena_block_size) { auto s = @@ -2979,44 +2979,44 @@ void Java_org_rocksdb_Options_setArenaBlockSize(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: disableAutoCompactions * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_disableAutoCompactions(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_disableAutoCompactions(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->disable_auto_compactions; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setDisableAutoCompactions * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setDisableAutoCompactions( +void Java_org_forstdb_Options_setDisableAutoCompactions( JNIEnv*, jobject, jlong jhandle, jboolean jdisable_auto_compactions) { reinterpret_cast(jhandle) ->disable_auto_compactions = static_cast(jdisable_auto_compactions); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxSequentialSkipInIterations * Signature: (J)J */ -jlong Java_org_rocksdb_Options_maxSequentialSkipInIterations(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_maxSequentialSkipInIterations(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_sequential_skip_in_iterations; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxSequentialSkipInIterations * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setMaxSequentialSkipInIterations( +void Java_org_forstdb_Options_setMaxSequentialSkipInIterations( JNIEnv*, jobject, jlong jhandle, jlong jmax_sequential_skip_in_iterations) { reinterpret_cast(jhandle) ->max_sequential_skip_in_iterations = @@ -3024,44 +3024,44 @@ void Java_org_rocksdb_Options_setMaxSequentialSkipInIterations( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: inplaceUpdateSupport * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_inplaceUpdateSupport(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_inplaceUpdateSupport(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->inplace_update_support; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setInplaceUpdateSupport * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setInplaceUpdateSupport( +void Java_org_forstdb_Options_setInplaceUpdateSupport( JNIEnv*, jobject, jlong jhandle, jboolean jinplace_update_support) { reinterpret_cast(jhandle) ->inplace_update_support = static_cast(jinplace_update_support); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: inplaceUpdateNumLocks * Signature: (J)J */ -jlong Java_org_rocksdb_Options_inplaceUpdateNumLocks(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_inplaceUpdateNumLocks(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->inplace_update_num_locks; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setInplaceUpdateNumLocks * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setInplaceUpdateNumLocks( +void Java_org_forstdb_Options_setInplaceUpdateNumLocks( JNIEnv* env, jobject, jlong jhandle, jlong jinplace_update_num_locks) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( jinplace_update_num_locks); @@ -3074,22 +3074,22 @@ void Java_org_rocksdb_Options_setInplaceUpdateNumLocks( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: memtablePrefixBloomSizeRatio * Signature: (J)I */ -jdouble Java_org_rocksdb_Options_memtablePrefixBloomSizeRatio(JNIEnv*, jobject, +jdouble Java_org_forstdb_Options_memtablePrefixBloomSizeRatio(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->memtable_prefix_bloom_size_ratio; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMemtablePrefixBloomSizeRatio * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMemtablePrefixBloomSizeRatio( +void Java_org_forstdb_Options_setMemtablePrefixBloomSizeRatio( JNIEnv*, jobject, jlong jhandle, jdouble jmemtable_prefix_bloom_size_ratio) { reinterpret_cast(jhandle) @@ -3098,22 +3098,22 @@ void Java_org_rocksdb_Options_setMemtablePrefixBloomSizeRatio( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: experimentalMempurgeThreshold * Signature: (J)I */ -jdouble Java_org_rocksdb_Options_experimentalMempurgeThreshold(JNIEnv*, jobject, +jdouble Java_org_forstdb_Options_experimentalMempurgeThreshold(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->experimental_mempurge_threshold; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setExperimentalMempurgeThreshold * Signature: (JI)V */ -void Java_org_rocksdb_Options_setExperimentalMempurgeThreshold( +void Java_org_forstdb_Options_setExperimentalMempurgeThreshold( JNIEnv*, jobject, jlong jhandle, jdouble jexperimental_mempurge_threshold) { reinterpret_cast(jhandle) ->experimental_mempurge_threshold = @@ -3121,22 +3121,22 @@ void Java_org_rocksdb_Options_setExperimentalMempurgeThreshold( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: memtableWholeKeyFiltering * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_memtableWholeKeyFiltering(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_memtableWholeKeyFiltering(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->memtable_whole_key_filtering; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMemtableWholeKeyFiltering * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setMemtableWholeKeyFiltering( +void Java_org_forstdb_Options_setMemtableWholeKeyFiltering( JNIEnv*, jobject, jlong jhandle, jboolean jmemtable_whole_key_filtering) { reinterpret_cast(jhandle) ->memtable_whole_key_filtering = @@ -3144,42 +3144,42 @@ void Java_org_rocksdb_Options_setMemtableWholeKeyFiltering( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: bloomLocality * Signature: (J)I */ -jint Java_org_rocksdb_Options_bloomLocality(JNIEnv*, jobject, jlong jhandle) { +jint Java_org_forstdb_Options_bloomLocality(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->bloom_locality; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBloomLocality * Signature: (JI)V */ -void Java_org_rocksdb_Options_setBloomLocality(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setBloomLocality(JNIEnv*, jobject, jlong jhandle, jint jbloom_locality) { reinterpret_cast(jhandle)->bloom_locality = static_cast(jbloom_locality); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxSuccessiveMerges * Signature: (J)J */ -jlong Java_org_rocksdb_Options_maxSuccessiveMerges(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_maxSuccessiveMerges(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_successive_merges; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxSuccessiveMerges * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setMaxSuccessiveMerges( +void Java_org_forstdb_Options_setMaxSuccessiveMerges( JNIEnv* env, jobject, jlong jhandle, jlong jmax_successive_merges) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( jmax_successive_merges); @@ -3192,22 +3192,22 @@ void Java_org_rocksdb_Options_setMaxSuccessiveMerges( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: optimizeFiltersForHits * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_optimizeFiltersForHits(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_optimizeFiltersForHits(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->optimize_filters_for_hits; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setOptimizeFiltersForHits * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setOptimizeFiltersForHits( +void Java_org_forstdb_Options_setOptimizeFiltersForHits( JNIEnv*, jobject, jlong jhandle, jboolean joptimize_filters_for_hits) { reinterpret_cast(jhandle) ->optimize_filters_for_hits = @@ -3215,11 +3215,11 @@ void Java_org_rocksdb_Options_setOptimizeFiltersForHits( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: oldDefaults * Signature: (JII)V */ -void Java_org_rocksdb_Options_oldDefaults(JNIEnv*, jclass, jlong jhandle, +void Java_org_forstdb_Options_oldDefaults(JNIEnv*, jclass, jlong jhandle, jint major_version, jint minor_version) { reinterpret_cast(jhandle)->OldDefaults( @@ -3227,21 +3227,21 @@ void Java_org_rocksdb_Options_oldDefaults(JNIEnv*, jclass, jlong jhandle, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: optimizeForSmallDb * Signature: (J)V */ -void Java_org_rocksdb_Options_optimizeForSmallDb__J(JNIEnv*, jobject, +void Java_org_forstdb_Options_optimizeForSmallDb__J(JNIEnv*, jobject, jlong jhandle) { reinterpret_cast(jhandle)->OptimizeForSmallDb(); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: optimizeForSmallDb * Signature: (JJ)V */ -void Java_org_rocksdb_Options_optimizeForSmallDb__JJ(JNIEnv*, jclass, +void Java_org_forstdb_Options_optimizeForSmallDb__JJ(JNIEnv*, jclass, jlong jhandle, jlong cache_handle) { auto* cache_sptr_ptr = @@ -3254,65 +3254,65 @@ void Java_org_rocksdb_Options_optimizeForSmallDb__JJ(JNIEnv*, jclass, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: optimizeForPointLookup * Signature: (JJ)V */ -void Java_org_rocksdb_Options_optimizeForPointLookup( +void Java_org_forstdb_Options_optimizeForPointLookup( JNIEnv*, jobject, jlong jhandle, jlong block_cache_size_mb) { reinterpret_cast(jhandle) ->OptimizeForPointLookup(block_cache_size_mb); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: optimizeLevelStyleCompaction * Signature: (JJ)V */ -void Java_org_rocksdb_Options_optimizeLevelStyleCompaction( +void Java_org_forstdb_Options_optimizeLevelStyleCompaction( JNIEnv*, jobject, jlong jhandle, jlong memtable_memory_budget) { reinterpret_cast(jhandle) ->OptimizeLevelStyleCompaction(memtable_memory_budget); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: optimizeUniversalStyleCompaction * Signature: (JJ)V */ -void Java_org_rocksdb_Options_optimizeUniversalStyleCompaction( +void Java_org_forstdb_Options_optimizeUniversalStyleCompaction( JNIEnv*, jobject, jlong jhandle, jlong memtable_memory_budget) { reinterpret_cast(jhandle) ->OptimizeUniversalStyleCompaction(memtable_memory_budget); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: prepareForBulkLoad * Signature: (J)V */ -void Java_org_rocksdb_Options_prepareForBulkLoad(JNIEnv*, jobject, +void Java_org_forstdb_Options_prepareForBulkLoad(JNIEnv*, jobject, jlong jhandle) { reinterpret_cast(jhandle)->PrepareForBulkLoad(); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: memtableHugePageSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_memtableHugePageSize(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_memtableHugePageSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->memtable_huge_page_size; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMemtableHugePageSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setMemtableHugePageSize( +void Java_org_forstdb_Options_setMemtableHugePageSize( JNIEnv* env, jobject, jlong jhandle, jlong jmemtable_huge_page_size) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( jmemtable_huge_page_size); @@ -3325,22 +3325,22 @@ void Java_org_rocksdb_Options_setMemtableHugePageSize( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: softPendingCompactionBytesLimit * Signature: (J)J */ -jlong Java_org_rocksdb_Options_softPendingCompactionBytesLimit(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_softPendingCompactionBytesLimit(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->soft_pending_compaction_bytes_limit; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setSoftPendingCompactionBytesLimit * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setSoftPendingCompactionBytesLimit( +void Java_org_forstdb_Options_setSoftPendingCompactionBytesLimit( JNIEnv*, jobject, jlong jhandle, jlong jsoft_pending_compaction_bytes_limit) { reinterpret_cast(jhandle) @@ -3349,22 +3349,22 @@ void Java_org_rocksdb_Options_setSoftPendingCompactionBytesLimit( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: softHardCompactionBytesLimit * Signature: (J)J */ -jlong Java_org_rocksdb_Options_hardPendingCompactionBytesLimit(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_hardPendingCompactionBytesLimit(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->hard_pending_compaction_bytes_limit; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setHardPendingCompactionBytesLimit * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setHardPendingCompactionBytesLimit( +void Java_org_forstdb_Options_setHardPendingCompactionBytesLimit( JNIEnv*, jobject, jlong jhandle, jlong jhard_pending_compaction_bytes_limit) { reinterpret_cast(jhandle) @@ -3373,22 +3373,22 @@ void Java_org_rocksdb_Options_setHardPendingCompactionBytesLimit( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: level0FileNumCompactionTrigger * Signature: (J)I */ -jint Java_org_rocksdb_Options_level0FileNumCompactionTrigger(JNIEnv*, jobject, +jint Java_org_forstdb_Options_level0FileNumCompactionTrigger(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level0_file_num_compaction_trigger; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setLevel0FileNumCompactionTrigger * Signature: (JI)V */ -void Java_org_rocksdb_Options_setLevel0FileNumCompactionTrigger( +void Java_org_forstdb_Options_setLevel0FileNumCompactionTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_file_num_compaction_trigger) { reinterpret_cast(jhandle) ->level0_file_num_compaction_trigger = @@ -3396,22 +3396,22 @@ void Java_org_rocksdb_Options_setLevel0FileNumCompactionTrigger( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: level0SlowdownWritesTrigger * Signature: (J)I */ -jint Java_org_rocksdb_Options_level0SlowdownWritesTrigger(JNIEnv*, jobject, +jint Java_org_forstdb_Options_level0SlowdownWritesTrigger(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level0_slowdown_writes_trigger; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setLevel0SlowdownWritesTrigger * Signature: (JI)V */ -void Java_org_rocksdb_Options_setLevel0SlowdownWritesTrigger( +void Java_org_forstdb_Options_setLevel0SlowdownWritesTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_slowdown_writes_trigger) { reinterpret_cast(jhandle) ->level0_slowdown_writes_trigger = @@ -3419,22 +3419,22 @@ void Java_org_rocksdb_Options_setLevel0SlowdownWritesTrigger( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: level0StopWritesTrigger * Signature: (J)I */ -jint Java_org_rocksdb_Options_level0StopWritesTrigger(JNIEnv*, jobject, +jint Java_org_forstdb_Options_level0StopWritesTrigger(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level0_stop_writes_trigger; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setLevel0StopWritesTrigger * Signature: (JI)V */ -void Java_org_rocksdb_Options_setLevel0StopWritesTrigger( +void Java_org_forstdb_Options_setLevel0StopWritesTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_stop_writes_trigger) { reinterpret_cast(jhandle) ->level0_stop_writes_trigger = @@ -3442,11 +3442,11 @@ void Java_org_rocksdb_Options_setLevel0StopWritesTrigger( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: maxBytesForLevelMultiplierAdditional * Signature: (J)[I */ -jintArray Java_org_rocksdb_Options_maxBytesForLevelMultiplierAdditional( +jintArray Java_org_forstdb_Options_maxBytesForLevelMultiplierAdditional( JNIEnv* env, jobject, jlong jhandle) { auto mbflma = reinterpret_cast(jhandle) ->max_bytes_for_level_multiplier_additional; @@ -3480,11 +3480,11 @@ jintArray Java_org_rocksdb_Options_maxBytesForLevelMultiplierAdditional( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMaxBytesForLevelMultiplierAdditional * Signature: (J[I)V */ -void Java_org_rocksdb_Options_setMaxBytesForLevelMultiplierAdditional( +void Java_org_forstdb_Options_setMaxBytesForLevelMultiplierAdditional( JNIEnv* env, jobject, jlong jhandle, jintArray jmax_bytes_for_level_multiplier_additional) { jsize len = env->GetArrayLength(jmax_bytes_for_level_multiplier_additional); @@ -3507,33 +3507,33 @@ void Java_org_rocksdb_Options_setMaxBytesForLevelMultiplierAdditional( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: paranoidFileChecks * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_paranoidFileChecks(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_paranoidFileChecks(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->paranoid_file_checks; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setParanoidFileChecks * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setParanoidFileChecks( +void Java_org_forstdb_Options_setParanoidFileChecks( JNIEnv*, jobject, jlong jhandle, jboolean jparanoid_file_checks) { reinterpret_cast(jhandle)->paranoid_file_checks = static_cast(jparanoid_file_checks); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCompactionPriority * Signature: (JB)V */ -void Java_org_rocksdb_Options_setCompactionPriority( +void Java_org_forstdb_Options_setCompactionPriority( JNIEnv*, jobject, jlong jhandle, jbyte jcompaction_priority_value) { auto* opts = reinterpret_cast(jhandle); opts->compaction_pri = @@ -3542,11 +3542,11 @@ void Java_org_rocksdb_Options_setCompactionPriority( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: compactionPriority * Signature: (J)B */ -jbyte Java_org_rocksdb_Options_compactionPriority(JNIEnv*, jobject, +jbyte Java_org_forstdb_Options_compactionPriority(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return ROCKSDB_NAMESPACE::CompactionPriorityJni::toJavaCompactionPriority( @@ -3554,11 +3554,11 @@ jbyte Java_org_rocksdb_Options_compactionPriority(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setReportBgIoStats * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setReportBgIoStats(JNIEnv*, jobject, +void Java_org_forstdb_Options_setReportBgIoStats(JNIEnv*, jobject, jlong jhandle, jboolean jreport_bg_io_stats) { auto* opts = reinterpret_cast(jhandle); @@ -3566,43 +3566,43 @@ void Java_org_rocksdb_Options_setReportBgIoStats(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: reportBgIoStats * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_reportBgIoStats(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_reportBgIoStats(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->report_bg_io_stats); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setTtl * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setTtl(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setTtl(JNIEnv*, jobject, jlong jhandle, jlong jttl) { auto* opts = reinterpret_cast(jhandle); opts->ttl = static_cast(jttl); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: ttl * Signature: (J)J */ -jlong Java_org_rocksdb_Options_ttl(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_Options_ttl(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->ttl); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setPeriodicCompactionSeconds * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setPeriodicCompactionSeconds( +void Java_org_forstdb_Options_setPeriodicCompactionSeconds( JNIEnv*, jobject, jlong jhandle, jlong jperiodicCompactionSeconds) { auto* opts = reinterpret_cast(jhandle); opts->periodic_compaction_seconds = @@ -3610,22 +3610,22 @@ void Java_org_rocksdb_Options_setPeriodicCompactionSeconds( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: periodicCompactionSeconds * Signature: (J)J */ -jlong Java_org_rocksdb_Options_periodicCompactionSeconds(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_periodicCompactionSeconds(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->periodic_compaction_seconds); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCompactionOptionsUniversal * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setCompactionOptionsUniversal( +void Java_org_forstdb_Options_setCompactionOptionsUniversal( JNIEnv*, jobject, jlong jhandle, jlong jcompaction_options_universal_handle) { auto* opts = reinterpret_cast(jhandle); @@ -3636,11 +3636,11 @@ void Java_org_rocksdb_Options_setCompactionOptionsUniversal( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setCompactionOptionsFIFO * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setCompactionOptionsFIFO( +void Java_org_forstdb_Options_setCompactionOptionsFIFO( JNIEnv*, jobject, jlong jhandle, jlong jcompaction_options_fifo_handle) { auto* opts = reinterpret_cast(jhandle); auto* opts_fifo = reinterpret_cast( @@ -3649,22 +3649,22 @@ void Java_org_rocksdb_Options_setCompactionOptionsFIFO( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setForceConsistencyChecks * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setForceConsistencyChecks( +void Java_org_forstdb_Options_setForceConsistencyChecks( JNIEnv*, jobject, jlong jhandle, jboolean jforce_consistency_checks) { auto* opts = reinterpret_cast(jhandle); opts->force_consistency_checks = static_cast(jforce_consistency_checks); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: forceConsistencyChecks * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_forceConsistencyChecks(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_forceConsistencyChecks(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->force_consistency_checks); @@ -3673,11 +3673,11 @@ jboolean Java_org_rocksdb_Options_forceConsistencyChecks(JNIEnv*, jobject, /// BLOB options /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setEnableBlobFiles * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setEnableBlobFiles(JNIEnv*, jobject, +void Java_org_forstdb_Options_setEnableBlobFiles(JNIEnv*, jobject, jlong jhandle, jboolean jenable_blob_files) { auto* opts = reinterpret_cast(jhandle); @@ -3685,64 +3685,64 @@ void Java_org_rocksdb_Options_setEnableBlobFiles(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: enableBlobFiles * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_enableBlobFiles(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_enableBlobFiles(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->enable_blob_files); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMinBlobSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setMinBlobSize(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setMinBlobSize(JNIEnv*, jobject, jlong jhandle, jlong jmin_blob_size) { auto* opts = reinterpret_cast(jhandle); opts->min_blob_size = static_cast(jmin_blob_size); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: minBlobSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_minBlobSize(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_Options_minBlobSize(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->min_blob_size); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBlobFileSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setBlobFileSize(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Options_setBlobFileSize(JNIEnv*, jobject, jlong jhandle, jlong jblob_file_size) { auto* opts = reinterpret_cast(jhandle); opts->blob_file_size = static_cast(jblob_file_size); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: blobFileSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_blobFileSize(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_Options_blobFileSize(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->blob_file_size); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBlobCompressionType * Signature: (JB)V */ -void Java_org_rocksdb_Options_setBlobCompressionType( +void Java_org_forstdb_Options_setBlobCompressionType( JNIEnv*, jobject, jlong jhandle, jbyte jblob_compression_type_value) { auto* opts = reinterpret_cast(jhandle); opts->blob_compression_type = @@ -3751,11 +3751,11 @@ void Java_org_rocksdb_Options_setBlobCompressionType( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: blobCompressionType * Signature: (J)B */ -jbyte Java_org_rocksdb_Options_blobCompressionType(JNIEnv*, jobject, +jbyte Java_org_forstdb_Options_blobCompressionType(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return ROCKSDB_NAMESPACE::CompressionTypeJni::toJavaCompressionType( @@ -3763,11 +3763,11 @@ jbyte Java_org_rocksdb_Options_blobCompressionType(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setEnableBlobGarbageCollection * Signature: (JZ)V */ -void Java_org_rocksdb_Options_setEnableBlobGarbageCollection( +void Java_org_forstdb_Options_setEnableBlobGarbageCollection( JNIEnv*, jobject, jlong jhandle, jboolean jenable_blob_garbage_collection) { auto* opts = reinterpret_cast(jhandle); opts->enable_blob_garbage_collection = @@ -3775,22 +3775,22 @@ void Java_org_rocksdb_Options_setEnableBlobGarbageCollection( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: enableBlobGarbageCollection * Signature: (J)Z */ -jboolean Java_org_rocksdb_Options_enableBlobGarbageCollection(JNIEnv*, jobject, +jboolean Java_org_forstdb_Options_enableBlobGarbageCollection(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->enable_blob_garbage_collection); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBlobGarbageCollectionAgeCutoff * Signature: (JD)V */ -void Java_org_rocksdb_Options_setBlobGarbageCollectionAgeCutoff( +void Java_org_forstdb_Options_setBlobGarbageCollectionAgeCutoff( JNIEnv*, jobject, jlong jhandle, jdouble jblob_garbage_collection_age_cutoff) { auto* opts = reinterpret_cast(jhandle); @@ -3799,11 +3799,11 @@ void Java_org_rocksdb_Options_setBlobGarbageCollectionAgeCutoff( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: blobGarbageCollectionAgeCutoff * Signature: (J)D */ -jdouble Java_org_rocksdb_Options_blobGarbageCollectionAgeCutoff(JNIEnv*, +jdouble Java_org_forstdb_Options_blobGarbageCollectionAgeCutoff(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -3811,11 +3811,11 @@ jdouble Java_org_rocksdb_Options_blobGarbageCollectionAgeCutoff(JNIEnv*, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBlobGarbageCollectionForceThreshold * Signature: (JD)V */ -void Java_org_rocksdb_Options_setBlobGarbageCollectionForceThreshold( +void Java_org_forstdb_Options_setBlobGarbageCollectionForceThreshold( JNIEnv*, jobject, jlong jhandle, jdouble jblob_garbage_collection_force_threshold) { auto* opts = reinterpret_cast(jhandle); @@ -3824,22 +3824,22 @@ void Java_org_rocksdb_Options_setBlobGarbageCollectionForceThreshold( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: blobGarbageCollectionForceThreshold * Signature: (J)D */ -jdouble Java_org_rocksdb_Options_blobGarbageCollectionForceThreshold( +jdouble Java_org_forstdb_Options_blobGarbageCollectionForceThreshold( JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->blob_garbage_collection_force_threshold); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBlobCompactionReadaheadSize * Signature: (JJ)V */ -void Java_org_rocksdb_Options_setBlobCompactionReadaheadSize( +void Java_org_forstdb_Options_setBlobCompactionReadaheadSize( JNIEnv*, jobject, jlong jhandle, jlong jblob_compaction_readahead_size) { auto* opts = reinterpret_cast(jhandle); opts->blob_compaction_readahead_size = @@ -3847,44 +3847,44 @@ void Java_org_rocksdb_Options_setBlobCompactionReadaheadSize( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: blobCompactionReadaheadSize * Signature: (J)J */ -jlong Java_org_rocksdb_Options_blobCompactionReadaheadSize(JNIEnv*, jobject, +jlong Java_org_forstdb_Options_blobCompactionReadaheadSize(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->blob_compaction_readahead_size); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setBlobFileStartingLevel * Signature: (JI)V */ -void Java_org_rocksdb_Options_setBlobFileStartingLevel( +void Java_org_forstdb_Options_setBlobFileStartingLevel( JNIEnv*, jobject, jlong jhandle, jint jblob_file_starting_level) { auto* opts = reinterpret_cast(jhandle); opts->blob_file_starting_level = jblob_file_starting_level; } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: blobFileStartingLevel * Signature: (J)I */ -jint Java_org_rocksdb_Options_blobFileStartingLevel(JNIEnv*, jobject, +jint Java_org_forstdb_Options_blobFileStartingLevel(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->blob_file_starting_level); } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setPrepopulateBlobCache * Signature: (JB)V */ -void Java_org_rocksdb_Options_setPrepopulateBlobCache( +void Java_org_forstdb_Options_setPrepopulateBlobCache( JNIEnv*, jobject, jlong jhandle, jbyte jprepopulate_blob_cache_value) { auto* opts = reinterpret_cast(jhandle); opts->prepopulate_blob_cache = @@ -3893,11 +3893,11 @@ void Java_org_rocksdb_Options_setPrepopulateBlobCache( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: prepopulateBlobCache * Signature: (J)B */ -jbyte Java_org_rocksdb_Options_prepopulateBlobCache(JNIEnv*, jobject, +jbyte Java_org_forstdb_Options_prepopulateBlobCache(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return ROCKSDB_NAMESPACE::PrepopulateBlobCacheJni::toJavaPrepopulateBlobCache( @@ -3905,11 +3905,11 @@ jbyte Java_org_rocksdb_Options_prepopulateBlobCache(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: setMemtableMaxRangeDeletions * Signature: (JI)V */ -void Java_org_rocksdb_Options_setMemtableMaxRangeDeletions( +void Java_org_forstdb_Options_setMemtableMaxRangeDeletions( JNIEnv*, jobject, jlong jhandle, jint jmemtable_max_range_deletions) { auto* opts = reinterpret_cast(jhandle); opts->memtable_max_range_deletions = @@ -3917,11 +3917,11 @@ void Java_org_rocksdb_Options_setMemtableMaxRangeDeletions( } /* - * Class: org_rocksdb_Options + * Class: org_forstdb_Options * Method: memtableMaxRangeDeletions * Signature: (J)I */ -jint Java_org_rocksdb_Options_memtableMaxRangeDeletions(JNIEnv*, jobject, +jint Java_org_forstdb_Options_memtableMaxRangeDeletions(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); return static_cast(opts->memtable_max_range_deletions); @@ -3931,22 +3931,22 @@ jint Java_org_rocksdb_Options_memtableMaxRangeDeletions(JNIEnv*, jobject, // ROCKSDB_NAMESPACE::ColumnFamilyOptions /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: newColumnFamilyOptions * Signature: ()J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_newColumnFamilyOptions(JNIEnv*, +jlong Java_org_forstdb_ColumnFamilyOptions_newColumnFamilyOptions(JNIEnv*, jclass) { auto* op = new ROCKSDB_NAMESPACE::ColumnFamilyOptions(); return GET_CPLUSPLUS_POINTER(op); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: copyColumnFamilyOptions * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_copyColumnFamilyOptions( +jlong Java_org_forstdb_ColumnFamilyOptions_copyColumnFamilyOptions( JNIEnv*, jclass, jlong jhandle) { auto new_opt = new ROCKSDB_NAMESPACE::ColumnFamilyOptions( *(reinterpret_cast(jhandle))); @@ -3954,11 +3954,11 @@ jlong Java_org_rocksdb_ColumnFamilyOptions_copyColumnFamilyOptions( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: newColumnFamilyOptionsFromOptions * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_newColumnFamilyOptionsFromOptions( +jlong Java_org_forstdb_ColumnFamilyOptions_newColumnFamilyOptionsFromOptions( JNIEnv*, jclass, jlong joptions_handle) { auto new_opt = new ROCKSDB_NAMESPACE::ColumnFamilyOptions( *reinterpret_cast(joptions_handle)); @@ -3966,11 +3966,11 @@ jlong Java_org_rocksdb_ColumnFamilyOptions_newColumnFamilyOptionsFromOptions( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: getColumnFamilyOptionsFromProps * Signature: (JLjava/lang/String;)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__JLjava_lang_String_2( +jlong Java_org_forstdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__JLjava_lang_String_2( JNIEnv* env, jclass, jlong cfg_handle, jstring jopt_string) { const char* opt_string = env->GetStringUTFChars(jopt_string, nullptr); if (opt_string == nullptr) { @@ -4000,11 +4000,11 @@ jlong Java_org_rocksdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__JLja } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: getColumnFamilyOptionsFromProps * Signature: (Ljava/util/String;)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__Ljava_lang_String_2( +jlong Java_org_forstdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__Ljava_lang_String_2( JNIEnv* env, jclass, jstring jopt_string) { const char* opt_string = env->GetStringUTFChars(jopt_string, nullptr); if (opt_string == nullptr) { @@ -4036,11 +4036,11 @@ jlong Java_org_rocksdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__Ljav } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_ColumnFamilyOptions_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_ColumnFamilyOptions_disposeInternal(JNIEnv*, jobject, jlong handle) { auto* cfo = reinterpret_cast(handle); assert(cfo != nullptr); @@ -4048,11 +4048,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: oldDefaults * Signature: (JII)V */ -void Java_org_rocksdb_ColumnFamilyOptions_oldDefaults(JNIEnv*, jclass, +void Java_org_forstdb_ColumnFamilyOptions_oldDefaults(JNIEnv*, jclass, jlong jhandle, jint major_version, jint minor_version) { @@ -4061,11 +4061,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_oldDefaults(JNIEnv*, jclass, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: optimizeForSmallDb * Signature: (J)V */ -void Java_org_rocksdb_ColumnFamilyOptions_optimizeForSmallDb__J(JNIEnv*, +void Java_org_forstdb_ColumnFamilyOptions_optimizeForSmallDb__J(JNIEnv*, jobject, jlong jhandle) { reinterpret_cast(jhandle) @@ -4073,11 +4073,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_optimizeForSmallDb__J(JNIEnv*, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: optimizeForSmallDb * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_optimizeForSmallDb__JJ( +void Java_org_forstdb_ColumnFamilyOptions_optimizeForSmallDb__JJ( JNIEnv*, jclass, jlong jhandle, jlong cache_handle) { auto* cache_sptr_ptr = reinterpret_cast*>( @@ -4087,44 +4087,44 @@ void Java_org_rocksdb_ColumnFamilyOptions_optimizeForSmallDb__JJ( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: optimizeForPointLookup * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_optimizeForPointLookup( +void Java_org_forstdb_ColumnFamilyOptions_optimizeForPointLookup( JNIEnv*, jobject, jlong jhandle, jlong block_cache_size_mb) { reinterpret_cast(jhandle) ->OptimizeForPointLookup(block_cache_size_mb); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: optimizeLevelStyleCompaction * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_optimizeLevelStyleCompaction( +void Java_org_forstdb_ColumnFamilyOptions_optimizeLevelStyleCompaction( JNIEnv*, jobject, jlong jhandle, jlong memtable_memory_budget) { reinterpret_cast(jhandle) ->OptimizeLevelStyleCompaction(memtable_memory_budget); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: optimizeUniversalStyleCompaction * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_optimizeUniversalStyleCompaction( +void Java_org_forstdb_ColumnFamilyOptions_optimizeUniversalStyleCompaction( JNIEnv*, jobject, jlong jhandle, jlong memtable_memory_budget) { reinterpret_cast(jhandle) ->OptimizeUniversalStyleCompaction(memtable_memory_budget); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setComparatorHandle * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JI( +void Java_org_forstdb_ColumnFamilyOptions_setComparatorHandle__JI( JNIEnv*, jobject, jlong jhandle, jint builtinComparator) { switch (builtinComparator) { case 1: @@ -4139,11 +4139,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JI( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setComparatorHandle * Signature: (JJB)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JJB( +void Java_org_forstdb_ColumnFamilyOptions_setComparatorHandle__JJB( JNIEnv*, jobject, jlong jopt_handle, jlong jcomparator_handle, jbyte jcomparator_type) { ROCKSDB_NAMESPACE::Comparator* comparator = nullptr; @@ -4166,11 +4166,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JJB( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMergeOperatorName * Signature: (JJjava/lang/String)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMergeOperatorName( +void Java_org_forstdb_ColumnFamilyOptions_setMergeOperatorName( JNIEnv* env, jobject, jlong jhandle, jstring jop_name) { auto* options = reinterpret_cast(jhandle); @@ -4186,11 +4186,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMergeOperatorName( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMergeOperator * Signature: (JJjava/lang/String)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMergeOperator( +void Java_org_forstdb_ColumnFamilyOptions_setMergeOperator( JNIEnv*, jobject, jlong jhandle, jlong mergeOperatorHandle) { reinterpret_cast(jhandle) ->merge_operator = @@ -4199,11 +4199,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMergeOperator( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setCompactionFilterHandle * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setCompactionFilterHandle( +void Java_org_forstdb_ColumnFamilyOptions_setCompactionFilterHandle( JNIEnv*, jobject, jlong jopt_handle, jlong jcompactionfilter_handle) { reinterpret_cast(jopt_handle) ->compaction_filter = @@ -4212,11 +4212,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setCompactionFilterHandle( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setCompactionFilterFactoryHandle * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setCompactionFilterFactoryHandle( +void Java_org_forstdb_ColumnFamilyOptions_setCompactionFilterFactoryHandle( JNIEnv*, jobject, jlong jopt_handle, jlong jcompactionfilterfactory_handle) { auto* cff_factory = reinterpret_cast< @@ -4227,11 +4227,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setCompactionFilterFactoryHandle( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setWriteBufferSize * Signature: (JJ)I */ -void Java_org_rocksdb_ColumnFamilyOptions_setWriteBufferSize( +void Java_org_forstdb_ColumnFamilyOptions_setWriteBufferSize( JNIEnv* env, jobject, jlong jhandle, jlong jwrite_buffer_size) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( jwrite_buffer_size); @@ -4244,33 +4244,33 @@ void Java_org_rocksdb_ColumnFamilyOptions_setWriteBufferSize( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: writeBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_writeBufferSize(JNIEnv*, jobject, +jlong Java_org_forstdb_ColumnFamilyOptions_writeBufferSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->write_buffer_size; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMaxWriteBufferNumber * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMaxWriteBufferNumber( +void Java_org_forstdb_ColumnFamilyOptions_setMaxWriteBufferNumber( JNIEnv*, jobject, jlong jhandle, jint jmax_write_buffer_number) { reinterpret_cast(jhandle) ->max_write_buffer_number = jmax_write_buffer_number; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: maxWriteBufferNumber * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_maxWriteBufferNumber(JNIEnv*, jobject, +jint Java_org_forstdb_ColumnFamilyOptions_maxWriteBufferNumber(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_write_buffer_number; @@ -4280,7 +4280,7 @@ jint Java_org_rocksdb_ColumnFamilyOptions_maxWriteBufferNumber(JNIEnv*, jobject, * Method: setMemTableFactory * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMemTableFactory( +void Java_org_forstdb_ColumnFamilyOptions_setMemTableFactory( JNIEnv*, jobject, jlong jhandle, jlong jfactory_handle) { reinterpret_cast(jhandle) ->memtable_factory.reset( @@ -4289,11 +4289,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMemTableFactory( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: memTableFactoryName * Signature: (J)Ljava/lang/String */ -jstring Java_org_rocksdb_ColumnFamilyOptions_memTableFactoryName( +jstring Java_org_forstdb_ColumnFamilyOptions_memTableFactoryName( JNIEnv* env, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); @@ -4315,7 +4315,7 @@ jstring Java_org_rocksdb_ColumnFamilyOptions_memTableFactoryName( * Method: useFixedLengthPrefixExtractor * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_useFixedLengthPrefixExtractor( +void Java_org_forstdb_ColumnFamilyOptions_useFixedLengthPrefixExtractor( JNIEnv*, jobject, jlong jhandle, jint jprefix_length) { reinterpret_cast(jhandle) ->prefix_extractor.reset(ROCKSDB_NAMESPACE::NewFixedPrefixTransform( @@ -4326,7 +4326,7 @@ void Java_org_rocksdb_ColumnFamilyOptions_useFixedLengthPrefixExtractor( * Method: useCappedPrefixExtractor * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_useCappedPrefixExtractor( +void Java_org_forstdb_ColumnFamilyOptions_useCappedPrefixExtractor( JNIEnv*, jobject, jlong jhandle, jint jprefix_length) { reinterpret_cast(jhandle) ->prefix_extractor.reset(ROCKSDB_NAMESPACE::NewCappedPrefixTransform( @@ -4337,7 +4337,7 @@ void Java_org_rocksdb_ColumnFamilyOptions_useCappedPrefixExtractor( * Method: setTableFactory * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setTableFactory( +void Java_org_forstdb_ColumnFamilyOptions_setTableFactory( JNIEnv*, jobject, jlong jhandle, jlong jfactory_handle) { reinterpret_cast(jhandle) ->table_factory.reset( @@ -4348,7 +4348,7 @@ void Java_org_rocksdb_ColumnFamilyOptions_setTableFactory( * Method: setSstPartitionerFactory * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setSstPartitionerFactory( +void Java_org_forstdb_ColumnFamilyOptions_setSstPartitionerFactory( JNIEnv*, jobject, jlong jhandle, jlong factory_handle) { auto* options = reinterpret_cast(jhandle); @@ -4359,11 +4359,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setSstPartitionerFactory( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setCompactionThreadLimiter * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setCompactionThreadLimiter( +void Java_org_forstdb_ColumnFamilyOptions_setCompactionThreadLimiter( JNIEnv*, jclass, jlong jhandle, jlong jlimiter_handle) { auto* options = reinterpret_cast(jhandle); @@ -4377,7 +4377,7 @@ void Java_org_rocksdb_ColumnFamilyOptions_setCompactionThreadLimiter( * Method: tableFactoryName * Signature: (J)Ljava/lang/String */ -jstring Java_org_rocksdb_ColumnFamilyOptions_tableFactoryName(JNIEnv* env, +jstring Java_org_forstdb_ColumnFamilyOptions_tableFactoryName(JNIEnv* env, jobject, jlong jhandle) { auto* opt = @@ -4392,11 +4392,11 @@ jstring Java_org_rocksdb_ColumnFamilyOptions_tableFactoryName(JNIEnv* env, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setCfPaths * Signature: (J[Ljava/lang/String;[J)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setCfPaths(JNIEnv* env, jclass, +void Java_org_forstdb_ColumnFamilyOptions_setCfPaths(JNIEnv* env, jclass, jlong jhandle, jobjectArray path_array, jlongArray size_array) { @@ -4412,11 +4412,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setCfPaths(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: cfPathsLen * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_cfPathsLen(JNIEnv*, jclass, +jlong Java_org_forstdb_ColumnFamilyOptions_cfPathsLen(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); @@ -4424,11 +4424,11 @@ jlong Java_org_rocksdb_ColumnFamilyOptions_cfPathsLen(JNIEnv*, jclass, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: cfPaths * Signature: (J[Ljava/lang/String;[J)V */ -void Java_org_rocksdb_ColumnFamilyOptions_cfPaths(JNIEnv* env, jclass, +void Java_org_forstdb_ColumnFamilyOptions_cfPaths(JNIEnv* env, jclass, jlong jhandle, jobjectArray jpaths, jlongArray jtarget_sizes) { @@ -4438,22 +4438,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_cfPaths(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: minWriteBufferNumberToMerge * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_minWriteBufferNumberToMerge( +jint Java_org_forstdb_ColumnFamilyOptions_minWriteBufferNumberToMerge( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->min_write_buffer_number_to_merge; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMinWriteBufferNumberToMerge * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMinWriteBufferNumberToMerge( +void Java_org_forstdb_ColumnFamilyOptions_setMinWriteBufferNumberToMerge( JNIEnv*, jobject, jlong jhandle, jint jmin_write_buffer_number_to_merge) { reinterpret_cast(jhandle) ->min_write_buffer_number_to_merge = @@ -4461,22 +4461,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMinWriteBufferNumberToMerge( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: maxWriteBufferNumberToMaintain * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_maxWriteBufferNumberToMaintain( +jint Java_org_forstdb_ColumnFamilyOptions_maxWriteBufferNumberToMaintain( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_write_buffer_number_to_maintain; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMaxWriteBufferNumberToMaintain * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMaxWriteBufferNumberToMaintain( +void Java_org_forstdb_ColumnFamilyOptions_setMaxWriteBufferNumberToMaintain( JNIEnv*, jobject, jlong jhandle, jint jmax_write_buffer_number_to_maintain) { reinterpret_cast(jhandle) @@ -4485,11 +4485,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMaxWriteBufferNumberToMaintain( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setCompressionType * Signature: (JB)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setCompressionType( +void Java_org_forstdb_ColumnFamilyOptions_setCompressionType( JNIEnv*, jobject, jlong jhandle, jbyte jcompression_type_value) { auto* cf_opts = reinterpret_cast(jhandle); @@ -4499,11 +4499,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setCompressionType( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: compressionType * Signature: (J)B */ -jbyte Java_org_rocksdb_ColumnFamilyOptions_compressionType(JNIEnv*, jobject, +jbyte Java_org_forstdb_ColumnFamilyOptions_compressionType(JNIEnv*, jobject, jlong jhandle) { auto* cf_opts = reinterpret_cast(jhandle); @@ -4512,11 +4512,11 @@ jbyte Java_org_rocksdb_ColumnFamilyOptions_compressionType(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setCompressionPerLevel * Signature: (J[B)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setCompressionPerLevel( +void Java_org_forstdb_ColumnFamilyOptions_setCompressionPerLevel( JNIEnv* env, jobject, jlong jhandle, jbyteArray jcompressionLevels) { auto* options = reinterpret_cast(jhandle); @@ -4530,11 +4530,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setCompressionPerLevel( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: compressionPerLevel * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_ColumnFamilyOptions_compressionPerLevel( +jbyteArray Java_org_forstdb_ColumnFamilyOptions_compressionPerLevel( JNIEnv* env, jobject, jlong jhandle) { auto* cf_options = reinterpret_cast(jhandle); @@ -4543,11 +4543,11 @@ jbyteArray Java_org_rocksdb_ColumnFamilyOptions_compressionPerLevel( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setBottommostCompressionType * Signature: (JB)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setBottommostCompressionType( +void Java_org_forstdb_ColumnFamilyOptions_setBottommostCompressionType( JNIEnv*, jobject, jlong jhandle, jbyte jcompression_type_value) { auto* cf_options = reinterpret_cast(jhandle); @@ -4557,11 +4557,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setBottommostCompressionType( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: bottommostCompressionType * Signature: (J)B */ -jbyte Java_org_rocksdb_ColumnFamilyOptions_bottommostCompressionType( +jbyte Java_org_forstdb_ColumnFamilyOptions_bottommostCompressionType( JNIEnv*, jobject, jlong jhandle) { auto* cf_options = reinterpret_cast(jhandle); @@ -4569,11 +4569,11 @@ jbyte Java_org_rocksdb_ColumnFamilyOptions_bottommostCompressionType( cf_options->bottommost_compression); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setBottommostCompressionOptions * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setBottommostCompressionOptions( +void Java_org_forstdb_ColumnFamilyOptions_setBottommostCompressionOptions( JNIEnv*, jobject, jlong jhandle, jlong jbottommost_compression_options_handle) { auto* cf_options = @@ -4585,11 +4585,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setBottommostCompressionOptions( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setCompressionOptions * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setCompressionOptions( +void Java_org_forstdb_ColumnFamilyOptions_setCompressionOptions( JNIEnv*, jobject, jlong jhandle, jlong jcompression_options_handle) { auto* cf_options = reinterpret_cast(jhandle); @@ -4600,11 +4600,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setCompressionOptions( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setCompactionStyle * Signature: (JB)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setCompactionStyle( +void Java_org_forstdb_ColumnFamilyOptions_setCompactionStyle( JNIEnv*, jobject, jlong jhandle, jbyte jcompaction_style) { auto* cf_options = reinterpret_cast(jhandle); @@ -4614,11 +4614,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setCompactionStyle( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: compactionStyle * Signature: (J)B */ -jbyte Java_org_rocksdb_ColumnFamilyOptions_compactionStyle(JNIEnv*, jobject, +jbyte Java_org_forstdb_ColumnFamilyOptions_compactionStyle(JNIEnv*, jobject, jlong jhandle) { auto* cf_options = reinterpret_cast(jhandle); @@ -4627,11 +4627,11 @@ jbyte Java_org_rocksdb_ColumnFamilyOptions_compactionStyle(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMaxTableFilesSizeFIFO * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMaxTableFilesSizeFIFO( +void Java_org_forstdb_ColumnFamilyOptions_setMaxTableFilesSizeFIFO( JNIEnv*, jobject, jlong jhandle, jlong jmax_table_files_size) { reinterpret_cast(jhandle) ->compaction_options_fifo.max_table_files_size = @@ -4639,33 +4639,33 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMaxTableFilesSizeFIFO( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: maxTableFilesSizeFIFO * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_maxTableFilesSizeFIFO( +jlong Java_org_forstdb_ColumnFamilyOptions_maxTableFilesSizeFIFO( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->compaction_options_fifo.max_table_files_size; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: numLevels * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_numLevels(JNIEnv*, jobject, +jint Java_org_forstdb_ColumnFamilyOptions_numLevels(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->num_levels; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setNumLevels * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setNumLevels(JNIEnv*, jobject, +void Java_org_forstdb_ColumnFamilyOptions_setNumLevels(JNIEnv*, jobject, jlong jhandle, jint jnum_levels) { reinterpret_cast(jhandle) @@ -4673,22 +4673,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setNumLevels(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: levelZeroFileNumCompactionTrigger * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_levelZeroFileNumCompactionTrigger( +jint Java_org_forstdb_ColumnFamilyOptions_levelZeroFileNumCompactionTrigger( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level0_file_num_compaction_trigger; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setLevelZeroFileNumCompactionTrigger * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroFileNumCompactionTrigger( +void Java_org_forstdb_ColumnFamilyOptions_setLevelZeroFileNumCompactionTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_file_num_compaction_trigger) { reinterpret_cast(jhandle) ->level0_file_num_compaction_trigger = @@ -4696,22 +4696,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroFileNumCompactionTrigger( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: levelZeroSlowdownWritesTrigger * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_levelZeroSlowdownWritesTrigger( +jint Java_org_forstdb_ColumnFamilyOptions_levelZeroSlowdownWritesTrigger( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level0_slowdown_writes_trigger; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setLevelSlowdownWritesTrigger * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroSlowdownWritesTrigger( +void Java_org_forstdb_ColumnFamilyOptions_setLevelZeroSlowdownWritesTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_slowdown_writes_trigger) { reinterpret_cast(jhandle) ->level0_slowdown_writes_trigger = @@ -4719,22 +4719,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroSlowdownWritesTrigger( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: levelZeroStopWritesTrigger * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_levelZeroStopWritesTrigger( +jint Java_org_forstdb_ColumnFamilyOptions_levelZeroStopWritesTrigger( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level0_stop_writes_trigger; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setLevelStopWritesTrigger * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroStopWritesTrigger( +void Java_org_forstdb_ColumnFamilyOptions_setLevelZeroStopWritesTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_stop_writes_trigger) { reinterpret_cast(jhandle) ->level0_stop_writes_trigger = @@ -4742,44 +4742,44 @@ void Java_org_rocksdb_ColumnFamilyOptions_setLevelZeroStopWritesTrigger( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: targetFileSizeBase * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_targetFileSizeBase(JNIEnv*, jobject, +jlong Java_org_forstdb_ColumnFamilyOptions_targetFileSizeBase(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->target_file_size_base; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setTargetFileSizeBase * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setTargetFileSizeBase( +void Java_org_forstdb_ColumnFamilyOptions_setTargetFileSizeBase( JNIEnv*, jobject, jlong jhandle, jlong jtarget_file_size_base) { reinterpret_cast(jhandle) ->target_file_size_base = static_cast(jtarget_file_size_base); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: targetFileSizeMultiplier * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_targetFileSizeMultiplier( +jint Java_org_forstdb_ColumnFamilyOptions_targetFileSizeMultiplier( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->target_file_size_multiplier; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setTargetFileSizeMultiplier * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setTargetFileSizeMultiplier( +void Java_org_forstdb_ColumnFamilyOptions_setTargetFileSizeMultiplier( JNIEnv*, jobject, jlong jhandle, jint jtarget_file_size_multiplier) { reinterpret_cast(jhandle) ->target_file_size_multiplier = @@ -4787,11 +4787,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setTargetFileSizeMultiplier( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: maxBytesForLevelBase * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelBase(JNIEnv*, +jlong Java_org_forstdb_ColumnFamilyOptions_maxBytesForLevelBase(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) @@ -4799,11 +4799,11 @@ jlong Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelBase(JNIEnv*, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMaxBytesForLevelBase * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelBase( +void Java_org_forstdb_ColumnFamilyOptions_setMaxBytesForLevelBase( JNIEnv*, jobject, jlong jhandle, jlong jmax_bytes_for_level_base) { reinterpret_cast(jhandle) ->max_bytes_for_level_base = @@ -4811,44 +4811,44 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelBase( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: levelCompactionDynamicLevelBytes * Signature: (J)Z */ -jboolean Java_org_rocksdb_ColumnFamilyOptions_levelCompactionDynamicLevelBytes( +jboolean Java_org_forstdb_ColumnFamilyOptions_levelCompactionDynamicLevelBytes( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level_compaction_dynamic_level_bytes; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setLevelCompactionDynamicLevelBytes * Signature: (JZ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setLevelCompactionDynamicLevelBytes( +void Java_org_forstdb_ColumnFamilyOptions_setLevelCompactionDynamicLevelBytes( JNIEnv*, jobject, jlong jhandle, jboolean jenable_dynamic_level_bytes) { reinterpret_cast(jhandle) ->level_compaction_dynamic_level_bytes = (jenable_dynamic_level_bytes); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: maxBytesForLevelMultiplier * Signature: (J)D */ -jdouble Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelMultiplier( +jdouble Java_org_forstdb_ColumnFamilyOptions_maxBytesForLevelMultiplier( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_bytes_for_level_multiplier; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMaxBytesForLevelMultiplier * Signature: (JD)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplier( +void Java_org_forstdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplier( JNIEnv*, jobject, jlong jhandle, jdouble jmax_bytes_for_level_multiplier) { reinterpret_cast(jhandle) ->max_bytes_for_level_multiplier = @@ -4856,11 +4856,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplier( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: maxCompactionBytes * Signature: (J)I */ -jlong Java_org_rocksdb_ColumnFamilyOptions_maxCompactionBytes(JNIEnv*, jobject, +jlong Java_org_forstdb_ColumnFamilyOptions_maxCompactionBytes(JNIEnv*, jobject, jlong jhandle) { return static_cast( reinterpret_cast(jhandle) @@ -4868,33 +4868,33 @@ jlong Java_org_rocksdb_ColumnFamilyOptions_maxCompactionBytes(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMaxCompactionBytes * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMaxCompactionBytes( +void Java_org_forstdb_ColumnFamilyOptions_setMaxCompactionBytes( JNIEnv*, jobject, jlong jhandle, jlong jmax_compaction_bytes) { reinterpret_cast(jhandle) ->max_compaction_bytes = static_cast(jmax_compaction_bytes); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: arenaBlockSize * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_arenaBlockSize(JNIEnv*, jobject, +jlong Java_org_forstdb_ColumnFamilyOptions_arenaBlockSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->arena_block_size; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setArenaBlockSize * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setArenaBlockSize( +void Java_org_forstdb_ColumnFamilyOptions_setArenaBlockSize( JNIEnv* env, jobject, jlong jhandle, jlong jarena_block_size) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t(jarena_block_size); @@ -4907,44 +4907,44 @@ void Java_org_rocksdb_ColumnFamilyOptions_setArenaBlockSize( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: disableAutoCompactions * Signature: (J)Z */ -jboolean Java_org_rocksdb_ColumnFamilyOptions_disableAutoCompactions( +jboolean Java_org_forstdb_ColumnFamilyOptions_disableAutoCompactions( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->disable_auto_compactions; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setDisableAutoCompactions * Signature: (JZ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setDisableAutoCompactions( +void Java_org_forstdb_ColumnFamilyOptions_setDisableAutoCompactions( JNIEnv*, jobject, jlong jhandle, jboolean jdisable_auto_compactions) { reinterpret_cast(jhandle) ->disable_auto_compactions = static_cast(jdisable_auto_compactions); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: maxSequentialSkipInIterations * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_maxSequentialSkipInIterations( +jlong Java_org_forstdb_ColumnFamilyOptions_maxSequentialSkipInIterations( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_sequential_skip_in_iterations; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMaxSequentialSkipInIterations * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMaxSequentialSkipInIterations( +void Java_org_forstdb_ColumnFamilyOptions_setMaxSequentialSkipInIterations( JNIEnv*, jobject, jlong jhandle, jlong jmax_sequential_skip_in_iterations) { reinterpret_cast(jhandle) ->max_sequential_skip_in_iterations = @@ -4952,44 +4952,44 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMaxSequentialSkipInIterations( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: inplaceUpdateSupport * Signature: (J)Z */ -jboolean Java_org_rocksdb_ColumnFamilyOptions_inplaceUpdateSupport( +jboolean Java_org_forstdb_ColumnFamilyOptions_inplaceUpdateSupport( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->inplace_update_support; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setInplaceUpdateSupport * Signature: (JZ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setInplaceUpdateSupport( +void Java_org_forstdb_ColumnFamilyOptions_setInplaceUpdateSupport( JNIEnv*, jobject, jlong jhandle, jboolean jinplace_update_support) { reinterpret_cast(jhandle) ->inplace_update_support = static_cast(jinplace_update_support); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: inplaceUpdateNumLocks * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_inplaceUpdateNumLocks( +jlong Java_org_forstdb_ColumnFamilyOptions_inplaceUpdateNumLocks( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->inplace_update_num_locks; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setInplaceUpdateNumLocks * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setInplaceUpdateNumLocks( +void Java_org_forstdb_ColumnFamilyOptions_setInplaceUpdateNumLocks( JNIEnv* env, jobject, jlong jhandle, jlong jinplace_update_num_locks) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( jinplace_update_num_locks); @@ -5002,22 +5002,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setInplaceUpdateNumLocks( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: memtablePrefixBloomSizeRatio * Signature: (J)I */ -jdouble Java_org_rocksdb_ColumnFamilyOptions_memtablePrefixBloomSizeRatio( +jdouble Java_org_forstdb_ColumnFamilyOptions_memtablePrefixBloomSizeRatio( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->memtable_prefix_bloom_size_ratio; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMemtablePrefixBloomSizeRatio * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMemtablePrefixBloomSizeRatio( +void Java_org_forstdb_ColumnFamilyOptions_setMemtablePrefixBloomSizeRatio( JNIEnv*, jobject, jlong jhandle, jdouble jmemtable_prefix_bloom_size_ratio) { reinterpret_cast(jhandle) @@ -5026,22 +5026,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMemtablePrefixBloomSizeRatio( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: experimentalMempurgeThreshold * Signature: (J)I */ -jdouble Java_org_rocksdb_ColumnFamilyOptions_experimentalMempurgeThreshold( +jdouble Java_org_forstdb_ColumnFamilyOptions_experimentalMempurgeThreshold( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->experimental_mempurge_threshold; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setExperimentalMempurgeThreshold * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setExperimentalMempurgeThreshold( +void Java_org_forstdb_ColumnFamilyOptions_setExperimentalMempurgeThreshold( JNIEnv*, jobject, jlong jhandle, jdouble jexperimental_mempurge_threshold) { reinterpret_cast(jhandle) ->experimental_mempurge_threshold = @@ -5049,22 +5049,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setExperimentalMempurgeThreshold( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: memtableWholeKeyFiltering * Signature: (J)Z */ -jboolean Java_org_rocksdb_ColumnFamilyOptions_memtableWholeKeyFiltering( +jboolean Java_org_forstdb_ColumnFamilyOptions_memtableWholeKeyFiltering( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->memtable_whole_key_filtering; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMemtableWholeKeyFiltering * Signature: (JZ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMemtableWholeKeyFiltering( +void Java_org_forstdb_ColumnFamilyOptions_setMemtableWholeKeyFiltering( JNIEnv*, jobject, jlong jhandle, jboolean jmemtable_whole_key_filtering) { reinterpret_cast(jhandle) ->memtable_whole_key_filtering = @@ -5072,44 +5072,44 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMemtableWholeKeyFiltering( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: bloomLocality * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_bloomLocality(JNIEnv*, jobject, +jint Java_org_forstdb_ColumnFamilyOptions_bloomLocality(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->bloom_locality; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setBloomLocality * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setBloomLocality( +void Java_org_forstdb_ColumnFamilyOptions_setBloomLocality( JNIEnv*, jobject, jlong jhandle, jint jbloom_locality) { reinterpret_cast(jhandle) ->bloom_locality = static_cast(jbloom_locality); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: maxSuccessiveMerges * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_maxSuccessiveMerges(JNIEnv*, jobject, +jlong Java_org_forstdb_ColumnFamilyOptions_maxSuccessiveMerges(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_successive_merges; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMaxSuccessiveMerges * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMaxSuccessiveMerges( +void Java_org_forstdb_ColumnFamilyOptions_setMaxSuccessiveMerges( JNIEnv* env, jobject, jlong jhandle, jlong jmax_successive_merges) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( jmax_successive_merges); @@ -5122,22 +5122,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMaxSuccessiveMerges( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: optimizeFiltersForHits * Signature: (J)Z */ -jboolean Java_org_rocksdb_ColumnFamilyOptions_optimizeFiltersForHits( +jboolean Java_org_forstdb_ColumnFamilyOptions_optimizeFiltersForHits( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->optimize_filters_for_hits; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setOptimizeFiltersForHits * Signature: (JZ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setOptimizeFiltersForHits( +void Java_org_forstdb_ColumnFamilyOptions_setOptimizeFiltersForHits( JNIEnv*, jobject, jlong jhandle, jboolean joptimize_filters_for_hits) { reinterpret_cast(jhandle) ->optimize_filters_for_hits = @@ -5145,11 +5145,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setOptimizeFiltersForHits( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: memtableHugePageSize * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_memtableHugePageSize(JNIEnv*, +jlong Java_org_forstdb_ColumnFamilyOptions_memtableHugePageSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) @@ -5157,11 +5157,11 @@ jlong Java_org_rocksdb_ColumnFamilyOptions_memtableHugePageSize(JNIEnv*, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMemtableHugePageSize * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMemtableHugePageSize( +void Java_org_forstdb_ColumnFamilyOptions_setMemtableHugePageSize( JNIEnv* env, jobject, jlong jhandle, jlong jmemtable_huge_page_size) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( jmemtable_huge_page_size); @@ -5174,22 +5174,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMemtableHugePageSize( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: softPendingCompactionBytesLimit * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_softPendingCompactionBytesLimit( +jlong Java_org_forstdb_ColumnFamilyOptions_softPendingCompactionBytesLimit( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->soft_pending_compaction_bytes_limit; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setSoftPendingCompactionBytesLimit * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setSoftPendingCompactionBytesLimit( +void Java_org_forstdb_ColumnFamilyOptions_setSoftPendingCompactionBytesLimit( JNIEnv*, jobject, jlong jhandle, jlong jsoft_pending_compaction_bytes_limit) { reinterpret_cast(jhandle) @@ -5198,22 +5198,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setSoftPendingCompactionBytesLimit( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: softHardCompactionBytesLimit * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_hardPendingCompactionBytesLimit( +jlong Java_org_forstdb_ColumnFamilyOptions_hardPendingCompactionBytesLimit( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->hard_pending_compaction_bytes_limit; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setHardPendingCompactionBytesLimit * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setHardPendingCompactionBytesLimit( +void Java_org_forstdb_ColumnFamilyOptions_setHardPendingCompactionBytesLimit( JNIEnv*, jobject, jlong jhandle, jlong jhard_pending_compaction_bytes_limit) { reinterpret_cast(jhandle) @@ -5222,22 +5222,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setHardPendingCompactionBytesLimit( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: level0FileNumCompactionTrigger * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_level0FileNumCompactionTrigger( +jint Java_org_forstdb_ColumnFamilyOptions_level0FileNumCompactionTrigger( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level0_file_num_compaction_trigger; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setLevel0FileNumCompactionTrigger * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setLevel0FileNumCompactionTrigger( +void Java_org_forstdb_ColumnFamilyOptions_setLevel0FileNumCompactionTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_file_num_compaction_trigger) { reinterpret_cast(jhandle) ->level0_file_num_compaction_trigger = @@ -5245,22 +5245,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setLevel0FileNumCompactionTrigger( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: level0SlowdownWritesTrigger * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_level0SlowdownWritesTrigger( +jint Java_org_forstdb_ColumnFamilyOptions_level0SlowdownWritesTrigger( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level0_slowdown_writes_trigger; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setLevel0SlowdownWritesTrigger * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setLevel0SlowdownWritesTrigger( +void Java_org_forstdb_ColumnFamilyOptions_setLevel0SlowdownWritesTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_slowdown_writes_trigger) { reinterpret_cast(jhandle) ->level0_slowdown_writes_trigger = @@ -5268,22 +5268,22 @@ void Java_org_rocksdb_ColumnFamilyOptions_setLevel0SlowdownWritesTrigger( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: level0StopWritesTrigger * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_level0StopWritesTrigger( +jint Java_org_forstdb_ColumnFamilyOptions_level0StopWritesTrigger( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->level0_stop_writes_trigger; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setLevel0StopWritesTrigger * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setLevel0StopWritesTrigger( +void Java_org_forstdb_ColumnFamilyOptions_setLevel0StopWritesTrigger( JNIEnv*, jobject, jlong jhandle, jint jlevel0_stop_writes_trigger) { reinterpret_cast(jhandle) ->level0_stop_writes_trigger = @@ -5291,12 +5291,12 @@ void Java_org_rocksdb_ColumnFamilyOptions_setLevel0StopWritesTrigger( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: maxBytesForLevelMultiplierAdditional * Signature: (J)[I */ jintArray -Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelMultiplierAdditional( +Java_org_forstdb_ColumnFamilyOptions_maxBytesForLevelMultiplierAdditional( JNIEnv* env, jobject, jlong jhandle) { auto mbflma = reinterpret_cast(jhandle) @@ -5330,11 +5330,11 @@ Java_org_rocksdb_ColumnFamilyOptions_maxBytesForLevelMultiplierAdditional( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMaxBytesForLevelMultiplierAdditional * Signature: (J[I)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplierAdditional( +void Java_org_forstdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplierAdditional( JNIEnv* env, jobject, jlong jhandle, jintArray jmax_bytes_for_level_multiplier_additional) { jsize len = env->GetArrayLength(jmax_bytes_for_level_multiplier_additional); @@ -5358,33 +5358,33 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplierAdditiona } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: paranoidFileChecks * Signature: (J)Z */ -jboolean Java_org_rocksdb_ColumnFamilyOptions_paranoidFileChecks( +jboolean Java_org_forstdb_ColumnFamilyOptions_paranoidFileChecks( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->paranoid_file_checks; } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setParanoidFileChecks * Signature: (JZ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setParanoidFileChecks( +void Java_org_forstdb_ColumnFamilyOptions_setParanoidFileChecks( JNIEnv*, jobject, jlong jhandle, jboolean jparanoid_file_checks) { reinterpret_cast(jhandle) ->paranoid_file_checks = static_cast(jparanoid_file_checks); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setCompactionPriority * Signature: (JB)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setCompactionPriority( +void Java_org_forstdb_ColumnFamilyOptions_setCompactionPriority( JNIEnv*, jobject, jlong jhandle, jbyte jcompaction_priority_value) { auto* cf_opts = reinterpret_cast(jhandle); @@ -5394,11 +5394,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setCompactionPriority( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: compactionPriority * Signature: (J)B */ -jbyte Java_org_rocksdb_ColumnFamilyOptions_compactionPriority(JNIEnv*, jobject, +jbyte Java_org_forstdb_ColumnFamilyOptions_compactionPriority(JNIEnv*, jobject, jlong jhandle) { auto* cf_opts = reinterpret_cast(jhandle); @@ -5407,11 +5407,11 @@ jbyte Java_org_rocksdb_ColumnFamilyOptions_compactionPriority(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setReportBgIoStats * Signature: (JZ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setReportBgIoStats( +void Java_org_forstdb_ColumnFamilyOptions_setReportBgIoStats( JNIEnv*, jobject, jlong jhandle, jboolean jreport_bg_io_stats) { auto* cf_opts = reinterpret_cast(jhandle); @@ -5419,11 +5419,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setReportBgIoStats( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: reportBgIoStats * Signature: (J)Z */ -jboolean Java_org_rocksdb_ColumnFamilyOptions_reportBgIoStats(JNIEnv*, jobject, +jboolean Java_org_forstdb_ColumnFamilyOptions_reportBgIoStats(JNIEnv*, jobject, jlong jhandle) { auto* cf_opts = reinterpret_cast(jhandle); @@ -5431,11 +5431,11 @@ jboolean Java_org_rocksdb_ColumnFamilyOptions_reportBgIoStats(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setTtl * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setTtl(JNIEnv*, jobject, +void Java_org_forstdb_ColumnFamilyOptions_setTtl(JNIEnv*, jobject, jlong jhandle, jlong jttl) { auto* cf_opts = reinterpret_cast(jhandle); @@ -5443,23 +5443,23 @@ void Java_org_rocksdb_ColumnFamilyOptions_setTtl(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: ttl * Signature: (J)J */ JNIEXPORT jlong JNICALL -Java_org_rocksdb_ColumnFamilyOptions_ttl(JNIEnv*, jobject, jlong jhandle) { +Java_org_forstdb_ColumnFamilyOptions_ttl(JNIEnv*, jobject, jlong jhandle) { auto* cf_opts = reinterpret_cast(jhandle); return static_cast(cf_opts->ttl); } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setPeriodicCompactionSeconds * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setPeriodicCompactionSeconds( +void Java_org_forstdb_ColumnFamilyOptions_setPeriodicCompactionSeconds( JNIEnv*, jobject, jlong jhandle, jlong jperiodicCompactionSeconds) { auto* cf_opts = reinterpret_cast(jhandle); @@ -5468,12 +5468,12 @@ void Java_org_rocksdb_ColumnFamilyOptions_setPeriodicCompactionSeconds( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: periodicCompactionSeconds * Signature: (J)J */ JNIEXPORT jlong JNICALL -Java_org_rocksdb_ColumnFamilyOptions_periodicCompactionSeconds(JNIEnv*, jobject, +Java_org_forstdb_ColumnFamilyOptions_periodicCompactionSeconds(JNIEnv*, jobject, jlong jhandle) { auto* cf_opts = reinterpret_cast(jhandle); @@ -5481,11 +5481,11 @@ Java_org_rocksdb_ColumnFamilyOptions_periodicCompactionSeconds(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setCompactionOptionsUniversal * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setCompactionOptionsUniversal( +void Java_org_forstdb_ColumnFamilyOptions_setCompactionOptionsUniversal( JNIEnv*, jobject, jlong jhandle, jlong jcompaction_options_universal_handle) { auto* cf_opts = @@ -5497,11 +5497,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setCompactionOptionsUniversal( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setCompactionOptionsFIFO * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setCompactionOptionsFIFO( +void Java_org_forstdb_ColumnFamilyOptions_setCompactionOptionsFIFO( JNIEnv*, jobject, jlong jhandle, jlong jcompaction_options_fifo_handle) { auto* cf_opts = reinterpret_cast(jhandle); @@ -5511,11 +5511,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setCompactionOptionsFIFO( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setForceConsistencyChecks * Signature: (JZ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setForceConsistencyChecks( +void Java_org_forstdb_ColumnFamilyOptions_setForceConsistencyChecks( JNIEnv*, jobject, jlong jhandle, jboolean jforce_consistency_checks) { auto* cf_opts = reinterpret_cast(jhandle); @@ -5524,11 +5524,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setForceConsistencyChecks( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: forceConsistencyChecks * Signature: (J)Z */ -jboolean Java_org_rocksdb_ColumnFamilyOptions_forceConsistencyChecks( +jboolean Java_org_forstdb_ColumnFamilyOptions_forceConsistencyChecks( JNIEnv*, jobject, jlong jhandle) { auto* cf_opts = reinterpret_cast(jhandle); @@ -5538,11 +5538,11 @@ jboolean Java_org_rocksdb_ColumnFamilyOptions_forceConsistencyChecks( /// BLOB options /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setEnableBlobFiles * Signature: (JZ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setEnableBlobFiles( +void Java_org_forstdb_ColumnFamilyOptions_setEnableBlobFiles( JNIEnv*, jobject, jlong jhandle, jboolean jenable_blob_files) { auto* opts = reinterpret_cast(jhandle); @@ -5550,11 +5550,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setEnableBlobFiles( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: enableBlobFiles * Signature: (J)Z */ -jboolean Java_org_rocksdb_ColumnFamilyOptions_enableBlobFiles(JNIEnv*, jobject, +jboolean Java_org_forstdb_ColumnFamilyOptions_enableBlobFiles(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -5562,11 +5562,11 @@ jboolean Java_org_rocksdb_ColumnFamilyOptions_enableBlobFiles(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMinBlobSize * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMinBlobSize(JNIEnv*, jobject, +void Java_org_forstdb_ColumnFamilyOptions_setMinBlobSize(JNIEnv*, jobject, jlong jhandle, jlong jmin_blob_size) { auto* opts = @@ -5575,11 +5575,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMinBlobSize(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: minBlobSize * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_minBlobSize(JNIEnv*, jobject, +jlong Java_org_forstdb_ColumnFamilyOptions_minBlobSize(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -5587,11 +5587,11 @@ jlong Java_org_rocksdb_ColumnFamilyOptions_minBlobSize(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setBlobFileSize * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setBlobFileSize( +void Java_org_forstdb_ColumnFamilyOptions_setBlobFileSize( JNIEnv*, jobject, jlong jhandle, jlong jblob_file_size) { auto* opts = reinterpret_cast(jhandle); @@ -5599,11 +5599,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setBlobFileSize( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: blobFileSize * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_blobFileSize(JNIEnv*, jobject, +jlong Java_org_forstdb_ColumnFamilyOptions_blobFileSize(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -5611,11 +5611,11 @@ jlong Java_org_rocksdb_ColumnFamilyOptions_blobFileSize(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setBlobCompressionType * Signature: (JB)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setBlobCompressionType( +void Java_org_forstdb_ColumnFamilyOptions_setBlobCompressionType( JNIEnv*, jobject, jlong jhandle, jbyte jblob_compression_type_value) { auto* opts = reinterpret_cast(jhandle); @@ -5625,11 +5625,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setBlobCompressionType( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: blobCompressionType * Signature: (J)B */ -jbyte Java_org_rocksdb_ColumnFamilyOptions_blobCompressionType(JNIEnv*, jobject, +jbyte Java_org_forstdb_ColumnFamilyOptions_blobCompressionType(JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -5638,11 +5638,11 @@ jbyte Java_org_rocksdb_ColumnFamilyOptions_blobCompressionType(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setEnableBlobGarbageCollection * Signature: (JZ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setEnableBlobGarbageCollection( +void Java_org_forstdb_ColumnFamilyOptions_setEnableBlobGarbageCollection( JNIEnv*, jobject, jlong jhandle, jboolean jenable_blob_garbage_collection) { auto* opts = reinterpret_cast(jhandle); @@ -5651,11 +5651,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setEnableBlobGarbageCollection( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: enableBlobGarbageCollection * Signature: (J)Z */ -jboolean Java_org_rocksdb_ColumnFamilyOptions_enableBlobGarbageCollection( +jboolean Java_org_forstdb_ColumnFamilyOptions_enableBlobGarbageCollection( JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -5663,11 +5663,11 @@ jboolean Java_org_rocksdb_ColumnFamilyOptions_enableBlobGarbageCollection( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setBlobGarbageCollectionAgeCutoff * Signature: (JD)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setBlobGarbageCollectionAgeCutoff( +void Java_org_forstdb_ColumnFamilyOptions_setBlobGarbageCollectionAgeCutoff( JNIEnv*, jobject, jlong jhandle, jdouble jblob_garbage_collection_age_cutoff) { auto* opts = @@ -5677,11 +5677,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setBlobGarbageCollectionAgeCutoff( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: blobGarbageCollectionAgeCutoff * Signature: (J)D */ -jdouble Java_org_rocksdb_ColumnFamilyOptions_blobGarbageCollectionAgeCutoff( +jdouble Java_org_forstdb_ColumnFamilyOptions_blobGarbageCollectionAgeCutoff( JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -5689,11 +5689,11 @@ jdouble Java_org_rocksdb_ColumnFamilyOptions_blobGarbageCollectionAgeCutoff( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setBlobGarbageCollectionForceThreshold * Signature: (JD)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setBlobGarbageCollectionForceThreshold( +void Java_org_forstdb_ColumnFamilyOptions_setBlobGarbageCollectionForceThreshold( JNIEnv*, jobject, jlong jhandle, jdouble jblob_garbage_collection_force_threshold) { auto* opts = @@ -5703,12 +5703,12 @@ void Java_org_rocksdb_ColumnFamilyOptions_setBlobGarbageCollectionForceThreshold } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: blobGarbageCollectionForceThreshold * Signature: (J)D */ jdouble -Java_org_rocksdb_ColumnFamilyOptions_blobGarbageCollectionForceThreshold( +Java_org_forstdb_ColumnFamilyOptions_blobGarbageCollectionForceThreshold( JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -5716,11 +5716,11 @@ Java_org_rocksdb_ColumnFamilyOptions_blobGarbageCollectionForceThreshold( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setBlobCompactionReadaheadSize * Signature: (JJ)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setBlobCompactionReadaheadSize( +void Java_org_forstdb_ColumnFamilyOptions_setBlobCompactionReadaheadSize( JNIEnv*, jobject, jlong jhandle, jlong jblob_compaction_readahead_size) { auto* opts = reinterpret_cast(jhandle); @@ -5729,11 +5729,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setBlobCompactionReadaheadSize( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: blobCompactionReadaheadSize * Signature: (J)J */ -jlong Java_org_rocksdb_ColumnFamilyOptions_blobCompactionReadaheadSize( +jlong Java_org_forstdb_ColumnFamilyOptions_blobCompactionReadaheadSize( JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -5741,11 +5741,11 @@ jlong Java_org_rocksdb_ColumnFamilyOptions_blobCompactionReadaheadSize( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setBlobFileStartingLevel * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setBlobFileStartingLevel( +void Java_org_forstdb_ColumnFamilyOptions_setBlobFileStartingLevel( JNIEnv*, jobject, jlong jhandle, jint jblob_file_starting_level) { auto* opts = reinterpret_cast(jhandle); @@ -5753,11 +5753,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setBlobFileStartingLevel( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: blobFileStartingLevel * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_blobFileStartingLevel(JNIEnv*, +jint Java_org_forstdb_ColumnFamilyOptions_blobFileStartingLevel(JNIEnv*, jobject, jlong jhandle) { auto* opts = @@ -5766,11 +5766,11 @@ jint Java_org_rocksdb_ColumnFamilyOptions_blobFileStartingLevel(JNIEnv*, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setPrepopulateBlobCache * Signature: (JB)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setPrepopulateBlobCache( +void Java_org_forstdb_ColumnFamilyOptions_setPrepopulateBlobCache( JNIEnv*, jobject, jlong jhandle, jbyte jprepopulate_blob_cache_value) { auto* opts = reinterpret_cast(jhandle); @@ -5780,11 +5780,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setPrepopulateBlobCache( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: prepopulateBlobCache * Signature: (J)B */ -jbyte Java_org_rocksdb_ColumnFamilyOptions_prepopulateBlobCache(JNIEnv*, +jbyte Java_org_forstdb_ColumnFamilyOptions_prepopulateBlobCache(JNIEnv*, jobject, jlong jhandle) { auto* opts = @@ -5794,11 +5794,11 @@ jbyte Java_org_rocksdb_ColumnFamilyOptions_prepopulateBlobCache(JNIEnv*, } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: setMemtableMaxRangeDeletions * Signature: (JI)V */ -void Java_org_rocksdb_ColumnFamilyOptions_setMemtableMaxRangeDeletions( +void Java_org_forstdb_ColumnFamilyOptions_setMemtableMaxRangeDeletions( JNIEnv*, jobject, jlong jhandle, jint jmemtable_max_range_deletions) { auto* opts = reinterpret_cast(jhandle); @@ -5806,11 +5806,11 @@ void Java_org_rocksdb_ColumnFamilyOptions_setMemtableMaxRangeDeletions( } /* - * Class: org_rocksdb_ColumnFamilyOptions + * Class: org_forstdb_ColumnFamilyOptions * Method: memtableMaxRangeDeletions * Signature: (J)I */ -jint Java_org_rocksdb_ColumnFamilyOptions_memtableMaxRangeDeletions( +jint Java_org_forstdb_ColumnFamilyOptions_memtableMaxRangeDeletions( JNIEnv*, jobject, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -5821,32 +5821,32 @@ jint Java_org_rocksdb_ColumnFamilyOptions_memtableMaxRangeDeletions( // ROCKSDB_NAMESPACE::DBOptions /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: newDBOptions * Signature: ()J */ -jlong Java_org_rocksdb_DBOptions_newDBOptions(JNIEnv*, jclass) { +jlong Java_org_forstdb_DBOptions_newDBOptions(JNIEnv*, jclass) { auto* dbop = new ROCKSDB_NAMESPACE::DBOptions(); return GET_CPLUSPLUS_POINTER(dbop); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: copyDBOptions * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_copyDBOptions(JNIEnv*, jclass, jlong jhandle) { +jlong Java_org_forstdb_DBOptions_copyDBOptions(JNIEnv*, jclass, jlong jhandle) { auto new_opt = new ROCKSDB_NAMESPACE::DBOptions( *(reinterpret_cast(jhandle))); return GET_CPLUSPLUS_POINTER(new_opt); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: newDBOptionsFromOptions * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_newDBOptionsFromOptions( +jlong Java_org_forstdb_DBOptions_newDBOptionsFromOptions( JNIEnv*, jclass, jlong joptions_handle) { auto new_opt = new ROCKSDB_NAMESPACE::DBOptions( *reinterpret_cast(joptions_handle)); @@ -5854,11 +5854,11 @@ jlong Java_org_rocksdb_DBOptions_newDBOptionsFromOptions( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: getDBOptionsFromProps * Signature: (JLjava/lang/String;)J */ -jlong Java_org_rocksdb_DBOptions_getDBOptionsFromProps__JLjava_lang_String_2( +jlong Java_org_forstdb_DBOptions_getDBOptionsFromProps__JLjava_lang_String_2( JNIEnv* env, jclass, jlong config_handle, jstring jopt_string) { const char* opt_string = env->GetStringUTFChars(jopt_string, nullptr); if (opt_string == nullptr) { @@ -5887,11 +5887,11 @@ jlong Java_org_rocksdb_DBOptions_getDBOptionsFromProps__JLjava_lang_String_2( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: getDBOptionsFromProps * Signature: (Ljava/util/String;)J */ -jlong Java_org_rocksdb_DBOptions_getDBOptionsFromProps__Ljava_lang_String_2( +jlong Java_org_forstdb_DBOptions_getDBOptionsFromProps__Ljava_lang_String_2( JNIEnv* env, jclass, jstring jopt_string) { const char* opt_string = env->GetStringUTFChars(jopt_string, nullptr); if (opt_string == nullptr) { @@ -5922,11 +5922,11 @@ jlong Java_org_rocksdb_DBOptions_getDBOptionsFromProps__Ljava_lang_String_2( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_DBOptions_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_disposeInternal(JNIEnv*, jobject, jlong handle) { auto* dbo = reinterpret_cast(handle); assert(dbo != nullptr); @@ -5934,33 +5934,33 @@ void Java_org_rocksdb_DBOptions_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: optimizeForSmallDb * Signature: (J)V */ -void Java_org_rocksdb_DBOptions_optimizeForSmallDb(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_optimizeForSmallDb(JNIEnv*, jobject, jlong jhandle) { reinterpret_cast(jhandle) ->OptimizeForSmallDb(); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setEnv * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setEnv(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setEnv(JNIEnv*, jobject, jlong jhandle, jlong jenv_handle) { reinterpret_cast(jhandle)->env = reinterpret_cast(jenv_handle); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setIncreaseParallelism * Signature: (JI)V */ -void Java_org_rocksdb_DBOptions_setIncreaseParallelism(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setIncreaseParallelism(JNIEnv*, jobject, jlong jhandle, jint totalThreads) { reinterpret_cast(jhandle)->IncreaseParallelism( @@ -5968,11 +5968,11 @@ void Java_org_rocksdb_DBOptions_setIncreaseParallelism(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setCreateIfMissing * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setCreateIfMissing(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setCreateIfMissing(JNIEnv*, jobject, jlong jhandle, jboolean flag) { reinterpret_cast(jhandle)->create_if_missing = @@ -5980,22 +5980,22 @@ void Java_org_rocksdb_DBOptions_setCreateIfMissing(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: createIfMissing * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_createIfMissing(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_createIfMissing(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->create_if_missing; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setCreateMissingColumnFamilies * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setCreateMissingColumnFamilies(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setCreateMissingColumnFamilies(JNIEnv*, jobject, jlong jhandle, jboolean flag) { reinterpret_cast(jhandle) @@ -6003,11 +6003,11 @@ void Java_org_rocksdb_DBOptions_setCreateMissingColumnFamilies(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: createMissingColumnFamilies * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_createMissingColumnFamilies(JNIEnv*, +jboolean Java_org_forstdb_DBOptions_createMissingColumnFamilies(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) @@ -6015,11 +6015,11 @@ jboolean Java_org_rocksdb_DBOptions_createMissingColumnFamilies(JNIEnv*, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setErrorIfExists * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setErrorIfExists(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setErrorIfExists(JNIEnv*, jobject, jlong jhandle, jboolean error_if_exists) { reinterpret_cast(jhandle)->error_if_exists = @@ -6027,22 +6027,22 @@ void Java_org_rocksdb_DBOptions_setErrorIfExists(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: errorIfExists * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_errorIfExists(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_errorIfExists(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->error_if_exists; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setParanoidChecks * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setParanoidChecks(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setParanoidChecks(JNIEnv*, jobject, jlong jhandle, jboolean paranoid_checks) { reinterpret_cast(jhandle)->paranoid_checks = @@ -6050,22 +6050,22 @@ void Java_org_rocksdb_DBOptions_setParanoidChecks(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: paranoidChecks * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_paranoidChecks(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_paranoidChecks(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->paranoid_checks; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setRateLimiter * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setRateLimiter(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setRateLimiter(JNIEnv*, jobject, jlong jhandle, jlong jrate_limiter_handle) { std::shared_ptr* pRateLimiter = reinterpret_cast*>( @@ -6075,11 +6075,11 @@ void Java_org_rocksdb_DBOptions_setRateLimiter(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setSstFileManager * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setSstFileManager( +void Java_org_forstdb_DBOptions_setSstFileManager( JNIEnv*, jobject, jlong jhandle, jlong jsst_file_manager_handle) { auto* sptr_sst_file_manager = reinterpret_cast*>( @@ -6089,11 +6089,11 @@ void Java_org_rocksdb_DBOptions_setSstFileManager( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setLogger * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setLogger(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setLogger(JNIEnv*, jobject, jlong jhandle, jlong jlogger_handle) { std::shared_ptr* pLogger = reinterpret_cast*>( @@ -6102,32 +6102,32 @@ void Java_org_rocksdb_DBOptions_setLogger(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setInfoLogLevel * Signature: (JB)V */ -void Java_org_rocksdb_DBOptions_setInfoLogLevel(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setInfoLogLevel(JNIEnv*, jobject, jlong jhandle, jbyte jlog_level) { reinterpret_cast(jhandle)->info_log_level = static_cast(jlog_level); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: infoLogLevel * Signature: (J)B */ -jbyte Java_org_rocksdb_DBOptions_infoLogLevel(JNIEnv*, jobject, jlong jhandle) { +jbyte Java_org_forstdb_DBOptions_infoLogLevel(JNIEnv*, jobject, jlong jhandle) { return static_cast( reinterpret_cast(jhandle)->info_log_level); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setMaxTotalWalSize * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setMaxTotalWalSize(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setMaxTotalWalSize(JNIEnv*, jobject, jlong jhandle, jlong jmax_total_wal_size) { reinterpret_cast(jhandle)->max_total_wal_size = @@ -6135,65 +6135,65 @@ void Java_org_rocksdb_DBOptions_setMaxTotalWalSize(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: maxTotalWalSize * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_maxTotalWalSize(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_maxTotalWalSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_total_wal_size; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setMaxOpenFiles * Signature: (JI)V */ -void Java_org_rocksdb_DBOptions_setMaxOpenFiles(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setMaxOpenFiles(JNIEnv*, jobject, jlong jhandle, jint max_open_files) { reinterpret_cast(jhandle)->max_open_files = static_cast(max_open_files); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: maxOpenFiles * Signature: (J)I */ -jint Java_org_rocksdb_DBOptions_maxOpenFiles(JNIEnv*, jobject, jlong jhandle) { +jint Java_org_forstdb_DBOptions_maxOpenFiles(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_open_files; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setMaxFileOpeningThreads * Signature: (JI)V */ -void Java_org_rocksdb_DBOptions_setMaxFileOpeningThreads( +void Java_org_forstdb_DBOptions_setMaxFileOpeningThreads( JNIEnv*, jobject, jlong jhandle, jint jmax_file_opening_threads) { reinterpret_cast(jhandle) ->max_file_opening_threads = static_cast(jmax_file_opening_threads); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: maxFileOpeningThreads * Signature: (J)I */ -jint Java_org_rocksdb_DBOptions_maxFileOpeningThreads(JNIEnv*, jobject, +jint Java_org_forstdb_DBOptions_maxFileOpeningThreads(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->max_file_opening_threads); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setStatistics * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setStatistics(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setStatistics(JNIEnv*, jobject, jlong jhandle, jlong jstatistics_handle) { auto* opt = reinterpret_cast(jhandle); auto* pSptr = @@ -6203,11 +6203,11 @@ void Java_org_rocksdb_DBOptions_setStatistics(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: statistics * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_statistics(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_DBOptions_statistics(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); std::shared_ptr sptr = opt->statistics; if (sptr == nullptr) { @@ -6220,31 +6220,31 @@ jlong Java_org_rocksdb_DBOptions_statistics(JNIEnv*, jobject, jlong jhandle) { } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setUseFsync * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setUseFsync(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setUseFsync(JNIEnv*, jobject, jlong jhandle, jboolean use_fsync) { reinterpret_cast(jhandle)->use_fsync = static_cast(use_fsync); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: useFsync * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_useFsync(JNIEnv*, jobject, jlong jhandle) { +jboolean Java_org_forstdb_DBOptions_useFsync(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->use_fsync; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setDbPaths * Signature: (J[Ljava/lang/String;[J)V */ -void Java_org_rocksdb_DBOptions_setDbPaths(JNIEnv* env, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setDbPaths(JNIEnv* env, jobject, jlong jhandle, jobjectArray jpaths, jlongArray jtarget_sizes) { std::vector db_paths; @@ -6286,21 +6286,21 @@ void Java_org_rocksdb_DBOptions_setDbPaths(JNIEnv* env, jobject, jlong jhandle, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: dbPathsLen * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_dbPathsLen(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_DBOptions_dbPathsLen(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->db_paths.size()); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: dbPaths * Signature: (J[Ljava/lang/String;[J)V */ -void Java_org_rocksdb_DBOptions_dbPaths(JNIEnv* env, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_dbPaths(JNIEnv* env, jobject, jlong jhandle, jobjectArray jpaths, jlongArray jtarget_sizes) { jboolean is_copy; @@ -6337,11 +6337,11 @@ void Java_org_rocksdb_DBOptions_dbPaths(JNIEnv* env, jobject, jlong jhandle, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setDbLogDir * Signature: (JLjava/lang/String)V */ -void Java_org_rocksdb_DBOptions_setDbLogDir(JNIEnv* env, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setDbLogDir(JNIEnv* env, jobject, jlong jhandle, jstring jdb_log_dir) { const char* log_dir = env->GetStringUTFChars(jdb_log_dir, nullptr); if (log_dir == nullptr) { @@ -6355,11 +6355,11 @@ void Java_org_rocksdb_DBOptions_setDbLogDir(JNIEnv* env, jobject, jlong jhandle, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: dbLogDir * Signature: (J)Ljava/lang/String */ -jstring Java_org_rocksdb_DBOptions_dbLogDir(JNIEnv* env, jobject, +jstring Java_org_forstdb_DBOptions_dbLogDir(JNIEnv* env, jobject, jlong jhandle) { return env->NewStringUTF( reinterpret_cast(jhandle) @@ -6367,11 +6367,11 @@ jstring Java_org_rocksdb_DBOptions_dbLogDir(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setWalDir * Signature: (JLjava/lang/String)V */ -void Java_org_rocksdb_DBOptions_setWalDir(JNIEnv* env, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setWalDir(JNIEnv* env, jobject, jlong jhandle, jstring jwal_dir) { const char* wal_dir = env->GetStringUTFChars(jwal_dir, 0); reinterpret_cast(jhandle)->wal_dir.assign( @@ -6380,44 +6380,44 @@ void Java_org_rocksdb_DBOptions_setWalDir(JNIEnv* env, jobject, jlong jhandle, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: walDir * Signature: (J)Ljava/lang/String */ -jstring Java_org_rocksdb_DBOptions_walDir(JNIEnv* env, jobject, jlong jhandle) { +jstring Java_org_forstdb_DBOptions_walDir(JNIEnv* env, jobject, jlong jhandle) { return env->NewStringUTF( reinterpret_cast(jhandle) ->wal_dir.c_str()); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setDeleteObsoleteFilesPeriodMicros * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setDeleteObsoleteFilesPeriodMicros( +void Java_org_forstdb_DBOptions_setDeleteObsoleteFilesPeriodMicros( JNIEnv*, jobject, jlong jhandle, jlong micros) { reinterpret_cast(jhandle) ->delete_obsolete_files_period_micros = static_cast(micros); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: deleteObsoleteFilesPeriodMicros * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_deleteObsoleteFilesPeriodMicros( +jlong Java_org_forstdb_DBOptions_deleteObsoleteFilesPeriodMicros( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->delete_obsolete_files_period_micros; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setMaxBackgroundCompactions * Signature: (JI)V */ -void Java_org_rocksdb_DBOptions_setMaxBackgroundCompactions(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setMaxBackgroundCompactions(JNIEnv*, jobject, jlong jhandle, jint max) { reinterpret_cast(jhandle) @@ -6425,66 +6425,66 @@ void Java_org_rocksdb_DBOptions_setMaxBackgroundCompactions(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: maxBackgroundCompactions * Signature: (J)I */ -jint Java_org_rocksdb_DBOptions_maxBackgroundCompactions(JNIEnv*, jobject, +jint Java_org_forstdb_DBOptions_maxBackgroundCompactions(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_background_compactions; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setMaxSubcompactions * Signature: (JI)V */ -void Java_org_rocksdb_DBOptions_setMaxSubcompactions(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setMaxSubcompactions(JNIEnv*, jobject, jlong jhandle, jint max) { reinterpret_cast(jhandle)->max_subcompactions = static_cast(max); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: maxSubcompactions * Signature: (J)I */ -jint Java_org_rocksdb_DBOptions_maxSubcompactions(JNIEnv*, jobject, +jint Java_org_forstdb_DBOptions_maxSubcompactions(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_subcompactions; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setMaxBackgroundFlushes * Signature: (JI)V */ -void Java_org_rocksdb_DBOptions_setMaxBackgroundFlushes( +void Java_org_forstdb_DBOptions_setMaxBackgroundFlushes( JNIEnv*, jobject, jlong jhandle, jint max_background_flushes) { reinterpret_cast(jhandle) ->max_background_flushes = static_cast(max_background_flushes); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: maxBackgroundFlushes * Signature: (J)I */ -jint Java_org_rocksdb_DBOptions_maxBackgroundFlushes(JNIEnv*, jobject, +jint Java_org_forstdb_DBOptions_maxBackgroundFlushes(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_background_flushes; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setMaxBackgroundJobs * Signature: (JI)V */ -void Java_org_rocksdb_DBOptions_setMaxBackgroundJobs(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setMaxBackgroundJobs(JNIEnv*, jobject, jlong jhandle, jint max_background_jobs) { reinterpret_cast(jhandle) @@ -6492,22 +6492,22 @@ void Java_org_rocksdb_DBOptions_setMaxBackgroundJobs(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: maxBackgroundJobs * Signature: (J)I */ -jint Java_org_rocksdb_DBOptions_maxBackgroundJobs(JNIEnv*, jobject, +jint Java_org_forstdb_DBOptions_maxBackgroundJobs(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_background_jobs; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setMaxLogFileSize * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setMaxLogFileSize(JNIEnv* env, jobject, +void Java_org_forstdb_DBOptions_setMaxLogFileSize(JNIEnv* env, jobject, jlong jhandle, jlong max_log_file_size) { auto s = @@ -6521,22 +6521,22 @@ void Java_org_rocksdb_DBOptions_setMaxLogFileSize(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: maxLogFileSize * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_maxLogFileSize(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_maxLogFileSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_log_file_size; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setLogFileTimeToRoll * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setLogFileTimeToRoll( +void Java_org_forstdb_DBOptions_setLogFileTimeToRoll( JNIEnv* env, jobject, jlong jhandle, jlong log_file_time_to_roll) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( log_file_time_to_roll); @@ -6549,22 +6549,22 @@ void Java_org_rocksdb_DBOptions_setLogFileTimeToRoll( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: logFileTimeToRoll * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_logFileTimeToRoll(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_logFileTimeToRoll(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->log_file_time_to_roll; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setKeepLogFileNum * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setKeepLogFileNum(JNIEnv* env, jobject, +void Java_org_forstdb_DBOptions_setKeepLogFileNum(JNIEnv* env, jobject, jlong jhandle, jlong keep_log_file_num) { auto s = @@ -6578,22 +6578,22 @@ void Java_org_rocksdb_DBOptions_setKeepLogFileNum(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: keepLogFileNum * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_keepLogFileNum(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_keepLogFileNum(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->keep_log_file_num; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setRecycleLogFileNum * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setRecycleLogFileNum( +void Java_org_forstdb_DBOptions_setRecycleLogFileNum( JNIEnv* env, jobject, jlong jhandle, jlong recycle_log_file_num) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( recycle_log_file_num); @@ -6606,66 +6606,66 @@ void Java_org_rocksdb_DBOptions_setRecycleLogFileNum( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: recycleLogFileNum * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_recycleLogFileNum(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_recycleLogFileNum(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->recycle_log_file_num; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setMaxManifestFileSize * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setMaxManifestFileSize( +void Java_org_forstdb_DBOptions_setMaxManifestFileSize( JNIEnv*, jobject, jlong jhandle, jlong max_manifest_file_size) { reinterpret_cast(jhandle) ->max_manifest_file_size = static_cast(max_manifest_file_size); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: maxManifestFileSize * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_maxManifestFileSize(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_maxManifestFileSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->max_manifest_file_size; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setTableCacheNumshardbits * Signature: (JI)V */ -void Java_org_rocksdb_DBOptions_setTableCacheNumshardbits( +void Java_org_forstdb_DBOptions_setTableCacheNumshardbits( JNIEnv*, jobject, jlong jhandle, jint table_cache_numshardbits) { reinterpret_cast(jhandle) ->table_cache_numshardbits = static_cast(table_cache_numshardbits); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: tableCacheNumshardbits * Signature: (J)I */ -jint Java_org_rocksdb_DBOptions_tableCacheNumshardbits(JNIEnv*, jobject, +jint Java_org_forstdb_DBOptions_tableCacheNumshardbits(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->table_cache_numshardbits; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setWalTtlSeconds * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setWalTtlSeconds(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setWalTtlSeconds(JNIEnv*, jobject, jlong jhandle, jlong WAL_ttl_seconds) { reinterpret_cast(jhandle)->WAL_ttl_seconds = @@ -6673,22 +6673,22 @@ void Java_org_rocksdb_DBOptions_setWalTtlSeconds(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: walTtlSeconds * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_walTtlSeconds(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_walTtlSeconds(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->WAL_ttl_seconds; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setWalSizeLimitMB * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setWalSizeLimitMB(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setWalSizeLimitMB(JNIEnv*, jobject, jlong jhandle, jlong WAL_size_limit_MB) { reinterpret_cast(jhandle)->WAL_size_limit_MB = @@ -6696,22 +6696,22 @@ void Java_org_rocksdb_DBOptions_setWalSizeLimitMB(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: walTtlSeconds * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_walSizeLimitMB(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_walSizeLimitMB(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->WAL_size_limit_MB; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setMaxWriteBatchGroupSizeBytes * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setMaxWriteBatchGroupSizeBytes( +void Java_org_forstdb_DBOptions_setMaxWriteBatchGroupSizeBytes( JNIEnv*, jclass, jlong jhandle, jlong jmax_write_batch_group_size_bytes) { auto* opt = reinterpret_cast(jhandle); opt->max_write_batch_group_size_bytes = @@ -6719,22 +6719,22 @@ void Java_org_rocksdb_DBOptions_setMaxWriteBatchGroupSizeBytes( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: maxWriteBatchGroupSizeBytes * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_maxWriteBatchGroupSizeBytes(JNIEnv*, jclass, +jlong Java_org_forstdb_DBOptions_maxWriteBatchGroupSizeBytes(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->max_write_batch_group_size_bytes); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setManifestPreallocationSize * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setManifestPreallocationSize( +void Java_org_forstdb_DBOptions_setManifestPreallocationSize( JNIEnv* env, jobject, jlong jhandle, jlong preallocation_size) { auto s = ROCKSDB_NAMESPACE::JniUtil::check_if_jlong_fits_size_t( preallocation_size); @@ -6747,33 +6747,33 @@ void Java_org_rocksdb_DBOptions_setManifestPreallocationSize( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: manifestPreallocationSize * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_manifestPreallocationSize(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_manifestPreallocationSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->manifest_preallocation_size; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: useDirectReads * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_useDirectReads(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_useDirectReads(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->use_direct_reads; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setUseDirectReads * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setUseDirectReads(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setUseDirectReads(JNIEnv*, jobject, jlong jhandle, jboolean use_direct_reads) { reinterpret_cast(jhandle)->use_direct_reads = @@ -6781,22 +6781,22 @@ void Java_org_rocksdb_DBOptions_setUseDirectReads(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: useDirectIoForFlushAndCompaction * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_useDirectIoForFlushAndCompaction( +jboolean Java_org_forstdb_DBOptions_useDirectIoForFlushAndCompaction( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->use_direct_io_for_flush_and_compaction; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setUseDirectReads * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setUseDirectIoForFlushAndCompaction( +void Java_org_forstdb_DBOptions_setUseDirectIoForFlushAndCompaction( JNIEnv*, jobject, jlong jhandle, jboolean use_direct_io_for_flush_and_compaction) { reinterpret_cast(jhandle) @@ -6805,11 +6805,11 @@ void Java_org_rocksdb_DBOptions_setUseDirectIoForFlushAndCompaction( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAllowFAllocate * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setAllowFAllocate(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setAllowFAllocate(JNIEnv*, jobject, jlong jhandle, jboolean jallow_fallocate) { reinterpret_cast(jhandle)->allow_fallocate = @@ -6817,22 +6817,22 @@ void Java_org_rocksdb_DBOptions_setAllowFAllocate(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: allowFAllocate * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_allowFAllocate(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_allowFAllocate(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->allow_fallocate); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAllowMmapReads * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setAllowMmapReads(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setAllowMmapReads(JNIEnv*, jobject, jlong jhandle, jboolean allow_mmap_reads) { reinterpret_cast(jhandle)->allow_mmap_reads = @@ -6840,22 +6840,22 @@ void Java_org_rocksdb_DBOptions_setAllowMmapReads(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: allowMmapReads * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_allowMmapReads(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_allowMmapReads(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->allow_mmap_reads; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAllowMmapWrites * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setAllowMmapWrites(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setAllowMmapWrites(JNIEnv*, jobject, jlong jhandle, jboolean allow_mmap_writes) { reinterpret_cast(jhandle)->allow_mmap_writes = @@ -6863,44 +6863,44 @@ void Java_org_rocksdb_DBOptions_setAllowMmapWrites(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: allowMmapWrites * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_allowMmapWrites(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_allowMmapWrites(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->allow_mmap_writes; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setIsFdCloseOnExec * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setIsFdCloseOnExec( +void Java_org_forstdb_DBOptions_setIsFdCloseOnExec( JNIEnv*, jobject, jlong jhandle, jboolean is_fd_close_on_exec) { reinterpret_cast(jhandle) ->is_fd_close_on_exec = static_cast(is_fd_close_on_exec); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: isFdCloseOnExec * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_isFdCloseOnExec(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_isFdCloseOnExec(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->is_fd_close_on_exec; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setStatsDumpPeriodSec * Signature: (JI)V */ -void Java_org_rocksdb_DBOptions_setStatsDumpPeriodSec( +void Java_org_forstdb_DBOptions_setStatsDumpPeriodSec( JNIEnv*, jobject, jlong jhandle, jint jstats_dump_period_sec) { reinterpret_cast(jhandle) ->stats_dump_period_sec = @@ -6908,22 +6908,22 @@ void Java_org_rocksdb_DBOptions_setStatsDumpPeriodSec( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: statsDumpPeriodSec * Signature: (J)I */ -jint Java_org_rocksdb_DBOptions_statsDumpPeriodSec(JNIEnv*, jobject, +jint Java_org_forstdb_DBOptions_statsDumpPeriodSec(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->stats_dump_period_sec; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setStatsPersistPeriodSec * Signature: (JI)V */ -void Java_org_rocksdb_DBOptions_setStatsPersistPeriodSec( +void Java_org_forstdb_DBOptions_setStatsPersistPeriodSec( JNIEnv*, jobject, jlong jhandle, jint jstats_persist_period_sec) { reinterpret_cast(jhandle) ->stats_persist_period_sec = @@ -6931,22 +6931,22 @@ void Java_org_rocksdb_DBOptions_setStatsPersistPeriodSec( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: statsPersistPeriodSec * Signature: (J)I */ -jint Java_org_rocksdb_DBOptions_statsPersistPeriodSec(JNIEnv*, jobject, +jint Java_org_forstdb_DBOptions_statsPersistPeriodSec(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->stats_persist_period_sec; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setStatsHistoryBufferSize * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setStatsHistoryBufferSize( +void Java_org_forstdb_DBOptions_setStatsHistoryBufferSize( JNIEnv*, jobject, jlong jhandle, jlong jstats_history_buffer_size) { reinterpret_cast(jhandle) ->stats_history_buffer_size = @@ -6954,55 +6954,55 @@ void Java_org_rocksdb_DBOptions_setStatsHistoryBufferSize( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: statsHistoryBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_statsHistoryBufferSize(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_statsHistoryBufferSize(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->stats_history_buffer_size; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAdviseRandomOnOpen * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setAdviseRandomOnOpen( +void Java_org_forstdb_DBOptions_setAdviseRandomOnOpen( JNIEnv*, jobject, jlong jhandle, jboolean advise_random_on_open) { reinterpret_cast(jhandle) ->advise_random_on_open = static_cast(advise_random_on_open); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: adviseRandomOnOpen * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_adviseRandomOnOpen(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_adviseRandomOnOpen(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->advise_random_on_open; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setDbWriteBufferSize * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setDbWriteBufferSize( +void Java_org_forstdb_DBOptions_setDbWriteBufferSize( JNIEnv*, jobject, jlong jhandle, jlong jdb_write_buffer_size) { auto* opt = reinterpret_cast(jhandle); opt->db_write_buffer_size = static_cast(jdb_write_buffer_size); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setWriteBufferManager * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setWriteBufferManager( +void Java_org_forstdb_DBOptions_setWriteBufferManager( JNIEnv*, jobject, jlong jdb_options_handle, jlong jwrite_buffer_manager_handle) { auto* write_buffer_manager = @@ -7013,22 +7013,22 @@ void Java_org_rocksdb_DBOptions_setWriteBufferManager( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: dbWriteBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_dbWriteBufferSize(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_dbWriteBufferSize(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->db_write_buffer_size); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAccessHintOnCompactionStart * Signature: (JB)V */ -void Java_org_rocksdb_DBOptions_setAccessHintOnCompactionStart( +void Java_org_forstdb_DBOptions_setAccessHintOnCompactionStart( JNIEnv*, jobject, jlong jhandle, jbyte jaccess_hint_value) { auto* opt = reinterpret_cast(jhandle); opt->access_hint_on_compaction_start = @@ -7036,11 +7036,11 @@ void Java_org_rocksdb_DBOptions_setAccessHintOnCompactionStart( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: accessHintOnCompactionStart * Signature: (J)B */ -jbyte Java_org_rocksdb_DBOptions_accessHintOnCompactionStart(JNIEnv*, jobject, +jbyte Java_org_forstdb_DBOptions_accessHintOnCompactionStart(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return ROCKSDB_NAMESPACE::AccessHintJni::toJavaAccessHint( @@ -7048,11 +7048,11 @@ jbyte Java_org_rocksdb_DBOptions_accessHintOnCompactionStart(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setCompactionReadaheadSize * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setCompactionReadaheadSize( +void Java_org_forstdb_DBOptions_setCompactionReadaheadSize( JNIEnv*, jobject, jlong jhandle, jlong jcompaction_readahead_size) { auto* opt = reinterpret_cast(jhandle); opt->compaction_readahead_size = @@ -7060,22 +7060,22 @@ void Java_org_rocksdb_DBOptions_setCompactionReadaheadSize( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: compactionReadaheadSize * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_compactionReadaheadSize(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_compactionReadaheadSize(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->compaction_readahead_size); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setRandomAccessMaxBufferSize * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setRandomAccessMaxBufferSize( +void Java_org_forstdb_DBOptions_setRandomAccessMaxBufferSize( JNIEnv*, jobject, jlong jhandle, jlong jrandom_access_max_buffer_size) { auto* opt = reinterpret_cast(jhandle); opt->random_access_max_buffer_size = @@ -7083,22 +7083,22 @@ void Java_org_rocksdb_DBOptions_setRandomAccessMaxBufferSize( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: randomAccessMaxBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_randomAccessMaxBufferSize(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_randomAccessMaxBufferSize(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->random_access_max_buffer_size); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setWritableFileMaxBufferSize * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setWritableFileMaxBufferSize( +void Java_org_forstdb_DBOptions_setWritableFileMaxBufferSize( JNIEnv*, jobject, jlong jhandle, jlong jwritable_file_max_buffer_size) { auto* opt = reinterpret_cast(jhandle); opt->writable_file_max_buffer_size = @@ -7106,65 +7106,65 @@ void Java_org_rocksdb_DBOptions_setWritableFileMaxBufferSize( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: writableFileMaxBufferSize * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_writableFileMaxBufferSize(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_writableFileMaxBufferSize(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->writable_file_max_buffer_size); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setUseAdaptiveMutex * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setUseAdaptiveMutex( +void Java_org_forstdb_DBOptions_setUseAdaptiveMutex( JNIEnv*, jobject, jlong jhandle, jboolean use_adaptive_mutex) { reinterpret_cast(jhandle)->use_adaptive_mutex = static_cast(use_adaptive_mutex); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: useAdaptiveMutex * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_useAdaptiveMutex(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_useAdaptiveMutex(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->use_adaptive_mutex; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setBytesPerSync * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setBytesPerSync(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setBytesPerSync(JNIEnv*, jobject, jlong jhandle, jlong bytes_per_sync) { reinterpret_cast(jhandle)->bytes_per_sync = static_cast(bytes_per_sync); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: bytesPerSync * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_bytesPerSync(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_DBOptions_bytesPerSync(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->bytes_per_sync; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setWalBytesPerSync * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setWalBytesPerSync(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setWalBytesPerSync(JNIEnv*, jobject, jlong jhandle, jlong jwal_bytes_per_sync) { reinterpret_cast(jhandle)->wal_bytes_per_sync = @@ -7172,33 +7172,33 @@ void Java_org_rocksdb_DBOptions_setWalBytesPerSync(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: walBytesPerSync * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_walBytesPerSync(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_walBytesPerSync(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->wal_bytes_per_sync); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setStrictBytesPerSync * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setStrictBytesPerSync( +void Java_org_forstdb_DBOptions_setStrictBytesPerSync( JNIEnv*, jobject, jlong jhandle, jboolean jstrict_bytes_per_sync) { reinterpret_cast(jhandle) ->strict_bytes_per_sync = jstrict_bytes_per_sync == JNI_TRUE; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: strictBytesPerSync * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_strictBytesPerSync(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_strictBytesPerSync(JNIEnv*, jobject, jlong jhandle) { return static_cast( reinterpret_cast(jhandle) @@ -7206,11 +7206,11 @@ jboolean Java_org_rocksdb_DBOptions_strictBytesPerSync(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setEventListeners * Signature: (J[J)V */ -void Java_org_rocksdb_DBOptions_setEventListeners(JNIEnv* env, jclass, +void Java_org_forstdb_DBOptions_setEventListeners(JNIEnv* env, jclass, jlong jhandle, jlongArray jlistener_array) { auto* opt = reinterpret_cast(jhandle); @@ -7218,22 +7218,22 @@ void Java_org_rocksdb_DBOptions_setEventListeners(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: eventListeners * Signature: (J)[Lorg/rocksdb/AbstractEventListener; */ -jobjectArray Java_org_rocksdb_DBOptions_eventListeners(JNIEnv* env, jclass, +jobjectArray Java_org_forstdb_DBOptions_eventListeners(JNIEnv* env, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return rocksdb_get_event_listeners_helper(env, opt->listeners); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setDelayedWriteRate * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setDelayedWriteRate(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setDelayedWriteRate(JNIEnv*, jobject, jlong jhandle, jlong jdelayed_write_rate) { auto* opt = reinterpret_cast(jhandle); @@ -7241,44 +7241,44 @@ void Java_org_rocksdb_DBOptions_setDelayedWriteRate(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: delayedWriteRate * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_delayedWriteRate(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_delayedWriteRate(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->delayed_write_rate); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setEnablePipelinedWrite * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setEnablePipelinedWrite( +void Java_org_forstdb_DBOptions_setEnablePipelinedWrite( JNIEnv*, jobject, jlong jhandle, jboolean jenable_pipelined_write) { auto* opt = reinterpret_cast(jhandle); opt->enable_pipelined_write = jenable_pipelined_write == JNI_TRUE; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: enablePipelinedWrite * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_enablePipelinedWrite(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_enablePipelinedWrite(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->enable_pipelined_write); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setUnorderedWrite * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setUnorderedWrite(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setUnorderedWrite(JNIEnv*, jobject, jlong jhandle, jboolean junordered_write) { auto* opt = reinterpret_cast(jhandle); @@ -7286,88 +7286,88 @@ void Java_org_rocksdb_DBOptions_setUnorderedWrite(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: unorderedWrite * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_unorderedWrite(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_unorderedWrite(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->unordered_write); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setEnableThreadTracking * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setEnableThreadTracking( +void Java_org_forstdb_DBOptions_setEnableThreadTracking( JNIEnv*, jobject, jlong jhandle, jboolean jenable_thread_tracking) { auto* opt = reinterpret_cast(jhandle); opt->enable_thread_tracking = jenable_thread_tracking == JNI_TRUE; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: enableThreadTracking * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_enableThreadTracking(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_enableThreadTracking(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->enable_thread_tracking); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAllowConcurrentMemtableWrite * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setAllowConcurrentMemtableWrite( +void Java_org_forstdb_DBOptions_setAllowConcurrentMemtableWrite( JNIEnv*, jobject, jlong jhandle, jboolean allow) { reinterpret_cast(jhandle) ->allow_concurrent_memtable_write = static_cast(allow); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: allowConcurrentMemtableWrite * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_allowConcurrentMemtableWrite( +jboolean Java_org_forstdb_DBOptions_allowConcurrentMemtableWrite( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->allow_concurrent_memtable_write; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setEnableWriteThreadAdaptiveYield * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setEnableWriteThreadAdaptiveYield( +void Java_org_forstdb_DBOptions_setEnableWriteThreadAdaptiveYield( JNIEnv*, jobject, jlong jhandle, jboolean yield) { reinterpret_cast(jhandle) ->enable_write_thread_adaptive_yield = static_cast(yield); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: enableWriteThreadAdaptiveYield * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_enableWriteThreadAdaptiveYield( +jboolean Java_org_forstdb_DBOptions_enableWriteThreadAdaptiveYield( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->enable_write_thread_adaptive_yield; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setWriteThreadMaxYieldUsec * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setWriteThreadMaxYieldUsec(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setWriteThreadMaxYieldUsec(JNIEnv*, jobject, jlong jhandle, jlong max) { reinterpret_cast(jhandle) @@ -7375,22 +7375,22 @@ void Java_org_rocksdb_DBOptions_setWriteThreadMaxYieldUsec(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: writeThreadMaxYieldUsec * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_writeThreadMaxYieldUsec(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_writeThreadMaxYieldUsec(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->write_thread_max_yield_usec; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setWriteThreadSlowYieldUsec * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setWriteThreadSlowYieldUsec(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setWriteThreadSlowYieldUsec(JNIEnv*, jobject, jlong jhandle, jlong slow) { reinterpret_cast(jhandle) @@ -7398,22 +7398,22 @@ void Java_org_rocksdb_DBOptions_setWriteThreadSlowYieldUsec(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: writeThreadSlowYieldUsec * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_writeThreadSlowYieldUsec(JNIEnv*, jobject, +jlong Java_org_forstdb_DBOptions_writeThreadSlowYieldUsec(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->write_thread_slow_yield_usec; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setSkipStatsUpdateOnDbOpen * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setSkipStatsUpdateOnDbOpen( +void Java_org_forstdb_DBOptions_setSkipStatsUpdateOnDbOpen( JNIEnv*, jobject, jlong jhandle, jboolean jskip_stats_update_on_db_open) { auto* opt = reinterpret_cast(jhandle); opt->skip_stats_update_on_db_open = @@ -7421,22 +7421,22 @@ void Java_org_rocksdb_DBOptions_setSkipStatsUpdateOnDbOpen( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: skipStatsUpdateOnDbOpen * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_skipStatsUpdateOnDbOpen(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_skipStatsUpdateOnDbOpen(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->skip_stats_update_on_db_open); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setSkipCheckingSstFileSizesOnDbOpen * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setSkipCheckingSstFileSizesOnDbOpen( +void Java_org_forstdb_DBOptions_setSkipCheckingSstFileSizesOnDbOpen( JNIEnv*, jclass, jlong jhandle, jboolean jskip_checking_sst_file_sizes_on_db_open) { auto* opt = reinterpret_cast(jhandle); @@ -7445,22 +7445,22 @@ void Java_org_rocksdb_DBOptions_setSkipCheckingSstFileSizesOnDbOpen( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: skipCheckingSstFileSizesOnDbOpen * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_skipCheckingSstFileSizesOnDbOpen( +jboolean Java_org_forstdb_DBOptions_skipCheckingSstFileSizesOnDbOpen( JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->skip_checking_sst_file_sizes_on_db_open); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setWalRecoveryMode * Signature: (JB)V */ -void Java_org_rocksdb_DBOptions_setWalRecoveryMode( +void Java_org_forstdb_DBOptions_setWalRecoveryMode( JNIEnv*, jobject, jlong jhandle, jbyte jwal_recovery_mode_value) { auto* opt = reinterpret_cast(jhandle); opt->wal_recovery_mode = @@ -7469,11 +7469,11 @@ void Java_org_rocksdb_DBOptions_setWalRecoveryMode( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: walRecoveryMode * Signature: (J)B */ -jbyte Java_org_rocksdb_DBOptions_walRecoveryMode(JNIEnv*, jobject, +jbyte Java_org_forstdb_DBOptions_walRecoveryMode(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return ROCKSDB_NAMESPACE::WALRecoveryModeJni::toJavaWALRecoveryMode( @@ -7481,32 +7481,32 @@ jbyte Java_org_rocksdb_DBOptions_walRecoveryMode(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAllow2pc * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setAllow2pc(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setAllow2pc(JNIEnv*, jobject, jlong jhandle, jboolean jallow_2pc) { auto* opt = reinterpret_cast(jhandle); opt->allow_2pc = static_cast(jallow_2pc); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: allow2pc * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_allow2pc(JNIEnv*, jobject, jlong jhandle) { +jboolean Java_org_forstdb_DBOptions_allow2pc(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->allow_2pc); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setRowCache * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setRowCache(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setRowCache(JNIEnv*, jobject, jlong jhandle, jlong jrow_cache_handle) { auto* opt = reinterpret_cast(jhandle); auto* row_cache = @@ -7516,11 +7516,11 @@ void Java_org_rocksdb_DBOptions_setRowCache(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setWalFilter * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setWalFilter(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setWalFilter(JNIEnv*, jobject, jlong jhandle, jlong jwal_filter_handle) { auto* opt = reinterpret_cast(jhandle); auto* wal_filter = reinterpret_cast( @@ -7529,11 +7529,11 @@ void Java_org_rocksdb_DBOptions_setWalFilter(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setFailIfOptionsFileError * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setFailIfOptionsFileError( +void Java_org_forstdb_DBOptions_setFailIfOptionsFileError( JNIEnv*, jobject, jlong jhandle, jboolean jfail_if_options_file_error) { auto* opt = reinterpret_cast(jhandle); opt->fail_if_options_file_error = @@ -7541,44 +7541,44 @@ void Java_org_rocksdb_DBOptions_setFailIfOptionsFileError( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: failIfOptionsFileError * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_failIfOptionsFileError(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_failIfOptionsFileError(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->fail_if_options_file_error); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setDumpMallocStats * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setDumpMallocStats( +void Java_org_forstdb_DBOptions_setDumpMallocStats( JNIEnv*, jobject, jlong jhandle, jboolean jdump_malloc_stats) { auto* opt = reinterpret_cast(jhandle); opt->dump_malloc_stats = static_cast(jdump_malloc_stats); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: dumpMallocStats * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_dumpMallocStats(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_dumpMallocStats(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->dump_malloc_stats); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAvoidFlushDuringRecovery * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setAvoidFlushDuringRecovery( +void Java_org_forstdb_DBOptions_setAvoidFlushDuringRecovery( JNIEnv*, jobject, jlong jhandle, jboolean javoid_flush_during_recovery) { auto* opt = reinterpret_cast(jhandle); opt->avoid_flush_during_recovery = @@ -7586,44 +7586,44 @@ void Java_org_rocksdb_DBOptions_setAvoidFlushDuringRecovery( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: avoidFlushDuringRecovery * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_avoidFlushDuringRecovery(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_avoidFlushDuringRecovery(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->avoid_flush_during_recovery); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAllowIngestBehind * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setAllowIngestBehind( +void Java_org_forstdb_DBOptions_setAllowIngestBehind( JNIEnv*, jobject, jlong jhandle, jboolean jallow_ingest_behind) { auto* opt = reinterpret_cast(jhandle); opt->allow_ingest_behind = jallow_ingest_behind == JNI_TRUE; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: allowIngestBehind * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_allowIngestBehind(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_allowIngestBehind(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->allow_ingest_behind); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setTwoWriteQueues * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setTwoWriteQueues(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setTwoWriteQueues(JNIEnv*, jobject, jlong jhandle, jboolean jtwo_write_queues) { auto* opt = reinterpret_cast(jhandle); @@ -7631,22 +7631,22 @@ void Java_org_rocksdb_DBOptions_setTwoWriteQueues(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: twoWriteQueues * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_twoWriteQueues(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_twoWriteQueues(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->two_write_queues); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setManualWalFlush * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setManualWalFlush(JNIEnv*, jobject, +void Java_org_forstdb_DBOptions_setManualWalFlush(JNIEnv*, jobject, jlong jhandle, jboolean jmanual_wal_flush) { auto* opt = reinterpret_cast(jhandle); @@ -7654,44 +7654,44 @@ void Java_org_rocksdb_DBOptions_setManualWalFlush(JNIEnv*, jobject, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: manualWalFlush * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_manualWalFlush(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_manualWalFlush(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->manual_wal_flush); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAtomicFlush * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setAtomicFlush(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_DBOptions_setAtomicFlush(JNIEnv*, jobject, jlong jhandle, jboolean jatomic_flush) { auto* opt = reinterpret_cast(jhandle); opt->atomic_flush = jatomic_flush == JNI_TRUE; } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: atomicFlush * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_atomicFlush(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_atomicFlush(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->atomic_flush); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAvoidFlushDuringShutdown * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setAvoidFlushDuringShutdown( +void Java_org_forstdb_DBOptions_setAvoidFlushDuringShutdown( JNIEnv*, jobject, jlong jhandle, jboolean javoid_flush_during_shutdown) { auto* opt = reinterpret_cast(jhandle); opt->avoid_flush_during_shutdown = @@ -7699,88 +7699,88 @@ void Java_org_rocksdb_DBOptions_setAvoidFlushDuringShutdown( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: avoidFlushDuringShutdown * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_avoidFlushDuringShutdown(JNIEnv*, jobject, +jboolean Java_org_forstdb_DBOptions_avoidFlushDuringShutdown(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->avoid_flush_during_shutdown); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setAvoidUnnecessaryBlockingIO * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setAvoidUnnecessaryBlockingIO( +void Java_org_forstdb_DBOptions_setAvoidUnnecessaryBlockingIO( JNIEnv*, jclass, jlong jhandle, jboolean avoid_blocking_io) { auto* opt = reinterpret_cast(jhandle); opt->avoid_unnecessary_blocking_io = static_cast(avoid_blocking_io); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: avoidUnnecessaryBlockingIO * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_avoidUnnecessaryBlockingIO(JNIEnv*, jclass, +jboolean Java_org_forstdb_DBOptions_avoidUnnecessaryBlockingIO(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->avoid_unnecessary_blocking_io); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setPersistStatsToDisk * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setPersistStatsToDisk( +void Java_org_forstdb_DBOptions_setPersistStatsToDisk( JNIEnv*, jclass, jlong jhandle, jboolean persist_stats_to_disk) { auto* opt = reinterpret_cast(jhandle); opt->persist_stats_to_disk = static_cast(persist_stats_to_disk); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: persistStatsToDisk * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_persistStatsToDisk(JNIEnv*, jclass, +jboolean Java_org_forstdb_DBOptions_persistStatsToDisk(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->persist_stats_to_disk); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setWriteDbidToManifest * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setWriteDbidToManifest( +void Java_org_forstdb_DBOptions_setWriteDbidToManifest( JNIEnv*, jclass, jlong jhandle, jboolean jwrite_dbid_to_manifest) { auto* opt = reinterpret_cast(jhandle); opt->write_dbid_to_manifest = static_cast(jwrite_dbid_to_manifest); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: writeDbidToManifest * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_writeDbidToManifest(JNIEnv*, jclass, +jboolean Java_org_forstdb_DBOptions_writeDbidToManifest(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->write_dbid_to_manifest); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setLogReadaheadSize * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setLogReadaheadSize(JNIEnv*, jclass, +void Java_org_forstdb_DBOptions_setLogReadaheadSize(JNIEnv*, jclass, jlong jhandle, jlong jlog_readahead_size) { auto* opt = reinterpret_cast(jhandle); @@ -7788,66 +7788,66 @@ void Java_org_rocksdb_DBOptions_setLogReadaheadSize(JNIEnv*, jclass, } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: logReasaheadSize * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_logReadaheadSize(JNIEnv*, jclass, +jlong Java_org_forstdb_DBOptions_logReadaheadSize(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->log_readahead_size); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setBestEffortsRecovery * Signature: (JZ)V */ -void Java_org_rocksdb_DBOptions_setBestEffortsRecovery( +void Java_org_forstdb_DBOptions_setBestEffortsRecovery( JNIEnv*, jclass, jlong jhandle, jboolean jbest_efforts_recovery) { auto* opt = reinterpret_cast(jhandle); opt->best_efforts_recovery = static_cast(jbest_efforts_recovery); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: bestEffortsRecovery * Signature: (J)Z */ -jboolean Java_org_rocksdb_DBOptions_bestEffortsRecovery(JNIEnv*, jclass, +jboolean Java_org_forstdb_DBOptions_bestEffortsRecovery(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->best_efforts_recovery); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setMaxBgErrorResumeCount * Signature: (JI)V */ -void Java_org_rocksdb_DBOptions_setMaxBgErrorResumeCount( +void Java_org_forstdb_DBOptions_setMaxBgErrorResumeCount( JNIEnv*, jclass, jlong jhandle, jint jmax_bgerror_resume_count) { auto* opt = reinterpret_cast(jhandle); opt->max_bgerror_resume_count = static_cast(jmax_bgerror_resume_count); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: maxBgerrorResumeCount * Signature: (J)I */ -jint Java_org_rocksdb_DBOptions_maxBgerrorResumeCount(JNIEnv*, jclass, +jint Java_org_forstdb_DBOptions_maxBgerrorResumeCount(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->max_bgerror_resume_count); } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: setBgerrorResumeRetryInterval * Signature: (JJ)V */ -void Java_org_rocksdb_DBOptions_setBgerrorResumeRetryInterval( +void Java_org_forstdb_DBOptions_setBgerrorResumeRetryInterval( JNIEnv*, jclass, jlong jhandle, jlong jbgerror_resume_retry_interval) { auto* opt = reinterpret_cast(jhandle); opt->bgerror_resume_retry_interval = @@ -7855,11 +7855,11 @@ void Java_org_rocksdb_DBOptions_setBgerrorResumeRetryInterval( } /* - * Class: org_rocksdb_DBOptions + * Class: org_forstdb_DBOptions * Method: bgerrorResumeRetryInterval * Signature: (J)J */ -jlong Java_org_rocksdb_DBOptions_bgerrorResumeRetryInterval(JNIEnv*, jclass, +jlong Java_org_forstdb_DBOptions_bgerrorResumeRetryInterval(JNIEnv*, jclass, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->bgerror_resume_retry_interval); @@ -7869,21 +7869,21 @@ jlong Java_org_rocksdb_DBOptions_bgerrorResumeRetryInterval(JNIEnv*, jclass, // ROCKSDB_NAMESPACE::WriteOptions /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: newWriteOptions * Signature: ()J */ -jlong Java_org_rocksdb_WriteOptions_newWriteOptions(JNIEnv*, jclass) { +jlong Java_org_forstdb_WriteOptions_newWriteOptions(JNIEnv*, jclass) { auto* op = new ROCKSDB_NAMESPACE::WriteOptions(); return GET_CPLUSPLUS_POINTER(op); } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: copyWriteOptions * Signature: (J)J */ -jlong Java_org_rocksdb_WriteOptions_copyWriteOptions(JNIEnv*, jclass, +jlong Java_org_forstdb_WriteOptions_copyWriteOptions(JNIEnv*, jclass, jlong jhandle) { auto new_opt = new ROCKSDB_NAMESPACE::WriteOptions( *(reinterpret_cast(jhandle))); @@ -7891,11 +7891,11 @@ jlong Java_org_rocksdb_WriteOptions_copyWriteOptions(JNIEnv*, jclass, } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: disposeInternal * Signature: ()V */ -void Java_org_rocksdb_WriteOptions_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_WriteOptions_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* write_options = reinterpret_cast(jhandle); @@ -7904,30 +7904,30 @@ void Java_org_rocksdb_WriteOptions_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: setSync * Signature: (JZ)V */ -void Java_org_rocksdb_WriteOptions_setSync(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_WriteOptions_setSync(JNIEnv*, jobject, jlong jhandle, jboolean jflag) { reinterpret_cast(jhandle)->sync = jflag; } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: sync * Signature: (J)Z */ -jboolean Java_org_rocksdb_WriteOptions_sync(JNIEnv*, jobject, jlong jhandle) { +jboolean Java_org_forstdb_WriteOptions_sync(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->sync; } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: setDisableWAL * Signature: (JZ)V */ -void Java_org_rocksdb_WriteOptions_setDisableWAL(JNIEnv*, jobject, +void Java_org_forstdb_WriteOptions_setDisableWAL(JNIEnv*, jobject, jlong jhandle, jboolean jflag) { reinterpret_cast(jhandle)->disableWAL = @@ -7935,22 +7935,22 @@ void Java_org_rocksdb_WriteOptions_setDisableWAL(JNIEnv*, jobject, } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: disableWAL * Signature: (J)Z */ -jboolean Java_org_rocksdb_WriteOptions_disableWAL(JNIEnv*, jobject, +jboolean Java_org_forstdb_WriteOptions_disableWAL(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->disableWAL; } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: setIgnoreMissingColumnFamilies * Signature: (JZ)V */ -void Java_org_rocksdb_WriteOptions_setIgnoreMissingColumnFamilies( +void Java_org_forstdb_WriteOptions_setIgnoreMissingColumnFamilies( JNIEnv*, jobject, jlong jhandle, jboolean jignore_missing_column_families) { reinterpret_cast(jhandle) ->ignore_missing_column_families = @@ -7958,22 +7958,22 @@ void Java_org_rocksdb_WriteOptions_setIgnoreMissingColumnFamilies( } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: ignoreMissingColumnFamilies * Signature: (J)Z */ -jboolean Java_org_rocksdb_WriteOptions_ignoreMissingColumnFamilies( +jboolean Java_org_forstdb_WriteOptions_ignoreMissingColumnFamilies( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->ignore_missing_column_families; } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: setNoSlowdown * Signature: (JZ)V */ -void Java_org_rocksdb_WriteOptions_setNoSlowdown(JNIEnv*, jobject, +void Java_org_forstdb_WriteOptions_setNoSlowdown(JNIEnv*, jobject, jlong jhandle, jboolean jno_slowdown) { reinterpret_cast(jhandle)->no_slowdown = @@ -7981,53 +7981,53 @@ void Java_org_rocksdb_WriteOptions_setNoSlowdown(JNIEnv*, jobject, } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: noSlowdown * Signature: (J)Z */ -jboolean Java_org_rocksdb_WriteOptions_noSlowdown(JNIEnv*, jobject, +jboolean Java_org_forstdb_WriteOptions_noSlowdown(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->no_slowdown; } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: setLowPri * Signature: (JZ)V */ -void Java_org_rocksdb_WriteOptions_setLowPri(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_WriteOptions_setLowPri(JNIEnv*, jobject, jlong jhandle, jboolean jlow_pri) { reinterpret_cast(jhandle)->low_pri = static_cast(jlow_pri); } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: lowPri * Signature: (J)Z */ -jboolean Java_org_rocksdb_WriteOptions_lowPri(JNIEnv*, jobject, jlong jhandle) { +jboolean Java_org_forstdb_WriteOptions_lowPri(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->low_pri; } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: memtableInsertHintPerBatch * Signature: (J)Z */ -jboolean Java_org_rocksdb_WriteOptions_memtableInsertHintPerBatch( +jboolean Java_org_forstdb_WriteOptions_memtableInsertHintPerBatch( JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->memtable_insert_hint_per_batch; } /* - * Class: org_rocksdb_WriteOptions + * Class: org_forstdb_WriteOptions * Method: setMemtableInsertHintPerBatch * Signature: (JZ)V */ -void Java_org_rocksdb_WriteOptions_setMemtableInsertHintPerBatch( +void Java_org_forstdb_WriteOptions_setMemtableInsertHintPerBatch( JNIEnv*, jobject, jlong jhandle, jboolean jmemtable_insert_hint_per_batch) { reinterpret_cast(jhandle) ->memtable_insert_hint_per_batch = @@ -8038,21 +8038,21 @@ void Java_org_rocksdb_WriteOptions_setMemtableInsertHintPerBatch( // ROCKSDB_NAMESPACE::ReadOptions /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: newReadOptions * Signature: ()J */ -jlong Java_org_rocksdb_ReadOptions_newReadOptions__(JNIEnv*, jclass) { +jlong Java_org_forstdb_ReadOptions_newReadOptions__(JNIEnv*, jclass) { auto* read_options = new ROCKSDB_NAMESPACE::ReadOptions(); return GET_CPLUSPLUS_POINTER(read_options); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: newReadOptions * Signature: (ZZ)J */ -jlong Java_org_rocksdb_ReadOptions_newReadOptions__ZZ( +jlong Java_org_forstdb_ReadOptions_newReadOptions__ZZ( JNIEnv*, jclass, jboolean jverify_checksums, jboolean jfill_cache) { auto* read_options = new ROCKSDB_NAMESPACE::ReadOptions( static_cast(jverify_checksums), static_cast(jfill_cache)); @@ -8060,11 +8060,11 @@ jlong Java_org_rocksdb_ReadOptions_newReadOptions__ZZ( } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: copyReadOptions * Signature: (J)J */ -jlong Java_org_rocksdb_ReadOptions_copyReadOptions(JNIEnv*, jclass, +jlong Java_org_forstdb_ReadOptions_copyReadOptions(JNIEnv*, jclass, jlong jhandle) { auto new_opt = new ROCKSDB_NAMESPACE::ReadOptions( *(reinterpret_cast(jhandle))); @@ -8072,11 +8072,11 @@ jlong Java_org_rocksdb_ReadOptions_copyReadOptions(JNIEnv*, jclass, } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_ReadOptions_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_ReadOptions_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* read_options = reinterpret_cast(jhandle); @@ -8085,169 +8085,169 @@ void Java_org_rocksdb_ReadOptions_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setVerifyChecksums * Signature: (JZ)V */ -void Java_org_rocksdb_ReadOptions_setVerifyChecksums( +void Java_org_forstdb_ReadOptions_setVerifyChecksums( JNIEnv*, jobject, jlong jhandle, jboolean jverify_checksums) { reinterpret_cast(jhandle)->verify_checksums = static_cast(jverify_checksums); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: verifyChecksums * Signature: (J)Z */ -jboolean Java_org_rocksdb_ReadOptions_verifyChecksums(JNIEnv*, jobject, +jboolean Java_org_forstdb_ReadOptions_verifyChecksums(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->verify_checksums; } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setFillCache * Signature: (JZ)V */ -void Java_org_rocksdb_ReadOptions_setFillCache(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_ReadOptions_setFillCache(JNIEnv*, jobject, jlong jhandle, jboolean jfill_cache) { reinterpret_cast(jhandle)->fill_cache = static_cast(jfill_cache); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: fillCache * Signature: (J)Z */ -jboolean Java_org_rocksdb_ReadOptions_fillCache(JNIEnv*, jobject, +jboolean Java_org_forstdb_ReadOptions_fillCache(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->fill_cache; } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setTailing * Signature: (JZ)V */ -void Java_org_rocksdb_ReadOptions_setTailing(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_ReadOptions_setTailing(JNIEnv*, jobject, jlong jhandle, jboolean jtailing) { reinterpret_cast(jhandle)->tailing = static_cast(jtailing); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: tailing * Signature: (J)Z */ -jboolean Java_org_rocksdb_ReadOptions_tailing(JNIEnv*, jobject, jlong jhandle) { +jboolean Java_org_forstdb_ReadOptions_tailing(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->tailing; } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: managed * Signature: (J)Z */ -jboolean Java_org_rocksdb_ReadOptions_managed(JNIEnv*, jobject, jlong jhandle) { +jboolean Java_org_forstdb_ReadOptions_managed(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->managed; } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setManaged * Signature: (JZ)V */ -void Java_org_rocksdb_ReadOptions_setManaged(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_ReadOptions_setManaged(JNIEnv*, jobject, jlong jhandle, jboolean jmanaged) { reinterpret_cast(jhandle)->managed = static_cast(jmanaged); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: totalOrderSeek * Signature: (J)Z */ -jboolean Java_org_rocksdb_ReadOptions_totalOrderSeek(JNIEnv*, jobject, +jboolean Java_org_forstdb_ReadOptions_totalOrderSeek(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->total_order_seek; } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setTotalOrderSeek * Signature: (JZ)V */ -void Java_org_rocksdb_ReadOptions_setTotalOrderSeek( +void Java_org_forstdb_ReadOptions_setTotalOrderSeek( JNIEnv*, jobject, jlong jhandle, jboolean jtotal_order_seek) { reinterpret_cast(jhandle)->total_order_seek = static_cast(jtotal_order_seek); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: prefixSameAsStart * Signature: (J)Z */ -jboolean Java_org_rocksdb_ReadOptions_prefixSameAsStart(JNIEnv*, jobject, +jboolean Java_org_forstdb_ReadOptions_prefixSameAsStart(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle) ->prefix_same_as_start; } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setPrefixSameAsStart * Signature: (JZ)V */ -void Java_org_rocksdb_ReadOptions_setPrefixSameAsStart( +void Java_org_forstdb_ReadOptions_setPrefixSameAsStart( JNIEnv*, jobject, jlong jhandle, jboolean jprefix_same_as_start) { reinterpret_cast(jhandle) ->prefix_same_as_start = static_cast(jprefix_same_as_start); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: pinData * Signature: (J)Z */ -jboolean Java_org_rocksdb_ReadOptions_pinData(JNIEnv*, jobject, jlong jhandle) { +jboolean Java_org_forstdb_ReadOptions_pinData(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->pin_data; } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setPinData * Signature: (JZ)V */ -void Java_org_rocksdb_ReadOptions_setPinData(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_ReadOptions_setPinData(JNIEnv*, jobject, jlong jhandle, jboolean jpin_data) { reinterpret_cast(jhandle)->pin_data = static_cast(jpin_data); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: backgroundPurgeOnIteratorCleanup * Signature: (J)Z */ -jboolean Java_org_rocksdb_ReadOptions_backgroundPurgeOnIteratorCleanup( +jboolean Java_org_forstdb_ReadOptions_backgroundPurgeOnIteratorCleanup( JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->background_purge_on_iterator_cleanup); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setBackgroundPurgeOnIteratorCleanup * Signature: (JZ)V */ -void Java_org_rocksdb_ReadOptions_setBackgroundPurgeOnIteratorCleanup( +void Java_org_forstdb_ReadOptions_setBackgroundPurgeOnIteratorCleanup( JNIEnv*, jobject, jlong jhandle, jboolean jbackground_purge_on_iterator_cleanup) { auto* opt = reinterpret_cast(jhandle); @@ -8256,22 +8256,22 @@ void Java_org_rocksdb_ReadOptions_setBackgroundPurgeOnIteratorCleanup( } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: readaheadSize * Signature: (J)J */ -jlong Java_org_rocksdb_ReadOptions_readaheadSize(JNIEnv*, jobject, +jlong Java_org_forstdb_ReadOptions_readaheadSize(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->readahead_size); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setReadaheadSize * Signature: (JJ)V */ -void Java_org_rocksdb_ReadOptions_setReadaheadSize(JNIEnv*, jobject, +void Java_org_forstdb_ReadOptions_setReadaheadSize(JNIEnv*, jobject, jlong jhandle, jlong jreadahead_size) { auto* opt = reinterpret_cast(jhandle); @@ -8279,22 +8279,22 @@ void Java_org_rocksdb_ReadOptions_setReadaheadSize(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: maxSkippableInternalKeys * Signature: (J)J */ -jlong Java_org_rocksdb_ReadOptions_maxSkippableInternalKeys(JNIEnv*, jobject, +jlong Java_org_forstdb_ReadOptions_maxSkippableInternalKeys(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->max_skippable_internal_keys); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setMaxSkippableInternalKeys * Signature: (JJ)V */ -void Java_org_rocksdb_ReadOptions_setMaxSkippableInternalKeys( +void Java_org_forstdb_ReadOptions_setMaxSkippableInternalKeys( JNIEnv*, jobject, jlong jhandle, jlong jmax_skippable_internal_keys) { auto* opt = reinterpret_cast(jhandle); opt->max_skippable_internal_keys = @@ -8302,76 +8302,76 @@ void Java_org_rocksdb_ReadOptions_setMaxSkippableInternalKeys( } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: ignoreRangeDeletions * Signature: (J)Z */ -jboolean Java_org_rocksdb_ReadOptions_ignoreRangeDeletions(JNIEnv*, jobject, +jboolean Java_org_forstdb_ReadOptions_ignoreRangeDeletions(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->ignore_range_deletions); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setIgnoreRangeDeletions * Signature: (JZ)V */ -void Java_org_rocksdb_ReadOptions_setIgnoreRangeDeletions( +void Java_org_forstdb_ReadOptions_setIgnoreRangeDeletions( JNIEnv*, jobject, jlong jhandle, jboolean jignore_range_deletions) { auto* opt = reinterpret_cast(jhandle); opt->ignore_range_deletions = static_cast(jignore_range_deletions); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setSnapshot * Signature: (JJ)V */ -void Java_org_rocksdb_ReadOptions_setSnapshot(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_ReadOptions_setSnapshot(JNIEnv*, jobject, jlong jhandle, jlong jsnapshot) { reinterpret_cast(jhandle)->snapshot = reinterpret_cast(jsnapshot); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: snapshot * Signature: (J)J */ -jlong Java_org_rocksdb_ReadOptions_snapshot(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_ReadOptions_snapshot(JNIEnv*, jobject, jlong jhandle) { auto& snapshot = reinterpret_cast(jhandle)->snapshot; return GET_CPLUSPLUS_POINTER(snapshot); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: readTier * Signature: (J)B */ -jbyte Java_org_rocksdb_ReadOptions_readTier(JNIEnv*, jobject, jlong jhandle) { +jbyte Java_org_forstdb_ReadOptions_readTier(JNIEnv*, jobject, jlong jhandle) { return static_cast( reinterpret_cast(jhandle)->read_tier); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setReadTier * Signature: (JB)V */ -void Java_org_rocksdb_ReadOptions_setReadTier(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_ReadOptions_setReadTier(JNIEnv*, jobject, jlong jhandle, jbyte jread_tier) { reinterpret_cast(jhandle)->read_tier = static_cast(jread_tier); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setIterateUpperBound * Signature: (JJ)I */ -void Java_org_rocksdb_ReadOptions_setIterateUpperBound( +void Java_org_forstdb_ReadOptions_setIterateUpperBound( JNIEnv*, jobject, jlong jhandle, jlong jupper_bound_slice_handle) { reinterpret_cast(jhandle) ->iterate_upper_bound = @@ -8379,11 +8379,11 @@ void Java_org_rocksdb_ReadOptions_setIterateUpperBound( } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: iterateUpperBound * Signature: (J)J */ -jlong Java_org_rocksdb_ReadOptions_iterateUpperBound(JNIEnv*, jobject, +jlong Java_org_forstdb_ReadOptions_iterateUpperBound(JNIEnv*, jobject, jlong jhandle) { auto& upper_bound_slice_handle = reinterpret_cast(jhandle) @@ -8392,11 +8392,11 @@ jlong Java_org_rocksdb_ReadOptions_iterateUpperBound(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setIterateLowerBound * Signature: (JJ)I */ -void Java_org_rocksdb_ReadOptions_setIterateLowerBound( +void Java_org_forstdb_ReadOptions_setIterateLowerBound( JNIEnv*, jobject, jlong jhandle, jlong jlower_bound_slice_handle) { reinterpret_cast(jhandle) ->iterate_lower_bound = @@ -8404,11 +8404,11 @@ void Java_org_rocksdb_ReadOptions_setIterateLowerBound( } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: iterateLowerBound * Signature: (J)J */ -jlong Java_org_rocksdb_ReadOptions_iterateLowerBound(JNIEnv*, jobject, +jlong Java_org_forstdb_ReadOptions_iterateLowerBound(JNIEnv*, jobject, jlong jhandle) { auto& lower_bound_slice_handle = reinterpret_cast(jhandle) @@ -8417,11 +8417,11 @@ jlong Java_org_rocksdb_ReadOptions_iterateLowerBound(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setTableFilter * Signature: (JJ)V */ -void Java_org_rocksdb_ReadOptions_setTableFilter( +void Java_org_forstdb_ReadOptions_setTableFilter( JNIEnv*, jobject, jlong jhandle, jlong jjni_table_filter_handle) { auto* opt = reinterpret_cast(jhandle); auto* jni_table_filter = @@ -8431,44 +8431,44 @@ void Java_org_rocksdb_ReadOptions_setTableFilter( } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: autoPrefixMode * Signature: (J)Z */ -jboolean Java_org_rocksdb_ReadOptions_autoPrefixMode(JNIEnv*, jobject, +jboolean Java_org_forstdb_ReadOptions_autoPrefixMode(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->auto_prefix_mode); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setAutoPrefixMode * Signature: (JZ)V */ -void Java_org_rocksdb_ReadOptions_setAutoPrefixMode( +void Java_org_forstdb_ReadOptions_setAutoPrefixMode( JNIEnv*, jobject, jlong jhandle, jboolean jauto_prefix_mode) { auto* opt = reinterpret_cast(jhandle); opt->auto_prefix_mode = static_cast(jauto_prefix_mode); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: timestamp * Signature: (J)J */ -jlong Java_org_rocksdb_ReadOptions_timestamp(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_ReadOptions_timestamp(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); auto& timestamp_slice_handle = opt->timestamp; return reinterpret_cast(timestamp_slice_handle); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setTimestamp * Signature: (JJ)V */ -void Java_org_rocksdb_ReadOptions_setTimestamp(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_ReadOptions_setTimestamp(JNIEnv*, jobject, jlong jhandle, jlong jtimestamp_slice_handle) { auto* opt = reinterpret_cast(jhandle); opt->timestamp = @@ -8476,11 +8476,11 @@ void Java_org_rocksdb_ReadOptions_setTimestamp(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: iterStartTs * Signature: (J)J */ -jlong Java_org_rocksdb_ReadOptions_iterStartTs(JNIEnv*, jobject, +jlong Java_org_forstdb_ReadOptions_iterStartTs(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); auto& iter_start_ts_handle = opt->iter_start_ts; @@ -8488,11 +8488,11 @@ jlong Java_org_rocksdb_ReadOptions_iterStartTs(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setIterStartTs * Signature: (JJ)V */ -void Java_org_rocksdb_ReadOptions_setIterStartTs(JNIEnv*, jobject, +void Java_org_forstdb_ReadOptions_setIterStartTs(JNIEnv*, jobject, jlong jhandle, jlong jiter_start_ts_handle) { auto* opt = reinterpret_cast(jhandle); @@ -8501,42 +8501,42 @@ void Java_org_rocksdb_ReadOptions_setIterStartTs(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: deadline * Signature: (J)J */ -jlong Java_org_rocksdb_ReadOptions_deadline(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_ReadOptions_deadline(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->deadline.count()); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setDeadline * Signature: (JJ)V */ -void Java_org_rocksdb_ReadOptions_setDeadline(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_ReadOptions_setDeadline(JNIEnv*, jobject, jlong jhandle, jlong jdeadline) { auto* opt = reinterpret_cast(jhandle); opt->deadline = std::chrono::microseconds(static_cast(jdeadline)); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: ioTimeout * Signature: (J)J */ -jlong Java_org_rocksdb_ReadOptions_ioTimeout(JNIEnv*, jobject, jlong jhandle) { +jlong Java_org_forstdb_ReadOptions_ioTimeout(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->io_timeout.count()); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setIoTimeout * Signature: (JJ)V */ -void Java_org_rocksdb_ReadOptions_setIoTimeout(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_ReadOptions_setIoTimeout(JNIEnv*, jobject, jlong jhandle, jlong jio_timeout) { auto* opt = reinterpret_cast(jhandle); opt->io_timeout = @@ -8544,22 +8544,22 @@ void Java_org_rocksdb_ReadOptions_setIoTimeout(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: valueSizeSofLimit * Signature: (J)J */ -jlong Java_org_rocksdb_ReadOptions_valueSizeSoftLimit(JNIEnv*, jobject, +jlong Java_org_forstdb_ReadOptions_valueSizeSoftLimit(JNIEnv*, jobject, jlong jhandle) { auto* opt = reinterpret_cast(jhandle); return static_cast(opt->value_size_soft_limit); } /* - * Class: org_rocksdb_ReadOptions + * Class: org_forstdb_ReadOptions * Method: setValueSizeSofLimit * Signature: (JJ)V */ -void Java_org_rocksdb_ReadOptions_setValueSizeSoftLimit( +void Java_org_forstdb_ReadOptions_setValueSizeSoftLimit( JNIEnv*, jobject, jlong jhandle, jlong jvalue_size_soft_limit) { auto* opt = reinterpret_cast(jhandle); opt->value_size_soft_limit = static_cast(jvalue_size_soft_limit); @@ -8569,21 +8569,21 @@ void Java_org_rocksdb_ReadOptions_setValueSizeSoftLimit( // ROCKSDB_NAMESPACE::ComparatorOptions /* - * Class: org_rocksdb_ComparatorOptions + * Class: org_forstdb_ComparatorOptions * Method: newComparatorOptions * Signature: ()J */ -jlong Java_org_rocksdb_ComparatorOptions_newComparatorOptions(JNIEnv*, jclass) { +jlong Java_org_forstdb_ComparatorOptions_newComparatorOptions(JNIEnv*, jclass) { auto* comparator_opt = new ROCKSDB_NAMESPACE::ComparatorJniCallbackOptions(); return GET_CPLUSPLUS_POINTER(comparator_opt); } /* - * Class: org_rocksdb_ComparatorOptions + * Class: org_forstdb_ComparatorOptions * Method: reusedSynchronisationType * Signature: (J)B */ -jbyte Java_org_rocksdb_ComparatorOptions_reusedSynchronisationType( +jbyte Java_org_forstdb_ComparatorOptions_reusedSynchronisationType( JNIEnv*, jobject, jlong jhandle) { auto* comparator_opt = reinterpret_cast( @@ -8594,11 +8594,11 @@ jbyte Java_org_rocksdb_ComparatorOptions_reusedSynchronisationType( } /* - * Class: org_rocksdb_ComparatorOptions + * Class: org_forstdb_ComparatorOptions * Method: setReusedSynchronisationType * Signature: (JB)V */ -void Java_org_rocksdb_ComparatorOptions_setReusedSynchronisationType( +void Java_org_forstdb_ComparatorOptions_setReusedSynchronisationType( JNIEnv*, jobject, jlong jhandle, jbyte jreused_synhcronisation_type) { auto* comparator_opt = reinterpret_cast( @@ -8609,11 +8609,11 @@ void Java_org_rocksdb_ComparatorOptions_setReusedSynchronisationType( } /* - * Class: org_rocksdb_ComparatorOptions + * Class: org_forstdb_ComparatorOptions * Method: useDirectBuffer * Signature: (J)Z */ -jboolean Java_org_rocksdb_ComparatorOptions_useDirectBuffer(JNIEnv*, jobject, +jboolean Java_org_forstdb_ComparatorOptions_useDirectBuffer(JNIEnv*, jobject, jlong jhandle) { return static_cast( reinterpret_cast( @@ -8622,22 +8622,22 @@ jboolean Java_org_rocksdb_ComparatorOptions_useDirectBuffer(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ComparatorOptions + * Class: org_forstdb_ComparatorOptions * Method: setUseDirectBuffer * Signature: (JZ)V */ -void Java_org_rocksdb_ComparatorOptions_setUseDirectBuffer( +void Java_org_forstdb_ComparatorOptions_setUseDirectBuffer( JNIEnv*, jobject, jlong jhandle, jboolean jdirect_buffer) { reinterpret_cast(jhandle) ->direct_buffer = jdirect_buffer == JNI_TRUE; } /* - * Class: org_rocksdb_ComparatorOptions + * Class: org_forstdb_ComparatorOptions * Method: maxReusedBufferSize * Signature: (J)I */ -jint Java_org_rocksdb_ComparatorOptions_maxReusedBufferSize(JNIEnv*, jobject, +jint Java_org_forstdb_ComparatorOptions_maxReusedBufferSize(JNIEnv*, jobject, jlong jhandle) { return static_cast( reinterpret_cast( @@ -8646,22 +8646,22 @@ jint Java_org_rocksdb_ComparatorOptions_maxReusedBufferSize(JNIEnv*, jobject, } /* - * Class: org_rocksdb_ComparatorOptions + * Class: org_forstdb_ComparatorOptions * Method: setMaxReusedBufferSize * Signature: (JI)V */ -void Java_org_rocksdb_ComparatorOptions_setMaxReusedBufferSize( +void Java_org_forstdb_ComparatorOptions_setMaxReusedBufferSize( JNIEnv*, jobject, jlong jhandle, jint jmax_reused_buffer_size) { reinterpret_cast(jhandle) ->max_reused_buffer_size = static_cast(jmax_reused_buffer_size); } /* - * Class: org_rocksdb_ComparatorOptions + * Class: org_forstdb_ComparatorOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_ComparatorOptions_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_ComparatorOptions_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* comparator_opt = reinterpret_cast( @@ -8674,21 +8674,21 @@ void Java_org_rocksdb_ComparatorOptions_disposeInternal(JNIEnv*, jobject, // ROCKSDB_NAMESPACE::FlushOptions /* - * Class: org_rocksdb_FlushOptions + * Class: org_forstdb_FlushOptions * Method: newFlushOptions * Signature: ()J */ -jlong Java_org_rocksdb_FlushOptions_newFlushOptions(JNIEnv*, jclass) { +jlong Java_org_forstdb_FlushOptions_newFlushOptions(JNIEnv*, jclass) { auto* flush_opt = new ROCKSDB_NAMESPACE::FlushOptions(); return GET_CPLUSPLUS_POINTER(flush_opt); } /* - * Class: org_rocksdb_FlushOptions + * Class: org_forstdb_FlushOptions * Method: setWaitForFlush * Signature: (JZ)V */ -void Java_org_rocksdb_FlushOptions_setWaitForFlush(JNIEnv*, jobject, +void Java_org_forstdb_FlushOptions_setWaitForFlush(JNIEnv*, jobject, jlong jhandle, jboolean jwait) { reinterpret_cast(jhandle)->wait = @@ -8696,21 +8696,21 @@ void Java_org_rocksdb_FlushOptions_setWaitForFlush(JNIEnv*, jobject, } /* - * Class: org_rocksdb_FlushOptions + * Class: org_forstdb_FlushOptions * Method: waitForFlush * Signature: (J)Z */ -jboolean Java_org_rocksdb_FlushOptions_waitForFlush(JNIEnv*, jobject, +jboolean Java_org_forstdb_FlushOptions_waitForFlush(JNIEnv*, jobject, jlong jhandle) { return reinterpret_cast(jhandle)->wait; } /* - * Class: org_rocksdb_FlushOptions + * Class: org_forstdb_FlushOptions * Method: setAllowWriteStall * Signature: (JZ)V */ -void Java_org_rocksdb_FlushOptions_setAllowWriteStall( +void Java_org_forstdb_FlushOptions_setAllowWriteStall( JNIEnv*, jobject, jlong jhandle, jboolean jallow_write_stall) { auto* flush_options = reinterpret_cast(jhandle); @@ -8718,11 +8718,11 @@ void Java_org_rocksdb_FlushOptions_setAllowWriteStall( } /* - * Class: org_rocksdb_FlushOptions + * Class: org_forstdb_FlushOptions * Method: allowWriteStall * Signature: (J)Z */ -jboolean Java_org_rocksdb_FlushOptions_allowWriteStall(JNIEnv*, jobject, +jboolean Java_org_forstdb_FlushOptions_allowWriteStall(JNIEnv*, jobject, jlong jhandle) { auto* flush_options = reinterpret_cast(jhandle); @@ -8730,11 +8730,11 @@ jboolean Java_org_rocksdb_FlushOptions_allowWriteStall(JNIEnv*, jobject, } /* - * Class: org_rocksdb_FlushOptions + * Class: org_forstdb_FlushOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_FlushOptions_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_FlushOptions_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* flush_opt = reinterpret_cast(jhandle); assert(flush_opt != nullptr); diff --git a/java/rocksjni/options_util.cc b/java/forstjni/options_util.cc similarity index 93% rename from java/rocksjni/options_util.cc rename to java/forstjni/options_util.cc index 5ebdbba92..99c8328a1 100644 --- a/java/rocksjni/options_util.cc +++ b/java/forstjni/options_util.cc @@ -12,10 +12,10 @@ #include -#include "include/org_rocksdb_OptionsUtil.h" +#include "include/org_forstdb_OptionsUtil.h" #include "rocksdb/db.h" #include "rocksdb/env.h" -#include "rocksjni/portal.h" +#include "forstjni/portal.h" void build_column_family_descriptor_list( JNIEnv* env, jobject jcfds, @@ -52,11 +52,11 @@ void build_column_family_descriptor_list( } /* - * Class: org_rocksdb_OptionsUtil + * Class: org_forstdb_OptionsUtil * Method: loadLatestOptions * Signature: (JLjava/lang/String;JLjava/util/List;)V */ -void Java_org_rocksdb_OptionsUtil_loadLatestOptions( +void Java_org_forstdb_OptionsUtil_loadLatestOptions( JNIEnv* env, jclass /*jcls*/, jlong cfg_handle, jstring jdbpath, jlong jdb_opts_handle, jobject jcfds) { jboolean has_exception = JNI_FALSE; @@ -82,11 +82,11 @@ void Java_org_rocksdb_OptionsUtil_loadLatestOptions( } /* - * Class: org_rocksdb_OptionsUtil + * Class: org_forstdb_OptionsUtil * Method: loadOptionsFromFile * Signature: (JLjava/lang/String;JLjava/util/List;)V */ -void Java_org_rocksdb_OptionsUtil_loadOptionsFromFile( +void Java_org_forstdb_OptionsUtil_loadOptionsFromFile( JNIEnv* env, jclass /*jcls*/, jlong cfg_handle, jstring jopts_file_name, jlong jdb_opts_handle, jobject jcfds) { jboolean has_exception = JNI_FALSE; @@ -112,11 +112,11 @@ void Java_org_rocksdb_OptionsUtil_loadOptionsFromFile( } /* - * Class: org_rocksdb_OptionsUtil + * Class: org_forstdb_OptionsUtil * Method: getLatestOptionsFileName * Signature: (Ljava/lang/String;J)Ljava/lang/String; */ -jstring Java_org_rocksdb_OptionsUtil_getLatestOptionsFileName( +jstring Java_org_forstdb_OptionsUtil_getLatestOptionsFileName( JNIEnv* env, jclass /*jcls*/, jstring jdbpath, jlong jenv_handle) { jboolean has_exception = JNI_FALSE; auto db_path = @@ -139,11 +139,11 @@ jstring Java_org_rocksdb_OptionsUtil_getLatestOptionsFileName( } /* - * Class: org_rocksdb_OptionsUtil + * Class: org_forstdb_OptionsUtil * Method: readTableFormatConfig * Signature: (J)Lorg/rocksdb/TableFormatConfig; */ -jobject Java_org_rocksdb_OptionsUtil_readTableFormatConfig(JNIEnv* env, jclass, +jobject Java_org_forstdb_OptionsUtil_readTableFormatConfig(JNIEnv* env, jclass, jlong jcf_options) { if (jcf_options == 0) { env->ThrowNew( diff --git a/java/rocksjni/persistent_cache.cc b/java/forstjni/persistent_cache.cc similarity index 85% rename from java/rocksjni/persistent_cache.cc rename to java/forstjni/persistent_cache.cc index 295d91798..f9a650751 100644 --- a/java/rocksjni/persistent_cache.cc +++ b/java/forstjni/persistent_cache.cc @@ -12,17 +12,17 @@ #include -#include "include/org_rocksdb_PersistentCache.h" +#include "include/org_forstdb_PersistentCache.h" #include "loggerjnicallback.h" #include "portal.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_PersistentCache + * Class: org_forstdb_PersistentCache * Method: newPersistentCache * Signature: (JLjava/lang/String;JJZ)J */ -jlong Java_org_rocksdb_PersistentCache_newPersistentCache( +jlong Java_org_forstdb_PersistentCache_newPersistentCache( JNIEnv* env, jclass, jlong jenv_handle, jstring jpath, jlong jsz, jlong jlogger_handle, jboolean joptimized_for_nvm) { auto* rocks_env = reinterpret_cast(jenv_handle); @@ -47,11 +47,11 @@ jlong Java_org_rocksdb_PersistentCache_newPersistentCache( } /* - * Class: org_rocksdb_PersistentCache + * Class: org_forstdb_PersistentCache * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_PersistentCache_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_PersistentCache_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* cache = reinterpret_cast*>( diff --git a/java/rocksjni/portal.h b/java/forstjni/portal.h similarity index 99% rename from java/rocksjni/portal.h rename to java/forstjni/portal.h index c13b8a666..1edb9a0f3 100644 --- a/java/rocksjni/portal.h +++ b/java/forstjni/portal.h @@ -35,16 +35,16 @@ #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/cplusplus_to_java_convert.h" -#include "rocksjni/event_listener_jnicallback.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" +#include "forstjni/compaction_filter_factory_jnicallback.h" +#include "forstjni/comparatorjnicallback.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/event_listener_jnicallback.h" +#include "forstjni/loggerjnicallback.h" +#include "forstjni/table_filter_jnicallback.h" +#include "forstjni/trace_writer_jnicallback.h" +#include "forstjni/transaction_notifier_jnicallback.h" +#include "forstjni/wal_filter_jnicallback.h" +#include "forstjni/writebatchhandlerjnicallback.h" // Remove macro on windows #ifdef DELETE diff --git a/java/rocksjni/ratelimiterjni.cc b/java/forstjni/ratelimiterjni.cc similarity index 79% rename from java/rocksjni/ratelimiterjni.cc rename to java/forstjni/ratelimiterjni.cc index 7a17f367e..83aead43c 100644 --- a/java/rocksjni/ratelimiterjni.cc +++ b/java/forstjni/ratelimiterjni.cc @@ -5,17 +5,17 @@ // // This file implements the "bridge" between Java and C++ for RateLimiter. -#include "include/org_rocksdb_RateLimiter.h" +#include "include/org_forstdb_RateLimiter.h" #include "rocksdb/rate_limiter.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_RateLimiter + * Class: org_forstdb_RateLimiter * Method: newRateLimiterHandle * Signature: (JJIBZ)J */ -jlong Java_org_rocksdb_RateLimiter_newRateLimiterHandle( +jlong Java_org_forstdb_RateLimiter_newRateLimiterHandle( JNIEnv* /*env*/, jclass /*jclazz*/, jlong jrate_bytes_per_second, jlong jrefill_period_micros, jint jfairness, jbyte jrate_limiter_mode, jboolean jauto_tune) { @@ -32,11 +32,11 @@ jlong Java_org_rocksdb_RateLimiter_newRateLimiterHandle( } /* - * Class: org_rocksdb_RateLimiter + * Class: org_forstdb_RateLimiter * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_RateLimiter_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_RateLimiter_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* handle = @@ -46,11 +46,11 @@ void Java_org_rocksdb_RateLimiter_disposeInternal(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_RateLimiter + * Class: org_forstdb_RateLimiter * Method: setBytesPerSecond * Signature: (JJ)V */ -void Java_org_rocksdb_RateLimiter_setBytesPerSecond(JNIEnv* /*env*/, +void Java_org_forstdb_RateLimiter_setBytesPerSecond(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle, jlong jbytes_per_second) { @@ -60,11 +60,11 @@ void Java_org_rocksdb_RateLimiter_setBytesPerSecond(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_RateLimiter + * Class: org_forstdb_RateLimiter * Method: getBytesPerSecond * Signature: (J)J */ -jlong Java_org_rocksdb_RateLimiter_getBytesPerSecond(JNIEnv* /*env*/, +jlong Java_org_forstdb_RateLimiter_getBytesPerSecond(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { return reinterpret_cast*>( @@ -74,11 +74,11 @@ jlong Java_org_rocksdb_RateLimiter_getBytesPerSecond(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_RateLimiter + * Class: org_forstdb_RateLimiter * Method: request * Signature: (JJ)V */ -void Java_org_rocksdb_RateLimiter_request(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_RateLimiter_request(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle, jlong jbytes) { reinterpret_cast*>(handle) ->get() @@ -86,11 +86,11 @@ void Java_org_rocksdb_RateLimiter_request(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_RateLimiter + * Class: org_forstdb_RateLimiter * Method: getSingleBurstBytes * Signature: (J)J */ -jlong Java_org_rocksdb_RateLimiter_getSingleBurstBytes(JNIEnv* /*env*/, +jlong Java_org_forstdb_RateLimiter_getSingleBurstBytes(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { return reinterpret_cast*>( @@ -100,11 +100,11 @@ jlong Java_org_rocksdb_RateLimiter_getSingleBurstBytes(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_RateLimiter + * Class: org_forstdb_RateLimiter * Method: getTotalBytesThrough * Signature: (J)J */ -jlong Java_org_rocksdb_RateLimiter_getTotalBytesThrough(JNIEnv* /*env*/, +jlong Java_org_forstdb_RateLimiter_getTotalBytesThrough(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { return reinterpret_cast*>( @@ -114,11 +114,11 @@ jlong Java_org_rocksdb_RateLimiter_getTotalBytesThrough(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_RateLimiter + * Class: org_forstdb_RateLimiter * Method: getTotalRequests * Signature: (J)J */ -jlong Java_org_rocksdb_RateLimiter_getTotalRequests(JNIEnv* /*env*/, +jlong Java_org_forstdb_RateLimiter_getTotalRequests(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { return reinterpret_cast*>( diff --git a/java/rocksjni/remove_emptyvalue_compactionfilterjni.cc b/java/forstjni/remove_emptyvalue_compactionfilterjni.cc similarity index 75% rename from java/rocksjni/remove_emptyvalue_compactionfilterjni.cc rename to java/forstjni/remove_emptyvalue_compactionfilterjni.cc index c0b09e151..2164fc44c 100644 --- a/java/rocksjni/remove_emptyvalue_compactionfilterjni.cc +++ b/java/forstjni/remove_emptyvalue_compactionfilterjni.cc @@ -5,16 +5,16 @@ #include -#include "include/org_rocksdb_RemoveEmptyValueCompactionFilter.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "include/org_forstdb_RemoveEmptyValueCompactionFilter.h" +#include "forstjni/cplusplus_to_java_convert.h" #include "utilities/compaction_filters/remove_emptyvalue_compactionfilter.h" /* - * Class: org_rocksdb_RemoveEmptyValueCompactionFilter + * Class: org_forstdb_RemoveEmptyValueCompactionFilter * Method: createNewRemoveEmptyValueCompactionFilter0 * Signature: ()J */ -jlong Java_org_rocksdb_RemoveEmptyValueCompactionFilter_createNewRemoveEmptyValueCompactionFilter0( +jlong Java_org_forstdb_RemoveEmptyValueCompactionFilter_createNewRemoveEmptyValueCompactionFilter0( JNIEnv* /*env*/, jclass /*jcls*/) { auto* compaction_filter = new ROCKSDB_NAMESPACE::RemoveEmptyValueCompactionFilter(); diff --git a/java/rocksjni/restorejni.cc b/java/forstjni/restorejni.cc similarity index 76% rename from java/rocksjni/restorejni.cc rename to java/forstjni/restorejni.cc index aadc86128..a20c883cc 100644 --- a/java/rocksjni/restorejni.cc +++ b/java/forstjni/restorejni.cc @@ -13,27 +13,27 @@ #include -#include "include/org_rocksdb_RestoreOptions.h" +#include "include/org_forstdb_RestoreOptions.h" #include "rocksdb/utilities/backup_engine.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_RestoreOptions + * Class: org_forstdb_RestoreOptions * Method: newRestoreOptions * Signature: (Z)J */ -jlong Java_org_rocksdb_RestoreOptions_newRestoreOptions( +jlong Java_org_forstdb_RestoreOptions_newRestoreOptions( JNIEnv* /*env*/, jclass /*jcls*/, jboolean keep_log_files) { auto* ropt = new ROCKSDB_NAMESPACE::RestoreOptions(keep_log_files); return GET_CPLUSPLUS_POINTER(ropt); } /* - * Class: org_rocksdb_RestoreOptions + * Class: org_forstdb_RestoreOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_RestoreOptions_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_RestoreOptions_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* ropt = reinterpret_cast(jhandle); diff --git a/java/rocksjni/rocks_callback_object.cc b/java/forstjni/rocks_callback_object.cc similarity index 87% rename from java/rocksjni/rocks_callback_object.cc rename to java/forstjni/rocks_callback_object.cc index 35513e151..19a32866a 100644 --- a/java/rocksjni/rocks_callback_object.cc +++ b/java/forstjni/rocks_callback_object.cc @@ -8,15 +8,15 @@ #include -#include "include/org_rocksdb_RocksCallbackObject.h" +#include "include/org_forstdb_RocksCallbackObject.h" #include "jnicallback.h" /* - * Class: org_rocksdb_RocksCallbackObject + * Class: org_forstdb_RocksCallbackObject * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_RocksCallbackObject_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_RocksCallbackObject_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { // TODO(AR) is deleting from the super class JniCallback OK, or must we delete diff --git a/java/rocksjni/rocksdb_exception_test.cc b/java/forstjni/rocksdb_exception_test.cc similarity index 72% rename from java/rocksjni/rocksdb_exception_test.cc rename to java/forstjni/rocksdb_exception_test.cc index 67e62f726..8150bb1ad 100644 --- a/java/rocksjni/rocksdb_exception_test.cc +++ b/java/forstjni/rocksdb_exception_test.cc @@ -5,50 +5,50 @@ #include -#include "include/org_rocksdb_RocksDBExceptionTest.h" +#include "include/org_forstdb_RocksDBExceptionTest.h" #include "rocksdb/slice.h" #include "rocksdb/status.h" -#include "rocksjni/portal.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_RocksDBExceptionTest + * Class: org_forstdb_RocksDBExceptionTest * Method: raiseException * Signature: ()V */ -void Java_org_rocksdb_RocksDBExceptionTest_raiseException(JNIEnv* env, +void Java_org_forstdb_RocksDBExceptionTest_raiseException(JNIEnv* env, jobject /*jobj*/) { ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, std::string("test message")); } /* - * Class: org_rocksdb_RocksDBExceptionTest + * Class: org_forstdb_RocksDBExceptionTest * Method: raiseExceptionWithStatusCode * Signature: ()V */ -void Java_org_rocksdb_RocksDBExceptionTest_raiseExceptionWithStatusCode( +void Java_org_forstdb_RocksDBExceptionTest_raiseExceptionWithStatusCode( JNIEnv* env, jobject /*jobj*/) { ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew( env, "test message", ROCKSDB_NAMESPACE::Status::NotSupported()); } /* - * Class: org_rocksdb_RocksDBExceptionTest + * Class: org_forstdb_RocksDBExceptionTest * Method: raiseExceptionNoMsgWithStatusCode * Signature: ()V */ -void Java_org_rocksdb_RocksDBExceptionTest_raiseExceptionNoMsgWithStatusCode( +void Java_org_forstdb_RocksDBExceptionTest_raiseExceptionNoMsgWithStatusCode( JNIEnv* env, jobject /*jobj*/) { ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew( env, ROCKSDB_NAMESPACE::Status::NotSupported()); } /* - * Class: org_rocksdb_RocksDBExceptionTest + * Class: org_forstdb_RocksDBExceptionTest * Method: raiseExceptionWithStatusCodeSubCode * Signature: ()V */ -void Java_org_rocksdb_RocksDBExceptionTest_raiseExceptionWithStatusCodeSubCode( +void Java_org_forstdb_RocksDBExceptionTest_raiseExceptionWithStatusCodeSubCode( JNIEnv* env, jobject /*jobj*/) { ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew( env, "test message", @@ -57,11 +57,11 @@ void Java_org_rocksdb_RocksDBExceptionTest_raiseExceptionWithStatusCodeSubCode( } /* - * Class: org_rocksdb_RocksDBExceptionTest + * Class: org_forstdb_RocksDBExceptionTest * Method: raiseExceptionNoMsgWithStatusCodeSubCode * Signature: ()V */ -void Java_org_rocksdb_RocksDBExceptionTest_raiseExceptionNoMsgWithStatusCodeSubCode( +void Java_org_forstdb_RocksDBExceptionTest_raiseExceptionNoMsgWithStatusCodeSubCode( JNIEnv* env, jobject /*jobj*/) { ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew( env, ROCKSDB_NAMESPACE::Status::TimedOut( @@ -69,11 +69,11 @@ void Java_org_rocksdb_RocksDBExceptionTest_raiseExceptionNoMsgWithStatusCodeSubC } /* - * Class: org_rocksdb_RocksDBExceptionTest + * Class: org_forstdb_RocksDBExceptionTest * Method: raiseExceptionWithStatusCodeState * Signature: ()V */ -void Java_org_rocksdb_RocksDBExceptionTest_raiseExceptionWithStatusCodeState( +void Java_org_forstdb_RocksDBExceptionTest_raiseExceptionWithStatusCodeState( JNIEnv* env, jobject /*jobj*/) { ROCKSDB_NAMESPACE::Slice state("test state"); ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew( diff --git a/java/rocksjni/rocksjni.cc b/java/forstjni/rocksjni.cc similarity index 92% rename from java/rocksjni/rocksjni.cc rename to java/forstjni/rocksjni.cc index 8b44a21dc..e9c9b7915 100644 --- a/java/rocksjni/rocksjni.cc +++ b/java/forstjni/rocksjni.cc @@ -17,7 +17,7 @@ #include #include -#include "include/org_rocksdb_RocksDB.h" +#include "include/org_forstdb_RocksDB.h" #include "rocksdb/cache.h" #include "rocksdb/convenience.h" #include "rocksdb/db.h" @@ -25,9 +25,9 @@ #include "rocksdb/perf_context.h" #include "rocksdb/types.h" #include "rocksdb/version.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/kv_helper.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/kv_helper.h" +#include "forstjni/portal.h" #ifdef min #undef min @@ -59,11 +59,11 @@ jlong rocksdb_open_helper(JNIEnv* env, jlong jopt_handle, jstring jdb_path, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: open * Signature: (JLjava/lang/String;)J */ -jlong Java_org_rocksdb_RocksDB_open__JLjava_lang_String_2(JNIEnv* env, jclass, +jlong Java_org_forstdb_RocksDB_open__JLjava_lang_String_2(JNIEnv* env, jclass, jlong jopt_handle, jstring jdb_path) { return rocksdb_open_helper(env, jopt_handle, jdb_path, @@ -74,11 +74,11 @@ jlong Java_org_rocksdb_RocksDB_open__JLjava_lang_String_2(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: openROnly * Signature: (JLjava/lang/String;Z)J */ -jlong Java_org_rocksdb_RocksDB_openROnly__JLjava_lang_String_2Z( +jlong Java_org_forstdb_RocksDB_openROnly__JLjava_lang_String_2Z( JNIEnv* env, jclass, jlong jopt_handle, jstring jdb_path, jboolean jerror_if_wal_file_exists) { const bool error_if_wal_file_exists = jerror_if_wal_file_exists == JNI_TRUE; @@ -178,11 +178,11 @@ jlongArray rocksdb_open_helper( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: openROnly * Signature: (JLjava/lang/String;[[B[JZ)[J */ -jlongArray Java_org_rocksdb_RocksDB_openROnly__JLjava_lang_String_2_3_3B_3JZ( +jlongArray Java_org_forstdb_RocksDB_openROnly__JLjava_lang_String_2_3_3B_3JZ( JNIEnv* env, jclass, jlong jopt_handle, jstring jdb_path, jobjectArray jcolumn_names, jlongArray jcolumn_options, jboolean jerror_if_wal_file_exists) { @@ -203,11 +203,11 @@ jlongArray Java_org_rocksdb_RocksDB_openROnly__JLjava_lang_String_2_3_3B_3JZ( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: open * Signature: (JLjava/lang/String;[[B[J)[J */ -jlongArray Java_org_rocksdb_RocksDB_open__JLjava_lang_String_2_3_3B_3J( +jlongArray Java_org_forstdb_RocksDB_open__JLjava_lang_String_2_3_3B_3J( JNIEnv* env, jclass, jlong jopt_handle, jstring jdb_path, jobjectArray jcolumn_names, jlongArray jcolumn_options) { return rocksdb_open_helper( @@ -221,11 +221,11 @@ jlongArray Java_org_rocksdb_RocksDB_open__JLjava_lang_String_2_3_3B_3J( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: openAsSecondary * Signature: (JLjava/lang/String;Ljava/lang/String;)J */ -jlong Java_org_rocksdb_RocksDB_openAsSecondary__JLjava_lang_String_2Ljava_lang_String_2( +jlong Java_org_forstdb_RocksDB_openAsSecondary__JLjava_lang_String_2Ljava_lang_String_2( JNIEnv* env, jclass, jlong jopt_handle, jstring jdb_path, jstring jsecondary_db_path) { const char* secondary_db_path = @@ -251,12 +251,12 @@ jlong Java_org_rocksdb_RocksDB_openAsSecondary__JLjava_lang_String_2Ljava_lang_S } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: openAsSecondary * Signature: (JLjava/lang/String;Ljava/lang/String;[[B[J)[J */ jlongArray -Java_org_rocksdb_RocksDB_openAsSecondary__JLjava_lang_String_2Ljava_lang_String_2_3_3B_3J( +Java_org_forstdb_RocksDB_openAsSecondary__JLjava_lang_String_2Ljava_lang_String_2_3_3B_3J( JNIEnv* env, jclass, jlong jopt_handle, jstring jdb_path, jstring jsecondary_db_path, jobjectArray jcolumn_names, jlongArray jcolumn_options) { @@ -287,22 +287,22 @@ Java_org_rocksdb_RocksDB_openAsSecondary__JLjava_lang_String_2Ljava_lang_String_ } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_RocksDB_disposeInternal(JNIEnv*, jobject, jlong jhandle) { +void Java_org_forstdb_RocksDB_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* db = reinterpret_cast(jhandle); assert(db != nullptr); delete db; } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: closeDatabase * Signature: (J)V */ -void Java_org_rocksdb_RocksDB_closeDatabase(JNIEnv* env, jclass, +void Java_org_forstdb_RocksDB_closeDatabase(JNIEnv* env, jclass, jlong jhandle) { auto* db = reinterpret_cast(jhandle); assert(db != nullptr); @@ -311,11 +311,11 @@ void Java_org_rocksdb_RocksDB_closeDatabase(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: listColumnFamilies * Signature: (JLjava/lang/String;)[[B */ -jobjectArray Java_org_rocksdb_RocksDB_listColumnFamilies(JNIEnv* env, jclass, +jobjectArray Java_org_forstdb_RocksDB_listColumnFamilies(JNIEnv* env, jclass, jlong jopt_handle, jstring jdb_path) { std::vector column_family_names; @@ -338,11 +338,11 @@ jobjectArray Java_org_rocksdb_RocksDB_listColumnFamilies(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: createColumnFamily * Signature: (J[BIJ)J */ -jlong Java_org_rocksdb_RocksDB_createColumnFamily(JNIEnv* env, jobject, +jlong Java_org_forstdb_RocksDB_createColumnFamily(JNIEnv* env, jobject, jlong jhandle, jbyteArray jcf_name, jint jcf_name_len, @@ -374,11 +374,11 @@ jlong Java_org_rocksdb_RocksDB_createColumnFamily(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: createColumnFamilies * Signature: (JJ[[B)[J */ -jlongArray Java_org_rocksdb_RocksDB_createColumnFamilies__JJ_3_3B( +jlongArray Java_org_forstdb_RocksDB_createColumnFamilies__JJ_3_3B( JNIEnv* env, jobject, jlong jhandle, jlong jcf_options_handle, jobjectArray jcf_names) { auto* db = reinterpret_cast(jhandle); @@ -415,11 +415,11 @@ jlongArray Java_org_rocksdb_RocksDB_createColumnFamilies__JJ_3_3B( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: createColumnFamilies * Signature: (J[J[[B)[J */ -jlongArray Java_org_rocksdb_RocksDB_createColumnFamilies__J_3J_3_3B( +jlongArray Java_org_forstdb_RocksDB_createColumnFamilies__J_3J_3_3B( JNIEnv* env, jobject, jlong jhandle, jlongArray jcf_options_handles, jobjectArray jcf_names) { auto* db = reinterpret_cast(jhandle); @@ -492,11 +492,11 @@ jlongArray Java_org_rocksdb_RocksDB_createColumnFamilies__J_3J_3_3B( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: createColumnFamilyWithImport * Signature: (J[BIJJ[J)J */ -jlong Java_org_rocksdb_RocksDB_createColumnFamilyWithImport( +jlong Java_org_forstdb_RocksDB_createColumnFamilyWithImport( JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jcf_name, jint jcf_name_len, jlong j_cf_options, jlong j_cf_import_options, jlongArray j_metadata_handle_array) { @@ -549,11 +549,11 @@ jlong Java_org_rocksdb_RocksDB_createColumnFamilyWithImport( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: dropColumnFamily * Signature: (JJ)V; */ -void Java_org_rocksdb_RocksDB_dropColumnFamily(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_dropColumnFamily(JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle) { auto* db_handle = reinterpret_cast(jdb_handle); @@ -566,11 +566,11 @@ void Java_org_rocksdb_RocksDB_dropColumnFamily(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: dropColumnFamilies * Signature: (J[J)V */ -void Java_org_rocksdb_RocksDB_dropColumnFamilies( +void Java_org_forstdb_RocksDB_dropColumnFamilies( JNIEnv* env, jobject, jlong jdb_handle, jlongArray jcolumn_family_handles) { auto* db_handle = reinterpret_cast(jdb_handle); @@ -602,11 +602,11 @@ void Java_org_rocksdb_RocksDB_dropColumnFamilies( // ROCKSDB_NAMESPACE::DB::Put /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: put * Signature: (J[BII[BII)V */ -void Java_org_rocksdb_RocksDB_put__J_3BII_3BII(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_put__J_3BII_3BII(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jbyteArray jval, @@ -625,11 +625,11 @@ void Java_org_rocksdb_RocksDB_put__J_3BII_3BII(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: put * Signature: (J[BII[BIIJ)V */ -void Java_org_rocksdb_RocksDB_put__J_3BII_3BIIJ(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_put__J_3BII_3BIIJ(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jbyteArray jval, @@ -659,11 +659,11 @@ void Java_org_rocksdb_RocksDB_put__J_3BII_3BIIJ(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: put * Signature: (JJ[BII[BII)V */ -void Java_org_rocksdb_RocksDB_put__JJ_3BII_3BII(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_put__JJ_3BII_3BII(JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options_handle, jbyteArray jkey, jint jkey_off, @@ -684,11 +684,11 @@ void Java_org_rocksdb_RocksDB_put__JJ_3BII_3BII(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: put * Signature: (JJ[BII[BIIJ)V */ -void Java_org_rocksdb_RocksDB_put__JJ_3BII_3BIIJ( +void Java_org_forstdb_RocksDB_put__JJ_3BII_3BIIJ( JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jbyteArray jval, jint jval_off, jint jval_len, jlong jcf_handle) { @@ -714,11 +714,11 @@ void Java_org_rocksdb_RocksDB_put__JJ_3BII_3BIIJ( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: putDirect * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V */ -void Java_org_rocksdb_RocksDB_putDirect( +void Java_org_forstdb_RocksDB_putDirect( JNIEnv* env, jobject /*jdb*/, jlong jdb_handle, jlong jwrite_options_handle, jobject jkey, jint jkey_off, jint jkey_len, jobject jval, jint jval_off, jint jval_len, jlong jcf_handle) { @@ -784,11 +784,11 @@ bool rocksdb_delete_helper(JNIEnv* env, ROCKSDB_NAMESPACE::DB* db, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: delete * Signature: (J[BII)V */ -void Java_org_rocksdb_RocksDB_delete__J_3BII(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_delete__J_3BII(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_off, jint jkey_len) { auto* db = reinterpret_cast(jdb_handle); @@ -799,11 +799,11 @@ void Java_org_rocksdb_RocksDB_delete__J_3BII(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: delete * Signature: (J[BIIJ)V */ -void Java_org_rocksdb_RocksDB_delete__J_3BIIJ(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_delete__J_3BIIJ(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jlong jcf_handle) { @@ -823,11 +823,11 @@ void Java_org_rocksdb_RocksDB_delete__J_3BIIJ(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: delete * Signature: (JJ[BII)V */ -void Java_org_rocksdb_RocksDB_delete__JJ_3BII(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_delete__JJ_3BII(JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options, jbyteArray jkey, jint jkey_off, @@ -840,11 +840,11 @@ void Java_org_rocksdb_RocksDB_delete__JJ_3BII(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: delete * Signature: (JJ[BIIJ)V */ -void Java_org_rocksdb_RocksDB_delete__JJ_3BIIJ( +void Java_org_forstdb_RocksDB_delete__JJ_3BIIJ( JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options, jbyteArray jkey, jint jkey_off, jint jkey_len, jlong jcf_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -901,11 +901,11 @@ bool rocksdb_single_delete_helper( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: singleDelete * Signature: (J[BI)V */ -void Java_org_rocksdb_RocksDB_singleDelete__J_3BI(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_singleDelete__J_3BI(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_len) { @@ -917,11 +917,11 @@ void Java_org_rocksdb_RocksDB_singleDelete__J_3BI(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: singleDelete * Signature: (J[BIJ)V */ -void Java_org_rocksdb_RocksDB_singleDelete__J_3BIJ(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_singleDelete__J_3BIJ(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_len, @@ -942,11 +942,11 @@ void Java_org_rocksdb_RocksDB_singleDelete__J_3BIJ(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: singleDelete * Signature: (JJ[BIJ)V */ -void Java_org_rocksdb_RocksDB_singleDelete__JJ_3BI(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_singleDelete__JJ_3BI(JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options, jbyteArray jkey, @@ -959,11 +959,11 @@ void Java_org_rocksdb_RocksDB_singleDelete__JJ_3BI(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: singleDelete * Signature: (JJ[BIJ)V */ -void Java_org_rocksdb_RocksDB_singleDelete__JJ_3BIJ( +void Java_org_forstdb_RocksDB_singleDelete__JJ_3BIJ( JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options, jbyteArray jkey, jint jkey_len, jlong jcf_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -1036,11 +1036,11 @@ bool rocksdb_delete_range_helper( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: deleteRange * Signature: (J[BII[BII)V */ -void Java_org_rocksdb_RocksDB_deleteRange__J_3BII_3BII( +void Java_org_forstdb_RocksDB_deleteRange__J_3BII_3BII( JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jbegin_key, jint jbegin_key_off, jint jbegin_key_len, jbyteArray jend_key, jint jend_key_off, jint jend_key_len) { @@ -1140,11 +1140,11 @@ jint rocksdb_get_helper_direct( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: deleteRange * Signature: (J[BII[BIIJ)V */ -void Java_org_rocksdb_RocksDB_deleteRange__J_3BII_3BIIJ( +void Java_org_forstdb_RocksDB_deleteRange__J_3BII_3BIIJ( JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jbegin_key, jint jbegin_key_off, jint jbegin_key_len, jbyteArray jend_key, jint jend_key_off, jint jend_key_len, jlong jcf_handle) { @@ -1165,11 +1165,11 @@ void Java_org_rocksdb_RocksDB_deleteRange__J_3BII_3BIIJ( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: deleteRange * Signature: (JJ[BII[BII)V */ -void Java_org_rocksdb_RocksDB_deleteRange__JJ_3BII_3BII( +void Java_org_forstdb_RocksDB_deleteRange__JJ_3BII_3BII( JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options, jbyteArray jbegin_key, jint jbegin_key_off, jint jbegin_key_len, jbyteArray jend_key, jint jend_key_off, jint jend_key_len) { @@ -1182,11 +1182,11 @@ void Java_org_rocksdb_RocksDB_deleteRange__JJ_3BII_3BII( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: deleteRange * Signature: (JJ[BII[BIIJ)V */ -void Java_org_rocksdb_RocksDB_deleteRange__JJ_3BII_3BIIJ( +void Java_org_forstdb_RocksDB_deleteRange__JJ_3BII_3BIIJ( JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options, jbyteArray jbegin_key, jint jbegin_key_off, jint jbegin_key_len, jbyteArray jend_key, jint jend_key_off, jint jend_key_len, @@ -1208,11 +1208,11 @@ void Java_org_rocksdb_RocksDB_deleteRange__JJ_3BII_3BIIJ( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: clipColumnFamily * Signature: (JJ[BII[BII)V */ -void Java_org_rocksdb_RocksDB_clipColumnFamily( +void Java_org_forstdb_RocksDB_clipColumnFamily( JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jbyteArray jbegin_key, jint jbegin_key_off, jint jbegin_key_len, jbyteArray jend_key, jint jend_key_off, jint jend_key_len) { @@ -1263,11 +1263,11 @@ void Java_org_rocksdb_RocksDB_clipColumnFamily( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getDirect * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)I */ -jint Java_org_rocksdb_RocksDB_getDirect(JNIEnv* env, jobject /*jdb*/, +jint Java_org_forstdb_RocksDB_getDirect(JNIEnv* env, jobject /*jdb*/, jlong jdb_handle, jlong jropt_handle, jobject jkey, jint jkey_off, jint jkey_len, jobject jval, @@ -1289,11 +1289,11 @@ jint Java_org_rocksdb_RocksDB_getDirect(JNIEnv* env, jobject /*jdb*/, // ROCKSDB_NAMESPACE::DB::Merge /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: merge * Signature: (J[BII[BII)V */ -void Java_org_rocksdb_RocksDB_merge__J_3BII_3BII(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_merge__J_3BII_3BII(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jbyteArray jval, @@ -1312,11 +1312,11 @@ void Java_org_rocksdb_RocksDB_merge__J_3BII_3BII(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: merge * Signature: (J[BII[BIIJ)V */ -void Java_org_rocksdb_RocksDB_merge__J_3BII_3BIIJ( +void Java_org_forstdb_RocksDB_merge__J_3BII_3BIIJ( JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jbyteArray jval, jint jval_off, jint jval_len, jlong jcf_handle) { @@ -1343,11 +1343,11 @@ void Java_org_rocksdb_RocksDB_merge__J_3BII_3BIIJ( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: merge * Signature: (JJ[BII[BII)V */ -void Java_org_rocksdb_RocksDB_merge__JJ_3BII_3BII( +void Java_org_forstdb_RocksDB_merge__JJ_3BII_3BII( JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jbyteArray jval, jint jval_off, jint jval_len) { @@ -1365,11 +1365,11 @@ void Java_org_rocksdb_RocksDB_merge__JJ_3BII_3BII( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: merge * Signature: (JJ[BII[BIIJ)V */ -void Java_org_rocksdb_RocksDB_merge__JJ_3BII_3BIIJ( +void Java_org_forstdb_RocksDB_merge__JJ_3BII_3BIIJ( JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jbyteArray jval, jint jval_off, jint jval_len, jlong jcf_handle) { @@ -1396,11 +1396,11 @@ void Java_org_rocksdb_RocksDB_merge__JJ_3BII_3BIIJ( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: mergeDirect * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V */ -void Java_org_rocksdb_RocksDB_mergeDirect( +void Java_org_forstdb_RocksDB_mergeDirect( JNIEnv* env, jobject /*jdb*/, jlong jdb_handle, jlong jwrite_options_handle, jobject jkey, jint jkey_off, jint jkey_len, jobject jval, jint jval_off, jint jval_len, jlong jcf_handle) { @@ -1429,11 +1429,11 @@ void Java_org_rocksdb_RocksDB_mergeDirect( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: deleteDirect * Signature: (JJLjava/nio/ByteBuffer;IIJ)V */ -void Java_org_rocksdb_RocksDB_deleteDirect(JNIEnv* env, jobject /*jdb*/, +void Java_org_forstdb_RocksDB_deleteDirect(JNIEnv* env, jobject /*jdb*/, jlong jdb_handle, jlong jwrite_options, jobject jkey, jint jkey_offset, jint jkey_len, @@ -1463,11 +1463,11 @@ void Java_org_rocksdb_RocksDB_deleteDirect(JNIEnv* env, jobject /*jdb*/, ////////////////////////////////////////////////////////////////////////////// // ROCKSDB_NAMESPACE::DB::Write /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: write0 * Signature: (JJJ)V */ -void Java_org_rocksdb_RocksDB_write0(JNIEnv* env, jobject, jlong jdb_handle, +void Java_org_forstdb_RocksDB_write0(JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options_handle, jlong jwb_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -1483,11 +1483,11 @@ void Java_org_rocksdb_RocksDB_write0(JNIEnv* env, jobject, jlong jdb_handle, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: write1 * Signature: (JJJ)V */ -void Java_org_rocksdb_RocksDB_write1(JNIEnv* env, jobject, jlong jdb_handle, +void Java_org_forstdb_RocksDB_write1(JNIEnv* env, jobject, jlong jdb_handle, jlong jwrite_options_handle, jlong jwbwi_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -1554,11 +1554,11 @@ jbyteArray rocksdb_get_helper( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: get * Signature: (J[BII)[B */ -jbyteArray Java_org_rocksdb_RocksDB_get__J_3BII(JNIEnv* env, jobject, +jbyteArray Java_org_forstdb_RocksDB_get__J_3BII(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_off, jint jkey_len) { @@ -1568,11 +1568,11 @@ jbyteArray Java_org_rocksdb_RocksDB_get__J_3BII(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: get * Signature: (J[BIIJ)[B */ -jbyteArray Java_org_rocksdb_RocksDB_get__J_3BIIJ(JNIEnv* env, jobject, +jbyteArray Java_org_forstdb_RocksDB_get__J_3BIIJ(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, @@ -1592,11 +1592,11 @@ jbyteArray Java_org_rocksdb_RocksDB_get__J_3BIIJ(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: get * Signature: (JJ[BII)[B */ -jbyteArray Java_org_rocksdb_RocksDB_get__JJ_3BII(JNIEnv* env, jobject, +jbyteArray Java_org_forstdb_RocksDB_get__JJ_3BII(JNIEnv* env, jobject, jlong jdb_handle, jlong jropt_handle, jbyteArray jkey, jint jkey_off, @@ -1608,11 +1608,11 @@ jbyteArray Java_org_rocksdb_RocksDB_get__JJ_3BII(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: get * Signature: (JJ[BIIJ)[B */ -jbyteArray Java_org_rocksdb_RocksDB_get__JJ_3BIIJ( +jbyteArray Java_org_forstdb_RocksDB_get__JJ_3BIIJ( JNIEnv* env, jobject, jlong jdb_handle, jlong jropt_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jlong jcf_handle) { auto* db_handle = reinterpret_cast(jdb_handle); @@ -1697,11 +1697,11 @@ jint rocksdb_get_helper( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: get * Signature: (J[BII[BII)I */ -jint Java_org_rocksdb_RocksDB_get__J_3BII_3BII(JNIEnv* env, jobject, +jint Java_org_forstdb_RocksDB_get__J_3BII_3BII(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jbyteArray jval, @@ -1714,11 +1714,11 @@ jint Java_org_rocksdb_RocksDB_get__J_3BII_3BII(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: get * Signature: (J[BII[BIIJ)I */ -jint Java_org_rocksdb_RocksDB_get__J_3BII_3BIIJ(JNIEnv* env, jobject, +jint Java_org_forstdb_RocksDB_get__J_3BII_3BIIJ(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jbyteArray jval, @@ -1742,11 +1742,11 @@ jint Java_org_rocksdb_RocksDB_get__J_3BII_3BIIJ(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: get * Signature: (JJ[BII[BII)I */ -jint Java_org_rocksdb_RocksDB_get__JJ_3BII_3BII(JNIEnv* env, jobject, +jint Java_org_forstdb_RocksDB_get__JJ_3BII_3BII(JNIEnv* env, jobject, jlong jdb_handle, jlong jropt_handle, jbyteArray jkey, jint jkey_off, @@ -1760,11 +1760,11 @@ jint Java_org_rocksdb_RocksDB_get__JJ_3BII_3BII(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: get * Signature: (JJ[BII[BIIJ)I */ -jint Java_org_rocksdb_RocksDB_get__JJ_3BII_3BIIJ( +jint Java_org_forstdb_RocksDB_get__JJ_3BII_3BIIJ( JNIEnv* env, jobject, jlong jdb_handle, jlong jropt_handle, jbyteArray jkey, jint jkey_off, jint jkey_len, jbyteArray jval, jint jval_off, jint jval_len, jlong jcf_handle) { @@ -2150,11 +2150,11 @@ void multi_get_helper_direct(JNIEnv* env, jobject, ROCKSDB_NAMESPACE::DB* db, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: multiGet * Signature: (J[[B[I[I)[[B */ -jobjectArray Java_org_rocksdb_RocksDB_multiGet__J_3_3B_3I_3I( +jobjectArray Java_org_forstdb_RocksDB_multiGet__J_3_3B_3I_3I( JNIEnv* env, jobject jdb, jlong jdb_handle, jobjectArray jkeys, jintArray jkey_offs, jintArray jkey_lens) { return multi_get_helper( @@ -2163,11 +2163,11 @@ jobjectArray Java_org_rocksdb_RocksDB_multiGet__J_3_3B_3I_3I( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: multiGet * Signature: (J[[B[I[I[J)[[B */ -jobjectArray Java_org_rocksdb_RocksDB_multiGet__J_3_3B_3I_3I_3J( +jobjectArray Java_org_forstdb_RocksDB_multiGet__J_3_3B_3I_3I_3J( JNIEnv* env, jobject jdb, jlong jdb_handle, jobjectArray jkeys, jintArray jkey_offs, jintArray jkey_lens, jlongArray jcolumn_family_handles) { @@ -2178,11 +2178,11 @@ jobjectArray Java_org_rocksdb_RocksDB_multiGet__J_3_3B_3I_3I_3J( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: multiGet * Signature: (JJ[[B[I[I)[[B */ -jobjectArray Java_org_rocksdb_RocksDB_multiGet__JJ_3_3B_3I_3I( +jobjectArray Java_org_forstdb_RocksDB_multiGet__JJ_3_3B_3I_3I( JNIEnv* env, jobject jdb, jlong jdb_handle, jlong jropt_handle, jobjectArray jkeys, jintArray jkey_offs, jintArray jkey_lens) { return multi_get_helper( @@ -2192,11 +2192,11 @@ jobjectArray Java_org_rocksdb_RocksDB_multiGet__JJ_3_3B_3I_3I( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: multiGet * Signature: (JJ[[B[I[I[J)[[B */ -jobjectArray Java_org_rocksdb_RocksDB_multiGet__JJ_3_3B_3I_3I_3J( +jobjectArray Java_org_forstdb_RocksDB_multiGet__JJ_3_3B_3I_3I_3J( JNIEnv* env, jobject jdb, jlong jdb_handle, jlong jropt_handle, jobjectArray jkeys, jintArray jkey_offs, jintArray jkey_lens, jlongArray jcolumn_family_handles) { @@ -2207,12 +2207,12 @@ jobjectArray Java_org_rocksdb_RocksDB_multiGet__JJ_3_3B_3I_3I_3J( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: multiGet * Signature: * (JJ[J[Ljava/nio/ByteBuffer;[I[I[Ljava/nio/ByteBuffer;[I[Lorg/rocksdb/Status;)V */ -void Java_org_rocksdb_RocksDB_multiGet__JJ_3J_3Ljava_nio_ByteBuffer_2_3I_3I_3Ljava_nio_ByteBuffer_2_3I_3Lorg_rocksdb_Status_2( +void Java_org_forstdb_RocksDB_multiGet__JJ_3J_3Ljava_nio_ByteBuffer_2_3I_3I_3Ljava_nio_ByteBuffer_2_3I_3Lorg_forstdb_Status_2( JNIEnv* env, jobject jdb, jlong jdb_handle, jlong jropt_handle, jlongArray jcolumn_family_handles, jobjectArray jkeys, jintArray jkey_offsets, jintArray jkey_lengths, jobjectArray jvalues, @@ -2357,11 +2357,11 @@ jboolean key_exists_helper(JNIEnv* env, jlong jdb_handle, jlong jcf_handle, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: keyExist * Signature: (JJJ[BII)Z */ -jboolean Java_org_rocksdb_RocksDB_keyExists(JNIEnv* env, jobject, +jboolean Java_org_forstdb_RocksDB_keyExists(JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jlong jread_opts_handle, jbyteArray jkey, jint jkey_offset, @@ -2387,11 +2387,11 @@ jboolean Java_org_rocksdb_RocksDB_keyExists(JNIEnv* env, jobject, final int keyLength); - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: keyExistDirect * Signature: (JJJLjava/nio/ByteBuffer;II)Z */ -jboolean Java_org_rocksdb_RocksDB_keyExistsDirect( +jboolean Java_org_forstdb_RocksDB_keyExistsDirect( JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jlong jread_opts_handle, jobject jkey, jint jkey_offset, jint jkey_len) { char* key = reinterpret_cast(env->GetDirectBufferAddress(jkey)); @@ -2414,11 +2414,11 @@ jboolean Java_org_rocksdb_RocksDB_keyExistsDirect( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: keyMayExist * Signature: (JJJ[BII)Z */ -jboolean Java_org_rocksdb_RocksDB_keyMayExist( +jboolean Java_org_forstdb_RocksDB_keyMayExist( JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jlong jread_opts_handle, jbyteArray jkey, jint jkey_offset, jint jkey_len) { bool has_exception = false; @@ -2438,11 +2438,11 @@ jboolean Java_org_rocksdb_RocksDB_keyMayExist( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: keyMayExistDirect * Signature: (JJJLjava/nio/ByteBuffer;II)Z */ -jboolean Java_org_rocksdb_RocksDB_keyMayExistDirect( +jboolean Java_org_forstdb_RocksDB_keyMayExistDirect( JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jlong jread_opts_handle, jobject jkey, jint jkey_offset, jint jkey_len) { bool has_exception = false; @@ -2461,12 +2461,12 @@ jboolean Java_org_rocksdb_RocksDB_keyMayExistDirect( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: keyMayExistDirectFoundValue * Signature: * (JJJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)[J */ -jintArray Java_org_rocksdb_RocksDB_keyMayExistDirectFoundValue( +jintArray Java_org_forstdb_RocksDB_keyMayExistDirectFoundValue( JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jlong jread_opts_handle, jobject jkey, jint jkey_offset, jint jkey_len, jobject jval, jint jval_offset, jint jval_len) { @@ -2533,11 +2533,11 @@ jintArray Java_org_rocksdb_RocksDB_keyMayExistDirectFoundValue( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: keyMayExistFoundValue * Signature: (JJJ[BII)[[B */ -jobjectArray Java_org_rocksdb_RocksDB_keyMayExistFoundValue( +jobjectArray Java_org_forstdb_RocksDB_keyMayExistFoundValue( JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jlong jread_opts_handle, jbyteArray jkey, jint jkey_offset, jint jkey_len) { bool has_exception = false; @@ -2621,11 +2621,11 @@ jobjectArray Java_org_rocksdb_RocksDB_keyMayExistFoundValue( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: iterator * Signature: (JJJ)J */ -jlong Java_org_rocksdb_RocksDB_iterator(JNIEnv*, jobject, jlong db_handle, +jlong Java_org_forstdb_RocksDB_iterator(JNIEnv*, jobject, jlong db_handle, jlong jcf_handle, jlong jread_options_handle) { auto* db = reinterpret_cast(db_handle); @@ -2637,11 +2637,11 @@ jlong Java_org_rocksdb_RocksDB_iterator(JNIEnv*, jobject, jlong db_handle, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: iterators * Signature: (J[JJ)[J */ -jlongArray Java_org_rocksdb_RocksDB_iterators(JNIEnv* env, jobject, +jlongArray Java_org_forstdb_RocksDB_iterators(JNIEnv* env, jobject, jlong db_handle, jlongArray jcolumn_family_handles, jlong jread_options_handle) { @@ -2701,7 +2701,7 @@ jlongArray Java_org_rocksdb_RocksDB_iterators(JNIEnv* env, jobject, * Method: getSnapshot * Signature: (J)J */ -jlong Java_org_rocksdb_RocksDB_getSnapshot(JNIEnv*, jobject, jlong db_handle) { +jlong Java_org_forstdb_RocksDB_getSnapshot(JNIEnv*, jobject, jlong db_handle) { auto* db = reinterpret_cast(db_handle); const ROCKSDB_NAMESPACE::Snapshot* snapshot = db->GetSnapshot(); return GET_CPLUSPLUS_POINTER(snapshot); @@ -2711,7 +2711,7 @@ jlong Java_org_rocksdb_RocksDB_getSnapshot(JNIEnv*, jobject, jlong db_handle) { * Method: releaseSnapshot * Signature: (JJ)V */ -void Java_org_rocksdb_RocksDB_releaseSnapshot(JNIEnv*, jobject, jlong db_handle, +void Java_org_forstdb_RocksDB_releaseSnapshot(JNIEnv*, jobject, jlong db_handle, jlong snapshot_handle) { auto* db = reinterpret_cast(db_handle); auto* snapshot = @@ -2720,11 +2720,11 @@ void Java_org_rocksdb_RocksDB_releaseSnapshot(JNIEnv*, jobject, jlong db_handle, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getProperty * Signature: (JJLjava/lang/String;I)Ljava/lang/String; */ -jstring Java_org_rocksdb_RocksDB_getProperty(JNIEnv* env, jobject, +jstring Java_org_forstdb_RocksDB_getProperty(JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jstring jproperty, jint jproperty_len) { @@ -2758,11 +2758,11 @@ jstring Java_org_rocksdb_RocksDB_getProperty(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getMapProperty * Signature: (JJLjava/lang/String;I)Ljava/util/Map; */ -jobject Java_org_rocksdb_RocksDB_getMapProperty(JNIEnv* env, jobject, +jobject Java_org_forstdb_RocksDB_getMapProperty(JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jstring jproperty, @@ -2797,11 +2797,11 @@ jobject Java_org_rocksdb_RocksDB_getMapProperty(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getLongProperty * Signature: (JJLjava/lang/String;I)J */ -jlong Java_org_rocksdb_RocksDB_getLongProperty(JNIEnv* env, jobject, +jlong Java_org_forstdb_RocksDB_getLongProperty(JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jstring jproperty, @@ -2836,21 +2836,21 @@ jlong Java_org_rocksdb_RocksDB_getLongProperty(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: resetStats * Signature: (J)V */ -void Java_org_rocksdb_RocksDB_resetStats(JNIEnv*, jobject, jlong jdb_handle) { +void Java_org_forstdb_RocksDB_resetStats(JNIEnv*, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); db->ResetStats(); } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getAggregatedLongProperty * Signature: (JLjava/lang/String;I)J */ -jlong Java_org_rocksdb_RocksDB_getAggregatedLongProperty(JNIEnv* env, jobject, +jlong Java_org_forstdb_RocksDB_getAggregatedLongProperty(JNIEnv* env, jobject, jlong db_handle, jstring jproperty, jint jproperty_len) { @@ -2874,11 +2874,11 @@ jlong Java_org_rocksdb_RocksDB_getAggregatedLongProperty(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getApproximateSizes * Signature: (JJ[JB)[J */ -jlongArray Java_org_rocksdb_RocksDB_getApproximateSizes( +jlongArray Java_org_forstdb_RocksDB_getApproximateSizes( JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jlongArray jrange_slice_handles, jbyte jinclude_flags) { const jsize jlen = env->GetArrayLength(jrange_slice_handles); @@ -2953,11 +2953,11 @@ jlongArray Java_org_rocksdb_RocksDB_getApproximateSizes( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getApproximateMemTableStats * Signature: (JJJJ)[J */ -jlongArray Java_org_rocksdb_RocksDB_getApproximateMemTableStats( +jlongArray Java_org_forstdb_RocksDB_getApproximateMemTableStats( JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jlong jstartHandle, jlong jlimitHandle) { auto* start = reinterpret_cast(jstartHandle); @@ -2997,11 +2997,11 @@ jlongArray Java_org_rocksdb_RocksDB_getApproximateMemTableStats( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: compactRange * Signature: (J[BI[BIJJ)V */ -void Java_org_rocksdb_RocksDB_compactRange(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_compactRange(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jbegin, jint jbegin_len, jbyteArray jend, jint jend_len, @@ -3073,11 +3073,11 @@ void Java_org_rocksdb_RocksDB_compactRange(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: setOptions * Signature: (JJ[Ljava/lang/String;[Ljava/lang/String;)V */ -void Java_org_rocksdb_RocksDB_setOptions(JNIEnv* env, jobject, jlong jdb_handle, +void Java_org_forstdb_RocksDB_setOptions(JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jobjectArray jkeys, jobjectArray jvalues) { const jsize len = env->GetArrayLength(jkeys); @@ -3136,11 +3136,11 @@ void Java_org_rocksdb_RocksDB_setOptions(JNIEnv* env, jobject, jlong jdb_handle, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: setDBOptions * Signature: (J[Ljava/lang/String;[Ljava/lang/String;)V */ -void Java_org_rocksdb_RocksDB_setDBOptions(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_setDBOptions(JNIEnv* env, jobject, jlong jdb_handle, jobjectArray jkeys, jobjectArray jvalues) { const jsize len = env->GetArrayLength(jkeys); @@ -3194,11 +3194,11 @@ void Java_org_rocksdb_RocksDB_setDBOptions(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getOptions * Signature: (JJ)Ljava/lang/String; */ -jstring Java_org_rocksdb_RocksDB_getOptions(JNIEnv* env, jobject, +jstring Java_org_forstdb_RocksDB_getOptions(JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -3223,11 +3223,11 @@ jstring Java_org_rocksdb_RocksDB_getOptions(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getDBOptions * Signature: (J)Ljava/lang/String; */ -jstring Java_org_rocksdb_RocksDB_getDBOptions(JNIEnv* env, jobject, +jstring Java_org_forstdb_RocksDB_getDBOptions(JNIEnv* env, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -3243,42 +3243,42 @@ jstring Java_org_rocksdb_RocksDB_getDBOptions(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: setPerfLevel * Signature: (JB)V */ -void Java_org_rocksdb_RocksDB_setPerfLevel(JNIEnv*, jobject, +void Java_org_forstdb_RocksDB_setPerfLevel(JNIEnv*, jobject, jbyte jperf_level) { - rocksdb::SetPerfLevel( + ROCKSDB_NAMESPACE::SetPerfLevel( ROCKSDB_NAMESPACE::PerfLevelTypeJni::toCppPerfLevelType(jperf_level)); } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getPerfLevel * Signature: (J)B */ -jbyte Java_org_rocksdb_RocksDB_getPerfLevelNative(JNIEnv*, jobject) { +jbyte Java_org_forstdb_RocksDB_getPerfLevelNative(JNIEnv*, jobject) { return ROCKSDB_NAMESPACE::PerfLevelTypeJni::toJavaPerfLevelType( - rocksdb::GetPerfLevel()); + ROCKSDB_NAMESPACE::GetPerfLevel()); } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getPerfContextNative * Signature: ()J */ -jlong Java_org_rocksdb_RocksDB_getPerfContextNative(JNIEnv*, jobject) { - ROCKSDB_NAMESPACE::PerfContext* perf_context = rocksdb::get_perf_context(); +jlong Java_org_forstdb_RocksDB_getPerfContextNative(JNIEnv*, jobject) { + ROCKSDB_NAMESPACE::PerfContext* perf_context = ROCKSDB_NAMESPACE::get_perf_context(); return reinterpret_cast(perf_context); } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: compactFiles * Signature: (JJJ[Ljava/lang/String;IIJ)[Ljava/lang/String; */ -jobjectArray Java_org_rocksdb_RocksDB_compactFiles( +jobjectArray Java_org_forstdb_RocksDB_compactFiles( JNIEnv* env, jobject, jlong jdb_handle, jlong jcompaction_opts_handle, jlong jcf_handle, jobjectArray jinput_file_names, jint joutput_level, jint joutput_path_id, jlong jcompaction_job_info_handle) { @@ -3324,11 +3324,11 @@ jobjectArray Java_org_rocksdb_RocksDB_compactFiles( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: cancelAllBackgroundWork * Signature: (JZ)V */ -void Java_org_rocksdb_RocksDB_cancelAllBackgroundWork(JNIEnv*, jobject, +void Java_org_forstdb_RocksDB_cancelAllBackgroundWork(JNIEnv*, jobject, jlong jdb_handle, jboolean jwait) { auto* db = reinterpret_cast(jdb_handle); @@ -3336,11 +3336,11 @@ void Java_org_rocksdb_RocksDB_cancelAllBackgroundWork(JNIEnv*, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: pauseBackgroundWork * Signature: (J)V */ -void Java_org_rocksdb_RocksDB_pauseBackgroundWork(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_pauseBackgroundWork(JNIEnv* env, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); auto s = db->PauseBackgroundWork(); @@ -3350,11 +3350,11 @@ void Java_org_rocksdb_RocksDB_pauseBackgroundWork(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: continueBackgroundWork * Signature: (J)V */ -void Java_org_rocksdb_RocksDB_continueBackgroundWork(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_continueBackgroundWork(JNIEnv* env, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); auto s = db->ContinueBackgroundWork(); @@ -3364,11 +3364,11 @@ void Java_org_rocksdb_RocksDB_continueBackgroundWork(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: enableAutoCompaction * Signature: (J[J)V */ -void Java_org_rocksdb_RocksDB_enableAutoCompaction(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_enableAutoCompaction(JNIEnv* env, jobject, jlong jdb_handle, jlongArray jcf_handles) { auto* db = reinterpret_cast(jdb_handle); @@ -3385,11 +3385,11 @@ void Java_org_rocksdb_RocksDB_enableAutoCompaction(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: numberLevels * Signature: (JJ)I */ -jint Java_org_rocksdb_RocksDB_numberLevels(JNIEnv*, jobject, jlong jdb_handle, +jint Java_org_forstdb_RocksDB_numberLevels(JNIEnv*, jobject, jlong jdb_handle, jlong jcf_handle) { auto* db = reinterpret_cast(jdb_handle); ROCKSDB_NAMESPACE::ColumnFamilyHandle* cf_handle; @@ -3403,11 +3403,11 @@ jint Java_org_rocksdb_RocksDB_numberLevels(JNIEnv*, jobject, jlong jdb_handle, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: maxMemCompactionLevel * Signature: (JJ)I */ -jint Java_org_rocksdb_RocksDB_maxMemCompactionLevel(JNIEnv*, jobject, +jint Java_org_forstdb_RocksDB_maxMemCompactionLevel(JNIEnv*, jobject, jlong jdb_handle, jlong jcf_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -3422,11 +3422,11 @@ jint Java_org_rocksdb_RocksDB_maxMemCompactionLevel(JNIEnv*, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: level0StopWriteTrigger * Signature: (JJ)I */ -jint Java_org_rocksdb_RocksDB_level0StopWriteTrigger(JNIEnv*, jobject, +jint Java_org_forstdb_RocksDB_level0StopWriteTrigger(JNIEnv*, jobject, jlong jdb_handle, jlong jcf_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -3441,11 +3441,11 @@ jint Java_org_rocksdb_RocksDB_level0StopWriteTrigger(JNIEnv*, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getName * Signature: (J)Ljava/lang/String; */ -jstring Java_org_rocksdb_RocksDB_getName(JNIEnv* env, jobject, +jstring Java_org_forstdb_RocksDB_getName(JNIEnv* env, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); std::string name = db->GetName(); @@ -3453,21 +3453,21 @@ jstring Java_org_rocksdb_RocksDB_getName(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getEnv * Signature: (J)J */ -jlong Java_org_rocksdb_RocksDB_getEnv(JNIEnv*, jobject, jlong jdb_handle) { +jlong Java_org_forstdb_RocksDB_getEnv(JNIEnv*, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); return GET_CPLUSPLUS_POINTER(db->GetEnv()); } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: flush * Signature: (JJ[J)V */ -void Java_org_rocksdb_RocksDB_flush(JNIEnv* env, jobject, jlong jdb_handle, +void Java_org_forstdb_RocksDB_flush(JNIEnv* env, jobject, jlong jdb_handle, jlong jflush_opts_handle, jlongArray jcf_handles) { auto* db = reinterpret_cast(jdb_handle); @@ -3493,11 +3493,11 @@ void Java_org_rocksdb_RocksDB_flush(JNIEnv* env, jobject, jlong jdb_handle, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: flushWal * Signature: (JZ)V */ -void Java_org_rocksdb_RocksDB_flushWal(JNIEnv* env, jobject, jlong jdb_handle, +void Java_org_forstdb_RocksDB_flushWal(JNIEnv* env, jobject, jlong jdb_handle, jboolean jsync) { auto* db = reinterpret_cast(jdb_handle); auto s = db->FlushWAL(jsync == JNI_TRUE); @@ -3507,11 +3507,11 @@ void Java_org_rocksdb_RocksDB_flushWal(JNIEnv* env, jobject, jlong jdb_handle, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: syncWal * Signature: (J)V */ -void Java_org_rocksdb_RocksDB_syncWal(JNIEnv* env, jobject, jlong jdb_handle) { +void Java_org_forstdb_RocksDB_syncWal(JNIEnv* env, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); auto s = db->SyncWAL(); if (!s.ok()) { @@ -3520,22 +3520,22 @@ void Java_org_rocksdb_RocksDB_syncWal(JNIEnv* env, jobject, jlong jdb_handle) { } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getLatestSequenceNumber * Signature: (J)V */ -jlong Java_org_rocksdb_RocksDB_getLatestSequenceNumber(JNIEnv*, jobject, +jlong Java_org_forstdb_RocksDB_getLatestSequenceNumber(JNIEnv*, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); return db->GetLatestSequenceNumber(); } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: disableFileDeletions * Signature: (J)V */ -void Java_org_rocksdb_RocksDB_disableFileDeletions(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_disableFileDeletions(JNIEnv* env, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); ROCKSDB_NAMESPACE::Status s = db->DisableFileDeletions(); @@ -3545,11 +3545,11 @@ void Java_org_rocksdb_RocksDB_disableFileDeletions(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: enableFileDeletions * Signature: (JZ)V */ -void Java_org_rocksdb_RocksDB_enableFileDeletions(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_enableFileDeletions(JNIEnv* env, jobject, jlong jdb_handle, jboolean jforce) { auto* db = reinterpret_cast(jdb_handle); @@ -3560,11 +3560,11 @@ void Java_org_rocksdb_RocksDB_enableFileDeletions(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getLiveFiles * Signature: (JZ)[Ljava/lang/String; */ -jobjectArray Java_org_rocksdb_RocksDB_getLiveFiles(JNIEnv* env, jobject, +jobjectArray Java_org_forstdb_RocksDB_getLiveFiles(JNIEnv* env, jobject, jlong jdb_handle, jboolean jflush_memtable) { auto* db = reinterpret_cast(jdb_handle); @@ -3585,11 +3585,11 @@ jobjectArray Java_org_rocksdb_RocksDB_getLiveFiles(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getSortedWalFiles * Signature: (J)[Lorg/rocksdb/LogFile; */ -jobjectArray Java_org_rocksdb_RocksDB_getSortedWalFiles(JNIEnv* env, jobject, +jobjectArray Java_org_forstdb_RocksDB_getSortedWalFiles(JNIEnv* env, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); std::vector> sorted_wal_files; @@ -3633,11 +3633,11 @@ jobjectArray Java_org_rocksdb_RocksDB_getSortedWalFiles(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getUpdatesSince * Signature: (JJ)J */ -jlong Java_org_rocksdb_RocksDB_getUpdatesSince(JNIEnv* env, jobject, +jlong Java_org_forstdb_RocksDB_getUpdatesSince(JNIEnv* env, jobject, jlong jdb_handle, jlong jsequence_number) { auto* db = reinterpret_cast(jdb_handle); @@ -3654,11 +3654,11 @@ jlong Java_org_rocksdb_RocksDB_getUpdatesSince(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: deleteFile * Signature: (JLjava/lang/String;)V */ -void Java_org_rocksdb_RocksDB_deleteFile(JNIEnv* env, jobject, jlong jdb_handle, +void Java_org_forstdb_RocksDB_deleteFile(JNIEnv* env, jobject, jlong jdb_handle, jstring jname) { auto* db = reinterpret_cast(jdb_handle); jboolean has_exception = JNI_FALSE; @@ -3672,11 +3672,11 @@ void Java_org_rocksdb_RocksDB_deleteFile(JNIEnv* env, jobject, jlong jdb_handle, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getLiveFilesMetaData * Signature: (J)[Lorg/rocksdb/LiveFileMetaData; */ -jobjectArray Java_org_rocksdb_RocksDB_getLiveFilesMetaData(JNIEnv* env, jobject, +jobjectArray Java_org_forstdb_RocksDB_getLiveFilesMetaData(JNIEnv* env, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); std::vector live_files_meta_data; @@ -3719,11 +3719,11 @@ jobjectArray Java_org_rocksdb_RocksDB_getLiveFilesMetaData(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getColumnFamilyMetaData * Signature: (JJ)Lorg/rocksdb/ColumnFamilyMetaData; */ -jobject Java_org_rocksdb_RocksDB_getColumnFamilyMetaData(JNIEnv* env, jobject, +jobject Java_org_forstdb_RocksDB_getColumnFamilyMetaData(JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -3741,11 +3741,11 @@ jobject Java_org_rocksdb_RocksDB_getColumnFamilyMetaData(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: ingestExternalFile * Signature: (JJ[Ljava/lang/String;IJ)V */ -void Java_org_rocksdb_RocksDB_ingestExternalFile( +void Java_org_forstdb_RocksDB_ingestExternalFile( JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jobjectArray jfile_path_list, jint jfile_path_list_len, jlong jingest_external_file_options_handle) { @@ -3771,11 +3771,11 @@ void Java_org_rocksdb_RocksDB_ingestExternalFile( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: verifyChecksum * Signature: (J)V */ -void Java_org_rocksdb_RocksDB_verifyChecksum(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_verifyChecksum(JNIEnv* env, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); auto s = db->VerifyChecksum(); @@ -3785,11 +3785,11 @@ void Java_org_rocksdb_RocksDB_verifyChecksum(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getDefaultColumnFamily * Signature: (J)J */ -jlong Java_org_rocksdb_RocksDB_getDefaultColumnFamily(JNIEnv*, jobject, +jlong Java_org_forstdb_RocksDB_getDefaultColumnFamily(JNIEnv*, jobject, jlong jdb_handle) { auto* db_handle = reinterpret_cast(jdb_handle); auto* cf_handle = db_handle->DefaultColumnFamily(); @@ -3797,11 +3797,11 @@ jlong Java_org_rocksdb_RocksDB_getDefaultColumnFamily(JNIEnv*, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getPropertiesOfAllTables * Signature: (JJ)Ljava/util/Map; */ -jobject Java_org_rocksdb_RocksDB_getPropertiesOfAllTables(JNIEnv* env, jobject, +jobject Java_org_forstdb_RocksDB_getPropertiesOfAllTables(JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -3869,11 +3869,11 @@ jobject Java_org_rocksdb_RocksDB_getPropertiesOfAllTables(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: getPropertiesOfTablesInRange * Signature: (JJ[J)Ljava/util/Map; */ -jobject Java_org_rocksdb_RocksDB_getPropertiesOfTablesInRange( +jobject Java_org_forstdb_RocksDB_getPropertiesOfTablesInRange( JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle, jlongArray jrange_slice_handles) { auto* db = reinterpret_cast(jdb_handle); @@ -3922,11 +3922,11 @@ jobject Java_org_rocksdb_RocksDB_getPropertiesOfTablesInRange( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: suggestCompactRange * Signature: (JJ)[J */ -jlongArray Java_org_rocksdb_RocksDB_suggestCompactRange(JNIEnv* env, jobject, +jlongArray Java_org_forstdb_RocksDB_suggestCompactRange(JNIEnv* env, jobject, jlong jdb_handle, jlong jcf_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -3972,11 +3972,11 @@ jlongArray Java_org_rocksdb_RocksDB_suggestCompactRange(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: promoteL0 * Signature: (JJI)V */ -void Java_org_rocksdb_RocksDB_promoteL0(JNIEnv*, jobject, jlong jdb_handle, +void Java_org_forstdb_RocksDB_promoteL0(JNIEnv*, jobject, jlong jdb_handle, jlong jcf_handle, jint jtarget_level) { auto* db = reinterpret_cast(jdb_handle); ROCKSDB_NAMESPACE::ColumnFamilyHandle* cf_handle; @@ -3990,11 +3990,11 @@ void Java_org_rocksdb_RocksDB_promoteL0(JNIEnv*, jobject, jlong jdb_handle, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: startTrace * Signature: (JJJ)V */ -void Java_org_rocksdb_RocksDB_startTrace( +void Java_org_forstdb_RocksDB_startTrace( JNIEnv* env, jobject, jlong jdb_handle, jlong jmax_trace_file_size, jlong jtrace_writer_jnicallback_handle) { auto* db = reinterpret_cast(jdb_handle); @@ -4013,11 +4013,11 @@ void Java_org_rocksdb_RocksDB_startTrace( } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: endTrace * Signature: (J)V */ -void Java_org_rocksdb_RocksDB_endTrace(JNIEnv* env, jobject, jlong jdb_handle) { +void Java_org_forstdb_RocksDB_endTrace(JNIEnv* env, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); auto s = db->EndTrace(); if (!s.ok()) { @@ -4026,11 +4026,11 @@ void Java_org_rocksdb_RocksDB_endTrace(JNIEnv* env, jobject, jlong jdb_handle) { } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: tryCatchUpWithPrimary * Signature: (J)V */ -void Java_org_rocksdb_RocksDB_tryCatchUpWithPrimary(JNIEnv* env, jobject, +void Java_org_forstdb_RocksDB_tryCatchUpWithPrimary(JNIEnv* env, jobject, jlong jdb_handle) { auto* db = reinterpret_cast(jdb_handle); auto s = db->TryCatchUpWithPrimary(); @@ -4040,11 +4040,11 @@ void Java_org_rocksdb_RocksDB_tryCatchUpWithPrimary(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: destroyDB * Signature: (Ljava/lang/String;J)V */ -void Java_org_rocksdb_RocksDB_destroyDB(JNIEnv* env, jclass, jstring jdb_path, +void Java_org_forstdb_RocksDB_destroyDB(JNIEnv* env, jclass, jstring jdb_path, jlong joptions_handle) { const char* db_path = env->GetStringUTFChars(jdb_path, nullptr); if (db_path == nullptr) { @@ -4095,11 +4095,11 @@ bool get_slice_helper(JNIEnv* env, jobjectArray ranges, jsize index, return true; } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: deleteFilesInRanges * Signature: (JJLjava/util/List;Z)V */ -void Java_org_rocksdb_RocksDB_deleteFilesInRanges(JNIEnv* env, jobject /*jdb*/, +void Java_org_forstdb_RocksDB_deleteFilesInRanges(JNIEnv* env, jobject /*jdb*/, jlong jdb_handle, jlong jcf_handle, jobjectArray ranges, @@ -4140,11 +4140,11 @@ void Java_org_rocksdb_RocksDB_deleteFilesInRanges(JNIEnv* env, jobject /*jdb*/, } /* - * Class: org_rocksdb_RocksDB + * Class: org_forstdb_RocksDB * Method: version * Signature: ()I */ -jint Java_org_rocksdb_RocksDB_version(JNIEnv*, jclass) { +jint Java_org_forstdb_RocksDB_version(JNIEnv*, jclass) { uint32_t encodedVersion = (ROCKSDB_MAJOR & 0xff) << 16; encodedVersion |= (ROCKSDB_MINOR & 0xff) << 8; encodedVersion |= (ROCKSDB_PATCH & 0xff); diff --git a/java/rocksjni/slice.cc b/java/forstjni/slice.cc similarity index 79% rename from java/rocksjni/slice.cc rename to java/forstjni/slice.cc index 63c6b1b9f..3d447562c 100644 --- a/java/rocksjni/slice.cc +++ b/java/forstjni/slice.cc @@ -14,20 +14,20 @@ #include -#include "include/org_rocksdb_AbstractSlice.h" -#include "include/org_rocksdb_DirectSlice.h" -#include "include/org_rocksdb_Slice.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_AbstractSlice.h" +#include "include/org_forstdb_DirectSlice.h" +#include "include/org_forstdb_Slice.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" // /* - * Class: org_rocksdb_Slice + * Class: org_forstdb_Slice * Method: createNewSlice0 * Signature: ([BI)J */ -jlong Java_org_rocksdb_Slice_createNewSlice0(JNIEnv* env, jclass /*jcls*/, +jlong Java_org_forstdb_Slice_createNewSlice0(JNIEnv* env, jclass /*jcls*/, jbyteArray data, jint offset) { const jsize dataSize = env->GetArrayLength(data); const int len = dataSize - offset; - // NOTE: buf will be deleted in the Java_org_rocksdb_Slice_disposeInternalBuf + // NOTE: buf will be deleted in the Java_org_forstdb_Slice_disposeInternalBuf // method jbyte* buf = new jbyte[len]; env->GetByteArrayRegion(data, offset, len, buf); @@ -151,11 +151,11 @@ jlong Java_org_rocksdb_Slice_createNewSlice0(JNIEnv* env, jclass /*jcls*/, } /* - * Class: org_rocksdb_Slice + * Class: org_forstdb_Slice * Method: createNewSlice1 * Signature: ([B)J */ -jlong Java_org_rocksdb_Slice_createNewSlice1(JNIEnv* env, jclass /*jcls*/, +jlong Java_org_forstdb_Slice_createNewSlice1(JNIEnv* env, jclass /*jcls*/, jbyteArray data) { jbyte* ptrData = env->GetByteArrayElements(data, nullptr); if (ptrData == nullptr) { @@ -164,7 +164,7 @@ jlong Java_org_rocksdb_Slice_createNewSlice1(JNIEnv* env, jclass /*jcls*/, } const int len = env->GetArrayLength(data) + 1; - // NOTE: buf will be deleted in the Java_org_rocksdb_Slice_disposeInternalBuf + // NOTE: buf will be deleted in the Java_org_forstdb_Slice_disposeInternalBuf // method char* buf = new char[len]; memcpy(buf, ptrData, len - 1); @@ -178,11 +178,11 @@ jlong Java_org_rocksdb_Slice_createNewSlice1(JNIEnv* env, jclass /*jcls*/, } /* - * Class: org_rocksdb_Slice + * Class: org_forstdb_Slice * Method: data0 * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_Slice_data0(JNIEnv* env, jobject /*jobj*/, +jbyteArray Java_org_forstdb_Slice_data0(JNIEnv* env, jobject /*jobj*/, jlong handle) { const auto* slice = reinterpret_cast(handle); const jsize len = static_cast(slice->size()); @@ -205,11 +205,11 @@ jbyteArray Java_org_rocksdb_Slice_data0(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_Slice + * Class: org_forstdb_Slice * Method: clear0 * Signature: (JZJ)V */ -void Java_org_rocksdb_Slice_clear0(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_Slice_clear0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle, jboolean shouldRelease, jlong internalBufferOffset) { auto* slice = reinterpret_cast(handle); @@ -221,33 +221,33 @@ void Java_org_rocksdb_Slice_clear0(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_Slice + * Class: org_forstdb_Slice * Method: removePrefix0 * Signature: (JI)V */ -void Java_org_rocksdb_Slice_removePrefix0(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_Slice_removePrefix0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle, jint length) { auto* slice = reinterpret_cast(handle); slice->remove_prefix(length); } /* - * Class: org_rocksdb_DirectSlice + * Class: org_forstdb_DirectSlice * Method: setLength0 * Signature: (JI)V */ -void Java_org_rocksdb_DirectSlice_setLength0(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_DirectSlice_setLength0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle, jint length) { auto* slice = reinterpret_cast(handle); slice->size_ = length; } /* - * Class: org_rocksdb_Slice + * Class: org_forstdb_Slice * Method: disposeInternalBuf * Signature: (JJ)V */ -void Java_org_rocksdb_Slice_disposeInternalBuf(JNIEnv* /*env*/, +void Java_org_forstdb_Slice_disposeInternalBuf(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle, jlong internalBufferOffset) { const auto* slice = reinterpret_cast(handle); @@ -260,11 +260,11 @@ void Java_org_rocksdb_Slice_disposeInternalBuf(JNIEnv* /*env*/, // -#include "include/org_rocksdb_SstFileManager.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_SstFileManager.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: newSstFileManager * Signature: (JJJDJ)J */ -jlong Java_org_rocksdb_SstFileManager_newSstFileManager( +jlong Java_org_forstdb_SstFileManager_newSstFileManager( JNIEnv* jnienv, jclass /*jcls*/, jlong jenv_handle, jlong jlogger_handle, jlong jrate_bytes, jdouble jmax_trash_db_ratio, jlong jmax_delete_chunk_bytes) { @@ -56,11 +56,11 @@ jlong Java_org_rocksdb_SstFileManager_newSstFileManager( } /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: setMaxAllowedSpaceUsage * Signature: (JJ)V */ -void Java_org_rocksdb_SstFileManager_setMaxAllowedSpaceUsage( +void Java_org_forstdb_SstFileManager_setMaxAllowedSpaceUsage( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jmax_allowed_space) { auto* sptr_sst_file_manager = @@ -70,11 +70,11 @@ void Java_org_rocksdb_SstFileManager_setMaxAllowedSpaceUsage( } /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: setCompactionBufferSize * Signature: (JJ)V */ -void Java_org_rocksdb_SstFileManager_setCompactionBufferSize( +void Java_org_forstdb_SstFileManager_setCompactionBufferSize( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jcompaction_buffer_size) { auto* sptr_sst_file_manager = @@ -85,11 +85,11 @@ void Java_org_rocksdb_SstFileManager_setCompactionBufferSize( } /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: isMaxAllowedSpaceReached * Signature: (J)Z */ -jboolean Java_org_rocksdb_SstFileManager_isMaxAllowedSpaceReached( +jboolean Java_org_forstdb_SstFileManager_isMaxAllowedSpaceReached( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* sptr_sst_file_manager = reinterpret_cast*>( @@ -98,12 +98,12 @@ jboolean Java_org_rocksdb_SstFileManager_isMaxAllowedSpaceReached( } /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: isMaxAllowedSpaceReachedIncludingCompactions * Signature: (J)Z */ jboolean -Java_org_rocksdb_SstFileManager_isMaxAllowedSpaceReachedIncludingCompactions( +Java_org_forstdb_SstFileManager_isMaxAllowedSpaceReachedIncludingCompactions( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* sptr_sst_file_manager = reinterpret_cast*>( @@ -113,11 +113,11 @@ Java_org_rocksdb_SstFileManager_isMaxAllowedSpaceReachedIncludingCompactions( } /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: getTotalSize * Signature: (J)J */ -jlong Java_org_rocksdb_SstFileManager_getTotalSize(JNIEnv* /*env*/, +jlong Java_org_forstdb_SstFileManager_getTotalSize(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* sptr_sst_file_manager = @@ -127,11 +127,11 @@ jlong Java_org_rocksdb_SstFileManager_getTotalSize(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: getTrackedFiles * Signature: (J)Ljava/util/Map; */ -jobject Java_org_rocksdb_SstFileManager_getTrackedFiles(JNIEnv* env, +jobject Java_org_forstdb_SstFileManager_getTrackedFiles(JNIEnv* env, jobject /*jobj*/, jlong jhandle) { auto* sptr_sst_file_manager = @@ -181,11 +181,11 @@ jobject Java_org_rocksdb_SstFileManager_getTrackedFiles(JNIEnv* env, } /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: getDeleteRateBytesPerSecond * Signature: (J)J */ -jlong Java_org_rocksdb_SstFileManager_getDeleteRateBytesPerSecond( +jlong Java_org_forstdb_SstFileManager_getDeleteRateBytesPerSecond( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* sptr_sst_file_manager = reinterpret_cast*>( @@ -194,11 +194,11 @@ jlong Java_org_rocksdb_SstFileManager_getDeleteRateBytesPerSecond( } /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: setDeleteRateBytesPerSecond * Signature: (JJ)V */ -void Java_org_rocksdb_SstFileManager_setDeleteRateBytesPerSecond( +void Java_org_forstdb_SstFileManager_setDeleteRateBytesPerSecond( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jdelete_rate) { auto* sptr_sst_file_manager = reinterpret_cast*>( @@ -207,11 +207,11 @@ void Java_org_rocksdb_SstFileManager_setDeleteRateBytesPerSecond( } /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: getMaxTrashDBRatio * Signature: (J)D */ -jdouble Java_org_rocksdb_SstFileManager_getMaxTrashDBRatio(JNIEnv* /*env*/, +jdouble Java_org_forstdb_SstFileManager_getMaxTrashDBRatio(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* sptr_sst_file_manager = @@ -221,11 +221,11 @@ jdouble Java_org_rocksdb_SstFileManager_getMaxTrashDBRatio(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: setMaxTrashDBRatio * Signature: (JD)V */ -void Java_org_rocksdb_SstFileManager_setMaxTrashDBRatio(JNIEnv* /*env*/, +void Java_org_forstdb_SstFileManager_setMaxTrashDBRatio(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jdouble jratio) { @@ -236,11 +236,11 @@ void Java_org_rocksdb_SstFileManager_setMaxTrashDBRatio(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_SstFileManager + * Class: org_forstdb_SstFileManager * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_SstFileManager_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_SstFileManager_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* sptr_sst_file_manager = diff --git a/java/rocksjni/sst_file_reader_iterator.cc b/java/forstjni/sst_file_reader_iterator.cc similarity index 82% rename from java/rocksjni/sst_file_reader_iterator.cc rename to java/forstjni/sst_file_reader_iterator.cc index 68fa4c37c..71e33b781 100644 --- a/java/rocksjni/sst_file_reader_iterator.cc +++ b/java/forstjni/sst_file_reader_iterator.cc @@ -10,16 +10,16 @@ #include #include -#include "include/org_rocksdb_SstFileReaderIterator.h" +#include "include/org_forstdb_SstFileReaderIterator.h" #include "rocksdb/iterator.h" -#include "rocksjni/portal.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_SstFileReaderIterator_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_SstFileReaderIterator_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); @@ -28,66 +28,66 @@ void Java_org_rocksdb_SstFileReaderIterator_disposeInternal(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: isValid0 * Signature: (J)Z */ -jboolean Java_org_rocksdb_SstFileReaderIterator_isValid0(JNIEnv* /*env*/, +jboolean Java_org_forstdb_SstFileReaderIterator_isValid0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { return reinterpret_cast(handle)->Valid(); } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: seekToFirst0 * Signature: (J)V */ -void Java_org_rocksdb_SstFileReaderIterator_seekToFirst0(JNIEnv* /*env*/, +void Java_org_forstdb_SstFileReaderIterator_seekToFirst0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->SeekToFirst(); } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: seekToLast0 * Signature: (J)V */ -void Java_org_rocksdb_SstFileReaderIterator_seekToLast0(JNIEnv* /*env*/, +void Java_org_forstdb_SstFileReaderIterator_seekToLast0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->SeekToLast(); } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: next0 * Signature: (J)V */ -void Java_org_rocksdb_SstFileReaderIterator_next0(JNIEnv* /*env*/, +void Java_org_forstdb_SstFileReaderIterator_next0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->Next(); } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: prev0 * Signature: (J)V */ -void Java_org_rocksdb_SstFileReaderIterator_prev0(JNIEnv* /*env*/, +void Java_org_forstdb_SstFileReaderIterator_prev0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->Prev(); } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: seek0 * Signature: (J[BI)V */ -void Java_org_rocksdb_SstFileReaderIterator_seek0(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_SstFileReaderIterator_seek0(JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, jint jtarget_len) { @@ -107,11 +107,11 @@ void Java_org_rocksdb_SstFileReaderIterator_seek0(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: seekForPrev0 * Signature: (J[BI)V */ -void Java_org_rocksdb_SstFileReaderIterator_seekForPrev0(JNIEnv* env, +void Java_org_forstdb_SstFileReaderIterator_seekForPrev0(JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, @@ -132,11 +132,11 @@ void Java_org_rocksdb_SstFileReaderIterator_seekForPrev0(JNIEnv* env, } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: status0 * Signature: (J)V */ -void Java_org_rocksdb_SstFileReaderIterator_status0(JNIEnv* env, +void Java_org_forstdb_SstFileReaderIterator_status0(JNIEnv* env, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); @@ -150,11 +150,11 @@ void Java_org_rocksdb_SstFileReaderIterator_status0(JNIEnv* env, } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: key0 * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_SstFileReaderIterator_key0(JNIEnv* env, +jbyteArray Java_org_forstdb_SstFileReaderIterator_key0(JNIEnv* env, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); @@ -172,11 +172,11 @@ jbyteArray Java_org_rocksdb_SstFileReaderIterator_key0(JNIEnv* env, } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: value0 * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_SstFileReaderIterator_value0(JNIEnv* env, +jbyteArray Java_org_forstdb_SstFileReaderIterator_value0(JNIEnv* env, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); @@ -195,11 +195,11 @@ jbyteArray Java_org_rocksdb_SstFileReaderIterator_value0(JNIEnv* env, } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: keyDirect0 * Signature: (JLjava/nio/ByteBuffer;II)I */ -jint Java_org_rocksdb_SstFileReaderIterator_keyDirect0( +jint Java_org_forstdb_SstFileReaderIterator_keyDirect0( JNIEnv* env, jobject /*jobj*/, jlong handle, jobject jtarget, jint jtarget_off, jint jtarget_len) { auto* it = reinterpret_cast(handle); @@ -212,11 +212,11 @@ jint Java_org_rocksdb_SstFileReaderIterator_keyDirect0( * This method supports fetching into indirect byte buffers; * the Java wrapper extracts the byte[] and passes it here. * - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: keyByteArray0 * Signature: (J[BII)I */ -jint Java_org_rocksdb_SstFileReaderIterator_keyByteArray0( +jint Java_org_forstdb_SstFileReaderIterator_keyByteArray0( JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jkey, jint jkey_off, jint jkey_len) { auto* it = reinterpret_cast(handle); @@ -232,11 +232,11 @@ jint Java_org_rocksdb_SstFileReaderIterator_keyByteArray0( } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: valueDirect0 * Signature: (JLjava/nio/ByteBuffer;II)I */ -jint Java_org_rocksdb_SstFileReaderIterator_valueDirect0( +jint Java_org_forstdb_SstFileReaderIterator_valueDirect0( JNIEnv* env, jobject /*jobj*/, jlong handle, jobject jtarget, jint jtarget_off, jint jtarget_len) { auto* it = reinterpret_cast(handle); @@ -249,11 +249,11 @@ jint Java_org_rocksdb_SstFileReaderIterator_valueDirect0( * This method supports fetching into indirect byte buffers; * the Java wrapper extracts the byte[] and passes it here. * - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: valueByteArray0 * Signature: (J[BII)I */ -jint Java_org_rocksdb_SstFileReaderIterator_valueByteArray0( +jint Java_org_forstdb_SstFileReaderIterator_valueByteArray0( JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jvalue_target, jint jvalue_off, jint jvalue_len) { auto* it = reinterpret_cast(handle); @@ -269,11 +269,11 @@ jint Java_org_rocksdb_SstFileReaderIterator_valueByteArray0( } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: seekDirect0 * Signature: (JLjava/nio/ByteBuffer;II)V */ -void Java_org_rocksdb_SstFileReaderIterator_seekDirect0( +void Java_org_forstdb_SstFileReaderIterator_seekDirect0( JNIEnv* env, jobject /*jobj*/, jlong handle, jobject jtarget, jint jtarget_off, jint jtarget_len) { auto* it = reinterpret_cast(handle); @@ -285,11 +285,11 @@ void Java_org_rocksdb_SstFileReaderIterator_seekDirect0( } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: seekForPrevDirect0 * Signature: (JLjava/nio/ByteBuffer;II)V */ -void Java_org_rocksdb_SstFileReaderIterator_seekForPrevDirect0( +void Java_org_forstdb_SstFileReaderIterator_seekForPrevDirect0( JNIEnv* env, jobject /*jobj*/, jlong handle, jobject jtarget, jint jtarget_off, jint jtarget_len) { auto* it = reinterpret_cast(handle); @@ -304,11 +304,11 @@ void Java_org_rocksdb_SstFileReaderIterator_seekForPrevDirect0( * This method supports fetching into indirect byte buffers; * the Java wrapper extracts the byte[] and passes it here. * - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: seekByteArray0 * Signature: (J[BII)V */ -void Java_org_rocksdb_SstFileReaderIterator_seekByteArray0( +void Java_org_forstdb_SstFileReaderIterator_seekByteArray0( JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, jint jtarget_off, jint jtarget_len) { const std::unique_ptr target(new char[jtarget_len]); @@ -331,11 +331,11 @@ void Java_org_rocksdb_SstFileReaderIterator_seekByteArray0( * This method supports fetching into indirect byte buffers; * the Java wrapper extracts the byte[] and passes it here. * - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: seekForPrevByteArray0 * Signature: (J[BII)V */ -void Java_org_rocksdb_SstFileReaderIterator_seekForPrevByteArray0( +void Java_org_forstdb_SstFileReaderIterator_seekForPrevByteArray0( JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, jint jtarget_off, jint jtarget_len) { const std::unique_ptr target(new char[jtarget_len]); @@ -355,11 +355,11 @@ void Java_org_rocksdb_SstFileReaderIterator_seekForPrevByteArray0( } /* - * Class: org_rocksdb_SstFileReaderIterator + * Class: org_forstdb_SstFileReaderIterator * Method: refresh0 * Signature: (J)V */ -void Java_org_rocksdb_SstFileReaderIterator_refresh0(JNIEnv* env, +void Java_org_forstdb_SstFileReaderIterator_refresh0(JNIEnv* env, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); diff --git a/java/rocksjni/sst_file_readerjni.cc b/java/forstjni/sst_file_readerjni.cc similarity index 82% rename from java/rocksjni/sst_file_readerjni.cc rename to java/forstjni/sst_file_readerjni.cc index 7ef711842..325ed6251 100644 --- a/java/rocksjni/sst_file_readerjni.cc +++ b/java/forstjni/sst_file_readerjni.cc @@ -11,20 +11,20 @@ #include -#include "include/org_rocksdb_SstFileReader.h" +#include "include/org_forstdb_SstFileReader.h" #include "rocksdb/comparator.h" #include "rocksdb/env.h" #include "rocksdb/options.h" #include "rocksdb/sst_file_reader.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_SstFileReader + * Class: org_forstdb_SstFileReader * Method: newSstFileReader * Signature: (J)J */ -jlong Java_org_rocksdb_SstFileReader_newSstFileReader(JNIEnv * /*env*/, +jlong Java_org_forstdb_SstFileReader_newSstFileReader(JNIEnv * /*env*/, jclass /*jcls*/, jlong joptions) { auto *options = @@ -35,11 +35,11 @@ jlong Java_org_rocksdb_SstFileReader_newSstFileReader(JNIEnv * /*env*/, } /* - * Class: org_rocksdb_SstFileReader + * Class: org_forstdb_SstFileReader * Method: open * Signature: (JLjava/lang/String;)V */ -void Java_org_rocksdb_SstFileReader_open(JNIEnv *env, jobject /*jobj*/, +void Java_org_forstdb_SstFileReader_open(JNIEnv *env, jobject /*jobj*/, jlong jhandle, jstring jfile_path) { const char *file_path = env->GetStringUTFChars(jfile_path, nullptr); if (file_path == nullptr) { @@ -57,11 +57,11 @@ void Java_org_rocksdb_SstFileReader_open(JNIEnv *env, jobject /*jobj*/, } /* - * Class: org_rocksdb_SstFileReader + * Class: org_forstdb_SstFileReader * Method: newIterator * Signature: (JJ)J */ -jlong Java_org_rocksdb_SstFileReader_newIterator(JNIEnv * /*env*/, +jlong Java_org_forstdb_SstFileReader_newIterator(JNIEnv * /*env*/, jobject /*jobj*/, jlong jhandle, jlong jread_options_handle) { @@ -73,22 +73,22 @@ jlong Java_org_rocksdb_SstFileReader_newIterator(JNIEnv * /*env*/, } /* - * Class: org_rocksdb_SstFileReader + * Class: org_forstdb_SstFileReader * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_SstFileReader_disposeInternal(JNIEnv * /*env*/, +void Java_org_forstdb_SstFileReader_disposeInternal(JNIEnv * /*env*/, jobject /*jobj*/, jlong jhandle) { delete reinterpret_cast(jhandle); } /* - * Class: org_rocksdb_SstFileReader + * Class: org_forstdb_SstFileReader * Method: verifyChecksum * Signature: (J)V */ -void Java_org_rocksdb_SstFileReader_verifyChecksum(JNIEnv *env, +void Java_org_forstdb_SstFileReader_verifyChecksum(JNIEnv *env, jobject /*jobj*/, jlong jhandle) { auto *sst_file_reader = @@ -100,11 +100,11 @@ void Java_org_rocksdb_SstFileReader_verifyChecksum(JNIEnv *env, } /* - * Class: org_rocksdb_SstFileReader + * Class: org_forstdb_SstFileReader * Method: getTableProperties * Signature: (J)J */ -jobject Java_org_rocksdb_SstFileReader_getTableProperties(JNIEnv *env, +jobject Java_org_forstdb_SstFileReader_getTableProperties(JNIEnv *env, jobject /*jobj*/, jlong jhandle) { auto *sst_file_reader = diff --git a/java/rocksjni/sst_file_writerjni.cc b/java/forstjni/sst_file_writerjni.cc similarity index 86% rename from java/rocksjni/sst_file_writerjni.cc rename to java/forstjni/sst_file_writerjni.cc index 1898c3cfc..a21742228 100644 --- a/java/rocksjni/sst_file_writerjni.cc +++ b/java/forstjni/sst_file_writerjni.cc @@ -11,20 +11,20 @@ #include -#include "include/org_rocksdb_SstFileWriter.h" +#include "include/org_forstdb_SstFileWriter.h" #include "rocksdb/comparator.h" #include "rocksdb/env.h" #include "rocksdb/options.h" #include "rocksdb/sst_file_writer.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: newSstFileWriter * Signature: (JJJB)J */ -jlong Java_org_rocksdb_SstFileWriter_newSstFileWriter__JJJB( +jlong Java_org_forstdb_SstFileWriter_newSstFileWriter__JJJB( JNIEnv * /*env*/, jclass /*jcls*/, jlong jenvoptions, jlong joptions, jlong jcomparator_handle, jbyte jcomparator_type) { ROCKSDB_NAMESPACE::Comparator *comparator = nullptr; @@ -51,11 +51,11 @@ jlong Java_org_rocksdb_SstFileWriter_newSstFileWriter__JJJB( } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: newSstFileWriter * Signature: (JJ)J */ -jlong Java_org_rocksdb_SstFileWriter_newSstFileWriter__JJ(JNIEnv * /*env*/, +jlong Java_org_forstdb_SstFileWriter_newSstFileWriter__JJ(JNIEnv * /*env*/, jclass /*jcls*/, jlong jenvoptions, jlong joptions) { @@ -69,11 +69,11 @@ jlong Java_org_rocksdb_SstFileWriter_newSstFileWriter__JJ(JNIEnv * /*env*/, } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: open * Signature: (JLjava/lang/String;)V */ -void Java_org_rocksdb_SstFileWriter_open(JNIEnv *env, jobject /*jobj*/, +void Java_org_forstdb_SstFileWriter_open(JNIEnv *env, jobject /*jobj*/, jlong jhandle, jstring jfile_path) { const char *file_path = env->GetStringUTFChars(jfile_path, nullptr); if (file_path == nullptr) { @@ -91,11 +91,11 @@ void Java_org_rocksdb_SstFileWriter_open(JNIEnv *env, jobject /*jobj*/, } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: put * Signature: (JJJ)V */ -void Java_org_rocksdb_SstFileWriter_put__JJJ(JNIEnv *env, jobject /*jobj*/, +void Java_org_forstdb_SstFileWriter_put__JJJ(JNIEnv *env, jobject /*jobj*/, jlong jhandle, jlong jkey_handle, jlong jvalue_handle) { auto *key_slice = reinterpret_cast(jkey_handle); @@ -110,11 +110,11 @@ void Java_org_rocksdb_SstFileWriter_put__JJJ(JNIEnv *env, jobject /*jobj*/, } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: put * Signature: (JJJ)V */ -void Java_org_rocksdb_SstFileWriter_put__J_3B_3B(JNIEnv *env, jobject /*jobj*/, +void Java_org_forstdb_SstFileWriter_put__J_3B_3B(JNIEnv *env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jbyteArray jval) { jbyte *key = env->GetByteArrayElements(jkey, nullptr); @@ -147,11 +147,11 @@ void Java_org_rocksdb_SstFileWriter_put__J_3B_3B(JNIEnv *env, jobject /*jobj*/, } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: putDirect * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)V */ -void Java_org_rocksdb_SstFileWriter_putDirect(JNIEnv *env, jobject /*jdb*/, +void Java_org_forstdb_SstFileWriter_putDirect(JNIEnv *env, jobject /*jdb*/, jlong jdb_handle, jobject jkey, jint jkey_off, jint jkey_len, jobject jval, jint jval_off, @@ -171,11 +171,11 @@ void Java_org_rocksdb_SstFileWriter_putDirect(JNIEnv *env, jobject /*jdb*/, } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: fileSize * Signature: (J)J */ -jlong Java_org_rocksdb_SstFileWriter_fileSize(JNIEnv * /*env*/, jobject /*jdb*/, +jlong Java_org_forstdb_SstFileWriter_fileSize(JNIEnv * /*env*/, jobject /*jdb*/, jlong jdb_handle) { auto *writer = reinterpret_cast(jdb_handle); @@ -183,11 +183,11 @@ jlong Java_org_rocksdb_SstFileWriter_fileSize(JNIEnv * /*env*/, jobject /*jdb*/, } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: merge * Signature: (JJJ)V */ -void Java_org_rocksdb_SstFileWriter_merge__JJJ(JNIEnv *env, jobject /*jobj*/, +void Java_org_forstdb_SstFileWriter_merge__JJJ(JNIEnv *env, jobject /*jobj*/, jlong jhandle, jlong jkey_handle, jlong jvalue_handle) { auto *key_slice = reinterpret_cast(jkey_handle); @@ -202,11 +202,11 @@ void Java_org_rocksdb_SstFileWriter_merge__JJJ(JNIEnv *env, jobject /*jobj*/, } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: merge * Signature: (J[B[B)V */ -void Java_org_rocksdb_SstFileWriter_merge__J_3B_3B(JNIEnv *env, +void Java_org_forstdb_SstFileWriter_merge__J_3B_3B(JNIEnv *env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, @@ -241,11 +241,11 @@ void Java_org_rocksdb_SstFileWriter_merge__J_3B_3B(JNIEnv *env, } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: delete * Signature: (JJJ)V */ -void Java_org_rocksdb_SstFileWriter_delete__J_3B(JNIEnv *env, jobject /*jobj*/, +void Java_org_forstdb_SstFileWriter_delete__J_3B(JNIEnv *env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey) { jbyte *key = env->GetByteArrayElements(jkey, nullptr); @@ -268,11 +268,11 @@ void Java_org_rocksdb_SstFileWriter_delete__J_3B(JNIEnv *env, jobject /*jobj*/, } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: delete * Signature: (JJJ)V */ -void Java_org_rocksdb_SstFileWriter_delete__JJ(JNIEnv *env, jobject /*jobj*/, +void Java_org_forstdb_SstFileWriter_delete__JJ(JNIEnv *env, jobject /*jobj*/, jlong jhandle, jlong jkey_handle) { auto *key_slice = reinterpret_cast(jkey_handle); @@ -285,11 +285,11 @@ void Java_org_rocksdb_SstFileWriter_delete__JJ(JNIEnv *env, jobject /*jobj*/, } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: finish * Signature: (J)V */ -void Java_org_rocksdb_SstFileWriter_finish(JNIEnv *env, jobject /*jobj*/, +void Java_org_forstdb_SstFileWriter_finish(JNIEnv *env, jobject /*jobj*/, jlong jhandle) { ROCKSDB_NAMESPACE::Status s = reinterpret_cast(jhandle)->Finish(); @@ -299,11 +299,11 @@ void Java_org_rocksdb_SstFileWriter_finish(JNIEnv *env, jobject /*jobj*/, } /* - * Class: org_rocksdb_SstFileWriter + * Class: org_forstdb_SstFileWriter * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_SstFileWriter_disposeInternal(JNIEnv * /*env*/, +void Java_org_forstdb_SstFileWriter_disposeInternal(JNIEnv * /*env*/, jobject /*jobj*/, jlong jhandle) { delete reinterpret_cast(jhandle); diff --git a/java/rocksjni/sst_partitioner.cc b/java/forstjni/sst_partitioner.cc similarity index 74% rename from java/rocksjni/sst_partitioner.cc rename to java/forstjni/sst_partitioner.cc index 1cea3b0cb..f249cb13a 100644 --- a/java/rocksjni/sst_partitioner.cc +++ b/java/forstjni/sst_partitioner.cc @@ -13,17 +13,17 @@ #include -#include "include/org_rocksdb_SstPartitionerFixedPrefixFactory.h" +#include "include/org_forstdb_SstPartitionerFixedPrefixFactory.h" #include "rocksdb/sst_file_manager.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_SstPartitionerFixedPrefixFactory + * Class: org_forstdb_SstPartitionerFixedPrefixFactory * Method: newSstPartitionerFixedPrefixFactory0 * Signature: (J)J */ -jlong Java_org_rocksdb_SstPartitionerFixedPrefixFactory_newSstPartitionerFixedPrefixFactory0( +jlong Java_org_forstdb_SstPartitionerFixedPrefixFactory_newSstPartitionerFixedPrefixFactory0( JNIEnv*, jclass, jlong prefix_len) { auto* ptr = new std::shared_ptr( ROCKSDB_NAMESPACE::NewSstPartitionerFixedPrefixFactory(prefix_len)); @@ -31,11 +31,11 @@ jlong Java_org_rocksdb_SstPartitionerFixedPrefixFactory_newSstPartitionerFixedPr } /* - * Class: org_rocksdb_SstPartitionerFixedPrefixFactory + * Class: org_forstdb_SstPartitionerFixedPrefixFactory * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_SstPartitionerFixedPrefixFactory_disposeInternal( +void Java_org_forstdb_SstPartitionerFixedPrefixFactory_disposeInternal( JNIEnv*, jobject, jlong jhandle) { auto* ptr = reinterpret_cast< std::shared_ptr*>(jhandle); diff --git a/java/rocksjni/statistics.cc b/java/forstjni/statistics.cc similarity index 81% rename from java/rocksjni/statistics.cc rename to java/forstjni/statistics.cc index bd405afa1..c6d0c8257 100644 --- a/java/rocksjni/statistics.cc +++ b/java/forstjni/statistics.cc @@ -13,48 +13,48 @@ #include #include -#include "include/org_rocksdb_Statistics.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" -#include "rocksjni/statisticsjni.h" +#include "include/org_forstdb_Statistics.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" +#include "forstjni/statisticsjni.h" /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: newStatistics * Signature: ()J */ -jlong Java_org_rocksdb_Statistics_newStatistics__(JNIEnv* env, jclass jcls) { - return Java_org_rocksdb_Statistics_newStatistics___3BJ(env, jcls, nullptr, 0); +jlong Java_org_forstdb_Statistics_newStatistics__(JNIEnv* env, jclass jcls) { + return Java_org_forstdb_Statistics_newStatistics___3BJ(env, jcls, nullptr, 0); } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: newStatistics * Signature: (J)J */ -jlong Java_org_rocksdb_Statistics_newStatistics__J( +jlong Java_org_forstdb_Statistics_newStatistics__J( JNIEnv* env, jclass jcls, jlong jother_statistics_handle) { - return Java_org_rocksdb_Statistics_newStatistics___3BJ( + return Java_org_forstdb_Statistics_newStatistics___3BJ( env, jcls, nullptr, jother_statistics_handle); } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: newStatistics * Signature: ([B)J */ -jlong Java_org_rocksdb_Statistics_newStatistics___3B(JNIEnv* env, jclass jcls, +jlong Java_org_forstdb_Statistics_newStatistics___3B(JNIEnv* env, jclass jcls, jbyteArray jhistograms) { - return Java_org_rocksdb_Statistics_newStatistics___3BJ(env, jcls, jhistograms, + return Java_org_forstdb_Statistics_newStatistics___3BJ(env, jcls, jhistograms, 0); } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: newStatistics * Signature: ([BJ)J */ -jlong Java_org_rocksdb_Statistics_newStatistics___3BJ( +jlong Java_org_forstdb_Statistics_newStatistics___3BJ( JNIEnv* env, jclass, jbyteArray jhistograms, jlong jother_statistics_handle) { std::shared_ptr* pSptr_other_statistics = @@ -100,11 +100,11 @@ jlong Java_org_rocksdb_Statistics_newStatistics___3BJ( } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_Statistics_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_Statistics_disposeInternal(JNIEnv*, jobject, jlong jhandle) { if (jhandle > 0) { auto* pSptr_statistics = @@ -115,11 +115,11 @@ void Java_org_rocksdb_Statistics_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: statsLevel * Signature: (J)B */ -jbyte Java_org_rocksdb_Statistics_statsLevel(JNIEnv*, jobject, jlong jhandle) { +jbyte Java_org_forstdb_Statistics_statsLevel(JNIEnv*, jobject, jlong jhandle) { auto* pSptr_statistics = reinterpret_cast*>( jhandle); @@ -129,11 +129,11 @@ jbyte Java_org_rocksdb_Statistics_statsLevel(JNIEnv*, jobject, jlong jhandle) { } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: setStatsLevel * Signature: (JB)V */ -void Java_org_rocksdb_Statistics_setStatsLevel(JNIEnv*, jobject, jlong jhandle, +void Java_org_forstdb_Statistics_setStatsLevel(JNIEnv*, jobject, jlong jhandle, jbyte jstats_level) { auto* pSptr_statistics = reinterpret_cast*>( @@ -145,11 +145,11 @@ void Java_org_rocksdb_Statistics_setStatsLevel(JNIEnv*, jobject, jlong jhandle, } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: getTickerCount * Signature: (JB)J */ -jlong Java_org_rocksdb_Statistics_getTickerCount(JNIEnv*, jobject, +jlong Java_org_forstdb_Statistics_getTickerCount(JNIEnv*, jobject, jlong jhandle, jbyte jticker_type) { auto* pSptr_statistics = @@ -162,11 +162,11 @@ jlong Java_org_rocksdb_Statistics_getTickerCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: getAndResetTickerCount * Signature: (JB)J */ -jlong Java_org_rocksdb_Statistics_getAndResetTickerCount(JNIEnv*, jobject, +jlong Java_org_forstdb_Statistics_getAndResetTickerCount(JNIEnv*, jobject, jlong jhandle, jbyte jticker_type) { auto* pSptr_statistics = @@ -178,11 +178,11 @@ jlong Java_org_rocksdb_Statistics_getAndResetTickerCount(JNIEnv*, jobject, } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: getHistogramData * Signature: (JB)Lorg/rocksdb/HistogramData; */ -jobject Java_org_rocksdb_Statistics_getHistogramData(JNIEnv* env, jobject, +jobject Java_org_forstdb_Statistics_getHistogramData(JNIEnv* env, jobject, jlong jhandle, jbyte jhistogram_type) { auto* pSptr_statistics = @@ -219,11 +219,11 @@ jobject Java_org_rocksdb_Statistics_getHistogramData(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: getHistogramString * Signature: (JB)Ljava/lang/String; */ -jstring Java_org_rocksdb_Statistics_getHistogramString(JNIEnv* env, jobject, +jstring Java_org_forstdb_Statistics_getHistogramString(JNIEnv* env, jobject, jlong jhandle, jbyte jhistogram_type) { auto* pSptr_statistics = @@ -237,11 +237,11 @@ jstring Java_org_rocksdb_Statistics_getHistogramString(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: reset * Signature: (J)V */ -void Java_org_rocksdb_Statistics_reset(JNIEnv* env, jobject, jlong jhandle) { +void Java_org_forstdb_Statistics_reset(JNIEnv* env, jobject, jlong jhandle) { auto* pSptr_statistics = reinterpret_cast*>( jhandle); @@ -253,11 +253,11 @@ void Java_org_rocksdb_Statistics_reset(JNIEnv* env, jobject, jlong jhandle) { } /* - * Class: org_rocksdb_Statistics + * Class: org_forstdb_Statistics * Method: toString * Signature: (J)Ljava/lang/String; */ -jstring Java_org_rocksdb_Statistics_toString(JNIEnv* env, jobject, +jstring Java_org_forstdb_Statistics_toString(JNIEnv* env, jobject, jlong jhandle) { auto* pSptr_statistics = reinterpret_cast*>( diff --git a/java/rocksjni/statisticsjni.cc b/java/forstjni/statisticsjni.cc similarity index 96% rename from java/rocksjni/statisticsjni.cc rename to java/forstjni/statisticsjni.cc index f46337893..4a053033f 100644 --- a/java/rocksjni/statisticsjni.cc +++ b/java/forstjni/statisticsjni.cc @@ -6,7 +6,7 @@ // This file implements the callback "bridge" between Java and C++ for // ROCKSDB_NAMESPACE::Statistics -#include "rocksjni/statisticsjni.h" +#include "forstjni/statisticsjni.h" namespace ROCKSDB_NAMESPACE { diff --git a/java/rocksjni/statisticsjni.h b/java/forstjni/statisticsjni.h similarity index 100% rename from java/rocksjni/statisticsjni.h rename to java/forstjni/statisticsjni.h diff --git a/java/rocksjni/table.cc b/java/forstjni/table.cc similarity index 94% rename from java/rocksjni/table.cc rename to java/forstjni/table.cc index 7f99900e4..b15c9777f 100644 --- a/java/rocksjni/table.cc +++ b/java/forstjni/table.cc @@ -10,19 +10,19 @@ #include -#include "include/org_rocksdb_BlockBasedTableConfig.h" -#include "include/org_rocksdb_PlainTableConfig.h" +#include "include/org_forstdb_BlockBasedTableConfig.h" +#include "include/org_forstdb_PlainTableConfig.h" #include "portal.h" #include "rocksdb/cache.h" #include "rocksdb/filter_policy.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_PlainTableConfig + * Class: org_forstdb_PlainTableConfig * Method: newTableFactoryHandle * Signature: (IIDIIBZZ)J */ -jlong Java_org_rocksdb_PlainTableConfig_newTableFactoryHandle( +jlong Java_org_forstdb_PlainTableConfig_newTableFactoryHandle( JNIEnv * /*env*/, jobject /*jobj*/, jint jkey_size, jint jbloom_bits_per_key, jdouble jhash_table_ratio, jint jindex_sparseness, jint jhuge_page_tlb_size, jbyte jencoding_type, jboolean jfull_scan_mode, @@ -43,11 +43,11 @@ jlong Java_org_rocksdb_PlainTableConfig_newTableFactoryHandle( } /* - * Class: org_rocksdb_BlockBasedTableConfig + * Class: org_forstdb_BlockBasedTableConfig * Method: newTableFactoryHandle * Signature: (ZZZZBBDBZJJJJIIIJZZZJZZIIZZBJIJI)J */ -jlong Java_org_rocksdb_BlockBasedTableConfig_newTableFactoryHandle( +jlong Java_org_forstdb_BlockBasedTableConfig_newTableFactoryHandle( JNIEnv *, jobject, jboolean jcache_index_and_filter_blocks, jboolean jcache_index_and_filter_blocks_with_high_priority, jboolean jpin_l0_filter_and_index_blocks_in_cache, diff --git a/java/rocksjni/table_filter.cc b/java/forstjni/table_filter.cc similarity index 72% rename from java/rocksjni/table_filter.cc rename to java/forstjni/table_filter.cc index 1400fa1d9..ac234d889 100644 --- a/java/rocksjni/table_filter.cc +++ b/java/forstjni/table_filter.cc @@ -10,16 +10,16 @@ #include -#include "include/org_rocksdb_AbstractTableFilter.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/table_filter_jnicallback.h" +#include "include/org_forstdb_AbstractTableFilter.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/table_filter_jnicallback.h" /* - * Class: org_rocksdb_AbstractTableFilter + * Class: org_forstdb_AbstractTableFilter * Method: createNewTableFilter * Signature: ()J */ -jlong Java_org_rocksdb_AbstractTableFilter_createNewTableFilter( +jlong Java_org_forstdb_AbstractTableFilter_createNewTableFilter( JNIEnv* env, jobject jtable_filter) { auto* table_filter_jnicallback = new ROCKSDB_NAMESPACE::TableFilterJniCallback(env, jtable_filter); diff --git a/java/rocksjni/table_filter_jnicallback.cc b/java/forstjni/table_filter_jnicallback.cc similarity index 96% rename from java/rocksjni/table_filter_jnicallback.cc rename to java/forstjni/table_filter_jnicallback.cc index 5350c5cee..061919f7b 100644 --- a/java/rocksjni/table_filter_jnicallback.cc +++ b/java/forstjni/table_filter_jnicallback.cc @@ -6,9 +6,9 @@ // This file implements the callback "bridge" between Java and C++ for // ROCKSDB_NAMESPACE::TableFilter. -#include "rocksjni/table_filter_jnicallback.h" +#include "forstjni/table_filter_jnicallback.h" -#include "rocksjni/portal.h" +#include "forstjni/portal.h" namespace ROCKSDB_NAMESPACE { TableFilterJniCallback::TableFilterJniCallback(JNIEnv* env, diff --git a/java/rocksjni/table_filter_jnicallback.h b/java/forstjni/table_filter_jnicallback.h similarity index 96% rename from java/rocksjni/table_filter_jnicallback.h rename to java/forstjni/table_filter_jnicallback.h index 0ef404ca2..7fbec5994 100644 --- a/java/rocksjni/table_filter_jnicallback.h +++ b/java/forstjni/table_filter_jnicallback.h @@ -15,7 +15,7 @@ #include #include "rocksdb/table_properties.h" -#include "rocksjni/jnicallback.h" +#include "forstjni/jnicallback.h" namespace ROCKSDB_NAMESPACE { diff --git a/java/rocksjni/testable_event_listener.cc b/java/forstjni/testable_event_listener.cc similarity index 98% rename from java/rocksjni/testable_event_listener.cc rename to java/forstjni/testable_event_listener.cc index 71188bc3c..a9380d440 100644 --- a/java/rocksjni/testable_event_listener.cc +++ b/java/forstjni/testable_event_listener.cc @@ -7,7 +7,7 @@ #include #include -#include "include/org_rocksdb_test_TestableEventListener.h" +#include "include/org_forstdb_test_TestableEventListener.h" #include "rocksdb/listener.h" #include "rocksdb/status.h" #include "rocksdb/table_properties.h" @@ -73,11 +73,11 @@ static TableProperties newTablePropertiesForTest() { } /* - * Class: org_rocksdb_test_TestableEventListener + * Class: org_forstdb_test_TestableEventListener * Method: invokeAllCallbacks * Signature: (J)V */ -void Java_org_rocksdb_test_TestableEventListener_invokeAllCallbacks( +void Java_org_forstdb_test_TestableEventListener_invokeAllCallbacks( JNIEnv *, jclass, jlong jhandle) { const auto &el = *reinterpret_cast *>( diff --git a/java/rocksjni/thread_status.cc b/java/forstjni/thread_status.cc similarity index 83% rename from java/rocksjni/thread_status.cc rename to java/forstjni/thread_status.cc index c600f6cd5..312e8c590 100644 --- a/java/rocksjni/thread_status.cc +++ b/java/forstjni/thread_status.cc @@ -10,15 +10,15 @@ #include -#include "include/org_rocksdb_ThreadStatus.h" +#include "include/org_forstdb_ThreadStatus.h" #include "portal.h" /* - * Class: org_rocksdb_ThreadStatus + * Class: org_forstdb_ThreadStatus * Method: getThreadTypeName * Signature: (B)Ljava/lang/String; */ -jstring Java_org_rocksdb_ThreadStatus_getThreadTypeName( +jstring Java_org_forstdb_ThreadStatus_getThreadTypeName( JNIEnv* env, jclass, jbyte jthread_type_value) { auto name = ROCKSDB_NAMESPACE::ThreadStatus::GetThreadTypeName( ROCKSDB_NAMESPACE::ThreadTypeJni::toCppThreadType(jthread_type_value)); @@ -26,11 +26,11 @@ jstring Java_org_rocksdb_ThreadStatus_getThreadTypeName( } /* - * Class: org_rocksdb_ThreadStatus + * Class: org_forstdb_ThreadStatus * Method: getOperationName * Signature: (B)Ljava/lang/String; */ -jstring Java_org_rocksdb_ThreadStatus_getOperationName( +jstring Java_org_forstdb_ThreadStatus_getOperationName( JNIEnv* env, jclass, jbyte joperation_type_value) { auto name = ROCKSDB_NAMESPACE::ThreadStatus::GetOperationName( ROCKSDB_NAMESPACE::OperationTypeJni::toCppOperationType( @@ -39,11 +39,11 @@ jstring Java_org_rocksdb_ThreadStatus_getOperationName( } /* - * Class: org_rocksdb_ThreadStatus + * Class: org_forstdb_ThreadStatus * Method: microsToStringNative * Signature: (J)Ljava/lang/String; */ -jstring Java_org_rocksdb_ThreadStatus_microsToStringNative(JNIEnv* env, jclass, +jstring Java_org_forstdb_ThreadStatus_microsToStringNative(JNIEnv* env, jclass, jlong jmicros) { auto str = ROCKSDB_NAMESPACE::ThreadStatus::MicrosToString( static_cast(jmicros)); @@ -51,11 +51,11 @@ jstring Java_org_rocksdb_ThreadStatus_microsToStringNative(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_ThreadStatus + * Class: org_forstdb_ThreadStatus * Method: getOperationStageName * Signature: (B)Ljava/lang/String; */ -jstring Java_org_rocksdb_ThreadStatus_getOperationStageName( +jstring Java_org_forstdb_ThreadStatus_getOperationStageName( JNIEnv* env, jclass, jbyte joperation_stage_value) { auto name = ROCKSDB_NAMESPACE::ThreadStatus::GetOperationStageName( ROCKSDB_NAMESPACE::OperationStageJni::toCppOperationStage( @@ -64,11 +64,11 @@ jstring Java_org_rocksdb_ThreadStatus_getOperationStageName( } /* - * Class: org_rocksdb_ThreadStatus + * Class: org_forstdb_ThreadStatus * Method: getOperationPropertyName * Signature: (BI)Ljava/lang/String; */ -jstring Java_org_rocksdb_ThreadStatus_getOperationPropertyName( +jstring Java_org_forstdb_ThreadStatus_getOperationPropertyName( JNIEnv* env, jclass, jbyte joperation_type_value, jint jindex) { auto name = ROCKSDB_NAMESPACE::ThreadStatus::GetOperationPropertyName( ROCKSDB_NAMESPACE::OperationTypeJni::toCppOperationType( @@ -78,11 +78,11 @@ jstring Java_org_rocksdb_ThreadStatus_getOperationPropertyName( } /* - * Class: org_rocksdb_ThreadStatus + * Class: org_forstdb_ThreadStatus * Method: interpretOperationProperties * Signature: (B[J)Ljava/util/Map; */ -jobject Java_org_rocksdb_ThreadStatus_interpretOperationProperties( +jobject Java_org_forstdb_ThreadStatus_interpretOperationProperties( JNIEnv* env, jclass, jbyte joperation_type_value, jlongArray joperation_properties) { // convert joperation_properties @@ -113,11 +113,11 @@ jobject Java_org_rocksdb_ThreadStatus_interpretOperationProperties( } /* - * Class: org_rocksdb_ThreadStatus + * Class: org_forstdb_ThreadStatus * Method: getStateName * Signature: (B)Ljava/lang/String; */ -jstring Java_org_rocksdb_ThreadStatus_getStateName(JNIEnv* env, jclass, +jstring Java_org_forstdb_ThreadStatus_getStateName(JNIEnv* env, jclass, jbyte jstate_type_value) { auto name = ROCKSDB_NAMESPACE::ThreadStatus::GetStateName( ROCKSDB_NAMESPACE::StateTypeJni::toCppStateType(jstate_type_value)); diff --git a/java/rocksjni/trace_writer.cc b/java/forstjni/trace_writer.cc similarity index 72% rename from java/rocksjni/trace_writer.cc rename to java/forstjni/trace_writer.cc index d58276399..8152a0b17 100644 --- a/java/rocksjni/trace_writer.cc +++ b/java/forstjni/trace_writer.cc @@ -8,16 +8,16 @@ #include -#include "include/org_rocksdb_AbstractTraceWriter.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/trace_writer_jnicallback.h" +#include "include/org_forstdb_AbstractTraceWriter.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/trace_writer_jnicallback.h" /* - * Class: org_rocksdb_AbstractTraceWriter + * Class: org_forstdb_AbstractTraceWriter * Method: createNewTraceWriter * Signature: ()J */ -jlong Java_org_rocksdb_AbstractTraceWriter_createNewTraceWriter(JNIEnv* env, +jlong Java_org_forstdb_AbstractTraceWriter_createNewTraceWriter(JNIEnv* env, jobject jobj) { auto* trace_writer = new ROCKSDB_NAMESPACE::TraceWriterJniCallback(env, jobj); return GET_CPLUSPLUS_POINTER(trace_writer); diff --git a/java/rocksjni/trace_writer_jnicallback.cc b/java/forstjni/trace_writer_jnicallback.cc similarity index 97% rename from java/rocksjni/trace_writer_jnicallback.cc rename to java/forstjni/trace_writer_jnicallback.cc index d1ed32038..88934f269 100644 --- a/java/rocksjni/trace_writer_jnicallback.cc +++ b/java/forstjni/trace_writer_jnicallback.cc @@ -6,9 +6,9 @@ // This file implements the callback "bridge" between Java and C++ for // ROCKSDB_NAMESPACE::TraceWriter. -#include "rocksjni/trace_writer_jnicallback.h" +#include "forstjni/trace_writer_jnicallback.h" -#include "rocksjni/portal.h" +#include "forstjni/portal.h" namespace ROCKSDB_NAMESPACE { TraceWriterJniCallback::TraceWriterJniCallback(JNIEnv* env, diff --git a/java/rocksjni/trace_writer_jnicallback.h b/java/forstjni/trace_writer_jnicallback.h similarity index 96% rename from java/rocksjni/trace_writer_jnicallback.h rename to java/forstjni/trace_writer_jnicallback.h index c82a3a72c..bb9ee895d 100644 --- a/java/rocksjni/trace_writer_jnicallback.h +++ b/java/forstjni/trace_writer_jnicallback.h @@ -14,7 +14,7 @@ #include #include "rocksdb/trace_reader_writer.h" -#include "rocksjni/jnicallback.h" +#include "forstjni/jnicallback.h" namespace ROCKSDB_NAMESPACE { diff --git a/java/rocksjni/transaction.cc b/java/forstjni/transaction.cc similarity index 88% rename from java/rocksjni/transaction.cc rename to java/forstjni/transaction.cc index 3e90db8bc..5212d2ad8 100644 --- a/java/rocksjni/transaction.cc +++ b/java/forstjni/transaction.cc @@ -12,10 +12,10 @@ #include -#include "include/org_rocksdb_Transaction.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/kv_helper.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_Transaction.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/kv_helper.h" +#include "forstjni/portal.h" #if defined(_MSC_VER) #pragma warning(push) @@ -24,33 +24,33 @@ #endif /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: setSnapshot * Signature: (J)V */ -void Java_org_rocksdb_Transaction_setSnapshot(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_Transaction_setSnapshot(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); txn->SetSnapshot(); } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: setSnapshotOnNextOperation * Signature: (J)V */ -void Java_org_rocksdb_Transaction_setSnapshotOnNextOperation__J( +void Java_org_forstdb_Transaction_setSnapshotOnNextOperation__J( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); txn->SetSnapshotOnNextOperation(nullptr); } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: setSnapshotOnNextOperation * Signature: (JJ)V */ -void Java_org_rocksdb_Transaction_setSnapshotOnNextOperation__JJ( +void Java_org_forstdb_Transaction_setSnapshotOnNextOperation__JJ( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jtxn_notifier_handle) { auto* txn = reinterpret_cast(jhandle); @@ -61,11 +61,11 @@ void Java_org_rocksdb_Transaction_setSnapshotOnNextOperation__JJ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getSnapshot * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getSnapshot(JNIEnv* /*env*/, +jlong Java_org_forstdb_Transaction_getSnapshot(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -74,11 +74,11 @@ jlong Java_org_rocksdb_Transaction_getSnapshot(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: clearSnapshot * Signature: (J)V */ -void Java_org_rocksdb_Transaction_clearSnapshot(JNIEnv* /*env*/, +void Java_org_forstdb_Transaction_clearSnapshot(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -86,11 +86,11 @@ void Java_org_rocksdb_Transaction_clearSnapshot(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: prepare * Signature: (J)V */ -void Java_org_rocksdb_Transaction_prepare(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_Transaction_prepare(JNIEnv* env, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); ROCKSDB_NAMESPACE::Status s = txn->Prepare(); @@ -100,11 +100,11 @@ void Java_org_rocksdb_Transaction_prepare(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: commit * Signature: (J)V */ -void Java_org_rocksdb_Transaction_commit(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_Transaction_commit(JNIEnv* env, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); ROCKSDB_NAMESPACE::Status s = txn->Commit(); @@ -114,11 +114,11 @@ void Java_org_rocksdb_Transaction_commit(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: rollback * Signature: (J)V */ -void Java_org_rocksdb_Transaction_rollback(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_Transaction_rollback(JNIEnv* env, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); ROCKSDB_NAMESPACE::Status s = txn->Rollback(); @@ -128,11 +128,11 @@ void Java_org_rocksdb_Transaction_rollback(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: setSavePoint * Signature: (J)V */ -void Java_org_rocksdb_Transaction_setSavePoint(JNIEnv* /*env*/, +void Java_org_forstdb_Transaction_setSavePoint(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -140,11 +140,11 @@ void Java_org_rocksdb_Transaction_setSavePoint(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: rollbackToSavePoint * Signature: (J)V */ -void Java_org_rocksdb_Transaction_rollbackToSavePoint(JNIEnv* env, +void Java_org_forstdb_Transaction_rollbackToSavePoint(JNIEnv* env, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -160,11 +160,11 @@ typedef std::function(jhandle); @@ -209,11 +209,11 @@ jbyteArray Java_org_rocksdb_Transaction_get__JJ_3BII( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: get * Signature: (JJ[BII[BIIJ)I */ -jint Java_org_rocksdb_Transaction_get__JJ_3BII_3BIIJ( +jint Java_org_forstdb_Transaction_get__JJ_3BII_3BIIJ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jlong jread_options_handle, jbyteArray jkey, jint jkey_off, jint jkey_part_len, jbyteArray jval, jint jval_off, jint jval_part_len, jlong jcolumn_family_handle) { @@ -237,11 +237,11 @@ jint Java_org_rocksdb_Transaction_get__JJ_3BII_3BIIJ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getDirect * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)I */ -jint Java_org_rocksdb_Transaction_getDirect(JNIEnv* env, jobject, jlong jhandle, +jint Java_org_forstdb_Transaction_getDirect(JNIEnv* env, jobject, jlong jhandle, jlong jread_options_handle, jobject jkey_bb, jint jkey_off, jint jkey_part_len, jobject jval_bb, @@ -268,7 +268,7 @@ jint Java_org_rocksdb_Transaction_getDirect(JNIEnv* env, jobject, jlong jhandle, } } -// TODO(AR) consider refactoring to share this between here and rocksjni.cc +// TODO(AR) consider refactoring to share this between here and forstjni.cc // used by txn_multi_get_helper below std::vector txn_column_families_helper( JNIEnv* env, jlongArray jcolumn_family_handles, bool* has_exception) { @@ -317,7 +317,7 @@ void free_key_values(std::vector& keys_to_free) { } } -// TODO(AR) consider refactoring to share this between here and rocksjni.cc +// TODO(AR) consider refactoring to share this between here and forstjni.cc // cf multi get jobjectArray txn_multi_get_helper(JNIEnv* env, const FnMultiGet& fn_multi_get, const jlong& jread_options_handle, @@ -403,11 +403,11 @@ jobjectArray txn_multi_get_helper(JNIEnv* env, const FnMultiGet& fn_multi_get, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: multiGet * Signature: (JJ[[B[J)[[B */ -jobjectArray Java_org_rocksdb_Transaction_multiGet__JJ_3_3B_3J( +jobjectArray Java_org_forstdb_Transaction_multiGet__JJ_3_3B_3J( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jlong jread_options_handle, jobjectArray jkey_parts, jlongArray jcolumn_family_handles) { bool has_exception = false; @@ -431,11 +431,11 @@ jobjectArray Java_org_rocksdb_Transaction_multiGet__JJ_3_3B_3J( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: multiGet * Signature: (JJ[[B)[[B */ -jobjectArray Java_org_rocksdb_Transaction_multiGet__JJ_3_3B( +jobjectArray Java_org_forstdb_Transaction_multiGet__JJ_3_3B( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jlong jread_options_handle, jobjectArray jkey_parts) { auto* txn = reinterpret_cast(jhandle); @@ -450,11 +450,11 @@ jobjectArray Java_org_rocksdb_Transaction_multiGet__JJ_3_3B( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getForUpdate * Signature: (JJ[BIIJZZ)[B */ -jbyteArray Java_org_rocksdb_Transaction_getForUpdate__JJ_3BIIJZZ( +jbyteArray Java_org_forstdb_Transaction_getForUpdate__JJ_3BIIJZZ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jlong jread_options_handle, jbyteArray jkey, jint jkey_off, jint jkey_part_len, jlong jcolumn_family_handle, jboolean jexclusive, jboolean jdo_validate) { @@ -478,11 +478,11 @@ jbyteArray Java_org_rocksdb_Transaction_getForUpdate__JJ_3BIIJZZ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getForUpdate * Signature: (JJ[BII[BIIJZZ)I */ -jint Java_org_rocksdb_Transaction_getForUpdate__JJ_3BII_3BIIJZZ( +jint Java_org_forstdb_Transaction_getForUpdate__JJ_3BII_3BIIJZZ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jlong jread_options_handle, jbyteArray jkey, jint jkey_off, jint jkey_part_len, jbyteArray jval, jint jval_off, jint jval_len, jlong jcolumn_family_handle, @@ -508,11 +508,11 @@ jint Java_org_rocksdb_Transaction_getForUpdate__JJ_3BII_3BIIJZZ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getDirectForUpdate * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJZZ)I */ -jint Java_org_rocksdb_Transaction_getDirectForUpdate( +jint Java_org_forstdb_Transaction_getDirectForUpdate( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jlong jread_options_handle, jobject jkey_bb, jint jkey_off, jint jkey_part_len, jobject jval_bb, jint jval_off, jint jval_len, jlong jcolumn_family_handle, @@ -540,11 +540,11 @@ jint Java_org_rocksdb_Transaction_getDirectForUpdate( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: multiGetForUpdate * Signature: (JJ[[B[J)[[B */ -jobjectArray Java_org_rocksdb_Transaction_multiGetForUpdate__JJ_3_3B_3J( +jobjectArray Java_org_forstdb_Transaction_multiGetForUpdate__JJ_3_3B_3J( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jlong jread_options_handle, jobjectArray jkey_parts, jlongArray jcolumn_family_handles) { bool has_exception = false; @@ -569,11 +569,11 @@ jobjectArray Java_org_rocksdb_Transaction_multiGetForUpdate__JJ_3_3B_3J( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: multiGetForUpdate * Signature: (JJ[[B)[[B */ -jobjectArray Java_org_rocksdb_Transaction_multiGetForUpdate__JJ_3_3B( +jobjectArray Java_org_forstdb_Transaction_multiGetForUpdate__JJ_3_3B( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jlong jread_options_handle, jobjectArray jkey_parts) { auto* txn = reinterpret_cast(jhandle); @@ -588,11 +588,11 @@ jobjectArray Java_org_rocksdb_Transaction_multiGetForUpdate__JJ_3_3B( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getIterator * Signature: (JJJ)J */ -jlong Java_org_rocksdb_Transaction_getIterator(JNIEnv* /*env*/, +jlong Java_org_forstdb_Transaction_getIterator(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jread_options_handle, jlong jcolumn_family_handle) { @@ -607,11 +607,11 @@ jlong Java_org_rocksdb_Transaction_getIterator(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: put * Signature: (J[BII[BIIJZ)V */ -void Java_org_rocksdb_Transaction_put__J_3BII_3BIIJZ( +void Java_org_forstdb_Transaction_put__J_3BII_3BIIJZ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_off, jint jkey_part_len, jbyteArray jval, jint jval_off, jint jval_len, jlong jcolumn_family_handle, jboolean jassume_tracked) { @@ -631,11 +631,11 @@ void Java_org_rocksdb_Transaction_put__J_3BII_3BIIJZ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: put * Signature: (J[BII[BII)V */ -void Java_org_rocksdb_Transaction_put__J_3BII_3BII( +void Java_org_forstdb_Transaction_put__J_3BII_3BII( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_off, jint jkey_part_len, jbyteArray jval, jint jval_off, jint jval_len) { @@ -651,11 +651,11 @@ void Java_org_rocksdb_Transaction_put__J_3BII_3BII( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: putDirect * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJZ)V */ -void Java_org_rocksdb_Transaction_putDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2IIJZ( +void Java_org_forstdb_Transaction_putDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2IIJZ( JNIEnv* env, jobject, jlong jhandle, jobject jkey_bb, jint jkey_off, jint jkey_len, jobject jval_bb, jint jval_off, jint jval_len, jlong jcolumn_family_handle, jboolean jassume_tracked) { @@ -676,11 +676,11 @@ void Java_org_rocksdb_Transaction_putDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: putDirect * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)V */ -void Java_org_rocksdb_Transaction_putDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2II( +void Java_org_forstdb_Transaction_putDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2II( JNIEnv* env, jobject, jlong jhandle, jobject jkey_bb, jint jkey_off, jint jkey_len, jobject jval_bb, jint jval_off, jint jval_len) { auto* txn = reinterpret_cast(jhandle); @@ -699,7 +699,7 @@ typedef std::function FnWriteKVParts; -// TODO(AR) consider refactoring to share this between here and rocksjni.cc +// TODO(AR) consider refactoring to share this between here and forstjni.cc void txn_write_kv_parts_helper(JNIEnv* env, const FnWriteKVParts& fn_write_kv_parts, const jobjectArray& jkey_parts, @@ -799,11 +799,11 @@ void txn_write_kv_parts_helper(JNIEnv* env, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: put * Signature: (J[[BI[[BIJZ)V */ -void Java_org_rocksdb_Transaction_put__J_3_3BI_3_3BIJZ( +void Java_org_forstdb_Transaction_put__J_3_3BI_3_3BIJZ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jobjectArray jkey_parts, jint jkey_parts_len, jobjectArray jvalue_parts, jint jvalue_parts_len, jlong jcolumn_family_handle, jboolean jassume_tracked) { @@ -823,11 +823,11 @@ void Java_org_rocksdb_Transaction_put__J_3_3BI_3_3BIJZ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: put * Signature: (J[[BI[[BI)V */ -void Java_org_rocksdb_Transaction_put__J_3_3BI_3_3BI( +void Java_org_forstdb_Transaction_put__J_3_3BI_3_3BI( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jobjectArray jkey_parts, jint jkey_parts_len, jobjectArray jvalue_parts, jint jvalue_parts_len) { auto* txn = reinterpret_cast(jhandle); @@ -841,11 +841,11 @@ void Java_org_rocksdb_Transaction_put__J_3_3BI_3_3BI( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: merge * Signature: (J[BII[BIIJZ)V */ -void Java_org_rocksdb_Transaction_merge__J_3BII_3BIIJZ( +void Java_org_forstdb_Transaction_merge__J_3BII_3BIIJZ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_off, jint jkey_part_len, jbyteArray jval, jint jval_off, jint jval_len, jlong jcolumn_family_handle, jboolean jassume_tracked) { @@ -865,11 +865,11 @@ void Java_org_rocksdb_Transaction_merge__J_3BII_3BIIJZ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: merge * Signature: (J[BII[BII)V */ -void Java_org_rocksdb_Transaction_merge__J_3BII_3BII( +void Java_org_forstdb_Transaction_merge__J_3BII_3BII( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_off, jint jkey_part_len, jbyteArray jval, jint jval_off, jint jval_len) { @@ -885,12 +885,12 @@ void Java_org_rocksdb_Transaction_merge__J_3BII_3BII( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: mergeDirect * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJZ)V */ JNIEXPORT void JNICALL -Java_org_rocksdb_Transaction_mergeDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2IIJZ( +Java_org_forstdb_Transaction_mergeDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2IIJZ( JNIEnv* env, jobject, jlong jhandle, jobject jkey_bb, jint jkey_off, jint jkey_len, jobject jval_bb, jint jval_off, jint jval_len, jlong jcolumn_family_handle, jboolean jassume_tracked) { @@ -911,12 +911,12 @@ Java_org_rocksdb_Transaction_mergeDirect__JLjava_nio_ByteBuffer_2IILjava_nio_Byt } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: mergeDirect * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)V */ JNIEXPORT void JNICALL -Java_org_rocksdb_Transaction_mergeDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2II( +Java_org_forstdb_Transaction_mergeDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2II( JNIEnv* env, jobject, jlong jhandle, jobject jkey_bb, jint jkey_off, jint jkey_len, jobject jval_bb, jint jval_off, jint jval_len) { auto* txn = reinterpret_cast(jhandle); @@ -935,7 +935,7 @@ typedef std::function FnWriteK; -// TODO(AR) consider refactoring to share this between here and rocksjni.cc +// TODO(AR) consider refactoring to share this between here and forstjni.cc void txn_write_k_helper(JNIEnv* env, const FnWriteK& fn_write_k, const jbyteArray& jkey, const jint& jkey_part_len) { jbyte* key = env->GetByteArrayElements(jkey, nullptr); @@ -960,11 +960,11 @@ void txn_write_k_helper(JNIEnv* env, const FnWriteK& fn_write_k, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: delete * Signature: (J[BIJZ)V */ -void Java_org_rocksdb_Transaction_delete__J_3BIJZ( +void Java_org_forstdb_Transaction_delete__J_3BIJZ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_part_len, jlong jcolumn_family_handle, jboolean jassume_tracked) { auto* txn = reinterpret_cast(jhandle); @@ -981,11 +981,11 @@ void Java_org_rocksdb_Transaction_delete__J_3BIJZ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: delete * Signature: (J[BI)V */ -void Java_org_rocksdb_Transaction_delete__J_3BI(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_Transaction_delete__J_3BI(JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_part_len) { auto* txn = reinterpret_cast(jhandle); @@ -999,7 +999,7 @@ typedef std::function FnWriteKParts; -// TODO(AR) consider refactoring to share this between here and rocksjni.cc +// TODO(AR) consider refactoring to share this between here and forstjni.cc void txn_write_k_parts_helper(JNIEnv* env, const FnWriteKParts& fn_write_k_parts, const jobjectArray& jkey_parts, @@ -1048,11 +1048,11 @@ void txn_write_k_parts_helper(JNIEnv* env, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: delete * Signature: (J[[BIJZ)V */ -void Java_org_rocksdb_Transaction_delete__J_3_3BIJZ( +void Java_org_forstdb_Transaction_delete__J_3_3BIJZ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jobjectArray jkey_parts, jint jkey_parts_len, jlong jcolumn_family_handle, jboolean jassume_tracked) { @@ -1070,11 +1070,11 @@ void Java_org_rocksdb_Transaction_delete__J_3_3BIJZ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: delete * Signature: (J[[BI)V */ -void Java_org_rocksdb_Transaction_delete__J_3_3BI(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_Transaction_delete__J_3_3BI(JNIEnv* env, jobject /*jobj*/, jlong jhandle, jobjectArray jkey_parts, jint jkey_parts_len) { @@ -1086,11 +1086,11 @@ void Java_org_rocksdb_Transaction_delete__J_3_3BI(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: singleDelete * Signature: (J[BIJZ)V */ -void Java_org_rocksdb_Transaction_singleDelete__J_3BIJZ( +void Java_org_forstdb_Transaction_singleDelete__J_3BIJZ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_part_len, jlong jcolumn_family_handle, jboolean jassume_tracked) { auto* txn = reinterpret_cast(jhandle); @@ -1107,11 +1107,11 @@ void Java_org_rocksdb_Transaction_singleDelete__J_3BIJZ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: singleDelete * Signature: (J[BI)V */ -void Java_org_rocksdb_Transaction_singleDelete__J_3BI(JNIEnv* env, +void Java_org_forstdb_Transaction_singleDelete__J_3BI(JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, @@ -1125,11 +1125,11 @@ void Java_org_rocksdb_Transaction_singleDelete__J_3BI(JNIEnv* env, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: singleDelete * Signature: (J[[BIJZ)V */ -void Java_org_rocksdb_Transaction_singleDelete__J_3_3BIJZ( +void Java_org_forstdb_Transaction_singleDelete__J_3_3BIJZ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jobjectArray jkey_parts, jint jkey_parts_len, jlong jcolumn_family_handle, jboolean jassume_tracked) { @@ -1148,11 +1148,11 @@ void Java_org_rocksdb_Transaction_singleDelete__J_3_3BIJZ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: singleDelete * Signature: (J[[BI)V */ -void Java_org_rocksdb_Transaction_singleDelete__J_3_3BI(JNIEnv* env, +void Java_org_forstdb_Transaction_singleDelete__J_3_3BI(JNIEnv* env, jobject /*jobj*/, jlong jhandle, jobjectArray jkey_parts, @@ -1167,11 +1167,11 @@ void Java_org_rocksdb_Transaction_singleDelete__J_3_3BI(JNIEnv* env, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: putUntracked * Signature: (J[BI[BIJ)V */ -void Java_org_rocksdb_Transaction_putUntracked__J_3BI_3BIJ( +void Java_org_forstdb_Transaction_putUntracked__J_3BI_3BIJ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_part_len, jbyteArray jval, jint jval_len, jlong jcolumn_family_handle) { @@ -1191,11 +1191,11 @@ void Java_org_rocksdb_Transaction_putUntracked__J_3BI_3BIJ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: putUntracked * Signature: (J[BI[BI)V */ -void Java_org_rocksdb_Transaction_putUntracked__J_3BI_3BI( +void Java_org_forstdb_Transaction_putUntracked__J_3BI_3BI( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_part_len, jbyteArray jval, jint jval_len) { auto* txn = reinterpret_cast(jhandle); @@ -1210,11 +1210,11 @@ void Java_org_rocksdb_Transaction_putUntracked__J_3BI_3BI( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: putUntracked * Signature: (J[[BI[[BIJ)V */ -void Java_org_rocksdb_Transaction_putUntracked__J_3_3BI_3_3BIJ( +void Java_org_forstdb_Transaction_putUntracked__J_3_3BI_3_3BIJ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jobjectArray jkey_parts, jint jkey_parts_len, jobjectArray jvalue_parts, jint jvalue_parts_len, jlong jcolumn_family_handle) { @@ -1233,11 +1233,11 @@ void Java_org_rocksdb_Transaction_putUntracked__J_3_3BI_3_3BIJ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: putUntracked * Signature: (J[[BI[[BI)V */ -void Java_org_rocksdb_Transaction_putUntracked__J_3_3BI_3_3BI( +void Java_org_forstdb_Transaction_putUntracked__J_3_3BI_3_3BI( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jobjectArray jkey_parts, jint jkey_parts_len, jobjectArray jvalue_parts, jint jvalue_parts_len) { auto* txn = reinterpret_cast(jhandle); @@ -1251,11 +1251,11 @@ void Java_org_rocksdb_Transaction_putUntracked__J_3_3BI_3_3BI( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: mergeUntracked * Signature: (J[BII[BIIJ)V */ -void Java_org_rocksdb_Transaction_mergeUntracked( +void Java_org_forstdb_Transaction_mergeUntracked( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_off, jint jkey_part_len, jbyteArray jval, jint jval_off, jint jval_len, jlong jcolumn_family_handle) { @@ -1275,11 +1275,11 @@ void Java_org_rocksdb_Transaction_mergeUntracked( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: mergeUntrackedDirect * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V */ -void Java_org_rocksdb_Transaction_mergeUntrackedDirect( +void Java_org_forstdb_Transaction_mergeUntrackedDirect( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jobject jkey, jint jkey_off, jint jkey_part_len, jobject jval, jint jval_off, jint jval_len, jlong jcolumn_family_handle) { @@ -1300,11 +1300,11 @@ void Java_org_rocksdb_Transaction_mergeUntrackedDirect( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: deleteUntracked * Signature: (J[BIJ)V */ -void Java_org_rocksdb_Transaction_deleteUntracked__J_3BIJ( +void Java_org_forstdb_Transaction_deleteUntracked__J_3BIJ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_part_len, jlong jcolumn_family_handle) { auto* txn = reinterpret_cast(jhandle); @@ -1320,11 +1320,11 @@ void Java_org_rocksdb_Transaction_deleteUntracked__J_3BIJ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: deleteUntracked * Signature: (J[BI)V */ -void Java_org_rocksdb_Transaction_deleteUntracked__J_3BI(JNIEnv* env, +void Java_org_forstdb_Transaction_deleteUntracked__J_3BI(JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, @@ -1338,11 +1338,11 @@ void Java_org_rocksdb_Transaction_deleteUntracked__J_3BI(JNIEnv* env, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: deleteUntracked * Signature: (J[[BIJ)V */ -void Java_org_rocksdb_Transaction_deleteUntracked__J_3_3BIJ( +void Java_org_forstdb_Transaction_deleteUntracked__J_3_3BIJ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jobjectArray jkey_parts, jint jkey_parts_len, jlong jcolumn_family_handle) { auto* txn = reinterpret_cast(jhandle); @@ -1360,11 +1360,11 @@ void Java_org_rocksdb_Transaction_deleteUntracked__J_3_3BIJ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: deleteUntracked * Signature: (J[[BI)V */ -void Java_org_rocksdb_Transaction_deleteUntracked__J_3_3BI( +void Java_org_forstdb_Transaction_deleteUntracked__J_3_3BI( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jobjectArray jkey_parts, jint jkey_parts_len) { auto* txn = reinterpret_cast(jhandle); @@ -1378,11 +1378,11 @@ void Java_org_rocksdb_Transaction_deleteUntracked__J_3_3BI( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: putLogData * Signature: (J[BI)V */ -void Java_org_rocksdb_Transaction_putLogData(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_Transaction_putLogData(JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_part_len) { auto* txn = reinterpret_cast(jhandle); @@ -1404,11 +1404,11 @@ void Java_org_rocksdb_Transaction_putLogData(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: disableIndexing * Signature: (J)V */ -void Java_org_rocksdb_Transaction_disableIndexing(JNIEnv* /*env*/, +void Java_org_forstdb_Transaction_disableIndexing(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -1416,11 +1416,11 @@ void Java_org_rocksdb_Transaction_disableIndexing(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: enableIndexing * Signature: (J)V */ -void Java_org_rocksdb_Transaction_enableIndexing(JNIEnv* /*env*/, +void Java_org_forstdb_Transaction_enableIndexing(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -1428,33 +1428,33 @@ void Java_org_rocksdb_Transaction_enableIndexing(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getNumKeys * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getNumKeys(JNIEnv* /*env*/, jobject /*jobj*/, +jlong Java_org_forstdb_Transaction_getNumKeys(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); return txn->GetNumKeys(); } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getNumPuts * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getNumPuts(JNIEnv* /*env*/, jobject /*jobj*/, +jlong Java_org_forstdb_Transaction_getNumPuts(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); return txn->GetNumPuts(); } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getNumDeletes * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getNumDeletes(JNIEnv* /*env*/, +jlong Java_org_forstdb_Transaction_getNumDeletes(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -1462,11 +1462,11 @@ jlong Java_org_rocksdb_Transaction_getNumDeletes(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getNumMerges * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getNumMerges(JNIEnv* /*env*/, +jlong Java_org_forstdb_Transaction_getNumMerges(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -1474,11 +1474,11 @@ jlong Java_org_rocksdb_Transaction_getNumMerges(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getElapsedTime * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getElapsedTime(JNIEnv* /*env*/, +jlong Java_org_forstdb_Transaction_getElapsedTime(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -1486,11 +1486,11 @@ jlong Java_org_rocksdb_Transaction_getElapsedTime(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getWriteBatch * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getWriteBatch(JNIEnv* /*env*/, +jlong Java_org_forstdb_Transaction_getWriteBatch(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -1498,11 +1498,11 @@ jlong Java_org_rocksdb_Transaction_getWriteBatch(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: setLockTimeout * Signature: (JJ)V */ -void Java_org_rocksdb_Transaction_setLockTimeout(JNIEnv* /*env*/, +void Java_org_forstdb_Transaction_setLockTimeout(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jlock_timeout) { @@ -1511,11 +1511,11 @@ void Java_org_rocksdb_Transaction_setLockTimeout(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getWriteOptions * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getWriteOptions(JNIEnv* /*env*/, +jlong Java_org_forstdb_Transaction_getWriteOptions(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -1523,11 +1523,11 @@ jlong Java_org_rocksdb_Transaction_getWriteOptions(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: setWriteOptions * Signature: (JJ)V */ -void Java_org_rocksdb_Transaction_setWriteOptions(JNIEnv* /*env*/, +void Java_org_forstdb_Transaction_setWriteOptions(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jwrite_options_handle) { @@ -1538,11 +1538,11 @@ void Java_org_rocksdb_Transaction_setWriteOptions(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: undo * Signature: (J[BIJ)V */ -void Java_org_rocksdb_Transaction_undoGetForUpdate__J_3BIJ( +void Java_org_forstdb_Transaction_undoGetForUpdate__J_3BIJ( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, jint jkey_part_len, jlong jcolumn_family_handle) { auto* txn = reinterpret_cast(jhandle); @@ -1563,11 +1563,11 @@ void Java_org_rocksdb_Transaction_undoGetForUpdate__J_3BIJ( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: undoGetForUpdate * Signature: (J[BI)V */ -void Java_org_rocksdb_Transaction_undoGetForUpdate__J_3BI(JNIEnv* env, +void Java_org_forstdb_Transaction_undoGetForUpdate__J_3BI(JNIEnv* env, jobject /*jobj*/, jlong jhandle, jbyteArray jkey, @@ -1587,11 +1587,11 @@ void Java_org_rocksdb_Transaction_undoGetForUpdate__J_3BI(JNIEnv* env, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: rebuildFromWriteBatch * Signature: (JJ)V */ -void Java_org_rocksdb_Transaction_rebuildFromWriteBatch( +void Java_org_forstdb_Transaction_rebuildFromWriteBatch( JNIEnv* env, jobject /*jobj*/, jlong jhandle, jlong jwrite_batch_handle) { auto* txn = reinterpret_cast(jhandle); auto* write_batch = @@ -1603,11 +1603,11 @@ void Java_org_rocksdb_Transaction_rebuildFromWriteBatch( } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getCommitTimeWriteBatch * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getCommitTimeWriteBatch(JNIEnv* /*env*/, +jlong Java_org_forstdb_Transaction_getCommitTimeWriteBatch(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -1615,11 +1615,11 @@ jlong Java_org_rocksdb_Transaction_getCommitTimeWriteBatch(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: setLogNumber * Signature: (JJ)V */ -void Java_org_rocksdb_Transaction_setLogNumber(JNIEnv* /*env*/, +void Java_org_forstdb_Transaction_setLogNumber(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jlog_number) { auto* txn = reinterpret_cast(jhandle); @@ -1627,11 +1627,11 @@ void Java_org_rocksdb_Transaction_setLogNumber(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getLogNumber * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getLogNumber(JNIEnv* /*env*/, +jlong Java_org_forstdb_Transaction_getLogNumber(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -1639,11 +1639,11 @@ jlong Java_org_rocksdb_Transaction_getLogNumber(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: setName * Signature: (JLjava/lang/String;)V */ -void Java_org_rocksdb_Transaction_setName(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_Transaction_setName(JNIEnv* env, jobject /*jobj*/, jlong jhandle, jstring jname) { auto* txn = reinterpret_cast(jhandle); const char* name = env->GetStringUTFChars(jname, nullptr); @@ -1662,11 +1662,11 @@ void Java_org_rocksdb_Transaction_setName(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getName * Signature: (J)Ljava/lang/String; */ -jstring Java_org_rocksdb_Transaction_getName(JNIEnv* env, jobject /*jobj*/, +jstring Java_org_forstdb_Transaction_getName(JNIEnv* env, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); ROCKSDB_NAMESPACE::TransactionName name = txn->GetName(); @@ -1674,11 +1674,11 @@ jstring Java_org_rocksdb_Transaction_getName(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getID * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getID(JNIEnv* /*env*/, jobject /*jobj*/, +jlong Java_org_forstdb_Transaction_getID(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); ROCKSDB_NAMESPACE::TransactionID id = txn->GetID(); @@ -1686,11 +1686,11 @@ jlong Java_org_rocksdb_Transaction_getID(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: isDeadlockDetect * Signature: (J)Z */ -jboolean Java_org_rocksdb_Transaction_isDeadlockDetect(JNIEnv* /*env*/, +jboolean Java_org_forstdb_Transaction_isDeadlockDetect(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -1698,11 +1698,11 @@ jboolean Java_org_rocksdb_Transaction_isDeadlockDetect(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getWaitingTxns * Signature: (J)Lorg/rocksdb/Transaction/WaitingTransactions; */ -jobject Java_org_rocksdb_Transaction_getWaitingTxns(JNIEnv* env, +jobject Java_org_forstdb_Transaction_getWaitingTxns(JNIEnv* env, jobject jtransaction_obj, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); @@ -1717,11 +1717,11 @@ jobject Java_org_rocksdb_Transaction_getWaitingTxns(JNIEnv* env, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getState * Signature: (J)B */ -jbyte Java_org_rocksdb_Transaction_getState(JNIEnv* /*env*/, jobject /*jobj*/, +jbyte Java_org_forstdb_Transaction_getState(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); ROCKSDB_NAMESPACE::Transaction::TransactionState txn_status = txn->GetState(); @@ -1756,11 +1756,11 @@ jbyte Java_org_rocksdb_Transaction_getState(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: getId * Signature: (J)J */ -jlong Java_org_rocksdb_Transaction_getId(JNIEnv* /*env*/, jobject /*jobj*/, +jlong Java_org_forstdb_Transaction_getId(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* txn = reinterpret_cast(jhandle); uint64_t id = txn->GetId(); @@ -1768,11 +1768,11 @@ jlong Java_org_rocksdb_Transaction_getId(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_Transaction + * Class: org_forstdb_Transaction * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_Transaction_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_Transaction_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { delete reinterpret_cast(jhandle); diff --git a/java/rocksjni/transaction_db.cc b/java/forstjni/transaction_db.cc similarity index 91% rename from java/rocksjni/transaction_db.cc rename to java/forstjni/transaction_db.cc index 0adf85606..0d8ae20c6 100644 --- a/java/rocksjni/transaction_db.cc +++ b/java/forstjni/transaction_db.cc @@ -14,18 +14,18 @@ #include #include -#include "include/org_rocksdb_TransactionDB.h" +#include "include/org_forstdb_TransactionDB.h" #include "rocksdb/options.h" #include "rocksdb/utilities/transaction.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: open * Signature: (JJLjava/lang/String;)J */ -jlong Java_org_rocksdb_TransactionDB_open__JJLjava_lang_String_2( +jlong Java_org_forstdb_TransactionDB_open__JJLjava_lang_String_2( JNIEnv* env, jclass, jlong joptions_handle, jlong jtxn_db_options_handle, jstring jdb_path) { auto* options = @@ -52,11 +52,11 @@ jlong Java_org_rocksdb_TransactionDB_open__JJLjava_lang_String_2( } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: open * Signature: (JJLjava/lang/String;[[B[J)[J */ -jlongArray Java_org_rocksdb_TransactionDB_open__JJLjava_lang_String_2_3_3B_3J( +jlongArray Java_org_forstdb_TransactionDB_open__JJLjava_lang_String_2_3_3B_3J( JNIEnv* env, jclass, jlong jdb_options_handle, jlong jtxn_db_options_handle, jstring jdb_path, jobjectArray jcolumn_names, jlongArray jcolumn_options_handles) { @@ -143,11 +143,11 @@ jlongArray Java_org_rocksdb_TransactionDB_open__JJLjava_lang_String_2_3_3B_3J( } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_TransactionDB_disposeInternal(JNIEnv*, jobject, +void Java_org_forstdb_TransactionDB_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* txn_db = reinterpret_cast(jhandle); assert(txn_db != nullptr); @@ -155,11 +155,11 @@ void Java_org_rocksdb_TransactionDB_disposeInternal(JNIEnv*, jobject, } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: closeDatabase * Signature: (J)V */ -void Java_org_rocksdb_TransactionDB_closeDatabase(JNIEnv* env, jclass, +void Java_org_forstdb_TransactionDB_closeDatabase(JNIEnv* env, jclass, jlong jhandle) { auto* txn_db = reinterpret_cast(jhandle); assert(txn_db != nullptr); @@ -168,11 +168,11 @@ void Java_org_rocksdb_TransactionDB_closeDatabase(JNIEnv* env, jclass, } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: beginTransaction * Signature: (JJ)J */ -jlong Java_org_rocksdb_TransactionDB_beginTransaction__JJ( +jlong Java_org_forstdb_TransactionDB_beginTransaction__JJ( JNIEnv*, jobject, jlong jhandle, jlong jwrite_options_handle) { auto* txn_db = reinterpret_cast(jhandle); auto* write_options = @@ -183,11 +183,11 @@ jlong Java_org_rocksdb_TransactionDB_beginTransaction__JJ( } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: beginTransaction * Signature: (JJJ)J */ -jlong Java_org_rocksdb_TransactionDB_beginTransaction__JJJ( +jlong Java_org_forstdb_TransactionDB_beginTransaction__JJJ( JNIEnv*, jobject, jlong jhandle, jlong jwrite_options_handle, jlong jtxn_options_handle) { auto* txn_db = reinterpret_cast(jhandle); @@ -201,11 +201,11 @@ jlong Java_org_rocksdb_TransactionDB_beginTransaction__JJJ( } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: beginTransaction_withOld * Signature: (JJJ)J */ -jlong Java_org_rocksdb_TransactionDB_beginTransaction_1withOld__JJJ( +jlong Java_org_forstdb_TransactionDB_beginTransaction_1withOld__JJJ( JNIEnv*, jobject, jlong jhandle, jlong jwrite_options_handle, jlong jold_txn_handle) { auto* txn_db = reinterpret_cast(jhandle); @@ -226,11 +226,11 @@ jlong Java_org_rocksdb_TransactionDB_beginTransaction_1withOld__JJJ( } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: beginTransaction_withOld * Signature: (JJJJ)J */ -jlong Java_org_rocksdb_TransactionDB_beginTransaction_1withOld__JJJJ( +jlong Java_org_forstdb_TransactionDB_beginTransaction_1withOld__JJJJ( JNIEnv*, jobject, jlong jhandle, jlong jwrite_options_handle, jlong jtxn_options_handle, jlong jold_txn_handle) { auto* txn_db = reinterpret_cast(jhandle); @@ -252,11 +252,11 @@ jlong Java_org_rocksdb_TransactionDB_beginTransaction_1withOld__JJJJ( } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: getTransactionByName * Signature: (JLjava/lang/String;)J */ -jlong Java_org_rocksdb_TransactionDB_getTransactionByName(JNIEnv* env, jobject, +jlong Java_org_forstdb_TransactionDB_getTransactionByName(JNIEnv* env, jobject, jlong jhandle, jstring jname) { auto* txn_db = reinterpret_cast(jhandle); @@ -271,11 +271,11 @@ jlong Java_org_rocksdb_TransactionDB_getTransactionByName(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: getAllPreparedTransactions * Signature: (J)[J */ -jlongArray Java_org_rocksdb_TransactionDB_getAllPreparedTransactions( +jlongArray Java_org_forstdb_TransactionDB_getAllPreparedTransactions( JNIEnv* env, jobject, jlong jhandle) { auto* txn_db = reinterpret_cast(jhandle); std::vector txns; @@ -306,11 +306,11 @@ jlongArray Java_org_rocksdb_TransactionDB_getAllPreparedTransactions( } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: getLockStatusData * Signature: (J)Ljava/util/Map; */ -jobject Java_org_rocksdb_TransactionDB_getLockStatusData(JNIEnv* env, jobject, +jobject Java_org_forstdb_TransactionDB_getLockStatusData(JNIEnv* env, jobject, jlong jhandle) { auto* txn_db = reinterpret_cast(jhandle); const std::unordered_multimap @@ -355,11 +355,11 @@ jobject Java_org_rocksdb_TransactionDB_getLockStatusData(JNIEnv* env, jobject, } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: getDeadlockInfoBuffer * Signature: (J)[Lorg/rocksdb/TransactionDB/DeadlockPath; */ -jobjectArray Java_org_rocksdb_TransactionDB_getDeadlockInfoBuffer( +jobjectArray Java_org_forstdb_TransactionDB_getDeadlockInfoBuffer( JNIEnv* env, jobject jobj, jlong jhandle) { auto* txn_db = reinterpret_cast(jhandle); const std::vector deadlock_info_buffer = @@ -440,11 +440,11 @@ jobjectArray Java_org_rocksdb_TransactionDB_getDeadlockInfoBuffer( } /* - * Class: org_rocksdb_TransactionDB + * Class: org_forstdb_TransactionDB * Method: setDeadlockInfoBufferSize * Signature: (JI)V */ -void Java_org_rocksdb_TransactionDB_setDeadlockInfoBufferSize( +void Java_org_forstdb_TransactionDB_setDeadlockInfoBufferSize( JNIEnv*, jobject, jlong jhandle, jint jdeadlock_info_buffer_size) { auto* txn_db = reinterpret_cast(jhandle); txn_db->SetDeadlockInfoBufferSize(jdeadlock_info_buffer_size); diff --git a/java/rocksjni/transaction_db_options.cc b/java/forstjni/transaction_db_options.cc similarity index 75% rename from java/rocksjni/transaction_db_options.cc rename to java/forstjni/transaction_db_options.cc index 4cf27121e..d908ad37d 100644 --- a/java/rocksjni/transaction_db_options.cc +++ b/java/forstjni/transaction_db_options.cc @@ -8,17 +8,17 @@ #include -#include "include/org_rocksdb_TransactionDBOptions.h" +#include "include/org_forstdb_TransactionDBOptions.h" #include "rocksdb/utilities/transaction_db.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: newTransactionDBOptions * Signature: ()J */ -jlong Java_org_rocksdb_TransactionDBOptions_newTransactionDBOptions( +jlong Java_org_forstdb_TransactionDBOptions_newTransactionDBOptions( JNIEnv* /*env*/, jclass /*jcls*/) { ROCKSDB_NAMESPACE::TransactionDBOptions* opts = new ROCKSDB_NAMESPACE::TransactionDBOptions(); @@ -26,11 +26,11 @@ jlong Java_org_rocksdb_TransactionDBOptions_newTransactionDBOptions( } /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: getMaxNumLocks * Signature: (J)J */ -jlong Java_org_rocksdb_TransactionDBOptions_getMaxNumLocks(JNIEnv* /*env*/, +jlong Java_org_forstdb_TransactionDBOptions_getMaxNumLocks(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = @@ -39,11 +39,11 @@ jlong Java_org_rocksdb_TransactionDBOptions_getMaxNumLocks(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: setMaxNumLocks * Signature: (JJ)V */ -void Java_org_rocksdb_TransactionDBOptions_setMaxNumLocks( +void Java_org_forstdb_TransactionDBOptions_setMaxNumLocks( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jmax_num_locks) { auto* opts = reinterpret_cast(jhandle); @@ -51,11 +51,11 @@ void Java_org_rocksdb_TransactionDBOptions_setMaxNumLocks( } /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: getNumStripes * Signature: (J)J */ -jlong Java_org_rocksdb_TransactionDBOptions_getNumStripes(JNIEnv* /*env*/, +jlong Java_org_forstdb_TransactionDBOptions_getNumStripes(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = @@ -64,11 +64,11 @@ jlong Java_org_rocksdb_TransactionDBOptions_getNumStripes(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: setNumStripes * Signature: (JJ)V */ -void Java_org_rocksdb_TransactionDBOptions_setNumStripes(JNIEnv* /*env*/, +void Java_org_forstdb_TransactionDBOptions_setNumStripes(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jnum_stripes) { @@ -78,11 +78,11 @@ void Java_org_rocksdb_TransactionDBOptions_setNumStripes(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: getTransactionLockTimeout * Signature: (J)J */ -jlong Java_org_rocksdb_TransactionDBOptions_getTransactionLockTimeout( +jlong Java_org_forstdb_TransactionDBOptions_getTransactionLockTimeout( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -90,11 +90,11 @@ jlong Java_org_rocksdb_TransactionDBOptions_getTransactionLockTimeout( } /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: setTransactionLockTimeout * Signature: (JJ)V */ -void Java_org_rocksdb_TransactionDBOptions_setTransactionLockTimeout( +void Java_org_forstdb_TransactionDBOptions_setTransactionLockTimeout( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jtransaction_lock_timeout) { auto* opts = @@ -103,11 +103,11 @@ void Java_org_rocksdb_TransactionDBOptions_setTransactionLockTimeout( } /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: getDefaultLockTimeout * Signature: (J)J */ -jlong Java_org_rocksdb_TransactionDBOptions_getDefaultLockTimeout( +jlong Java_org_forstdb_TransactionDBOptions_getDefaultLockTimeout( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -115,11 +115,11 @@ jlong Java_org_rocksdb_TransactionDBOptions_getDefaultLockTimeout( } /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: setDefaultLockTimeout * Signature: (JJ)V */ -void Java_org_rocksdb_TransactionDBOptions_setDefaultLockTimeout( +void Java_org_forstdb_TransactionDBOptions_setDefaultLockTimeout( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jdefault_lock_timeout) { auto* opts = @@ -128,11 +128,11 @@ void Java_org_rocksdb_TransactionDBOptions_setDefaultLockTimeout( } /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: getWritePolicy * Signature: (J)B */ -jbyte Java_org_rocksdb_TransactionDBOptions_getWritePolicy(JNIEnv* /*env*/, +jbyte Java_org_forstdb_TransactionDBOptions_getWritePolicy(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = @@ -142,11 +142,11 @@ jbyte Java_org_rocksdb_TransactionDBOptions_getWritePolicy(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: setWritePolicy * Signature: (JB)V */ -void Java_org_rocksdb_TransactionDBOptions_setWritePolicy(JNIEnv* /*env*/, +void Java_org_forstdb_TransactionDBOptions_setWritePolicy(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jbyte jwrite_policy) { @@ -158,11 +158,11 @@ void Java_org_rocksdb_TransactionDBOptions_setWritePolicy(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionDBOptions + * Class: org_forstdb_TransactionDBOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_TransactionDBOptions_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_TransactionDBOptions_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { delete reinterpret_cast(jhandle); diff --git a/java/rocksjni/transaction_log.cc b/java/forstjni/transaction_log.cc similarity index 77% rename from java/rocksjni/transaction_log.cc rename to java/forstjni/transaction_log.cc index 97c3bb301..8ddc64322 100644 --- a/java/rocksjni/transaction_log.cc +++ b/java/forstjni/transaction_log.cc @@ -12,26 +12,26 @@ #include #include -#include "include/org_rocksdb_TransactionLogIterator.h" -#include "rocksjni/portal.h" +#include "include/org_forstdb_TransactionLogIterator.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_TransactionLogIterator + * Class: org_forstdb_TransactionLogIterator * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_TransactionLogIterator_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_TransactionLogIterator_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { delete reinterpret_cast(handle); } /* - * Class: org_rocksdb_TransactionLogIterator + * Class: org_forstdb_TransactionLogIterator * Method: isValid * Signature: (J)Z */ -jboolean Java_org_rocksdb_TransactionLogIterator_isValid(JNIEnv* /*env*/, +jboolean Java_org_forstdb_TransactionLogIterator_isValid(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { return reinterpret_cast(handle) @@ -39,22 +39,22 @@ jboolean Java_org_rocksdb_TransactionLogIterator_isValid(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionLogIterator + * Class: org_forstdb_TransactionLogIterator * Method: next * Signature: (J)V */ -void Java_org_rocksdb_TransactionLogIterator_next(JNIEnv* /*env*/, +void Java_org_forstdb_TransactionLogIterator_next(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->Next(); } /* - * Class: org_rocksdb_TransactionLogIterator + * Class: org_forstdb_TransactionLogIterator * Method: status * Signature: (J)V */ -void Java_org_rocksdb_TransactionLogIterator_status(JNIEnv* env, +void Java_org_forstdb_TransactionLogIterator_status(JNIEnv* env, jobject /*jobj*/, jlong handle) { ROCKSDB_NAMESPACE::Status s = @@ -66,11 +66,11 @@ void Java_org_rocksdb_TransactionLogIterator_status(JNIEnv* env, } /* - * Class: org_rocksdb_TransactionLogIterator + * Class: org_forstdb_TransactionLogIterator * Method: getBatch * Signature: (J)Lorg/rocksdb/TransactionLogIterator$BatchResult */ -jobject Java_org_rocksdb_TransactionLogIterator_getBatch(JNIEnv* env, +jobject Java_org_forstdb_TransactionLogIterator_getBatch(JNIEnv* env, jobject /*jobj*/, jlong handle) { ROCKSDB_NAMESPACE::BatchResult batch_result = diff --git a/java/rocksjni/transaction_notifier.cc b/java/forstjni/transaction_notifier.cc similarity index 76% rename from java/rocksjni/transaction_notifier.cc rename to java/forstjni/transaction_notifier.cc index cefeb648a..1a556460c 100644 --- a/java/rocksjni/transaction_notifier.cc +++ b/java/forstjni/transaction_notifier.cc @@ -8,16 +8,16 @@ #include -#include "include/org_rocksdb_AbstractTransactionNotifier.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/transaction_notifier_jnicallback.h" +#include "include/org_forstdb_AbstractTransactionNotifier.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/transaction_notifier_jnicallback.h" /* - * Class: org_rocksdb_AbstractTransactionNotifier + * Class: org_forstdb_AbstractTransactionNotifier * Method: createNewTransactionNotifier * Signature: ()J */ -jlong Java_org_rocksdb_AbstractTransactionNotifier_createNewTransactionNotifier( +jlong Java_org_forstdb_AbstractTransactionNotifier_createNewTransactionNotifier( JNIEnv* env, jobject jobj) { auto* transaction_notifier = new ROCKSDB_NAMESPACE::TransactionNotifierJniCallback(env, jobj); @@ -28,11 +28,11 @@ jlong Java_org_rocksdb_AbstractTransactionNotifier_createNewTransactionNotifier( } /* - * Class: org_rocksdb_AbstractTransactionNotifier + * Class: org_forstdb_AbstractTransactionNotifier * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_AbstractTransactionNotifier_disposeInternal( +void Java_org_forstdb_AbstractTransactionNotifier_disposeInternal( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { // TODO(AR) refactor to use JniCallback::JniCallback // when https://github.com/facebook/rocksdb/pull/1241/ is merged diff --git a/java/rocksjni/transaction_notifier_jnicallback.cc b/java/forstjni/transaction_notifier_jnicallback.cc similarity index 90% rename from java/rocksjni/transaction_notifier_jnicallback.cc rename to java/forstjni/transaction_notifier_jnicallback.cc index 26761cabd..abd133e3b 100644 --- a/java/rocksjni/transaction_notifier_jnicallback.cc +++ b/java/forstjni/transaction_notifier_jnicallback.cc @@ -6,10 +6,10 @@ // This file implements the callback "bridge" between Java and C++ for // ROCKSDB_NAMESPACE::TransactionNotifier. -#include "rocksjni/transaction_notifier_jnicallback.h" +#include "forstjni/transaction_notifier_jnicallback.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" namespace ROCKSDB_NAMESPACE { diff --git a/java/rocksjni/transaction_notifier_jnicallback.h b/java/forstjni/transaction_notifier_jnicallback.h similarity index 97% rename from java/rocksjni/transaction_notifier_jnicallback.h rename to java/forstjni/transaction_notifier_jnicallback.h index 089a5ee4a..d31c7b22e 100644 --- a/java/rocksjni/transaction_notifier_jnicallback.h +++ b/java/forstjni/transaction_notifier_jnicallback.h @@ -12,7 +12,7 @@ #include #include "rocksdb/utilities/transaction.h" -#include "rocksjni/jnicallback.h" +#include "forstjni/jnicallback.h" namespace ROCKSDB_NAMESPACE { diff --git a/java/rocksjni/transaction_options.cc b/java/forstjni/transaction_options.cc similarity index 75% rename from java/rocksjni/transaction_options.cc rename to java/forstjni/transaction_options.cc index dcf363e14..8cf3339c9 100644 --- a/java/rocksjni/transaction_options.cc +++ b/java/forstjni/transaction_options.cc @@ -8,27 +8,27 @@ #include -#include "include/org_rocksdb_TransactionOptions.h" +#include "include/org_forstdb_TransactionOptions.h" #include "rocksdb/utilities/transaction_db.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: newTransactionOptions * Signature: ()J */ -jlong Java_org_rocksdb_TransactionOptions_newTransactionOptions( +jlong Java_org_forstdb_TransactionOptions_newTransactionOptions( JNIEnv* /*env*/, jclass /*jcls*/) { auto* opts = new ROCKSDB_NAMESPACE::TransactionOptions(); return GET_CPLUSPLUS_POINTER(opts); } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: isSetSnapshot * Signature: (J)Z */ -jboolean Java_org_rocksdb_TransactionOptions_isSetSnapshot(JNIEnv* /*env*/, +jboolean Java_org_forstdb_TransactionOptions_isSetSnapshot(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = @@ -37,11 +37,11 @@ jboolean Java_org_rocksdb_TransactionOptions_isSetSnapshot(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: setSetSnapshot * Signature: (JZ)V */ -void Java_org_rocksdb_TransactionOptions_setSetSnapshot( +void Java_org_forstdb_TransactionOptions_setSetSnapshot( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jboolean jset_snapshot) { auto* opts = reinterpret_cast(jhandle); @@ -49,11 +49,11 @@ void Java_org_rocksdb_TransactionOptions_setSetSnapshot( } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: isDeadlockDetect * Signature: (J)Z */ -jboolean Java_org_rocksdb_TransactionOptions_isDeadlockDetect(JNIEnv* /*env*/, +jboolean Java_org_forstdb_TransactionOptions_isDeadlockDetect(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = @@ -62,11 +62,11 @@ jboolean Java_org_rocksdb_TransactionOptions_isDeadlockDetect(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: setDeadlockDetect * Signature: (JZ)V */ -void Java_org_rocksdb_TransactionOptions_setDeadlockDetect( +void Java_org_forstdb_TransactionOptions_setDeadlockDetect( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jboolean jdeadlock_detect) { auto* opts = @@ -75,11 +75,11 @@ void Java_org_rocksdb_TransactionOptions_setDeadlockDetect( } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: getLockTimeout * Signature: (J)J */ -jlong Java_org_rocksdb_TransactionOptions_getLockTimeout(JNIEnv* /*env*/, +jlong Java_org_forstdb_TransactionOptions_getLockTimeout(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = @@ -88,11 +88,11 @@ jlong Java_org_rocksdb_TransactionOptions_getLockTimeout(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: setLockTimeout * Signature: (JJ)V */ -void Java_org_rocksdb_TransactionOptions_setLockTimeout(JNIEnv* /*env*/, +void Java_org_forstdb_TransactionOptions_setLockTimeout(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jlock_timeout) { @@ -102,11 +102,11 @@ void Java_org_rocksdb_TransactionOptions_setLockTimeout(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: getExpiration * Signature: (J)J */ -jlong Java_org_rocksdb_TransactionOptions_getExpiration(JNIEnv* /*env*/, +jlong Java_org_forstdb_TransactionOptions_getExpiration(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = @@ -115,11 +115,11 @@ jlong Java_org_rocksdb_TransactionOptions_getExpiration(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: setExpiration * Signature: (JJ)V */ -void Java_org_rocksdb_TransactionOptions_setExpiration(JNIEnv* /*env*/, +void Java_org_forstdb_TransactionOptions_setExpiration(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jexpiration) { @@ -129,11 +129,11 @@ void Java_org_rocksdb_TransactionOptions_setExpiration(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: getDeadlockDetectDepth * Signature: (J)J */ -jlong Java_org_rocksdb_TransactionOptions_getDeadlockDetectDepth( +jlong Java_org_forstdb_TransactionOptions_getDeadlockDetectDepth( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = reinterpret_cast(jhandle); @@ -141,11 +141,11 @@ jlong Java_org_rocksdb_TransactionOptions_getDeadlockDetectDepth( } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: setDeadlockDetectDepth * Signature: (JJ)V */ -void Java_org_rocksdb_TransactionOptions_setDeadlockDetectDepth( +void Java_org_forstdb_TransactionOptions_setDeadlockDetectDepth( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jdeadlock_detect_depth) { auto* opts = @@ -154,11 +154,11 @@ void Java_org_rocksdb_TransactionOptions_setDeadlockDetectDepth( } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: getMaxWriteBatchSize * Signature: (J)J */ -jlong Java_org_rocksdb_TransactionOptions_getMaxWriteBatchSize(JNIEnv* /*env*/, +jlong Java_org_forstdb_TransactionOptions_getMaxWriteBatchSize(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* opts = @@ -167,11 +167,11 @@ jlong Java_org_rocksdb_TransactionOptions_getMaxWriteBatchSize(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: setMaxWriteBatchSize * Signature: (JJ)V */ -void Java_org_rocksdb_TransactionOptions_setMaxWriteBatchSize( +void Java_org_forstdb_TransactionOptions_setMaxWriteBatchSize( JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jmax_write_batch_size) { auto* opts = @@ -180,11 +180,11 @@ void Java_org_rocksdb_TransactionOptions_setMaxWriteBatchSize( } /* - * Class: org_rocksdb_TransactionOptions + * Class: org_forstdb_TransactionOptions * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_TransactionOptions_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_TransactionOptions_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { delete reinterpret_cast(jhandle); diff --git a/java/rocksjni/ttl.cc b/java/forstjni/ttl.cc similarity index 91% rename from java/rocksjni/ttl.cc rename to java/forstjni/ttl.cc index 1fe2083d9..4621c245f 100644 --- a/java/rocksjni/ttl.cc +++ b/java/forstjni/ttl.cc @@ -15,17 +15,17 @@ #include #include -#include "include/org_rocksdb_TtlDB.h" +#include "include/org_forstdb_TtlDB.h" #include "rocksdb/utilities/db_ttl.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_TtlDB + * Class: org_forstdb_TtlDB * Method: open * Signature: (JLjava/lang/String;IZ)J */ -jlong Java_org_rocksdb_TtlDB_open(JNIEnv* env, jclass, jlong joptions_handle, +jlong Java_org_forstdb_TtlDB_open(JNIEnv* env, jclass, jlong joptions_handle, jstring jdb_path, jint jttl, jboolean jread_only) { const char* db_path = env->GetStringUTFChars(jdb_path, nullptr); @@ -51,11 +51,11 @@ jlong Java_org_rocksdb_TtlDB_open(JNIEnv* env, jclass, jlong joptions_handle, } /* - * Class: org_rocksdb_TtlDB + * Class: org_forstdb_TtlDB * Method: openCF * Signature: (JLjava/lang/String;[[B[J[IZ)[J */ -jlongArray Java_org_rocksdb_TtlDB_openCF(JNIEnv* env, jclass, jlong jopt_handle, +jlongArray Java_org_forstdb_TtlDB_openCF(JNIEnv* env, jclass, jlong jopt_handle, jstring jdb_path, jobjectArray jcolumn_names, jlongArray jcolumn_options, @@ -150,22 +150,22 @@ jlongArray Java_org_rocksdb_TtlDB_openCF(JNIEnv* env, jclass, jlong jopt_handle, } /* - * Class: org_rocksdb_TtlDB + * Class: org_forstdb_TtlDB * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_TtlDB_disposeInternal(JNIEnv*, jobject, jlong jhandle) { +void Java_org_forstdb_TtlDB_disposeInternal(JNIEnv*, jobject, jlong jhandle) { auto* ttl_db = reinterpret_cast(jhandle); assert(ttl_db != nullptr); delete ttl_db; } /* - * Class: org_rocksdb_TtlDB + * Class: org_forstdb_TtlDB * Method: closeDatabase * Signature: (J)V */ -void Java_org_rocksdb_TtlDB_closeDatabase(JNIEnv* /* env */, jclass, +void Java_org_forstdb_TtlDB_closeDatabase(JNIEnv* /* env */, jclass, jlong /* jhandle */) { // auto* ttl_db = reinterpret_cast(jhandle); // assert(ttl_db != nullptr); @@ -177,11 +177,11 @@ void Java_org_rocksdb_TtlDB_closeDatabase(JNIEnv* /* env */, jclass, } /* - * Class: org_rocksdb_TtlDB + * Class: org_forstdb_TtlDB * Method: createColumnFamilyWithTtl * Signature: (JLorg/rocksdb/ColumnFamilyDescriptor;[BJI)J; */ -jlong Java_org_rocksdb_TtlDB_createColumnFamilyWithTtl(JNIEnv* env, jobject, +jlong Java_org_forstdb_TtlDB_createColumnFamilyWithTtl(JNIEnv* env, jobject, jlong jdb_handle, jbyteArray jcolumn_name, jlong jcolumn_options, diff --git a/java/rocksjni/wal_filter.cc b/java/forstjni/wal_filter.cc similarity index 71% rename from java/rocksjni/wal_filter.cc rename to java/forstjni/wal_filter.cc index 24b88afed..3fbd59a7a 100644 --- a/java/rocksjni/wal_filter.cc +++ b/java/forstjni/wal_filter.cc @@ -8,16 +8,16 @@ #include -#include "include/org_rocksdb_AbstractWalFilter.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/wal_filter_jnicallback.h" +#include "include/org_forstdb_AbstractWalFilter.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/wal_filter_jnicallback.h" /* - * Class: org_rocksdb_AbstractWalFilter + * Class: org_forstdb_AbstractWalFilter * Method: createNewWalFilter * Signature: ()J */ -jlong Java_org_rocksdb_AbstractWalFilter_createNewWalFilter(JNIEnv* env, +jlong Java_org_forstdb_AbstractWalFilter_createNewWalFilter(JNIEnv* env, jobject jobj) { auto* wal_filter = new ROCKSDB_NAMESPACE::WalFilterJniCallback(env, jobj); return GET_CPLUSPLUS_POINTER(wal_filter); diff --git a/java/rocksjni/wal_filter_jnicallback.cc b/java/forstjni/wal_filter_jnicallback.cc similarity index 97% rename from java/rocksjni/wal_filter_jnicallback.cc rename to java/forstjni/wal_filter_jnicallback.cc index d2e3c9076..aa5c2f31b 100644 --- a/java/rocksjni/wal_filter_jnicallback.cc +++ b/java/forstjni/wal_filter_jnicallback.cc @@ -6,10 +6,10 @@ // This file implements the callback "bridge" between Java and C++ for // ROCKSDB_NAMESPACE::WalFilter. -#include "rocksjni/wal_filter_jnicallback.h" +#include "forstjni/wal_filter_jnicallback.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" namespace ROCKSDB_NAMESPACE { WalFilterJniCallback::WalFilterJniCallback(JNIEnv* env, jobject jwal_filter) diff --git a/java/rocksjni/wal_filter_jnicallback.h b/java/forstjni/wal_filter_jnicallback.h similarity index 97% rename from java/rocksjni/wal_filter_jnicallback.h rename to java/forstjni/wal_filter_jnicallback.h index 5cdc65978..d933a2e8e 100644 --- a/java/rocksjni/wal_filter_jnicallback.h +++ b/java/forstjni/wal_filter_jnicallback.h @@ -16,7 +16,7 @@ #include #include "rocksdb/wal_filter.h" -#include "rocksjni/jnicallback.h" +#include "forstjni/jnicallback.h" namespace ROCKSDB_NAMESPACE { diff --git a/java/rocksjni/write_batch.cc b/java/forstjni/write_batch.cc similarity index 83% rename from java/rocksjni/write_batch.cc rename to java/forstjni/write_batch.cc index 6704e4a7e..d9dc5557a 100644 --- a/java/rocksjni/write_batch.cc +++ b/java/forstjni/write_batch.cc @@ -11,25 +11,25 @@ #include "db/memtable.h" #include "db/write_batch_internal.h" -#include "include/org_rocksdb_WriteBatch.h" -#include "include/org_rocksdb_WriteBatch_Handler.h" +#include "include/org_forstdb_WriteBatch.h" +#include "include/org_forstdb_WriteBatch_Handler.h" #include "logging/logging.h" #include "rocksdb/db.h" #include "rocksdb/env.h" #include "rocksdb/memtablerep.h" #include "rocksdb/status.h" #include "rocksdb/write_buffer_manager.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" -#include "rocksjni/writebatchhandlerjnicallback.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" +#include "forstjni/writebatchhandlerjnicallback.h" #include "table/scoped_arena_iterator.h" /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: newWriteBatch * Signature: (I)J */ -jlong Java_org_rocksdb_WriteBatch_newWriteBatch__I(JNIEnv* /*env*/, +jlong Java_org_forstdb_WriteBatch_newWriteBatch__I(JNIEnv* /*env*/, jclass /*jcls*/, jint jreserved_bytes) { auto* wb = @@ -38,11 +38,11 @@ jlong Java_org_rocksdb_WriteBatch_newWriteBatch__I(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: newWriteBatch * Signature: ([BI)J */ -jlong Java_org_rocksdb_WriteBatch_newWriteBatch___3BI(JNIEnv* env, +jlong Java_org_forstdb_WriteBatch_newWriteBatch___3BI(JNIEnv* env, jclass /*jcls*/, jbyteArray jserialized, jint jserialized_length) { @@ -61,11 +61,11 @@ jlong Java_org_rocksdb_WriteBatch_newWriteBatch___3BI(JNIEnv* env, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: count0 * Signature: (J)I */ -jint Java_org_rocksdb_WriteBatch_count0(JNIEnv* /*env*/, jobject /*jobj*/, +jint Java_org_forstdb_WriteBatch_count0(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -74,11 +74,11 @@ jint Java_org_rocksdb_WriteBatch_count0(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: clear0 * Signature: (J)V */ -void Java_org_rocksdb_WriteBatch_clear0(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_WriteBatch_clear0(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -87,11 +87,11 @@ void Java_org_rocksdb_WriteBatch_clear0(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: setSavePoint0 * Signature: (J)V */ -void Java_org_rocksdb_WriteBatch_setSavePoint0(JNIEnv* /*env*/, +void Java_org_forstdb_WriteBatch_setSavePoint0(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); @@ -101,11 +101,11 @@ void Java_org_rocksdb_WriteBatch_setSavePoint0(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: rollbackToSavePoint0 * Signature: (J)V */ -void Java_org_rocksdb_WriteBatch_rollbackToSavePoint0(JNIEnv* env, +void Java_org_forstdb_WriteBatch_rollbackToSavePoint0(JNIEnv* env, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); @@ -120,11 +120,11 @@ void Java_org_rocksdb_WriteBatch_rollbackToSavePoint0(JNIEnv* env, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: popSavePoint * Signature: (J)V */ -void Java_org_rocksdb_WriteBatch_popSavePoint(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_WriteBatch_popSavePoint(JNIEnv* env, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -138,11 +138,11 @@ void Java_org_rocksdb_WriteBatch_popSavePoint(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: setMaxBytes * Signature: (JJ)V */ -void Java_org_rocksdb_WriteBatch_setMaxBytes(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_WriteBatch_setMaxBytes(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle, jlong jmax_bytes) { auto* wb = reinterpret_cast(jwb_handle); @@ -152,11 +152,11 @@ void Java_org_rocksdb_WriteBatch_setMaxBytes(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: put * Signature: (J[BI[BI)V */ -void Java_org_rocksdb_WriteBatch_put__J_3BI_3BI(JNIEnv* env, jobject jobj, +void Java_org_forstdb_WriteBatch_put__J_3BI_3BI(JNIEnv* env, jobject jobj, jlong jwb_handle, jbyteArray jkey, jint jkey_len, jbyteArray jentry_value, @@ -176,11 +176,11 @@ void Java_org_rocksdb_WriteBatch_put__J_3BI_3BI(JNIEnv* env, jobject jobj, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: put * Signature: (J[BI[BIJ)V */ -void Java_org_rocksdb_WriteBatch_put__J_3BI_3BIJ( +void Java_org_forstdb_WriteBatch_put__J_3BI_3BIJ( JNIEnv* env, jobject jobj, jlong jwb_handle, jbyteArray jkey, jint jkey_len, jbyteArray jentry_value, jint jentry_value_len, jlong jcf_handle) { auto* wb = reinterpret_cast(jwb_handle); @@ -201,11 +201,11 @@ void Java_org_rocksdb_WriteBatch_put__J_3BI_3BIJ( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: putDirect * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V */ -void Java_org_rocksdb_WriteBatch_putDirect(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_WriteBatch_putDirect(JNIEnv* env, jobject /*jobj*/, jlong jwb_handle, jobject jkey, jint jkey_offset, jint jkey_len, jobject jval, jint jval_offset, @@ -227,11 +227,11 @@ void Java_org_rocksdb_WriteBatch_putDirect(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: merge * Signature: (J[BI[BI)V */ -void Java_org_rocksdb_WriteBatch_merge__J_3BI_3BI( +void Java_org_forstdb_WriteBatch_merge__J_3BI_3BI( JNIEnv* env, jobject jobj, jlong jwb_handle, jbyteArray jkey, jint jkey_len, jbyteArray jentry_value, jint jentry_value_len) { auto* wb = reinterpret_cast(jwb_handle); @@ -249,11 +249,11 @@ void Java_org_rocksdb_WriteBatch_merge__J_3BI_3BI( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: merge * Signature: (J[BI[BIJ)V */ -void Java_org_rocksdb_WriteBatch_merge__J_3BI_3BIJ( +void Java_org_forstdb_WriteBatch_merge__J_3BI_3BIJ( JNIEnv* env, jobject jobj, jlong jwb_handle, jbyteArray jkey, jint jkey_len, jbyteArray jentry_value, jint jentry_value_len, jlong jcf_handle) { auto* wb = reinterpret_cast(jwb_handle); @@ -274,11 +274,11 @@ void Java_org_rocksdb_WriteBatch_merge__J_3BI_3BIJ( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: delete * Signature: (J[BI)V */ -void Java_org_rocksdb_WriteBatch_delete__J_3BI(JNIEnv* env, jobject jobj, +void Java_org_forstdb_WriteBatch_delete__J_3BI(JNIEnv* env, jobject jobj, jlong jwb_handle, jbyteArray jkey, jint jkey_len) { auto* wb = reinterpret_cast(jwb_handle); @@ -292,11 +292,11 @@ void Java_org_rocksdb_WriteBatch_delete__J_3BI(JNIEnv* env, jobject jobj, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: delete * Signature: (J[BIJ)V */ -void Java_org_rocksdb_WriteBatch_delete__J_3BIJ(JNIEnv* env, jobject jobj, +void Java_org_forstdb_WriteBatch_delete__J_3BIJ(JNIEnv* env, jobject jobj, jlong jwb_handle, jbyteArray jkey, jint jkey_len, jlong jcf_handle) { @@ -316,11 +316,11 @@ void Java_org_rocksdb_WriteBatch_delete__J_3BIJ(JNIEnv* env, jobject jobj, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: singleDelete * Signature: (J[BI)V */ -void Java_org_rocksdb_WriteBatch_singleDelete__J_3BI(JNIEnv* env, jobject jobj, +void Java_org_forstdb_WriteBatch_singleDelete__J_3BI(JNIEnv* env, jobject jobj, jlong jwb_handle, jbyteArray jkey, jint jkey_len) { @@ -338,11 +338,11 @@ void Java_org_rocksdb_WriteBatch_singleDelete__J_3BI(JNIEnv* env, jobject jobj, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: singleDelete * Signature: (J[BIJ)V */ -void Java_org_rocksdb_WriteBatch_singleDelete__J_3BIJ(JNIEnv* env, jobject jobj, +void Java_org_forstdb_WriteBatch_singleDelete__J_3BIJ(JNIEnv* env, jobject jobj, jlong jwb_handle, jbyteArray jkey, jint jkey_len, @@ -364,11 +364,11 @@ void Java_org_rocksdb_WriteBatch_singleDelete__J_3BIJ(JNIEnv* env, jobject jobj, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: deleteDirect * Signature: (JLjava/nio/ByteBuffer;IIJ)V */ -void Java_org_rocksdb_WriteBatch_deleteDirect(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_WriteBatch_deleteDirect(JNIEnv* env, jobject /*jobj*/, jlong jwb_handle, jobject jkey, jint jkey_offset, jint jkey_len, jlong jcf_handle) { @@ -388,11 +388,11 @@ void Java_org_rocksdb_WriteBatch_deleteDirect(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: deleteRange * Signature: (J[BI[BI)V */ -void Java_org_rocksdb_WriteBatch_deleteRange__J_3BI_3BI( +void Java_org_forstdb_WriteBatch_deleteRange__J_3BI_3BI( JNIEnv* env, jobject jobj, jlong jwb_handle, jbyteArray jbegin_key, jint jbegin_key_len, jbyteArray jend_key, jint jend_key_len) { auto* wb = reinterpret_cast(jwb_handle); @@ -410,11 +410,11 @@ void Java_org_rocksdb_WriteBatch_deleteRange__J_3BI_3BI( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: deleteRange * Signature: (J[BI[BIJ)V */ -void Java_org_rocksdb_WriteBatch_deleteRange__J_3BI_3BIJ( +void Java_org_forstdb_WriteBatch_deleteRange__J_3BI_3BIJ( JNIEnv* env, jobject jobj, jlong jwb_handle, jbyteArray jbegin_key, jint jbegin_key_len, jbyteArray jend_key, jint jend_key_len, jlong jcf_handle) { @@ -436,11 +436,11 @@ void Java_org_rocksdb_WriteBatch_deleteRange__J_3BI_3BIJ( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: putLogData * Signature: (J[BI)V */ -void Java_org_rocksdb_WriteBatch_putLogData(JNIEnv* env, jobject jobj, +void Java_org_forstdb_WriteBatch_putLogData(JNIEnv* env, jobject jobj, jlong jwb_handle, jbyteArray jblob, jint jblob_len) { auto* wb = reinterpret_cast(jwb_handle); @@ -456,11 +456,11 @@ void Java_org_rocksdb_WriteBatch_putLogData(JNIEnv* env, jobject jobj, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: iterate * Signature: (JJ)V */ -void Java_org_rocksdb_WriteBatch_iterate(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_WriteBatch_iterate(JNIEnv* env, jobject /*jobj*/, jlong jwb_handle, jlong handlerHandle) { auto* wb = reinterpret_cast(jwb_handle); @@ -477,11 +477,11 @@ void Java_org_rocksdb_WriteBatch_iterate(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: data * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_WriteBatch_data(JNIEnv* env, jobject /*jobj*/, +jbyteArray Java_org_forstdb_WriteBatch_data(JNIEnv* env, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -491,11 +491,11 @@ jbyteArray Java_org_rocksdb_WriteBatch_data(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: getDataSize * Signature: (J)J */ -jlong Java_org_rocksdb_WriteBatch_getDataSize(JNIEnv* /*env*/, jobject /*jobj*/, +jlong Java_org_forstdb_WriteBatch_getDataSize(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -505,11 +505,11 @@ jlong Java_org_rocksdb_WriteBatch_getDataSize(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: hasPut * Signature: (J)Z */ -jboolean Java_org_rocksdb_WriteBatch_hasPut(JNIEnv* /*env*/, jobject /*jobj*/, +jboolean Java_org_forstdb_WriteBatch_hasPut(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -518,11 +518,11 @@ jboolean Java_org_rocksdb_WriteBatch_hasPut(JNIEnv* /*env*/, jobject /*jobj*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: hasDelete * Signature: (J)Z */ -jboolean Java_org_rocksdb_WriteBatch_hasDelete(JNIEnv* /*env*/, +jboolean Java_org_forstdb_WriteBatch_hasDelete(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); @@ -532,11 +532,11 @@ jboolean Java_org_rocksdb_WriteBatch_hasDelete(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: hasSingleDelete * Signature: (J)Z */ -JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasSingleDelete( +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasSingleDelete( JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -545,11 +545,11 @@ JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasSingleDelete( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: hasDeleteRange * Signature: (J)Z */ -JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasDeleteRange( +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasDeleteRange( JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -558,11 +558,11 @@ JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasDeleteRange( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: hasMerge * Signature: (J)Z */ -JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasMerge( +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasMerge( JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -571,11 +571,11 @@ JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasMerge( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: hasBeginPrepare * Signature: (J)Z */ -JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasBeginPrepare( +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasBeginPrepare( JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -584,11 +584,11 @@ JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasBeginPrepare( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: hasEndPrepare * Signature: (J)Z */ -JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasEndPrepare( +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasEndPrepare( JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -597,11 +597,11 @@ JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasEndPrepare( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: hasCommit * Signature: (J)Z */ -JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasCommit( +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasCommit( JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -610,11 +610,11 @@ JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasCommit( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: hasRollback * Signature: (J)Z */ -JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasRollback( +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasRollback( JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -623,11 +623,11 @@ JNIEXPORT jboolean JNICALL Java_org_rocksdb_WriteBatch_hasRollback( } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: markWalTerminationPoint * Signature: (J)V */ -void Java_org_rocksdb_WriteBatch_markWalTerminationPoint(JNIEnv* /*env*/, +void Java_org_forstdb_WriteBatch_markWalTerminationPoint(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); @@ -637,11 +637,11 @@ void Java_org_rocksdb_WriteBatch_markWalTerminationPoint(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: getWalTerminationPoint * Signature: (J)Lorg/rocksdb/WriteBatch/SavePoint; */ -jobject Java_org_rocksdb_WriteBatch_getWalTerminationPoint(JNIEnv* env, +jobject Java_org_forstdb_WriteBatch_getWalTerminationPoint(JNIEnv* env, jobject /*jobj*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); @@ -652,11 +652,11 @@ jobject Java_org_rocksdb_WriteBatch_getWalTerminationPoint(JNIEnv* env, } /* - * Class: org_rocksdb_WriteBatch + * Class: org_forstdb_WriteBatch * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_WriteBatch_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_WriteBatch_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { auto* wb = reinterpret_cast(handle); @@ -665,11 +665,11 @@ void Java_org_rocksdb_WriteBatch_disposeInternal(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatch_Handler + * Class: org_forstdb_WriteBatch_Handler * Method: createNewHandler0 * Signature: ()J */ -jlong Java_org_rocksdb_WriteBatch_00024Handler_createNewHandler0(JNIEnv* env, +jlong Java_org_forstdb_WriteBatch_00024Handler_createNewHandler0(JNIEnv* env, jobject jobj) { auto* wbjnic = new ROCKSDB_NAMESPACE::WriteBatchHandlerJniCallback(env, jobj); return GET_CPLUSPLUS_POINTER(wbjnic); diff --git a/java/rocksjni/write_batch_test.cc b/java/forstjni/write_batch_test.cc similarity index 90% rename from java/rocksjni/write_batch_test.cc rename to java/forstjni/write_batch_test.cc index 30b9a7229..bf3669d0c 100644 --- a/java/rocksjni/write_batch_test.cc +++ b/java/forstjni/write_batch_test.cc @@ -11,27 +11,27 @@ #include "db/memtable.h" #include "db/write_batch_internal.h" -#include "include/org_rocksdb_WriteBatch.h" -#include "include/org_rocksdb_WriteBatchTest.h" -#include "include/org_rocksdb_WriteBatchTestInternalHelper.h" -#include "include/org_rocksdb_WriteBatch_Handler.h" +#include "include/org_forstdb_WriteBatch.h" +#include "include/org_forstdb_WriteBatchTest.h" +#include "include/org_forstdb_WriteBatchTestInternalHelper.h" +#include "include/org_forstdb_WriteBatch_Handler.h" #include "options/cf_options.h" #include "rocksdb/db.h" #include "rocksdb/env.h" #include "rocksdb/memtablerep.h" #include "rocksdb/status.h" #include "rocksdb/write_buffer_manager.h" -#include "rocksjni/portal.h" +#include "forstjni/portal.h" #include "table/scoped_arena_iterator.h" #include "test_util/testharness.h" #include "util/string_util.h" /* - * Class: org_rocksdb_WriteBatchTest + * Class: org_forstdb_WriteBatchTest * Method: getContents * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_WriteBatchTest_getContents(JNIEnv* env, +jbyteArray Java_org_forstdb_WriteBatchTest_getContents(JNIEnv* env, jclass /*jclazz*/, jlong jwb_handle) { auto* b = reinterpret_cast(jwb_handle); @@ -153,11 +153,11 @@ jbyteArray Java_org_rocksdb_WriteBatchTest_getContents(JNIEnv* env, } /* - * Class: org_rocksdb_WriteBatchTestInternalHelper + * Class: org_forstdb_WriteBatchTestInternalHelper * Method: setSequence * Signature: (JJ)V */ -void Java_org_rocksdb_WriteBatchTestInternalHelper_setSequence( +void Java_org_forstdb_WriteBatchTestInternalHelper_setSequence( JNIEnv* /*env*/, jclass /*jclazz*/, jlong jwb_handle, jlong jsn) { auto* wb = reinterpret_cast(jwb_handle); assert(wb != nullptr); @@ -167,11 +167,11 @@ void Java_org_rocksdb_WriteBatchTestInternalHelper_setSequence( } /* - * Class: org_rocksdb_WriteBatchTestInternalHelper + * Class: org_forstdb_WriteBatchTestInternalHelper * Method: sequence * Signature: (J)J */ -jlong Java_org_rocksdb_WriteBatchTestInternalHelper_sequence(JNIEnv* /*env*/, +jlong Java_org_forstdb_WriteBatchTestInternalHelper_sequence(JNIEnv* /*env*/, jclass /*jclazz*/, jlong jwb_handle) { auto* wb = reinterpret_cast(jwb_handle); @@ -182,11 +182,11 @@ jlong Java_org_rocksdb_WriteBatchTestInternalHelper_sequence(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatchTestInternalHelper + * Class: org_forstdb_WriteBatchTestInternalHelper * Method: append * Signature: (JJ)V */ -void Java_org_rocksdb_WriteBatchTestInternalHelper_append(JNIEnv* /*env*/, +void Java_org_forstdb_WriteBatchTestInternalHelper_append(JNIEnv* /*env*/, jclass /*jclazz*/, jlong jwb_handle_1, jlong jwb_handle_2) { diff --git a/java/rocksjni/write_batch_with_index.cc b/java/forstjni/write_batch_with_index.cc similarity index 84% rename from java/rocksjni/write_batch_with_index.cc rename to java/forstjni/write_batch_with_index.cc index a5c3216cb..e4ed9a449 100644 --- a/java/rocksjni/write_batch_with_index.cc +++ b/java/forstjni/write_batch_with_index.cc @@ -8,29 +8,29 @@ #include "rocksdb/utilities/write_batch_with_index.h" -#include "include/org_rocksdb_WBWIRocksIterator.h" -#include "include/org_rocksdb_WriteBatchWithIndex.h" +#include "include/org_forstdb_WBWIRocksIterator.h" +#include "include/org_forstdb_WriteBatchWithIndex.h" #include "rocksdb/comparator.h" -#include "rocksjni/cplusplus_to_java_convert.h" -#include "rocksjni/portal.h" +#include "forstjni/cplusplus_to_java_convert.h" +#include "forstjni/portal.h" /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: newWriteBatchWithIndex * Signature: ()J */ -jlong Java_org_rocksdb_WriteBatchWithIndex_newWriteBatchWithIndex__( +jlong Java_org_forstdb_WriteBatchWithIndex_newWriteBatchWithIndex__( JNIEnv* /*env*/, jclass /*jcls*/) { auto* wbwi = new ROCKSDB_NAMESPACE::WriteBatchWithIndex(); return GET_CPLUSPLUS_POINTER(wbwi); } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: newWriteBatchWithIndex * Signature: (Z)J */ -jlong Java_org_rocksdb_WriteBatchWithIndex_newWriteBatchWithIndex__Z( +jlong Java_org_forstdb_WriteBatchWithIndex_newWriteBatchWithIndex__Z( JNIEnv* /*env*/, jclass /*jcls*/, jboolean joverwrite_key) { auto* wbwi = new ROCKSDB_NAMESPACE::WriteBatchWithIndex( ROCKSDB_NAMESPACE::BytewiseComparator(), 0, @@ -39,11 +39,11 @@ jlong Java_org_rocksdb_WriteBatchWithIndex_newWriteBatchWithIndex__Z( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: newWriteBatchWithIndex * Signature: (JBIZ)J */ -jlong Java_org_rocksdb_WriteBatchWithIndex_newWriteBatchWithIndex__JBIZ( +jlong Java_org_forstdb_WriteBatchWithIndex_newWriteBatchWithIndex__JBIZ( JNIEnv* /*env*/, jclass /*jcls*/, jlong jfallback_index_comparator_handle, jbyte jcomparator_type, jint jreserved_bytes, jboolean joverwrite_key) { ROCKSDB_NAMESPACE::Comparator* fallback_comparator = nullptr; @@ -68,11 +68,11 @@ jlong Java_org_rocksdb_WriteBatchWithIndex_newWriteBatchWithIndex__JBIZ( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: count0 * Signature: (J)I */ -jint Java_org_rocksdb_WriteBatchWithIndex_count0(JNIEnv* /*env*/, +jint Java_org_forstdb_WriteBatchWithIndex_count0(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwbwi_handle) { auto* wbwi = @@ -83,11 +83,11 @@ jint Java_org_rocksdb_WriteBatchWithIndex_count0(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: put * Signature: (J[BI[BI)V */ -void Java_org_rocksdb_WriteBatchWithIndex_put__J_3BI_3BI( +void Java_org_forstdb_WriteBatchWithIndex_put__J_3BI_3BI( JNIEnv* env, jobject jobj, jlong jwbwi_handle, jbyteArray jkey, jint jkey_len, jbyteArray jentry_value, jint jentry_value_len) { auto* wbwi = @@ -106,11 +106,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_put__J_3BI_3BI( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: put * Signature: (J[BI[BIJ)V */ -void Java_org_rocksdb_WriteBatchWithIndex_put__J_3BI_3BIJ( +void Java_org_forstdb_WriteBatchWithIndex_put__J_3BI_3BIJ( JNIEnv* env, jobject jobj, jlong jwbwi_handle, jbyteArray jkey, jint jkey_len, jbyteArray jentry_value, jint jentry_value_len, jlong jcf_handle) { @@ -133,11 +133,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_put__J_3BI_3BIJ( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: putDirect * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V */ -void Java_org_rocksdb_WriteBatchWithIndex_putDirect( +void Java_org_forstdb_WriteBatchWithIndex_putDirect( JNIEnv* env, jobject /*jobj*/, jlong jwb_handle, jobject jkey, jint jkey_offset, jint jkey_len, jobject jval, jint jval_offset, jint jval_len, jlong jcf_handle) { @@ -158,11 +158,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_putDirect( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: merge * Signature: (J[BI[BI)V */ -void Java_org_rocksdb_WriteBatchWithIndex_merge__J_3BI_3BI( +void Java_org_forstdb_WriteBatchWithIndex_merge__J_3BI_3BI( JNIEnv* env, jobject jobj, jlong jwbwi_handle, jbyteArray jkey, jint jkey_len, jbyteArray jentry_value, jint jentry_value_len) { auto* wbwi = @@ -181,11 +181,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_merge__J_3BI_3BI( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: merge * Signature: (J[BI[BIJ)V */ -void Java_org_rocksdb_WriteBatchWithIndex_merge__J_3BI_3BIJ( +void Java_org_forstdb_WriteBatchWithIndex_merge__J_3BI_3BIJ( JNIEnv* env, jobject jobj, jlong jwbwi_handle, jbyteArray jkey, jint jkey_len, jbyteArray jentry_value, jint jentry_value_len, jlong jcf_handle) { @@ -208,11 +208,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_merge__J_3BI_3BIJ( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: delete * Signature: (J[BI)V */ -void Java_org_rocksdb_WriteBatchWithIndex_delete__J_3BI(JNIEnv* env, +void Java_org_forstdb_WriteBatchWithIndex_delete__J_3BI(JNIEnv* env, jobject jobj, jlong jwbwi_handle, jbyteArray jkey, @@ -231,11 +231,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_delete__J_3BI(JNIEnv* env, } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: delete * Signature: (J[BIJ)V */ -void Java_org_rocksdb_WriteBatchWithIndex_delete__J_3BIJ( +void Java_org_forstdb_WriteBatchWithIndex_delete__J_3BIJ( JNIEnv* env, jobject jobj, jlong jwbwi_handle, jbyteArray jkey, jint jkey_len, jlong jcf_handle) { auto* wbwi = @@ -255,11 +255,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_delete__J_3BIJ( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: singleDelete * Signature: (J[BI)V */ -void Java_org_rocksdb_WriteBatchWithIndex_singleDelete__J_3BI( +void Java_org_forstdb_WriteBatchWithIndex_singleDelete__J_3BI( JNIEnv* env, jobject jobj, jlong jwbwi_handle, jbyteArray jkey, jint jkey_len) { auto* wbwi = @@ -277,11 +277,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_singleDelete__J_3BI( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: singleDelete * Signature: (J[BIJ)V */ -void Java_org_rocksdb_WriteBatchWithIndex_singleDelete__J_3BIJ( +void Java_org_forstdb_WriteBatchWithIndex_singleDelete__J_3BIJ( JNIEnv* env, jobject jobj, jlong jwbwi_handle, jbyteArray jkey, jint jkey_len, jlong jcf_handle) { auto* wbwi = @@ -302,11 +302,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_singleDelete__J_3BIJ( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: deleteDirect * Signature: (JLjava/nio/ByteBuffer;IIJ)V */ -void Java_org_rocksdb_WriteBatchWithIndex_deleteDirect( +void Java_org_forstdb_WriteBatchWithIndex_deleteDirect( JNIEnv* env, jobject /*jobj*/, jlong jwb_handle, jobject jkey, jint jkey_offset, jint jkey_len, jlong jcf_handle) { auto* wb = reinterpret_cast(jwb_handle); @@ -325,11 +325,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_deleteDirect( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: deleteRange * Signature: (J[BI[BI)V */ -void Java_org_rocksdb_WriteBatchWithIndex_deleteRange__J_3BI_3BI( +void Java_org_forstdb_WriteBatchWithIndex_deleteRange__J_3BI_3BI( JNIEnv* env, jobject jobj, jlong jwbwi_handle, jbyteArray jbegin_key, jint jbegin_key_len, jbyteArray jend_key, jint jend_key_len) { auto* wbwi = @@ -348,11 +348,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_deleteRange__J_3BI_3BI( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: deleteRange * Signature: (J[BI[BIJ)V */ -void Java_org_rocksdb_WriteBatchWithIndex_deleteRange__J_3BI_3BIJ( +void Java_org_forstdb_WriteBatchWithIndex_deleteRange__J_3BI_3BIJ( JNIEnv* env, jobject jobj, jlong jwbwi_handle, jbyteArray jbegin_key, jint jbegin_key_len, jbyteArray jend_key, jint jend_key_len, jlong jcf_handle) { @@ -375,11 +375,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_deleteRange__J_3BI_3BIJ( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: putLogData * Signature: (J[BI)V */ -void Java_org_rocksdb_WriteBatchWithIndex_putLogData(JNIEnv* env, jobject jobj, +void Java_org_forstdb_WriteBatchWithIndex_putLogData(JNIEnv* env, jobject jobj, jlong jwbwi_handle, jbyteArray jblob, jint jblob_len) { @@ -397,11 +397,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_putLogData(JNIEnv* env, jobject jobj, } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: clear * Signature: (J)V */ -void Java_org_rocksdb_WriteBatchWithIndex_clear0(JNIEnv* /*env*/, +void Java_org_forstdb_WriteBatchWithIndex_clear0(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwbwi_handle) { auto* wbwi = @@ -412,11 +412,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_clear0(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: setSavePoint0 * Signature: (J)V */ -void Java_org_rocksdb_WriteBatchWithIndex_setSavePoint0(JNIEnv* /*env*/, +void Java_org_forstdb_WriteBatchWithIndex_setSavePoint0(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwbwi_handle) { auto* wbwi = @@ -427,11 +427,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_setSavePoint0(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: rollbackToSavePoint0 * Signature: (J)V */ -void Java_org_rocksdb_WriteBatchWithIndex_rollbackToSavePoint0( +void Java_org_forstdb_WriteBatchWithIndex_rollbackToSavePoint0( JNIEnv* env, jobject /*jobj*/, jlong jwbwi_handle) { auto* wbwi = reinterpret_cast(jwbwi_handle); @@ -447,11 +447,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_rollbackToSavePoint0( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: popSavePoint * Signature: (J)V */ -void Java_org_rocksdb_WriteBatchWithIndex_popSavePoint(JNIEnv* env, +void Java_org_forstdb_WriteBatchWithIndex_popSavePoint(JNIEnv* env, jobject /*jobj*/, jlong jwbwi_handle) { auto* wbwi = @@ -468,11 +468,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_popSavePoint(JNIEnv* env, } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: setMaxBytes * Signature: (JJ)V */ -void Java_org_rocksdb_WriteBatchWithIndex_setMaxBytes(JNIEnv* /*env*/, +void Java_org_forstdb_WriteBatchWithIndex_setMaxBytes(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwbwi_handle, jlong jmax_bytes) { @@ -484,11 +484,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_setMaxBytes(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: getWriteBatch * Signature: (J)Lorg/rocksdb/WriteBatch; */ -jobject Java_org_rocksdb_WriteBatchWithIndex_getWriteBatch(JNIEnv* env, +jobject Java_org_forstdb_WriteBatchWithIndex_getWriteBatch(JNIEnv* env, jobject /*jobj*/, jlong jwbwi_handle) { auto* wbwi = @@ -502,11 +502,11 @@ jobject Java_org_rocksdb_WriteBatchWithIndex_getWriteBatch(JNIEnv* env, } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: iterator0 * Signature: (J)J */ -jlong Java_org_rocksdb_WriteBatchWithIndex_iterator0(JNIEnv* /*env*/, +jlong Java_org_forstdb_WriteBatchWithIndex_iterator0(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwbwi_handle) { auto* wbwi = @@ -516,11 +516,11 @@ jlong Java_org_rocksdb_WriteBatchWithIndex_iterator0(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: iterator1 * Signature: (JJ)J */ -jlong Java_org_rocksdb_WriteBatchWithIndex_iterator1(JNIEnv* /*env*/, +jlong Java_org_forstdb_WriteBatchWithIndex_iterator1(JNIEnv* /*env*/, jobject /*jobj*/, jlong jwbwi_handle, jlong jcf_handle) { @@ -533,11 +533,11 @@ jlong Java_org_rocksdb_WriteBatchWithIndex_iterator1(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: iteratorWithBase * Signature: (JJJJ)J */ -jlong Java_org_rocksdb_WriteBatchWithIndex_iteratorWithBase( +jlong Java_org_forstdb_WriteBatchWithIndex_iteratorWithBase( JNIEnv*, jobject, jlong jwbwi_handle, jlong jcf_handle, jlong jbase_iterator_handle, jlong jread_opts_handle) { auto* wbwi = @@ -557,11 +557,11 @@ jlong Java_org_rocksdb_WriteBatchWithIndex_iteratorWithBase( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: getFromBatch * Signature: (JJ[BI)[B */ -jbyteArray JNICALL Java_org_rocksdb_WriteBatchWithIndex_getFromBatch__JJ_3BI( +jbyteArray JNICALL Java_org_forstdb_WriteBatchWithIndex_getFromBatch__JJ_3BI( JNIEnv* env, jobject /*jobj*/, jlong jwbwi_handle, jlong jdbopt_handle, jbyteArray jkey, jint jkey_len) { auto* wbwi = @@ -577,11 +577,11 @@ jbyteArray JNICALL Java_org_rocksdb_WriteBatchWithIndex_getFromBatch__JJ_3BI( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: getFromBatch * Signature: (JJ[BIJ)[B */ -jbyteArray Java_org_rocksdb_WriteBatchWithIndex_getFromBatch__JJ_3BIJ( +jbyteArray Java_org_forstdb_WriteBatchWithIndex_getFromBatch__JJ_3BIJ( JNIEnv* env, jobject /*jobj*/, jlong jwbwi_handle, jlong jdbopt_handle, jbyteArray jkey, jint jkey_len, jlong jcf_handle) { auto* wbwi = @@ -599,11 +599,11 @@ jbyteArray Java_org_rocksdb_WriteBatchWithIndex_getFromBatch__JJ_3BIJ( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: getFromBatchAndDB * Signature: (JJJ[BI)[B */ -jbyteArray Java_org_rocksdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BI( +jbyteArray Java_org_forstdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BI( JNIEnv* env, jobject /*jobj*/, jlong jwbwi_handle, jlong jdb_handle, jlong jreadopt_handle, jbyteArray jkey, jint jkey_len) { auto* wbwi = @@ -621,11 +621,11 @@ jbyteArray Java_org_rocksdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BI( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: getFromBatchAndDB * Signature: (JJJ[BIJ)[B */ -jbyteArray Java_org_rocksdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BIJ( +jbyteArray Java_org_forstdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BIJ( JNIEnv* env, jobject /*jobj*/, jlong jwbwi_handle, jlong jdb_handle, jlong jreadopt_handle, jbyteArray jkey, jint jkey_len, jlong jcf_handle) { auto* wbwi = @@ -645,11 +645,11 @@ jbyteArray Java_org_rocksdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BIJ( } /* - * Class: org_rocksdb_WriteBatchWithIndex + * Class: org_forstdb_WriteBatchWithIndex * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_WriteBatchWithIndex_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_WriteBatchWithIndex_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { auto* wbwi = @@ -661,11 +661,11 @@ void Java_org_rocksdb_WriteBatchWithIndex_disposeInternal(JNIEnv* /*env*/, /* WBWIRocksIterator below */ /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_WBWIRocksIterator_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_WBWIRocksIterator_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); @@ -674,64 +674,64 @@ void Java_org_rocksdb_WBWIRocksIterator_disposeInternal(JNIEnv* /*env*/, } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: isValid0 * Signature: (J)Z */ -jboolean Java_org_rocksdb_WBWIRocksIterator_isValid0(JNIEnv* /*env*/, +jboolean Java_org_forstdb_WBWIRocksIterator_isValid0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { return reinterpret_cast(handle)->Valid(); } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: seekToFirst0 * Signature: (J)V */ -void Java_org_rocksdb_WBWIRocksIterator_seekToFirst0(JNIEnv* /*env*/, +void Java_org_forstdb_WBWIRocksIterator_seekToFirst0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->SeekToFirst(); } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: seekToLast0 * Signature: (J)V */ -void Java_org_rocksdb_WBWIRocksIterator_seekToLast0(JNIEnv* /*env*/, +void Java_org_forstdb_WBWIRocksIterator_seekToLast0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->SeekToLast(); } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: next0 * Signature: (J)V */ -void Java_org_rocksdb_WBWIRocksIterator_next0(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_WBWIRocksIterator_next0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->Next(); } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: prev0 * Signature: (J)V */ -void Java_org_rocksdb_WBWIRocksIterator_prev0(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_forstdb_WBWIRocksIterator_prev0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { reinterpret_cast(handle)->Prev(); } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: seek0 * Signature: (J[BI)V */ -void Java_org_rocksdb_WBWIRocksIterator_seek0(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_WBWIRocksIterator_seek0(JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, jint jtarget_len) { auto* it = reinterpret_cast(handle); @@ -752,11 +752,11 @@ void Java_org_rocksdb_WBWIRocksIterator_seek0(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: seekDirect0 * Signature: (JLjava/nio/ByteBuffer;II)V */ -void Java_org_rocksdb_WBWIRocksIterator_seekDirect0( +void Java_org_forstdb_WBWIRocksIterator_seekDirect0( JNIEnv* env, jobject /*jobj*/, jlong handle, jobject jtarget, jint jtarget_off, jint jtarget_len) { auto* it = reinterpret_cast(handle); @@ -771,11 +771,11 @@ void Java_org_rocksdb_WBWIRocksIterator_seekDirect0( * This method supports fetching into indirect byte buffers; * the Java wrapper extracts the byte[] and passes it here. * - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: seekByteArray0 * Signature: (J[BII)V */ -void Java_org_rocksdb_WBWIRocksIterator_seekByteArray0( +void Java_org_forstdb_WBWIRocksIterator_seekByteArray0( JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, jint jtarget_off, jint jtarget_len) { const std::unique_ptr target(new char[jtarget_len]); @@ -795,11 +795,11 @@ void Java_org_rocksdb_WBWIRocksIterator_seekByteArray0( } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: seekForPrev0 * Signature: (J[BI)V */ -void Java_org_rocksdb_WBWIRocksIterator_seekForPrev0(JNIEnv* env, +void Java_org_forstdb_WBWIRocksIterator_seekForPrev0(JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, @@ -822,11 +822,11 @@ void Java_org_rocksdb_WBWIRocksIterator_seekForPrev0(JNIEnv* env, } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: seekForPrevDirect0 * Signature: (JLjava/nio/ByteBuffer;II)V */ -void Java_org_rocksdb_WBWIRocksIterator_seekForPrevDirect0( +void Java_org_forstdb_WBWIRocksIterator_seekForPrevDirect0( JNIEnv* env, jobject /*jobj*/, jlong handle, jobject jtarget, jint jtarget_off, jint jtarget_len) { auto* it = reinterpret_cast(handle); @@ -841,11 +841,11 @@ void Java_org_rocksdb_WBWIRocksIterator_seekForPrevDirect0( * This method supports fetching into indirect byte buffers; * the Java wrapper extracts the byte[] and passes it here. * - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: seekForPrevByteArray0 * Signature: (J[BII)V */ -void Java_org_rocksdb_WBWIRocksIterator_seekForPrevByteArray0( +void Java_org_forstdb_WBWIRocksIterator_seekForPrevByteArray0( JNIEnv* env, jobject /*jobj*/, jlong handle, jbyteArray jtarget, jint jtarget_off, jint jtarget_len) { const std::unique_ptr target(new char[jtarget_len]); @@ -865,11 +865,11 @@ void Java_org_rocksdb_WBWIRocksIterator_seekForPrevByteArray0( } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: status0 * Signature: (J)V */ -void Java_org_rocksdb_WBWIRocksIterator_status0(JNIEnv* env, jobject /*jobj*/, +void Java_org_forstdb_WBWIRocksIterator_status0(JNIEnv* env, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); ROCKSDB_NAMESPACE::Status s = it->status(); @@ -882,11 +882,11 @@ void Java_org_rocksdb_WBWIRocksIterator_status0(JNIEnv* env, jobject /*jobj*/, } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: entry1 * Signature: (J)[J */ -jlongArray Java_org_rocksdb_WBWIRocksIterator_entry1(JNIEnv* env, +jlongArray Java_org_forstdb_WBWIRocksIterator_entry1(JNIEnv* env, jobject /*jobj*/, jlong handle) { auto* it = reinterpret_cast(handle); @@ -942,11 +942,11 @@ jlongArray Java_org_rocksdb_WBWIRocksIterator_entry1(JNIEnv* env, } /* - * Class: org_rocksdb_WBWIRocksIterator + * Class: org_forstdb_WBWIRocksIterator * Method: refresh0 * Signature: (J)V */ -void Java_org_rocksdb_WBWIRocksIterator_refresh0(JNIEnv* env) { +void Java_org_forstdb_WBWIRocksIterator_refresh0(JNIEnv* env) { ROCKSDB_NAMESPACE::Status s = ROCKSDB_NAMESPACE::Status::NotSupported("Refresh() is not supported"); ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, s); diff --git a/java/rocksjni/write_buffer_manager.cc b/java/forstjni/write_buffer_manager.cc similarity index 81% rename from java/rocksjni/write_buffer_manager.cc rename to java/forstjni/write_buffer_manager.cc index 9ce697e10..114d3a64b 100644 --- a/java/rocksjni/write_buffer_manager.cc +++ b/java/forstjni/write_buffer_manager.cc @@ -9,16 +9,16 @@ #include -#include "include/org_rocksdb_WriteBufferManager.h" +#include "include/org_forstdb_WriteBufferManager.h" #include "rocksdb/cache.h" -#include "rocksjni/cplusplus_to_java_convert.h" +#include "forstjni/cplusplus_to_java_convert.h" /* - * Class: org_rocksdb_WriteBufferManager + * Class: org_forstdb_WriteBufferManager * Method: newWriteBufferManager * Signature: (JJ)J */ -jlong Java_org_rocksdb_WriteBufferManager_newWriteBufferManager( +jlong Java_org_forstdb_WriteBufferManager_newWriteBufferManager( JNIEnv* /*env*/, jclass /*jclazz*/, jlong jbuffer_size, jlong jcache_handle, jboolean allow_stall) { auto* cache_ptr = @@ -32,11 +32,11 @@ jlong Java_org_rocksdb_WriteBufferManager_newWriteBufferManager( } /* - * Class: org_rocksdb_WriteBufferManager + * Class: org_forstdb_WriteBufferManager * Method: disposeInternal * Signature: (J)V */ -void Java_org_rocksdb_WriteBufferManager_disposeInternal(JNIEnv* /*env*/, +void Java_org_forstdb_WriteBufferManager_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) { auto* write_buffer_manager = diff --git a/java/rocksjni/writebatchhandlerjnicallback.cc b/java/forstjni/writebatchhandlerjnicallback.cc similarity index 99% rename from java/rocksjni/writebatchhandlerjnicallback.cc rename to java/forstjni/writebatchhandlerjnicallback.cc index 66ceabe9a..04e97f8bd 100644 --- a/java/rocksjni/writebatchhandlerjnicallback.cc +++ b/java/forstjni/writebatchhandlerjnicallback.cc @@ -6,9 +6,9 @@ // This file implements the callback "bridge" between Java and C++ for // ROCKSDB_NAMESPACE::Comparator. -#include "rocksjni/writebatchhandlerjnicallback.h" +#include "forstjni/writebatchhandlerjnicallback.h" -#include "rocksjni/portal.h" +#include "forstjni/portal.h" namespace ROCKSDB_NAMESPACE { WriteBatchHandlerJniCallback::WriteBatchHandlerJniCallback( diff --git a/java/rocksjni/writebatchhandlerjnicallback.h b/java/forstjni/writebatchhandlerjnicallback.h similarity index 99% rename from java/rocksjni/writebatchhandlerjnicallback.h rename to java/forstjni/writebatchhandlerjnicallback.h index 9629797ca..b71935ad3 100644 --- a/java/rocksjni/writebatchhandlerjnicallback.h +++ b/java/forstjni/writebatchhandlerjnicallback.h @@ -15,7 +15,7 @@ #include #include "rocksdb/write_batch.h" -#include "rocksjni/jnicallback.h" +#include "forstjni/jnicallback.h" namespace ROCKSDB_NAMESPACE { /** diff --git a/java/include/org_forstdb_AbstractCompactionFilter.h b/java/include/org_forstdb_AbstractCompactionFilter.h new file mode 100644 index 000000000..65ae517f7 --- /dev/null +++ b/java/include/org_forstdb_AbstractCompactionFilter.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_AbstractCompactionFilter */ + +#ifndef _Included_org_forstdb_AbstractCompactionFilter +#define _Included_org_forstdb_AbstractCompactionFilter +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_AbstractCompactionFilter + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_AbstractCompactionFilter_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_AbstractCompactionFilterFactory.h b/java/include/org_forstdb_AbstractCompactionFilterFactory.h new file mode 100644 index 000000000..1884a297d --- /dev/null +++ b/java/include/org_forstdb_AbstractCompactionFilterFactory.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_AbstractCompactionFilterFactory */ + +#ifndef _Included_org_forstdb_AbstractCompactionFilterFactory +#define _Included_org_forstdb_AbstractCompactionFilterFactory +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_AbstractCompactionFilterFactory + * Method: createNewCompactionFilterFactory0 + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractCompactionFilterFactory_createNewCompactionFilterFactory0 + (JNIEnv *, jobject); + +/* + * Class: org_forstdb_AbstractCompactionFilterFactory + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_AbstractCompactionFilterFactory_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_AbstractComparator.h b/java/include/org_forstdb_AbstractComparator.h new file mode 100644 index 000000000..d476fdbe7 --- /dev/null +++ b/java/include/org_forstdb_AbstractComparator.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_AbstractComparator */ + +#ifndef _Included_org_forstdb_AbstractComparator +#define _Included_org_forstdb_AbstractComparator +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_AbstractComparator + * Method: usingDirectBuffers + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_AbstractComparator_usingDirectBuffers + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_AbstractComparator + * Method: createNewComparator + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractComparator_createNewComparator + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_AbstractEventListener.h b/java/include/org_forstdb_AbstractEventListener.h new file mode 100644 index 000000000..e04648a8e --- /dev/null +++ b/java/include/org_forstdb_AbstractEventListener.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_AbstractEventListener */ + +#ifndef _Included_org_forstdb_AbstractEventListener +#define _Included_org_forstdb_AbstractEventListener +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_AbstractEventListener + * Method: createNewEventListener + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractEventListener_createNewEventListener + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_AbstractEventListener + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_AbstractEventListener_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_AbstractSlice.h b/java/include/org_forstdb_AbstractSlice.h new file mode 100644 index 000000000..2121b1fe3 --- /dev/null +++ b/java/include/org_forstdb_AbstractSlice.h @@ -0,0 +1,69 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_AbstractSlice */ + +#ifndef _Included_org_forstdb_AbstractSlice +#define _Included_org_forstdb_AbstractSlice +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_AbstractSlice + * Method: createNewSliceFromString + * Signature: (Ljava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractSlice_createNewSliceFromString + (JNIEnv *, jclass, jstring); + +/* + * Class: org_forstdb_AbstractSlice + * Method: size0 + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_AbstractSlice_size0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_AbstractSlice + * Method: empty0 + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_AbstractSlice_empty0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_AbstractSlice + * Method: toString0 + * Signature: (JZ)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_AbstractSlice_toString0 + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_AbstractSlice + * Method: compare0 + * Signature: (JJ)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_AbstractSlice_compare0 + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_AbstractSlice + * Method: startsWith0 + * Signature: (JJ)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_AbstractSlice_startsWith0 + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_AbstractSlice + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_AbstractSlice_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_AbstractTableFilter.h b/java/include/org_forstdb_AbstractTableFilter.h new file mode 100644 index 000000000..35fa3f360 --- /dev/null +++ b/java/include/org_forstdb_AbstractTableFilter.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_AbstractTableFilter */ + +#ifndef _Included_org_forstdb_AbstractTableFilter +#define _Included_org_forstdb_AbstractTableFilter +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_AbstractTableFilter + * Method: createNewTableFilter + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractTableFilter_createNewTableFilter + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_AbstractTraceWriter.h b/java/include/org_forstdb_AbstractTraceWriter.h new file mode 100644 index 000000000..820d6fe0d --- /dev/null +++ b/java/include/org_forstdb_AbstractTraceWriter.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_AbstractTraceWriter */ + +#ifndef _Included_org_forstdb_AbstractTraceWriter +#define _Included_org_forstdb_AbstractTraceWriter +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_AbstractTraceWriter + * Method: createNewTraceWriter + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractTraceWriter_createNewTraceWriter + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_AbstractTransactionNotifier.h b/java/include/org_forstdb_AbstractTransactionNotifier.h new file mode 100644 index 000000000..b43bad529 --- /dev/null +++ b/java/include/org_forstdb_AbstractTransactionNotifier.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_AbstractTransactionNotifier */ + +#ifndef _Included_org_forstdb_AbstractTransactionNotifier +#define _Included_org_forstdb_AbstractTransactionNotifier +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_AbstractTransactionNotifier + * Method: createNewTransactionNotifier + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractTransactionNotifier_createNewTransactionNotifier + (JNIEnv *, jobject); + +/* + * Class: org_forstdb_AbstractTransactionNotifier + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_AbstractTransactionNotifier_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_AbstractWalFilter.h b/java/include/org_forstdb_AbstractWalFilter.h new file mode 100644 index 000000000..ff7094403 --- /dev/null +++ b/java/include/org_forstdb_AbstractWalFilter.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_AbstractWalFilter */ + +#ifndef _Included_org_forstdb_AbstractWalFilter +#define _Included_org_forstdb_AbstractWalFilter +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_AbstractWalFilter + * Method: createNewWalFilter + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractWalFilter_createNewWalFilter + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_BackupEngine.h b/java/include/org_forstdb_BackupEngine.h new file mode 100644 index 000000000..a88572dd1 --- /dev/null +++ b/java/include/org_forstdb_BackupEngine.h @@ -0,0 +1,101 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_BackupEngine */ + +#ifndef _Included_org_forstdb_BackupEngine +#define _Included_org_forstdb_BackupEngine +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_BackupEngine + * Method: open + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_BackupEngine_open + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_BackupEngine + * Method: createNewBackup + * Signature: (JJZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_createNewBackup + (JNIEnv *, jobject, jlong, jlong, jboolean); + +/* + * Class: org_forstdb_BackupEngine + * Method: createNewBackupWithMetadata + * Signature: (JJLjava/lang/String;Z)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_createNewBackupWithMetadata + (JNIEnv *, jobject, jlong, jlong, jstring, jboolean); + +/* + * Class: org_forstdb_BackupEngine + * Method: getBackupInfo + * Signature: (J)Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_BackupEngine_getBackupInfo + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngine + * Method: getCorruptedBackups + * Signature: (J)[I + */ +JNIEXPORT jintArray JNICALL Java_org_forstdb_BackupEngine_getCorruptedBackups + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngine + * Method: garbageCollect + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_garbageCollect + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngine + * Method: purgeOldBackups + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_purgeOldBackups + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_BackupEngine + * Method: deleteBackup + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_deleteBackup + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_BackupEngine + * Method: restoreDbFromBackup + * Signature: (JILjava/lang/String;Ljava/lang/String;J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_restoreDbFromBackup + (JNIEnv *, jobject, jlong, jint, jstring, jstring, jlong); + +/* + * Class: org_forstdb_BackupEngine + * Method: restoreDbFromLatestBackup + * Signature: (JLjava/lang/String;Ljava/lang/String;J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_restoreDbFromLatestBackup + (JNIEnv *, jobject, jlong, jstring, jstring, jlong); + +/* + * Class: org_forstdb_BackupEngine + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_BackupEngineOptions.h b/java/include/org_forstdb_BackupEngineOptions.h new file mode 100644 index 000000000..2368d6f56 --- /dev/null +++ b/java/include/org_forstdb_BackupEngineOptions.h @@ -0,0 +1,213 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_BackupEngineOptions */ + +#ifndef _Included_org_forstdb_BackupEngineOptions +#define _Included_org_forstdb_BackupEngineOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_BackupEngineOptions + * Method: newBackupEngineOptions + * Signature: (Ljava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_BackupEngineOptions_newBackupEngineOptions + (JNIEnv *, jclass, jstring); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: backupDir + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_BackupEngineOptions_backupDir + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setBackupEnv + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setBackupEnv + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setShareTableFiles + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setShareTableFiles + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: shareTableFiles + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_BackupEngineOptions_shareTableFiles + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setInfoLog + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setInfoLog + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setSync + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setSync + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: sync + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_BackupEngineOptions_sync + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setDestroyOldData + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setDestroyOldData + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: destroyOldData + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_BackupEngineOptions_destroyOldData + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setBackupLogFiles + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setBackupLogFiles + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: backupLogFiles + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_BackupEngineOptions_backupLogFiles + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setBackupRateLimit + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setBackupRateLimit + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: backupRateLimit + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_BackupEngineOptions_backupRateLimit + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setBackupRateLimiter + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setBackupRateLimiter + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setRestoreRateLimit + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setRestoreRateLimit + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: restoreRateLimit + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_BackupEngineOptions_restoreRateLimit + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setRestoreRateLimiter + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setRestoreRateLimiter + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setShareFilesWithChecksum + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setShareFilesWithChecksum + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: shareFilesWithChecksum + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_BackupEngineOptions_shareFilesWithChecksum + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setMaxBackgroundOperations + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setMaxBackgroundOperations + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: maxBackgroundOperations + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_BackupEngineOptions_maxBackgroundOperations + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: setCallbackTriggerIntervalSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setCallbackTriggerIntervalSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: callbackTriggerIntervalSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_BackupEngineOptions_callbackTriggerIntervalSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_BackupEngineOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_BlockBasedTableConfig.h b/java/include/org_forstdb_BlockBasedTableConfig.h new file mode 100644 index 000000000..b83bdf655 --- /dev/null +++ b/java/include/org_forstdb_BlockBasedTableConfig.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_BlockBasedTableConfig */ + +#ifndef _Included_org_forstdb_BlockBasedTableConfig +#define _Included_org_forstdb_BlockBasedTableConfig +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_BlockBasedTableConfig + * Method: newTableFactoryHandle + * Signature: (ZZZZBBDBZJJJIIIJZZZJZZIIZZBJI)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_BlockBasedTableConfig_newTableFactoryHandle + (JNIEnv *, jobject, jboolean, jboolean, jboolean, jboolean, jbyte, jbyte, jdouble, jbyte, jboolean, jlong, jlong, jlong, jint, jint, jint, jlong, jboolean, jboolean, jboolean, jlong, jboolean, jboolean, jint, jint, jboolean, jboolean, jbyte, jlong, jint); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_BloomFilter.h b/java/include/org_forstdb_BloomFilter.h new file mode 100644 index 000000000..95d43d194 --- /dev/null +++ b/java/include/org_forstdb_BloomFilter.h @@ -0,0 +1,23 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_BloomFilter */ + +#ifndef _Included_org_forstdb_BloomFilter +#define _Included_org_forstdb_BloomFilter +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_BloomFilter_DEFAULT_BITS_PER_KEY +#define org_forstdb_BloomFilter_DEFAULT_BITS_PER_KEY 10.0 +/* + * Class: org_forstdb_BloomFilter + * Method: createNewBloomFilter + * Signature: (D)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_BloomFilter_createNewBloomFilter + (JNIEnv *, jclass, jdouble); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_Cache.h b/java/include/org_forstdb_Cache.h new file mode 100644 index 000000000..219d121ad --- /dev/null +++ b/java/include/org_forstdb_Cache.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_Cache */ + +#ifndef _Included_org_forstdb_Cache +#define _Included_org_forstdb_Cache +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_Cache + * Method: getUsage + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Cache_getUsage + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Cache + * Method: getPinnedUsage + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Cache_getPinnedUsage + (JNIEnv *, jclass, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_CassandraCompactionFilter.h b/java/include/org_forstdb_CassandraCompactionFilter.h new file mode 100644 index 000000000..76c66b9e7 --- /dev/null +++ b/java/include/org_forstdb_CassandraCompactionFilter.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_CassandraCompactionFilter */ + +#ifndef _Included_org_forstdb_CassandraCompactionFilter +#define _Included_org_forstdb_CassandraCompactionFilter +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_CassandraCompactionFilter + * Method: createNewCassandraCompactionFilter0 + * Signature: (ZI)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CassandraCompactionFilter_createNewCassandraCompactionFilter0 + (JNIEnv *, jclass, jboolean, jint); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_CassandraValueMergeOperator.h b/java/include/org_forstdb_CassandraValueMergeOperator.h new file mode 100644 index 000000000..a467d52cc --- /dev/null +++ b/java/include/org_forstdb_CassandraValueMergeOperator.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_CassandraValueMergeOperator */ + +#ifndef _Included_org_forstdb_CassandraValueMergeOperator +#define _Included_org_forstdb_CassandraValueMergeOperator +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_CassandraValueMergeOperator + * Method: newSharedCassandraValueMergeOperator + * Signature: (II)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CassandraValueMergeOperator_newSharedCassandraValueMergeOperator + (JNIEnv *, jclass, jint, jint); + +/* + * Class: org_forstdb_CassandraValueMergeOperator + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CassandraValueMergeOperator_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_Checkpoint.h b/java/include/org_forstdb_Checkpoint.h new file mode 100644 index 000000000..59021737c --- /dev/null +++ b/java/include/org_forstdb_Checkpoint.h @@ -0,0 +1,45 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_Checkpoint */ + +#ifndef _Included_org_forstdb_Checkpoint +#define _Included_org_forstdb_Checkpoint +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_Checkpoint + * Method: newCheckpoint + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Checkpoint_newCheckpoint + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Checkpoint + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Checkpoint_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Checkpoint + * Method: createCheckpoint + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Checkpoint_createCheckpoint + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_Checkpoint + * Method: exportColumnFamily + * Signature: (JJLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Checkpoint_exportColumnFamily + (JNIEnv *, jobject, jlong, jlong, jstring); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_ClockCache.h b/java/include/org_forstdb_ClockCache.h new file mode 100644 index 000000000..24533d053 --- /dev/null +++ b/java/include/org_forstdb_ClockCache.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_ClockCache */ + +#ifndef _Included_org_forstdb_ClockCache +#define _Included_org_forstdb_ClockCache +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_ClockCache + * Method: newClockCache + * Signature: (JIZ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ClockCache_newClockCache + (JNIEnv *, jclass, jlong, jint, jboolean); + +/* + * Class: org_forstdb_ClockCache + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ClockCache_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_ColumnFamilyHandle.h b/java/include/org_forstdb_ColumnFamilyHandle.h new file mode 100644 index 000000000..d14687dbe --- /dev/null +++ b/java/include/org_forstdb_ColumnFamilyHandle.h @@ -0,0 +1,45 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_ColumnFamilyHandle */ + +#ifndef _Included_org_forstdb_ColumnFamilyHandle +#define _Included_org_forstdb_ColumnFamilyHandle +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_ColumnFamilyHandle + * Method: getName + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_ColumnFamilyHandle_getName + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyHandle + * Method: getID + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyHandle_getID + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyHandle + * Method: getDescriptor + * Signature: (J)Lorg/forstdb/ColumnFamilyDescriptor; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_ColumnFamilyHandle_getDescriptor + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyHandle + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyHandle_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_ColumnFamilyOptions.h b/java/include/org_forstdb_ColumnFamilyOptions.h new file mode 100644 index 000000000..0e4e7c3e2 --- /dev/null +++ b/java/include/org_forstdb_ColumnFamilyOptions.h @@ -0,0 +1,1141 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_ColumnFamilyOptions */ + +#ifndef _Included_org_forstdb_ColumnFamilyOptions +#define _Included_org_forstdb_ColumnFamilyOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: getColumnFamilyOptionsFromProps + * Signature: (JLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__JLjava_lang_String_2 + (JNIEnv *, jclass, jlong, jstring); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: getColumnFamilyOptionsFromProps + * Signature: (Ljava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__Ljava_lang_String_2 + (JNIEnv *, jclass, jstring); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: newColumnFamilyOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_newColumnFamilyOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: copyColumnFamilyOptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_copyColumnFamilyOptions + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: newColumnFamilyOptionsFromOptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_newColumnFamilyOptionsFromOptions + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: oldDefaults + * Signature: (JII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_oldDefaults + (JNIEnv *, jclass, jlong, jint, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: optimizeForSmallDb + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeForSmallDb__J + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: optimizeForSmallDb + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeForSmallDb__JJ + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: optimizeForPointLookup + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeForPointLookup + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: optimizeLevelStyleCompaction + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeLevelStyleCompaction + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: optimizeUniversalStyleCompaction + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeUniversalStyleCompaction + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setComparatorHandle + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setComparatorHandle__JI + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setComparatorHandle + * Signature: (JJB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setComparatorHandle__JJB + (JNIEnv *, jobject, jlong, jlong, jbyte); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMergeOperatorName + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMergeOperatorName + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMergeOperator + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMergeOperator + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setCompactionFilterHandle + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionFilterHandle + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setCompactionFilterFactoryHandle + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionFilterFactoryHandle + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setWriteBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setWriteBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: writeBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_writeBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMaxWriteBufferNumber + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxWriteBufferNumber + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: maxWriteBufferNumber + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_maxWriteBufferNumber + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMinWriteBufferNumberToMerge + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMinWriteBufferNumberToMerge + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: minWriteBufferNumberToMerge + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_minWriteBufferNumberToMerge + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setCompressionType + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompressionType + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: compressionType + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_compressionType + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setCompressionPerLevel + * Signature: (J[B)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompressionPerLevel + (JNIEnv *, jobject, jlong, jbyteArray); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: compressionPerLevel + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_ColumnFamilyOptions_compressionPerLevel + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setBottommostCompressionType + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBottommostCompressionType + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: bottommostCompressionType + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_bottommostCompressionType + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setBottommostCompressionOptions + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBottommostCompressionOptions + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setCompressionOptions + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompressionOptions + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: useFixedLengthPrefixExtractor + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_useFixedLengthPrefixExtractor + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: useCappedPrefixExtractor + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_useCappedPrefixExtractor + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setNumLevels + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setNumLevels + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: numLevels + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_numLevels + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setLevelZeroFileNumCompactionTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevelZeroFileNumCompactionTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: levelZeroFileNumCompactionTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_levelZeroFileNumCompactionTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setLevelZeroSlowdownWritesTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevelZeroSlowdownWritesTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: levelZeroSlowdownWritesTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_levelZeroSlowdownWritesTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setLevelZeroStopWritesTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevelZeroStopWritesTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: levelZeroStopWritesTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_levelZeroStopWritesTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setTargetFileSizeBase + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setTargetFileSizeBase + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: targetFileSizeBase + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_targetFileSizeBase + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setTargetFileSizeMultiplier + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setTargetFileSizeMultiplier + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: targetFileSizeMultiplier + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_targetFileSizeMultiplier + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMaxBytesForLevelBase + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxBytesForLevelBase + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: maxBytesForLevelBase + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_maxBytesForLevelBase + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setLevelCompactionDynamicLevelBytes + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevelCompactionDynamicLevelBytes + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: levelCompactionDynamicLevelBytes + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_levelCompactionDynamicLevelBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMaxBytesForLevelMultiplier + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplier + (JNIEnv *, jobject, jlong, jdouble); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: maxBytesForLevelMultiplier + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_org_forstdb_ColumnFamilyOptions_maxBytesForLevelMultiplier + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMaxCompactionBytes + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxCompactionBytes + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: maxCompactionBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_maxCompactionBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setArenaBlockSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setArenaBlockSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: arenaBlockSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_arenaBlockSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setDisableAutoCompactions + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setDisableAutoCompactions + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: disableAutoCompactions + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_disableAutoCompactions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setCompactionStyle + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionStyle + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: compactionStyle + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_compactionStyle + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMaxTableFilesSizeFIFO + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxTableFilesSizeFIFO + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: maxTableFilesSizeFIFO + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_maxTableFilesSizeFIFO + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMaxSequentialSkipInIterations + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxSequentialSkipInIterations + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: maxSequentialSkipInIterations + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_maxSequentialSkipInIterations + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMemTableFactory + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMemTableFactory + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: memTableFactoryName + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_ColumnFamilyOptions_memTableFactoryName + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setTableFactory + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setTableFactory + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: tableFactoryName + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_ColumnFamilyOptions_tableFactoryName + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setCfPaths + * Signature: (J[Ljava/lang/String;[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCfPaths + (JNIEnv *, jclass, jlong, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: cfPathsLen + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_cfPathsLen + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: cfPaths + * Signature: (J[Ljava/lang/String;[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_cfPaths + (JNIEnv *, jclass, jlong, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setInplaceUpdateSupport + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setInplaceUpdateSupport + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: inplaceUpdateSupport + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_inplaceUpdateSupport + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setInplaceUpdateNumLocks + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setInplaceUpdateNumLocks + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: inplaceUpdateNumLocks + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_inplaceUpdateNumLocks + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMemtablePrefixBloomSizeRatio + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMemtablePrefixBloomSizeRatio + (JNIEnv *, jobject, jlong, jdouble); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: memtablePrefixBloomSizeRatio + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_org_forstdb_ColumnFamilyOptions_memtablePrefixBloomSizeRatio + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setExperimentalMempurgeThreshold + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setExperimentalMempurgeThreshold + (JNIEnv *, jobject, jlong, jdouble); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: experimentalMempurgeThreshold + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_org_forstdb_ColumnFamilyOptions_experimentalMempurgeThreshold + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMemtableWholeKeyFiltering + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMemtableWholeKeyFiltering + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: memtableWholeKeyFiltering + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_memtableWholeKeyFiltering + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setBloomLocality + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBloomLocality + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: bloomLocality + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_bloomLocality + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMaxSuccessiveMerges + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxSuccessiveMerges + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: maxSuccessiveMerges + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_maxSuccessiveMerges + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setOptimizeFiltersForHits + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setOptimizeFiltersForHits + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: optimizeFiltersForHits + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeFiltersForHits + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMemtableHugePageSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMemtableHugePageSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: memtableHugePageSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_memtableHugePageSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setSoftPendingCompactionBytesLimit + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setSoftPendingCompactionBytesLimit + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: softPendingCompactionBytesLimit + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_softPendingCompactionBytesLimit + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setHardPendingCompactionBytesLimit + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setHardPendingCompactionBytesLimit + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: hardPendingCompactionBytesLimit + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_hardPendingCompactionBytesLimit + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setLevel0FileNumCompactionTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevel0FileNumCompactionTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: level0FileNumCompactionTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_level0FileNumCompactionTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setLevel0SlowdownWritesTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevel0SlowdownWritesTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: level0SlowdownWritesTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_level0SlowdownWritesTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setLevel0StopWritesTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevel0StopWritesTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: level0StopWritesTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_level0StopWritesTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMaxBytesForLevelMultiplierAdditional + * Signature: (J[I)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplierAdditional + (JNIEnv *, jobject, jlong, jintArray); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: maxBytesForLevelMultiplierAdditional + * Signature: (J)[I + */ +JNIEXPORT jintArray JNICALL Java_org_forstdb_ColumnFamilyOptions_maxBytesForLevelMultiplierAdditional + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setParanoidFileChecks + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setParanoidFileChecks + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: paranoidFileChecks + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_paranoidFileChecks + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMaxWriteBufferNumberToMaintain + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxWriteBufferNumberToMaintain + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: maxWriteBufferNumberToMaintain + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_maxWriteBufferNumberToMaintain + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setCompactionPriority + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionPriority + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: compactionPriority + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_compactionPriority + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setReportBgIoStats + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setReportBgIoStats + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: reportBgIoStats + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_reportBgIoStats + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setTtl + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setTtl + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: ttl + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_ttl + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setPeriodicCompactionSeconds + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setPeriodicCompactionSeconds + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: periodicCompactionSeconds + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_periodicCompactionSeconds + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setCompactionOptionsUniversal + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionOptionsUniversal + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setCompactionOptionsFIFO + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionOptionsFIFO + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setForceConsistencyChecks + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setForceConsistencyChecks + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: forceConsistencyChecks + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_forceConsistencyChecks + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setSstPartitionerFactory + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setSstPartitionerFactory + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setCompactionThreadLimiter + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionThreadLimiter + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMemtableMaxRangeDeletions + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMemtableMaxRangeDeletions + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: memtableMaxRangeDeletions + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_memtableMaxRangeDeletions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setEnableBlobFiles + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setEnableBlobFiles + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: enableBlobFiles + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_enableBlobFiles + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setMinBlobSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMinBlobSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: minBlobSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_minBlobSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setBlobFileSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobFileSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: blobFileSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_blobFileSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setBlobCompressionType + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobCompressionType + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: blobCompressionType + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_blobCompressionType + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setEnableBlobGarbageCollection + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setEnableBlobGarbageCollection + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: enableBlobGarbageCollection + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_enableBlobGarbageCollection + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setBlobGarbageCollectionAgeCutoff + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobGarbageCollectionAgeCutoff + (JNIEnv *, jobject, jlong, jdouble); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: blobGarbageCollectionAgeCutoff + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_org_forstdb_ColumnFamilyOptions_blobGarbageCollectionAgeCutoff + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setBlobGarbageCollectionForceThreshold + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobGarbageCollectionForceThreshold + (JNIEnv *, jobject, jlong, jdouble); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: blobGarbageCollectionForceThreshold + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_org_forstdb_ColumnFamilyOptions_blobGarbageCollectionForceThreshold + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setBlobCompactionReadaheadSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobCompactionReadaheadSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: blobCompactionReadaheadSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_blobCompactionReadaheadSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setBlobFileStartingLevel + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobFileStartingLevel + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: blobFileStartingLevel + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_blobFileStartingLevel + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: setPrepopulateBlobCache + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setPrepopulateBlobCache + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_ColumnFamilyOptions + * Method: prepopulateBlobCache + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_prepopulateBlobCache + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_CompactRangeOptions.h b/java/include/org_forstdb_CompactRangeOptions.h new file mode 100644 index 000000000..40b48a147 --- /dev/null +++ b/java/include/org_forstdb_CompactRangeOptions.h @@ -0,0 +1,181 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_CompactRangeOptions */ + +#ifndef _Included_org_forstdb_CompactRangeOptions +#define _Included_org_forstdb_CompactRangeOptions +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_CompactRangeOptions_VALUE_kSkip +#define org_forstdb_CompactRangeOptions_VALUE_kSkip 0L +#undef org_forstdb_CompactRangeOptions_VALUE_kIfHaveCompactionFilter +#define org_forstdb_CompactRangeOptions_VALUE_kIfHaveCompactionFilter 1L +#undef org_forstdb_CompactRangeOptions_VALUE_kForce +#define org_forstdb_CompactRangeOptions_VALUE_kForce 2L +#undef org_forstdb_CompactRangeOptions_VALUE_kForceOptimized +#define org_forstdb_CompactRangeOptions_VALUE_kForceOptimized 3L +/* + * Class: org_forstdb_CompactRangeOptions + * Method: newCompactRangeOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactRangeOptions_newCompactRangeOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: exclusiveManualCompaction + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactRangeOptions_exclusiveManualCompaction + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: setExclusiveManualCompaction + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setExclusiveManualCompaction + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: changeLevel + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactRangeOptions_changeLevel + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: setChangeLevel + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setChangeLevel + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: targetLevel + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactRangeOptions_targetLevel + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: setTargetLevel + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setTargetLevel + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: targetPathId + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactRangeOptions_targetPathId + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: setTargetPathId + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setTargetPathId + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: bottommostLevelCompaction + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactRangeOptions_bottommostLevelCompaction + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: setBottommostLevelCompaction + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setBottommostLevelCompaction + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: allowWriteStall + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactRangeOptions_allowWriteStall + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: setAllowWriteStall + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setAllowWriteStall + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: setMaxSubcompactions + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setMaxSubcompactions + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: maxSubcompactions + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactRangeOptions_maxSubcompactions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: setFullHistoryTSLow + * Signature: (JJJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setFullHistoryTSLow + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: fullHistoryTSLow + * Signature: (J)Lorg/forstdb/CompactRangeOptions/Timestamp; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_CompactRangeOptions_fullHistoryTSLow + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: setCanceled + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setCanceled + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_CompactRangeOptions + * Method: canceled + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactRangeOptions_canceled + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_CompactionJobInfo.h b/java/include/org_forstdb_CompactionJobInfo.h new file mode 100644 index 000000000..35122098e --- /dev/null +++ b/java/include/org_forstdb_CompactionJobInfo.h @@ -0,0 +1,125 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_CompactionJobInfo */ + +#ifndef _Included_org_forstdb_CompactionJobInfo +#define _Included_org_forstdb_CompactionJobInfo +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_CompactionJobInfo + * Method: newCompactionJobInfo + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobInfo_newCompactionJobInfo + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionJobInfo_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: columnFamilyName + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_CompactionJobInfo_columnFamilyName + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: status + * Signature: (J)Lorg/forstdb/Status; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_CompactionJobInfo_status + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: threadId + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobInfo_threadId + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: jobId + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactionJobInfo_jobId + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: baseInputLevel + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactionJobInfo_baseInputLevel + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: outputLevel + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactionJobInfo_outputLevel + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: inputFiles + * Signature: (J)[Ljava/lang/String; + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_CompactionJobInfo_inputFiles + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: outputFiles + * Signature: (J)[Ljava/lang/String; + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_CompactionJobInfo_outputFiles + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: tableProperties + * Signature: (J)Ljava/util/Map; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_CompactionJobInfo_tableProperties + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: compactionReason + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_CompactionJobInfo_compactionReason + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: compression + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_CompactionJobInfo_compression + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobInfo + * Method: stats + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobInfo_stats + (JNIEnv *, jclass, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_CompactionJobStats.h b/java/include/org_forstdb_CompactionJobStats.h new file mode 100644 index 000000000..5bdb2ec33 --- /dev/null +++ b/java/include/org_forstdb_CompactionJobStats.h @@ -0,0 +1,229 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_CompactionJobStats */ + +#ifndef _Included_org_forstdb_CompactionJobStats +#define _Included_org_forstdb_CompactionJobStats +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_CompactionJobStats + * Method: newCompactionJobStats + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_newCompactionJobStats + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionJobStats_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: reset + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionJobStats_reset + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: add + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionJobStats_add + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: elapsedMicros + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_elapsedMicros + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: numInputRecords + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numInputRecords + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: numInputFiles + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numInputFiles + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: numInputFilesAtOutputLevel + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numInputFilesAtOutputLevel + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: numOutputRecords + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numOutputRecords + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: numOutputFiles + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numOutputFiles + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: isManualCompaction + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactionJobStats_isManualCompaction + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: totalInputBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_totalInputBytes + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: totalOutputBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_totalOutputBytes + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: numRecordsReplaced + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numRecordsReplaced + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: totalInputRawKeyBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_totalInputRawKeyBytes + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: totalInputRawValueBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_totalInputRawValueBytes + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: numInputDeletionRecords + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numInputDeletionRecords + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: numExpiredDeletionRecords + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numExpiredDeletionRecords + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: numCorruptKeys + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numCorruptKeys + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: fileWriteNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_fileWriteNanos + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: fileRangeSyncNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_fileRangeSyncNanos + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: fileFsyncNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_fileFsyncNanos + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: filePrepareWriteNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_filePrepareWriteNanos + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: smallestOutputKeyPrefix + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_CompactionJobStats_smallestOutputKeyPrefix + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: largestOutputKeyPrefix + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_CompactionJobStats_largestOutputKeyPrefix + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: numSingleDelFallthru + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numSingleDelFallthru + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionJobStats + * Method: numSingleDelMismatch + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numSingleDelMismatch + (JNIEnv *, jclass, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_CompactionOptions.h b/java/include/org_forstdb_CompactionOptions.h new file mode 100644 index 000000000..9de502251 --- /dev/null +++ b/java/include/org_forstdb_CompactionOptions.h @@ -0,0 +1,77 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_CompactionOptions */ + +#ifndef _Included_org_forstdb_CompactionOptions +#define _Included_org_forstdb_CompactionOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_CompactionOptions + * Method: newCompactionOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionOptions_newCompactionOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_CompactionOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionOptions + * Method: compression + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_CompactionOptions_compression + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionOptions + * Method: setCompression + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptions_setCompression + (JNIEnv *, jclass, jlong, jbyte); + +/* + * Class: org_forstdb_CompactionOptions + * Method: outputFileSizeLimit + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionOptions_outputFileSizeLimit + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionOptions + * Method: setOutputFileSizeLimit + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptions_setOutputFileSizeLimit + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_CompactionOptions + * Method: maxSubcompactions + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptions_maxSubcompactions + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_CompactionOptions + * Method: setMaxSubcompactions + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptions_setMaxSubcompactions + (JNIEnv *, jclass, jlong, jint); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_CompactionOptionsFIFO.h b/java/include/org_forstdb_CompactionOptionsFIFO.h new file mode 100644 index 000000000..aed1c4b69 --- /dev/null +++ b/java/include/org_forstdb_CompactionOptionsFIFO.h @@ -0,0 +1,61 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_CompactionOptionsFIFO */ + +#ifndef _Included_org_forstdb_CompactionOptionsFIFO +#define _Included_org_forstdb_CompactionOptionsFIFO +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_CompactionOptionsFIFO + * Method: newCompactionOptionsFIFO + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionOptionsFIFO_newCompactionOptionsFIFO + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_CompactionOptionsFIFO + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsFIFO_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionOptionsFIFO + * Method: setMaxTableFilesSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsFIFO_setMaxTableFilesSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_CompactionOptionsFIFO + * Method: maxTableFilesSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionOptionsFIFO_maxTableFilesSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionOptionsFIFO + * Method: setAllowCompaction + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsFIFO_setAllowCompaction + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_CompactionOptionsFIFO + * Method: allowCompaction + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactionOptionsFIFO_allowCompaction + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_CompactionOptionsUniversal.h b/java/include/org_forstdb_CompactionOptionsUniversal.h new file mode 100644 index 000000000..606032f24 --- /dev/null +++ b/java/include/org_forstdb_CompactionOptionsUniversal.h @@ -0,0 +1,141 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_CompactionOptionsUniversal */ + +#ifndef _Included_org_forstdb_CompactionOptionsUniversal +#define _Included_org_forstdb_CompactionOptionsUniversal +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: newCompactionOptionsUniversal + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionOptionsUniversal_newCompactionOptionsUniversal + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: setSizeRatio + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setSizeRatio + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: sizeRatio + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptionsUniversal_sizeRatio + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: setMinMergeWidth + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setMinMergeWidth + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: minMergeWidth + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptionsUniversal_minMergeWidth + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: setMaxMergeWidth + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setMaxMergeWidth + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: maxMergeWidth + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptionsUniversal_maxMergeWidth + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: setMaxSizeAmplificationPercent + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setMaxSizeAmplificationPercent + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: maxSizeAmplificationPercent + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptionsUniversal_maxSizeAmplificationPercent + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: setCompressionSizePercent + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setCompressionSizePercent + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: compressionSizePercent + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptionsUniversal_compressionSizePercent + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: setStopStyle + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setStopStyle + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: stopStyle + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_CompactionOptionsUniversal_stopStyle + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: setAllowTrivialMove + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setAllowTrivialMove + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_CompactionOptionsUniversal + * Method: allowTrivialMove + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactionOptionsUniversal_allowTrivialMove + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_ComparatorOptions.h b/java/include/org_forstdb_ComparatorOptions.h new file mode 100644 index 000000000..68c0846ea --- /dev/null +++ b/java/include/org_forstdb_ComparatorOptions.h @@ -0,0 +1,77 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_ComparatorOptions */ + +#ifndef _Included_org_forstdb_ComparatorOptions +#define _Included_org_forstdb_ComparatorOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_ComparatorOptions + * Method: newComparatorOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ComparatorOptions_newComparatorOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_ComparatorOptions + * Method: reusedSynchronisationType + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_ComparatorOptions_reusedSynchronisationType + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ComparatorOptions + * Method: setReusedSynchronisationType + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ComparatorOptions_setReusedSynchronisationType + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_ComparatorOptions + * Method: useDirectBuffer + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ComparatorOptions_useDirectBuffer + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ComparatorOptions + * Method: setUseDirectBuffer + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ComparatorOptions_setUseDirectBuffer + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ComparatorOptions + * Method: maxReusedBufferSize + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ComparatorOptions_maxReusedBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ComparatorOptions + * Method: setMaxReusedBufferSize + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ComparatorOptions_setMaxReusedBufferSize + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_ComparatorOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ComparatorOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_CompressionOptions.h b/java/include/org_forstdb_CompressionOptions.h new file mode 100644 index 000000000..b5d7fc79b --- /dev/null +++ b/java/include/org_forstdb_CompressionOptions.h @@ -0,0 +1,125 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_CompressionOptions */ + +#ifndef _Included_org_forstdb_CompressionOptions +#define _Included_org_forstdb_CompressionOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_CompressionOptions + * Method: newCompressionOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_CompressionOptions_newCompressionOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_CompressionOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompressionOptions + * Method: setWindowBits + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setWindowBits + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompressionOptions + * Method: windowBits + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompressionOptions_windowBits + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompressionOptions + * Method: setLevel + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setLevel + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompressionOptions + * Method: level + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompressionOptions_level + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompressionOptions + * Method: setStrategy + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setStrategy + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompressionOptions + * Method: strategy + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompressionOptions_strategy + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompressionOptions + * Method: setMaxDictBytes + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setMaxDictBytes + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompressionOptions + * Method: maxDictBytes + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompressionOptions_maxDictBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompressionOptions + * Method: setZstdMaxTrainBytes + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setZstdMaxTrainBytes + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_CompressionOptions + * Method: zstdMaxTrainBytes + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_CompressionOptions_zstdMaxTrainBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_CompressionOptions + * Method: setEnabled + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setEnabled + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_CompressionOptions + * Method: enabled + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_CompressionOptions_enabled + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_ConcurrentTaskLimiterImpl.h b/java/include/org_forstdb_ConcurrentTaskLimiterImpl.h new file mode 100644 index 000000000..e8ae61f40 --- /dev/null +++ b/java/include/org_forstdb_ConcurrentTaskLimiterImpl.h @@ -0,0 +1,61 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_ConcurrentTaskLimiterImpl */ + +#ifndef _Included_org_forstdb_ConcurrentTaskLimiterImpl +#define _Included_org_forstdb_ConcurrentTaskLimiterImpl +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_ConcurrentTaskLimiterImpl + * Method: newConcurrentTaskLimiterImpl0 + * Signature: (Ljava/lang/String;I)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_newConcurrentTaskLimiterImpl0 + (JNIEnv *, jclass, jstring, jint); + +/* + * Class: org_forstdb_ConcurrentTaskLimiterImpl + * Method: name + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_name + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_ConcurrentTaskLimiterImpl + * Method: setMaxOutstandingTask + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_setMaxOutstandingTask + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_forstdb_ConcurrentTaskLimiterImpl + * Method: resetMaxOutstandingTask + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_resetMaxOutstandingTask + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_ConcurrentTaskLimiterImpl + * Method: outstandingTask + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_outstandingTask + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_ConcurrentTaskLimiterImpl + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_ConfigOptions.h b/java/include/org_forstdb_ConfigOptions.h new file mode 100644 index 000000000..cd3afd215 --- /dev/null +++ b/java/include/org_forstdb_ConfigOptions.h @@ -0,0 +1,69 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_ConfigOptions */ + +#ifndef _Included_org_forstdb_ConfigOptions +#define _Included_org_forstdb_ConfigOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_ConfigOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ConfigOptions + * Method: newConfigOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ConfigOptions_newConfigOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_ConfigOptions + * Method: setEnv + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_setEnv + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_ConfigOptions + * Method: setDelimiter + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_setDelimiter + (JNIEnv *, jclass, jlong, jstring); + +/* + * Class: org_forstdb_ConfigOptions + * Method: setIgnoreUnknownOptions + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_setIgnoreUnknownOptions + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_ConfigOptions + * Method: setInputStringsEscaped + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_setInputStringsEscaped + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_ConfigOptions + * Method: setSanityLevel + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_setSanityLevel + (JNIEnv *, jclass, jlong, jbyte); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_DBOptions.h b/java/include/org_forstdb_DBOptions.h new file mode 100644 index 000000000..1392c0c3d --- /dev/null +++ b/java/include/org_forstdb_DBOptions.h @@ -0,0 +1,1343 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_DBOptions */ + +#ifndef _Included_org_forstdb_DBOptions +#define _Included_org_forstdb_DBOptions +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_DBOptions_DEFAULT_NUM_SHARD_BITS +#define org_forstdb_DBOptions_DEFAULT_NUM_SHARD_BITS -1L +/* + * Class: org_forstdb_DBOptions + * Method: getDBOptionsFromProps + * Signature: (JLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_getDBOptionsFromProps__JLjava_lang_String_2 + (JNIEnv *, jclass, jlong, jstring); + +/* + * Class: org_forstdb_DBOptions + * Method: getDBOptionsFromProps + * Signature: (Ljava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_getDBOptionsFromProps__Ljava_lang_String_2 + (JNIEnv *, jclass, jstring); + +/* + * Class: org_forstdb_DBOptions + * Method: newDBOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_newDBOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_DBOptions + * Method: copyDBOptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_copyDBOptions + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: newDBOptionsFromOptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_newDBOptionsFromOptions + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: optimizeForSmallDb + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_optimizeForSmallDb + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setIncreaseParallelism + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setIncreaseParallelism + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DBOptions + * Method: setCreateIfMissing + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setCreateIfMissing + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: createIfMissing + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_createIfMissing + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setCreateMissingColumnFamilies + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setCreateMissingColumnFamilies + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: createMissingColumnFamilies + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_createMissingColumnFamilies + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setEnv + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setEnv + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setErrorIfExists + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setErrorIfExists + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: errorIfExists + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_errorIfExists + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setParanoidChecks + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setParanoidChecks + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: paranoidChecks + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_paranoidChecks + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setRateLimiter + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setRateLimiter + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setSstFileManager + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setSstFileManager + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setLogger + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setLogger + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setInfoLogLevel + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setInfoLogLevel + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_DBOptions + * Method: infoLogLevel + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_DBOptions_infoLogLevel + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setMaxOpenFiles + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxOpenFiles + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DBOptions + * Method: maxOpenFiles + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxOpenFiles + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setMaxFileOpeningThreads + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxFileOpeningThreads + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DBOptions + * Method: maxFileOpeningThreads + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxFileOpeningThreads + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setMaxTotalWalSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxTotalWalSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: maxTotalWalSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_maxTotalWalSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setStatistics + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setStatistics + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: statistics + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_statistics + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: useFsync + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_useFsync + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setUseFsync + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setUseFsync + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: setDbPaths + * Signature: (J[Ljava/lang/String;[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDbPaths + (JNIEnv *, jobject, jlong, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_DBOptions + * Method: dbPathsLen + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_dbPathsLen + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: dbPaths + * Signature: (J[Ljava/lang/String;[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_dbPaths + (JNIEnv *, jobject, jlong, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_DBOptions + * Method: setDbLogDir + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDbLogDir + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_DBOptions + * Method: dbLogDir + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_DBOptions_dbLogDir + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setWalDir + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalDir + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_DBOptions + * Method: walDir + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_DBOptions_walDir + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setDeleteObsoleteFilesPeriodMicros + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDeleteObsoleteFilesPeriodMicros + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: deleteObsoleteFilesPeriodMicros + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_deleteObsoleteFilesPeriodMicros + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setMaxBackgroundCompactions + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxBackgroundCompactions + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DBOptions + * Method: maxBackgroundCompactions + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxBackgroundCompactions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setMaxSubcompactions + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxSubcompactions + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DBOptions + * Method: maxSubcompactions + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxSubcompactions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setMaxBackgroundFlushes + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxBackgroundFlushes + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DBOptions + * Method: maxBackgroundFlushes + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxBackgroundFlushes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setMaxBackgroundJobs + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxBackgroundJobs + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DBOptions + * Method: maxBackgroundJobs + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxBackgroundJobs + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setMaxLogFileSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxLogFileSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: maxLogFileSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_maxLogFileSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setLogFileTimeToRoll + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setLogFileTimeToRoll + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: logFileTimeToRoll + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_logFileTimeToRoll + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setKeepLogFileNum + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setKeepLogFileNum + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: keepLogFileNum + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_keepLogFileNum + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setRecycleLogFileNum + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setRecycleLogFileNum + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: recycleLogFileNum + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_recycleLogFileNum + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setMaxManifestFileSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxManifestFileSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: maxManifestFileSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_maxManifestFileSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setTableCacheNumshardbits + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setTableCacheNumshardbits + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DBOptions + * Method: tableCacheNumshardbits + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_tableCacheNumshardbits + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setWalTtlSeconds + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalTtlSeconds + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: walTtlSeconds + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_walTtlSeconds + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setWalSizeLimitMB + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalSizeLimitMB + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: walSizeLimitMB + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_walSizeLimitMB + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setMaxWriteBatchGroupSizeBytes + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxWriteBatchGroupSizeBytes + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: maxWriteBatchGroupSizeBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_maxWriteBatchGroupSizeBytes + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setManifestPreallocationSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setManifestPreallocationSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: manifestPreallocationSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_manifestPreallocationSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setUseDirectReads + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setUseDirectReads + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: useDirectReads + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_useDirectReads + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setUseDirectIoForFlushAndCompaction + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setUseDirectIoForFlushAndCompaction + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: useDirectIoForFlushAndCompaction + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_useDirectIoForFlushAndCompaction + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAllowFAllocate + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllowFAllocate + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: allowFAllocate + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allowFAllocate + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAllowMmapReads + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllowMmapReads + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: allowMmapReads + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allowMmapReads + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAllowMmapWrites + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllowMmapWrites + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: allowMmapWrites + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allowMmapWrites + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setIsFdCloseOnExec + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setIsFdCloseOnExec + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: isFdCloseOnExec + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_isFdCloseOnExec + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setStatsDumpPeriodSec + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setStatsDumpPeriodSec + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DBOptions + * Method: statsDumpPeriodSec + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_statsDumpPeriodSec + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setStatsPersistPeriodSec + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setStatsPersistPeriodSec + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DBOptions + * Method: statsPersistPeriodSec + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_statsPersistPeriodSec + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setStatsHistoryBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setStatsHistoryBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: statsHistoryBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_statsHistoryBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAdviseRandomOnOpen + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAdviseRandomOnOpen + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: adviseRandomOnOpen + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_adviseRandomOnOpen + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setDbWriteBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDbWriteBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setWriteBufferManager + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWriteBufferManager + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: dbWriteBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_dbWriteBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAccessHintOnCompactionStart + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAccessHintOnCompactionStart + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_DBOptions + * Method: accessHintOnCompactionStart + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_DBOptions_accessHintOnCompactionStart + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setCompactionReadaheadSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setCompactionReadaheadSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: compactionReadaheadSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_compactionReadaheadSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setRandomAccessMaxBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setRandomAccessMaxBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: randomAccessMaxBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_randomAccessMaxBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setWritableFileMaxBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWritableFileMaxBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: writableFileMaxBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_writableFileMaxBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setUseAdaptiveMutex + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setUseAdaptiveMutex + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: useAdaptiveMutex + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_useAdaptiveMutex + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setBytesPerSync + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setBytesPerSync + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: bytesPerSync + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_bytesPerSync + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setWalBytesPerSync + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalBytesPerSync + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: walBytesPerSync + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_walBytesPerSync + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setStrictBytesPerSync + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setStrictBytesPerSync + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: strictBytesPerSync + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_strictBytesPerSync + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setEventListeners + * Signature: (J[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setEventListeners + (JNIEnv *, jclass, jlong, jlongArray); + +/* + * Class: org_forstdb_DBOptions + * Method: eventListeners + * Signature: (J)[Lorg/forstdb/AbstractEventListener; + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_DBOptions_eventListeners + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setEnableThreadTracking + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setEnableThreadTracking + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: enableThreadTracking + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_enableThreadTracking + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setDelayedWriteRate + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDelayedWriteRate + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: delayedWriteRate + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_delayedWriteRate + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setEnablePipelinedWrite + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setEnablePipelinedWrite + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: enablePipelinedWrite + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_enablePipelinedWrite + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setUnorderedWrite + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setUnorderedWrite + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: unorderedWrite + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_unorderedWrite + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAllowConcurrentMemtableWrite + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllowConcurrentMemtableWrite + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: allowConcurrentMemtableWrite + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allowConcurrentMemtableWrite + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setEnableWriteThreadAdaptiveYield + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setEnableWriteThreadAdaptiveYield + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: enableWriteThreadAdaptiveYield + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_enableWriteThreadAdaptiveYield + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setWriteThreadMaxYieldUsec + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWriteThreadMaxYieldUsec + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: writeThreadMaxYieldUsec + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_writeThreadMaxYieldUsec + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setWriteThreadSlowYieldUsec + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWriteThreadSlowYieldUsec + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: writeThreadSlowYieldUsec + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_writeThreadSlowYieldUsec + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setSkipStatsUpdateOnDbOpen + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setSkipStatsUpdateOnDbOpen + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: skipStatsUpdateOnDbOpen + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_skipStatsUpdateOnDbOpen + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setSkipCheckingSstFileSizesOnDbOpen + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setSkipCheckingSstFileSizesOnDbOpen + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: skipCheckingSstFileSizesOnDbOpen + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_skipCheckingSstFileSizesOnDbOpen + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setWalRecoveryMode + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalRecoveryMode + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_DBOptions + * Method: walRecoveryMode + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_DBOptions_walRecoveryMode + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAllow2pc + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllow2pc + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: allow2pc + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allow2pc + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setRowCache + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setRowCache + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setWalFilter + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalFilter + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setFailIfOptionsFileError + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setFailIfOptionsFileError + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: failIfOptionsFileError + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_failIfOptionsFileError + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setDumpMallocStats + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDumpMallocStats + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: dumpMallocStats + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_dumpMallocStats + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAvoidFlushDuringRecovery + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAvoidFlushDuringRecovery + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: avoidFlushDuringRecovery + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_avoidFlushDuringRecovery + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAvoidFlushDuringShutdown + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAvoidFlushDuringShutdown + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: avoidFlushDuringShutdown + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_avoidFlushDuringShutdown + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAllowIngestBehind + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllowIngestBehind + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: allowIngestBehind + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allowIngestBehind + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setTwoWriteQueues + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setTwoWriteQueues + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: twoWriteQueues + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_twoWriteQueues + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setManualWalFlush + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setManualWalFlush + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: manualWalFlush + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_manualWalFlush + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAtomicFlush + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAtomicFlush + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: atomicFlush + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_atomicFlush + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setAvoidUnnecessaryBlockingIO + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAvoidUnnecessaryBlockingIO + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: avoidUnnecessaryBlockingIO + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_avoidUnnecessaryBlockingIO + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setPersistStatsToDisk + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setPersistStatsToDisk + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: persistStatsToDisk + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_persistStatsToDisk + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setWriteDbidToManifest + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWriteDbidToManifest + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: writeDbidToManifest + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_writeDbidToManifest + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setLogReadaheadSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setLogReadaheadSize + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: logReadaheadSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_logReadaheadSize + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setBestEffortsRecovery + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setBestEffortsRecovery + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_DBOptions + * Method: bestEffortsRecovery + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_bestEffortsRecovery + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setMaxBgErrorResumeCount + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxBgErrorResumeCount + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_forstdb_DBOptions + * Method: maxBgerrorResumeCount + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxBgerrorResumeCount + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: setBgerrorResumeRetryInterval + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setBgerrorResumeRetryInterval + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_DBOptions + * Method: bgerrorResumeRetryInterval + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_bgerrorResumeRetryInterval + (JNIEnv *, jclass, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_DirectSlice.h b/java/include/org_forstdb_DirectSlice.h new file mode 100644 index 000000000..ea809dcb9 --- /dev/null +++ b/java/include/org_forstdb_DirectSlice.h @@ -0,0 +1,77 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_DirectSlice */ + +#ifndef _Included_org_forstdb_DirectSlice +#define _Included_org_forstdb_DirectSlice +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_DirectSlice + * Method: createNewDirectSlice0 + * Signature: (Ljava/nio/ByteBuffer;I)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DirectSlice_createNewDirectSlice0 + (JNIEnv *, jclass, jobject, jint); + +/* + * Class: org_forstdb_DirectSlice + * Method: createNewDirectSlice1 + * Signature: (Ljava/nio/ByteBuffer;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_DirectSlice_createNewDirectSlice1 + (JNIEnv *, jclass, jobject); + +/* + * Class: org_forstdb_DirectSlice + * Method: data0 + * Signature: (J)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_DirectSlice_data0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_DirectSlice + * Method: get0 + * Signature: (JI)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_DirectSlice_get0 + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DirectSlice + * Method: clear0 + * Signature: (JZJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DirectSlice_clear0 + (JNIEnv *, jobject, jlong, jboolean, jlong); + +/* + * Class: org_forstdb_DirectSlice + * Method: removePrefix0 + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DirectSlice_removePrefix0 + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DirectSlice + * Method: setLength0 + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DirectSlice_setLength0 + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_DirectSlice + * Method: disposeInternalBuf + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_DirectSlice_disposeInternalBuf + (JNIEnv *, jobject, jlong, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_Env.h b/java/include/org_forstdb_Env.h new file mode 100644 index 000000000..8b9a95d66 --- /dev/null +++ b/java/include/org_forstdb_Env.h @@ -0,0 +1,77 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_Env */ + +#ifndef _Included_org_forstdb_Env +#define _Included_org_forstdb_Env +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_Env + * Method: getDefaultEnvInternal + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Env_getDefaultEnvInternal + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_Env + * Method: setBackgroundThreads + * Signature: (JIB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Env_setBackgroundThreads + (JNIEnv *, jobject, jlong, jint, jbyte); + +/* + * Class: org_forstdb_Env + * Method: getBackgroundThreads + * Signature: (JB)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Env_getBackgroundThreads + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Env + * Method: getThreadPoolQueueLen + * Signature: (JB)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Env_getThreadPoolQueueLen + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Env + * Method: incBackgroundThreadsIfNeeded + * Signature: (JIB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Env_incBackgroundThreadsIfNeeded + (JNIEnv *, jobject, jlong, jint, jbyte); + +/* + * Class: org_forstdb_Env + * Method: lowerThreadPoolIOPriority + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Env_lowerThreadPoolIOPriority + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Env + * Method: lowerThreadPoolCPUPriority + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Env_lowerThreadPoolCPUPriority + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Env + * Method: getThreadList + * Signature: (J)[Lorg/forstdb/ThreadStatus; + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Env_getThreadList + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_EnvFlinkTestSuite.h b/java/include/org_forstdb_EnvFlinkTestSuite.h new file mode 100644 index 000000000..1a880fa27 --- /dev/null +++ b/java/include/org_forstdb_EnvFlinkTestSuite.h @@ -0,0 +1,37 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_EnvFlinkTestSuite */ + +#ifndef _Included_org_forstdb_EnvFlinkTestSuite +#define _Included_org_forstdb_EnvFlinkTestSuite +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_EnvFlinkTestSuite + * Method: buildNativeObject + * Signature: (Ljava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_EnvFlinkTestSuite_buildNativeObject + (JNIEnv *, jobject, jstring); + +/* + * Class: org_forstdb_EnvFlinkTestSuite + * Method: runAllTestSuites + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvFlinkTestSuite_runAllTestSuites + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvFlinkTestSuite + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvFlinkTestSuite_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_EnvOptions.h b/java/include/org_forstdb_EnvOptions.h new file mode 100644 index 000000000..39795651a --- /dev/null +++ b/java/include/org_forstdb_EnvOptions.h @@ -0,0 +1,221 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_EnvOptions */ + +#ifndef _Included_org_forstdb_EnvOptions +#define _Included_org_forstdb_EnvOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_EnvOptions + * Method: newEnvOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_newEnvOptions__ + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_EnvOptions + * Method: newEnvOptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_newEnvOptions__J + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setUseMmapReads + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setUseMmapReads + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_EnvOptions + * Method: useMmapReads + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_useMmapReads + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setUseMmapWrites + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setUseMmapWrites + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_EnvOptions + * Method: useMmapWrites + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_useMmapWrites + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setUseDirectReads + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setUseDirectReads + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_EnvOptions + * Method: useDirectReads + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_useDirectReads + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setUseDirectWrites + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setUseDirectWrites + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_EnvOptions + * Method: useDirectWrites + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_useDirectWrites + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setAllowFallocate + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setAllowFallocate + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_EnvOptions + * Method: allowFallocate + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_allowFallocate + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setSetFdCloexec + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setSetFdCloexec + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_EnvOptions + * Method: setFdCloexec + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_setFdCloexec + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setBytesPerSync + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setBytesPerSync + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: bytesPerSync + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_bytesPerSync + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setFallocateWithKeepSize + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setFallocateWithKeepSize + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_EnvOptions + * Method: fallocateWithKeepSize + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_fallocateWithKeepSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setCompactionReadaheadSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setCompactionReadaheadSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: compactionReadaheadSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_compactionReadaheadSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setRandomAccessMaxBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setRandomAccessMaxBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: randomAccessMaxBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_randomAccessMaxBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setWritableFileMaxBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setWritableFileMaxBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: writableFileMaxBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_writableFileMaxBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_EnvOptions + * Method: setRateLimiter + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setRateLimiter + (JNIEnv *, jobject, jlong, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_ExportImportFilesMetaData.h b/java/include/org_forstdb_ExportImportFilesMetaData.h new file mode 100644 index 000000000..077daf31a --- /dev/null +++ b/java/include/org_forstdb_ExportImportFilesMetaData.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_ExportImportFilesMetaData */ + +#ifndef _Included_org_forstdb_ExportImportFilesMetaData +#define _Included_org_forstdb_ExportImportFilesMetaData +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_ExportImportFilesMetaData + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ExportImportFilesMetaData_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_Filter.h b/java/include/org_forstdb_Filter.h new file mode 100644 index 000000000..948c5ecaa --- /dev/null +++ b/java/include/org_forstdb_Filter.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_Filter */ + +#ifndef _Included_org_forstdb_Filter +#define _Included_org_forstdb_Filter +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_Filter + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Filter_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_FlinkCompactionFilter.h b/java/include/org_forstdb_FlinkCompactionFilter.h new file mode 100644 index 000000000..bb9bdb15c --- /dev/null +++ b/java/include/org_forstdb_FlinkCompactionFilter.h @@ -0,0 +1,45 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_FlinkCompactionFilter */ + +#ifndef _Included_org_forstdb_FlinkCompactionFilter +#define _Included_org_forstdb_FlinkCompactionFilter +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_FlinkCompactionFilter + * Method: createNewFlinkCompactionFilter0 + * Signature: (JLorg/forstdb/FlinkCompactionFilter/TimeProvider;J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_FlinkCompactionFilter_createNewFlinkCompactionFilter0 + (JNIEnv *, jclass, jlong, jobject, jlong); + +/* + * Class: org_forstdb_FlinkCompactionFilter + * Method: createNewFlinkCompactionFilterConfigHolder + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_FlinkCompactionFilter_createNewFlinkCompactionFilterConfigHolder + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_FlinkCompactionFilter + * Method: disposeFlinkCompactionFilterConfigHolder + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_FlinkCompactionFilter_disposeFlinkCompactionFilterConfigHolder + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_FlinkCompactionFilter + * Method: configureFlinkCompactionFilter + * Signature: (JIIJJILorg/forstdb/FlinkCompactionFilter/ListElementFilterFactory;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_FlinkCompactionFilter_configureFlinkCompactionFilter + (JNIEnv *, jclass, jlong, jint, jint, jlong, jlong, jint, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_FlinkEnv.h b/java/include/org_forstdb_FlinkEnv.h new file mode 100644 index 000000000..4dfe9e786 --- /dev/null +++ b/java/include/org_forstdb_FlinkEnv.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_FlinkEnv */ + +#ifndef _Included_org_forstdb_FlinkEnv +#define _Included_org_forstdb_FlinkEnv +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_FlinkEnv + * Method: createFlinkEnv + * Signature: (Ljava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_FlinkEnv_createFlinkEnv + (JNIEnv *, jclass, jstring); + +/* + * Class: org_forstdb_FlinkEnv + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_FlinkEnv_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_FlushOptions.h b/java/include/org_forstdb_FlushOptions.h new file mode 100644 index 000000000..97ff71b99 --- /dev/null +++ b/java/include/org_forstdb_FlushOptions.h @@ -0,0 +1,61 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_FlushOptions */ + +#ifndef _Included_org_forstdb_FlushOptions +#define _Included_org_forstdb_FlushOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_FlushOptions + * Method: newFlushOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_FlushOptions_newFlushOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_FlushOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_FlushOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_FlushOptions + * Method: setWaitForFlush + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_FlushOptions_setWaitForFlush + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_FlushOptions + * Method: waitForFlush + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_FlushOptions_waitForFlush + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_FlushOptions + * Method: setAllowWriteStall + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_FlushOptions_setAllowWriteStall + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_FlushOptions + * Method: allowWriteStall + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_FlushOptions_allowWriteStall + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_HashLinkedListMemTableConfig.h b/java/include/org_forstdb_HashLinkedListMemTableConfig.h new file mode 100644 index 000000000..bfc29cab3 --- /dev/null +++ b/java/include/org_forstdb_HashLinkedListMemTableConfig.h @@ -0,0 +1,31 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_HashLinkedListMemTableConfig */ + +#ifndef _Included_org_forstdb_HashLinkedListMemTableConfig +#define _Included_org_forstdb_HashLinkedListMemTableConfig +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_HashLinkedListMemTableConfig_DEFAULT_BUCKET_COUNT +#define org_forstdb_HashLinkedListMemTableConfig_DEFAULT_BUCKET_COUNT 50000LL +#undef org_forstdb_HashLinkedListMemTableConfig_DEFAULT_HUGE_PAGE_TLB_SIZE +#define org_forstdb_HashLinkedListMemTableConfig_DEFAULT_HUGE_PAGE_TLB_SIZE 0LL +#undef org_forstdb_HashLinkedListMemTableConfig_DEFAULT_BUCKET_ENTRIES_LOG_THRES +#define org_forstdb_HashLinkedListMemTableConfig_DEFAULT_BUCKET_ENTRIES_LOG_THRES 4096L +#undef org_forstdb_HashLinkedListMemTableConfig_DEFAULT_IF_LOG_BUCKET_DIST_WHEN_FLUSH +#define org_forstdb_HashLinkedListMemTableConfig_DEFAULT_IF_LOG_BUCKET_DIST_WHEN_FLUSH 1L +#undef org_forstdb_HashLinkedListMemTableConfig_DEFAUL_THRESHOLD_USE_SKIPLIST +#define org_forstdb_HashLinkedListMemTableConfig_DEFAUL_THRESHOLD_USE_SKIPLIST 256L +/* + * Class: org_forstdb_HashLinkedListMemTableConfig + * Method: newMemTableFactoryHandle + * Signature: (JJIZI)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_HashLinkedListMemTableConfig_newMemTableFactoryHandle + (JNIEnv *, jobject, jlong, jlong, jint, jboolean, jint); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_HashSkipListMemTableConfig.h b/java/include/org_forstdb_HashSkipListMemTableConfig.h new file mode 100644 index 000000000..bc800fe5a --- /dev/null +++ b/java/include/org_forstdb_HashSkipListMemTableConfig.h @@ -0,0 +1,27 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_HashSkipListMemTableConfig */ + +#ifndef _Included_org_forstdb_HashSkipListMemTableConfig +#define _Included_org_forstdb_HashSkipListMemTableConfig +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_HashSkipListMemTableConfig_DEFAULT_BUCKET_COUNT +#define org_forstdb_HashSkipListMemTableConfig_DEFAULT_BUCKET_COUNT 1000000L +#undef org_forstdb_HashSkipListMemTableConfig_DEFAULT_BRANCHING_FACTOR +#define org_forstdb_HashSkipListMemTableConfig_DEFAULT_BRANCHING_FACTOR 4L +#undef org_forstdb_HashSkipListMemTableConfig_DEFAULT_HEIGHT +#define org_forstdb_HashSkipListMemTableConfig_DEFAULT_HEIGHT 4L +/* + * Class: org_forstdb_HashSkipListMemTableConfig + * Method: newMemTableFactoryHandle + * Signature: (JII)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_HashSkipListMemTableConfig_newMemTableFactoryHandle + (JNIEnv *, jobject, jlong, jint, jint); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_HyperClockCache.h b/java/include/org_forstdb_HyperClockCache.h new file mode 100644 index 000000000..c7f5ea634 --- /dev/null +++ b/java/include/org_forstdb_HyperClockCache.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_HyperClockCache */ + +#ifndef _Included_org_forstdb_HyperClockCache +#define _Included_org_forstdb_HyperClockCache +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_HyperClockCache + * Method: disposeInternalJni + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_HyperClockCache_disposeInternalJni + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_HyperClockCache + * Method: newHyperClockCache + * Signature: (JJIZ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_HyperClockCache_newHyperClockCache + (JNIEnv *, jclass, jlong, jlong, jint, jboolean); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_ImportColumnFamilyOptions.h b/java/include/org_forstdb_ImportColumnFamilyOptions.h new file mode 100644 index 000000000..d97b72abb --- /dev/null +++ b/java/include/org_forstdb_ImportColumnFamilyOptions.h @@ -0,0 +1,45 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_ImportColumnFamilyOptions */ + +#ifndef _Included_org_forstdb_ImportColumnFamilyOptions +#define _Included_org_forstdb_ImportColumnFamilyOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_ImportColumnFamilyOptions + * Method: newImportColumnFamilyOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ImportColumnFamilyOptions_newImportColumnFamilyOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_ImportColumnFamilyOptions + * Method: moveFiles + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ImportColumnFamilyOptions_moveFiles + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ImportColumnFamilyOptions + * Method: setMoveFiles + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ImportColumnFamilyOptions_setMoveFiles + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ImportColumnFamilyOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ImportColumnFamilyOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_IngestExternalFileOptions.h b/java/include/org_forstdb_IngestExternalFileOptions.h new file mode 100644 index 000000000..7db0ec878 --- /dev/null +++ b/java/include/org_forstdb_IngestExternalFileOptions.h @@ -0,0 +1,133 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_IngestExternalFileOptions */ + +#ifndef _Included_org_forstdb_IngestExternalFileOptions +#define _Included_org_forstdb_IngestExternalFileOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: newIngestExternalFileOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_IngestExternalFileOptions_newIngestExternalFileOptions__ + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: newIngestExternalFileOptions + * Signature: (ZZZZ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_IngestExternalFileOptions_newIngestExternalFileOptions__ZZZZ + (JNIEnv *, jclass, jboolean, jboolean, jboolean, jboolean); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: moveFiles + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_moveFiles + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: setMoveFiles + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setMoveFiles + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: snapshotConsistency + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_snapshotConsistency + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: setSnapshotConsistency + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setSnapshotConsistency + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: allowGlobalSeqNo + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_allowGlobalSeqNo + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: setAllowGlobalSeqNo + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setAllowGlobalSeqNo + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: allowBlockingFlush + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_allowBlockingFlush + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: setAllowBlockingFlush + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setAllowBlockingFlush + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: ingestBehind + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_ingestBehind + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: setIngestBehind + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setIngestBehind + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: writeGlobalSeqno + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_writeGlobalSeqno + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_IngestExternalFileOptions + * Method: setWriteGlobalSeqno + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setWriteGlobalSeqno + (JNIEnv *, jobject, jlong, jboolean); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_LRUCache.h b/java/include/org_forstdb_LRUCache.h new file mode 100644 index 000000000..168288330 --- /dev/null +++ b/java/include/org_forstdb_LRUCache.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_LRUCache */ + +#ifndef _Included_org_forstdb_LRUCache +#define _Included_org_forstdb_LRUCache +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_LRUCache + * Method: newLRUCache + * Signature: (JIZDD)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_LRUCache_newLRUCache + (JNIEnv *, jclass, jlong, jint, jboolean, jdouble, jdouble); + +/* + * Class: org_forstdb_LRUCache + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_LRUCache_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_LiveFileMetaData.h b/java/include/org_forstdb_LiveFileMetaData.h new file mode 100644 index 000000000..f89568b61 --- /dev/null +++ b/java/include/org_forstdb_LiveFileMetaData.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_LiveFileMetaData */ + +#ifndef _Included_org_forstdb_LiveFileMetaData +#define _Included_org_forstdb_LiveFileMetaData +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_LiveFileMetaData + * Method: newLiveFileMetaDataHandle + * Signature: ([BIILjava/lang/String;Ljava/lang/String;JJJ[BI[BIJZJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_LiveFileMetaData_newLiveFileMetaDataHandle + (JNIEnv *, jobject, jbyteArray, jint, jint, jstring, jstring, jlong, jlong, jlong, jbyteArray, jint, jbyteArray, jint, jlong, jboolean, jlong, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_Logger.h b/java/include/org_forstdb_Logger.h new file mode 100644 index 000000000..d1968a3fd --- /dev/null +++ b/java/include/org_forstdb_Logger.h @@ -0,0 +1,57 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_Logger */ + +#ifndef _Included_org_forstdb_Logger +#define _Included_org_forstdb_Logger +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_Logger_WITH_OPTIONS +#define org_forstdb_Logger_WITH_OPTIONS 0LL +#undef org_forstdb_Logger_WITH_DBOPTIONS +#define org_forstdb_Logger_WITH_DBOPTIONS 1LL +/* + * Class: org_forstdb_Logger + * Method: createNewLoggerOptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Logger_createNewLoggerOptions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Logger + * Method: createNewLoggerDbOptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Logger_createNewLoggerDbOptions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Logger + * Method: setInfoLogLevel + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Logger_setInfoLogLevel + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Logger + * Method: infoLogLevel + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Logger_infoLogLevel + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Logger + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Logger_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_MemoryUtil.h b/java/include/org_forstdb_MemoryUtil.h new file mode 100644 index 000000000..ed7b3fd3f --- /dev/null +++ b/java/include/org_forstdb_MemoryUtil.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_MemoryUtil */ + +#ifndef _Included_org_forstdb_MemoryUtil +#define _Included_org_forstdb_MemoryUtil +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_MemoryUtil + * Method: getApproximateMemoryUsageByType + * Signature: ([J[J)Ljava/util/Map; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_MemoryUtil_getApproximateMemoryUsageByType + (JNIEnv *, jclass, jlongArray, jlongArray); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_NativeComparatorWrapper.h b/java/include/org_forstdb_NativeComparatorWrapper.h new file mode 100644 index 000000000..7fb7fb9d1 --- /dev/null +++ b/java/include/org_forstdb_NativeComparatorWrapper.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_NativeComparatorWrapper */ + +#ifndef _Included_org_forstdb_NativeComparatorWrapper +#define _Included_org_forstdb_NativeComparatorWrapper +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_NativeComparatorWrapper + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_NativeComparatorWrapper_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper.h b/java/include/org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper.h new file mode 100644 index 000000000..b94d5e91a --- /dev/null +++ b/java/include/org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper */ + +#ifndef _Included_org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper +#define _Included_org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper + * Method: newStringComparator + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_NativeComparatorWrapperTest_00024NativeStringComparatorWrapper_newStringComparator + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_OptimisticTransactionDB.h b/java/include/org_forstdb_OptimisticTransactionDB.h new file mode 100644 index 000000000..86f111d7b --- /dev/null +++ b/java/include/org_forstdb_OptimisticTransactionDB.h @@ -0,0 +1,87 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_OptimisticTransactionDB */ + +#ifndef _Included_org_forstdb_OptimisticTransactionDB +#define _Included_org_forstdb_OptimisticTransactionDB +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_OptimisticTransactionDB_NOT_FOUND +#define org_forstdb_OptimisticTransactionDB_NOT_FOUND -1L +/* + * Class: org_forstdb_OptimisticTransactionDB + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_OptimisticTransactionDB_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_OptimisticTransactionDB + * Method: open + * Signature: (JLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_open__JLjava_lang_String_2 + (JNIEnv *, jclass, jlong, jstring); + +/* + * Class: org_forstdb_OptimisticTransactionDB + * Method: open + * Signature: (JLjava/lang/String;[[B[J)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_OptimisticTransactionDB_open__JLjava_lang_String_2_3_3B_3J + (JNIEnv *, jclass, jlong, jstring, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_OptimisticTransactionDB + * Method: closeDatabase + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_OptimisticTransactionDB_closeDatabase + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_OptimisticTransactionDB + * Method: beginTransaction + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_beginTransaction__JJ + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_OptimisticTransactionDB + * Method: beginTransaction + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_beginTransaction__JJJ + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_OptimisticTransactionDB + * Method: beginTransaction_withOld + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_beginTransaction_1withOld__JJJ + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_OptimisticTransactionDB + * Method: beginTransaction_withOld + * Signature: (JJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_beginTransaction_1withOld__JJJJ + (JNIEnv *, jobject, jlong, jlong, jlong, jlong); + +/* + * Class: org_forstdb_OptimisticTransactionDB + * Method: getBaseDB + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_getBaseDB + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_OptimisticTransactionOptions.h b/java/include/org_forstdb_OptimisticTransactionOptions.h new file mode 100644 index 000000000..9060f1b13 --- /dev/null +++ b/java/include/org_forstdb_OptimisticTransactionOptions.h @@ -0,0 +1,53 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_OptimisticTransactionOptions */ + +#ifndef _Included_org_forstdb_OptimisticTransactionOptions +#define _Included_org_forstdb_OptimisticTransactionOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_OptimisticTransactionOptions + * Method: newOptimisticTransactionOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionOptions_newOptimisticTransactionOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_OptimisticTransactionOptions + * Method: isSetSnapshot + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_OptimisticTransactionOptions_isSetSnapshot + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_OptimisticTransactionOptions + * Method: setSetSnapshot + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_OptimisticTransactionOptions_setSetSnapshot + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_OptimisticTransactionOptions + * Method: setComparator + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_OptimisticTransactionOptions_setComparator + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_OptimisticTransactionOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_OptimisticTransactionOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_Options.h b/java/include/org_forstdb_Options.h new file mode 100644 index 000000000..363a38321 --- /dev/null +++ b/java/include/org_forstdb_Options.h @@ -0,0 +1,2405 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_Options */ + +#ifndef _Included_org_forstdb_Options +#define _Included_org_forstdb_Options +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_Options + * Method: newOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_newOptions__ + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_Options + * Method: newOptions + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_newOptions__JJ + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: copyOptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_copyOptions + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setEnv + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnv + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: prepareForBulkLoad + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_prepareForBulkLoad + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setIncreaseParallelism + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setIncreaseParallelism + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: setCreateIfMissing + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCreateIfMissing + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: createIfMissing + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_createIfMissing + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCreateMissingColumnFamilies + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCreateMissingColumnFamilies + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: createMissingColumnFamilies + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_createMissingColumnFamilies + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setErrorIfExists + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setErrorIfExists + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: errorIfExists + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_errorIfExists + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setParanoidChecks + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setParanoidChecks + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: paranoidChecks + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_paranoidChecks + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setRateLimiter + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setRateLimiter + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setSstFileManager + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setSstFileManager + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setLogger + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setLogger + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setInfoLogLevel + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setInfoLogLevel + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Options + * Method: infoLogLevel + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_infoLogLevel + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxOpenFiles + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxOpenFiles + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: maxOpenFiles + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxOpenFiles + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxTotalWalSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxTotalWalSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxFileOpeningThreads + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxFileOpeningThreads + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: maxFileOpeningThreads + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxFileOpeningThreads + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: maxTotalWalSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxTotalWalSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setStatistics + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setStatistics + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: statistics + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_statistics + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: useFsync + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_useFsync + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setUseFsync + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setUseFsync + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: setDbPaths + * Signature: (J[Ljava/lang/String;[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setDbPaths + (JNIEnv *, jobject, jlong, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_Options + * Method: dbPathsLen + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_dbPathsLen + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: dbPaths + * Signature: (J[Ljava/lang/String;[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_dbPaths + (JNIEnv *, jobject, jlong, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_Options + * Method: setDbLogDir + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setDbLogDir + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_Options + * Method: dbLogDir + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_Options_dbLogDir + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWalDir + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalDir + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_Options + * Method: walDir + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_Options_walDir + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setDeleteObsoleteFilesPeriodMicros + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setDeleteObsoleteFilesPeriodMicros + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: deleteObsoleteFilesPeriodMicros + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_deleteObsoleteFilesPeriodMicros + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxBackgroundCompactions + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBackgroundCompactions + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: maxBackgroundCompactions + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxBackgroundCompactions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxSubcompactions + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxSubcompactions + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: maxSubcompactions + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxSubcompactions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxBackgroundFlushes + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBackgroundFlushes + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: maxBackgroundFlushes + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxBackgroundFlushes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxBackgroundJobs + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBackgroundJobs + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: maxBackgroundJobs + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxBackgroundJobs + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxLogFileSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxLogFileSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: maxLogFileSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxLogFileSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setLogFileTimeToRoll + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setLogFileTimeToRoll + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: logFileTimeToRoll + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_logFileTimeToRoll + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setKeepLogFileNum + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setKeepLogFileNum + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: keepLogFileNum + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_keepLogFileNum + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setRecycleLogFileNum + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setRecycleLogFileNum + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: recycleLogFileNum + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_recycleLogFileNum + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxManifestFileSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxManifestFileSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: maxManifestFileSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxManifestFileSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxTableFilesSizeFIFO + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxTableFilesSizeFIFO + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: maxTableFilesSizeFIFO + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxTableFilesSizeFIFO + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setTableCacheNumshardbits + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setTableCacheNumshardbits + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: tableCacheNumshardbits + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_tableCacheNumshardbits + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWalTtlSeconds + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalTtlSeconds + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: walTtlSeconds + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_walTtlSeconds + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWalSizeLimitMB + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalSizeLimitMB + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: walSizeLimitMB + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_walSizeLimitMB + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxWriteBatchGroupSizeBytes + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxWriteBatchGroupSizeBytes + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: maxWriteBatchGroupSizeBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxWriteBatchGroupSizeBytes + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: setManifestPreallocationSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setManifestPreallocationSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: manifestPreallocationSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_manifestPreallocationSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setUseDirectReads + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setUseDirectReads + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: useDirectReads + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_useDirectReads + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setUseDirectIoForFlushAndCompaction + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setUseDirectIoForFlushAndCompaction + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: useDirectIoForFlushAndCompaction + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_useDirectIoForFlushAndCompaction + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAllowFAllocate + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllowFAllocate + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: allowFAllocate + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allowFAllocate + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAllowMmapReads + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllowMmapReads + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: allowMmapReads + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allowMmapReads + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAllowMmapWrites + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllowMmapWrites + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: allowMmapWrites + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allowMmapWrites + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setIsFdCloseOnExec + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setIsFdCloseOnExec + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: isFdCloseOnExec + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_isFdCloseOnExec + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setStatsDumpPeriodSec + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setStatsDumpPeriodSec + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: statsDumpPeriodSec + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_statsDumpPeriodSec + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setStatsPersistPeriodSec + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setStatsPersistPeriodSec + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: statsPersistPeriodSec + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_statsPersistPeriodSec + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setStatsHistoryBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setStatsHistoryBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: statsHistoryBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_statsHistoryBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAdviseRandomOnOpen + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAdviseRandomOnOpen + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: adviseRandomOnOpen + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_adviseRandomOnOpen + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setDbWriteBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setDbWriteBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWriteBufferManager + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWriteBufferManager + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: dbWriteBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_dbWriteBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAccessHintOnCompactionStart + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAccessHintOnCompactionStart + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Options + * Method: accessHintOnCompactionStart + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_accessHintOnCompactionStart + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCompactionReadaheadSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionReadaheadSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: compactionReadaheadSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_compactionReadaheadSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setRandomAccessMaxBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setRandomAccessMaxBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: randomAccessMaxBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_randomAccessMaxBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWritableFileMaxBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWritableFileMaxBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: writableFileMaxBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_writableFileMaxBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setUseAdaptiveMutex + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setUseAdaptiveMutex + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: useAdaptiveMutex + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_useAdaptiveMutex + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBytesPerSync + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBytesPerSync + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: bytesPerSync + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_bytesPerSync + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWalBytesPerSync + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalBytesPerSync + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: walBytesPerSync + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_walBytesPerSync + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setStrictBytesPerSync + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setStrictBytesPerSync + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: strictBytesPerSync + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_strictBytesPerSync + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setEventListeners + * Signature: (J[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setEventListeners + (JNIEnv *, jclass, jlong, jlongArray); + +/* + * Class: org_forstdb_Options + * Method: eventListeners + * Signature: (J)[Lorg/forstdb/AbstractEventListener; + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Options_eventListeners + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: setEnableThreadTracking + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnableThreadTracking + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: enableThreadTracking + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_enableThreadTracking + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setDelayedWriteRate + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setDelayedWriteRate + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: delayedWriteRate + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_delayedWriteRate + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setEnablePipelinedWrite + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnablePipelinedWrite + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: enablePipelinedWrite + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_enablePipelinedWrite + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setUnorderedWrite + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setUnorderedWrite + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: unorderedWrite + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_unorderedWrite + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAllowConcurrentMemtableWrite + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllowConcurrentMemtableWrite + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: allowConcurrentMemtableWrite + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allowConcurrentMemtableWrite + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setEnableWriteThreadAdaptiveYield + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnableWriteThreadAdaptiveYield + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: enableWriteThreadAdaptiveYield + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_enableWriteThreadAdaptiveYield + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWriteThreadMaxYieldUsec + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWriteThreadMaxYieldUsec + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: writeThreadMaxYieldUsec + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_writeThreadMaxYieldUsec + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWriteThreadSlowYieldUsec + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWriteThreadSlowYieldUsec + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: writeThreadSlowYieldUsec + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_writeThreadSlowYieldUsec + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setSkipStatsUpdateOnDbOpen + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setSkipStatsUpdateOnDbOpen + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: skipStatsUpdateOnDbOpen + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_skipStatsUpdateOnDbOpen + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setSkipCheckingSstFileSizesOnDbOpen + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setSkipCheckingSstFileSizesOnDbOpen + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: skipCheckingSstFileSizesOnDbOpen + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_skipCheckingSstFileSizesOnDbOpen + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWalRecoveryMode + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalRecoveryMode + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Options + * Method: walRecoveryMode + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_walRecoveryMode + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAllow2pc + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllow2pc + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: allow2pc + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allow2pc + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setRowCache + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setRowCache + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWalFilter + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalFilter + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setFailIfOptionsFileError + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setFailIfOptionsFileError + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: failIfOptionsFileError + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_failIfOptionsFileError + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setDumpMallocStats + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setDumpMallocStats + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: dumpMallocStats + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_dumpMallocStats + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAvoidFlushDuringRecovery + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAvoidFlushDuringRecovery + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: avoidFlushDuringRecovery + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_avoidFlushDuringRecovery + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAvoidFlushDuringShutdown + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAvoidFlushDuringShutdown + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: avoidFlushDuringShutdown + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_avoidFlushDuringShutdown + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAllowIngestBehind + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllowIngestBehind + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: allowIngestBehind + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allowIngestBehind + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setTwoWriteQueues + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setTwoWriteQueues + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: twoWriteQueues + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_twoWriteQueues + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setManualWalFlush + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setManualWalFlush + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: manualWalFlush + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_manualWalFlush + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: oldDefaults + * Signature: (JII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_oldDefaults + (JNIEnv *, jclass, jlong, jint, jint); + +/* + * Class: org_forstdb_Options + * Method: optimizeForSmallDb + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_optimizeForSmallDb__J + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: optimizeForSmallDb + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_optimizeForSmallDb__JJ + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: optimizeForPointLookup + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_optimizeForPointLookup + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: optimizeLevelStyleCompaction + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_optimizeLevelStyleCompaction + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: optimizeUniversalStyleCompaction + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_optimizeUniversalStyleCompaction + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setComparatorHandle + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setComparatorHandle__JI + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: setComparatorHandle + * Signature: (JJB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setComparatorHandle__JJB + (JNIEnv *, jobject, jlong, jlong, jbyte); + +/* + * Class: org_forstdb_Options + * Method: setMergeOperatorName + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMergeOperatorName + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_Options + * Method: setMergeOperator + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMergeOperator + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCompactionFilterHandle + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionFilterHandle + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCompactionFilterFactoryHandle + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionFilterFactoryHandle + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWriteBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWriteBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: writeBufferSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_writeBufferSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxWriteBufferNumber + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxWriteBufferNumber + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: maxWriteBufferNumber + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxWriteBufferNumber + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMinWriteBufferNumberToMerge + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMinWriteBufferNumberToMerge + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: minWriteBufferNumberToMerge + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_minWriteBufferNumberToMerge + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCompressionType + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompressionType + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Options + * Method: compressionType + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_compressionType + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCompressionPerLevel + * Signature: (J[B)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompressionPerLevel + (JNIEnv *, jobject, jlong, jbyteArray); + +/* + * Class: org_forstdb_Options + * Method: compressionPerLevel + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_Options_compressionPerLevel + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBottommostCompressionType + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBottommostCompressionType + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Options + * Method: bottommostCompressionType + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_bottommostCompressionType + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBottommostCompressionOptions + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBottommostCompressionOptions + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCompressionOptions + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompressionOptions + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: useFixedLengthPrefixExtractor + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_useFixedLengthPrefixExtractor + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: useCappedPrefixExtractor + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_useCappedPrefixExtractor + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: setNumLevels + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setNumLevels + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: numLevels + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_numLevels + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setLevelZeroFileNumCompactionTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevelZeroFileNumCompactionTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: levelZeroFileNumCompactionTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_levelZeroFileNumCompactionTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setLevelZeroSlowdownWritesTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevelZeroSlowdownWritesTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: levelZeroSlowdownWritesTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_levelZeroSlowdownWritesTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setLevelZeroStopWritesTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevelZeroStopWritesTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: levelZeroStopWritesTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_levelZeroStopWritesTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setTargetFileSizeBase + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setTargetFileSizeBase + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: targetFileSizeBase + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_targetFileSizeBase + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setTargetFileSizeMultiplier + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setTargetFileSizeMultiplier + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: targetFileSizeMultiplier + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_targetFileSizeMultiplier + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxBytesForLevelBase + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBytesForLevelBase + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: maxBytesForLevelBase + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxBytesForLevelBase + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setLevelCompactionDynamicLevelBytes + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevelCompactionDynamicLevelBytes + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: levelCompactionDynamicLevelBytes + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_levelCompactionDynamicLevelBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxBytesForLevelMultiplier + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBytesForLevelMultiplier + (JNIEnv *, jobject, jlong, jdouble); + +/* + * Class: org_forstdb_Options + * Method: maxBytesForLevelMultiplier + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_org_forstdb_Options_maxBytesForLevelMultiplier + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxCompactionBytes + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxCompactionBytes + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: maxCompactionBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxCompactionBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setArenaBlockSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setArenaBlockSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: arenaBlockSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_arenaBlockSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setDisableAutoCompactions + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setDisableAutoCompactions + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: disableAutoCompactions + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_disableAutoCompactions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCompactionStyle + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionStyle + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Options + * Method: compactionStyle + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_compactionStyle + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxSequentialSkipInIterations + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxSequentialSkipInIterations + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: maxSequentialSkipInIterations + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxSequentialSkipInIterations + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMemTableFactory + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMemTableFactory + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: memTableFactoryName + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_Options_memTableFactoryName + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setTableFactory + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setTableFactory + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: tableFactoryName + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_Options_tableFactoryName + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCfPaths + * Signature: (J[Ljava/lang/String;[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCfPaths + (JNIEnv *, jclass, jlong, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_Options + * Method: cfPathsLen + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_cfPathsLen + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: cfPaths + * Signature: (J[Ljava/lang/String;[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_cfPaths + (JNIEnv *, jclass, jlong, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_Options + * Method: setInplaceUpdateSupport + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setInplaceUpdateSupport + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: inplaceUpdateSupport + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_inplaceUpdateSupport + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setInplaceUpdateNumLocks + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setInplaceUpdateNumLocks + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: inplaceUpdateNumLocks + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_inplaceUpdateNumLocks + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMemtablePrefixBloomSizeRatio + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMemtablePrefixBloomSizeRatio + (JNIEnv *, jobject, jlong, jdouble); + +/* + * Class: org_forstdb_Options + * Method: memtablePrefixBloomSizeRatio + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_org_forstdb_Options_memtablePrefixBloomSizeRatio + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setExperimentalMempurgeThreshold + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setExperimentalMempurgeThreshold + (JNIEnv *, jobject, jlong, jdouble); + +/* + * Class: org_forstdb_Options + * Method: experimentalMempurgeThreshold + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_org_forstdb_Options_experimentalMempurgeThreshold + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMemtableWholeKeyFiltering + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMemtableWholeKeyFiltering + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: memtableWholeKeyFiltering + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_memtableWholeKeyFiltering + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBloomLocality + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBloomLocality + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: bloomLocality + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_bloomLocality + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxSuccessiveMerges + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxSuccessiveMerges + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: maxSuccessiveMerges + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxSuccessiveMerges + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setOptimizeFiltersForHits + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setOptimizeFiltersForHits + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: optimizeFiltersForHits + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_optimizeFiltersForHits + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMemtableHugePageSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMemtableHugePageSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: memtableHugePageSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_memtableHugePageSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setSoftPendingCompactionBytesLimit + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setSoftPendingCompactionBytesLimit + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: softPendingCompactionBytesLimit + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_softPendingCompactionBytesLimit + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setHardPendingCompactionBytesLimit + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setHardPendingCompactionBytesLimit + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: hardPendingCompactionBytesLimit + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_hardPendingCompactionBytesLimit + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setLevel0FileNumCompactionTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevel0FileNumCompactionTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: level0FileNumCompactionTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_level0FileNumCompactionTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setLevel0SlowdownWritesTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevel0SlowdownWritesTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: level0SlowdownWritesTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_level0SlowdownWritesTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setLevel0StopWritesTrigger + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevel0StopWritesTrigger + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: level0StopWritesTrigger + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_level0StopWritesTrigger + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxBytesForLevelMultiplierAdditional + * Signature: (J[I)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBytesForLevelMultiplierAdditional + (JNIEnv *, jobject, jlong, jintArray); + +/* + * Class: org_forstdb_Options + * Method: maxBytesForLevelMultiplierAdditional + * Signature: (J)[I + */ +JNIEXPORT jintArray JNICALL Java_org_forstdb_Options_maxBytesForLevelMultiplierAdditional + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setParanoidFileChecks + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setParanoidFileChecks + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: paranoidFileChecks + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_paranoidFileChecks + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxWriteBufferNumberToMaintain + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxWriteBufferNumberToMaintain + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: maxWriteBufferNumberToMaintain + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxWriteBufferNumberToMaintain + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCompactionPriority + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionPriority + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Options + * Method: compactionPriority + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_compactionPriority + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setReportBgIoStats + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setReportBgIoStats + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: reportBgIoStats + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_reportBgIoStats + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setTtl + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setTtl + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: ttl + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_ttl + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setPeriodicCompactionSeconds + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setPeriodicCompactionSeconds + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: periodicCompactionSeconds + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_periodicCompactionSeconds + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCompactionOptionsUniversal + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionOptionsUniversal + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCompactionOptionsFIFO + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionOptionsFIFO + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setForceConsistencyChecks + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setForceConsistencyChecks + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: forceConsistencyChecks + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_forceConsistencyChecks + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAtomicFlush + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAtomicFlush + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: atomicFlush + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_atomicFlush + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setSstPartitionerFactory + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setSstPartitionerFactory + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMemtableMaxRangeDeletions + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMemtableMaxRangeDeletions + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: memtableMaxRangeDeletions + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_memtableMaxRangeDeletions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setCompactionThreadLimiter + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionThreadLimiter + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: setAvoidUnnecessaryBlockingIO + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setAvoidUnnecessaryBlockingIO + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: avoidUnnecessaryBlockingIO + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_avoidUnnecessaryBlockingIO + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: setPersistStatsToDisk + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setPersistStatsToDisk + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: persistStatsToDisk + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_persistStatsToDisk + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: setWriteDbidToManifest + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setWriteDbidToManifest + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: writeDbidToManifest + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_writeDbidToManifest + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: setLogReadaheadSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setLogReadaheadSize + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: logReadaheadSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_logReadaheadSize + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBestEffortsRecovery + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBestEffortsRecovery + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: bestEffortsRecovery + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_bestEffortsRecovery + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMaxBgErrorResumeCount + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBgErrorResumeCount + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: maxBgerrorResumeCount + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxBgerrorResumeCount + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBgerrorResumeRetryInterval + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBgerrorResumeRetryInterval + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: bgerrorResumeRetryInterval + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_bgerrorResumeRetryInterval + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Options + * Method: setEnableBlobFiles + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnableBlobFiles + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: enableBlobFiles + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_enableBlobFiles + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setMinBlobSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setMinBlobSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: minBlobSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_minBlobSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBlobFileSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobFileSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: blobFileSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_blobFileSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBlobCompressionType + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobCompressionType + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Options + * Method: blobCompressionType + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_blobCompressionType + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setEnableBlobGarbageCollection + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnableBlobGarbageCollection + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_Options + * Method: enableBlobGarbageCollection + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_enableBlobGarbageCollection + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBlobGarbageCollectionAgeCutoff + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobGarbageCollectionAgeCutoff + (JNIEnv *, jobject, jlong, jdouble); + +/* + * Class: org_forstdb_Options + * Method: blobGarbageCollectionAgeCutoff + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_org_forstdb_Options_blobGarbageCollectionAgeCutoff + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBlobGarbageCollectionForceThreshold + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobGarbageCollectionForceThreshold + (JNIEnv *, jobject, jlong, jdouble); + +/* + * Class: org_forstdb_Options + * Method: blobGarbageCollectionForceThreshold + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_org_forstdb_Options_blobGarbageCollectionForceThreshold + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBlobCompactionReadaheadSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobCompactionReadaheadSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Options + * Method: blobCompactionReadaheadSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Options_blobCompactionReadaheadSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setBlobFileStartingLevel + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobFileStartingLevel + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Options + * Method: blobFileStartingLevel + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Options_blobFileStartingLevel + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Options + * Method: setPrepopulateBlobCache + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Options_setPrepopulateBlobCache + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Options + * Method: prepopulateBlobCache + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_prepopulateBlobCache + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_OptionsUtil.h b/java/include/org_forstdb_OptionsUtil.h new file mode 100644 index 000000000..e4bb85ab0 --- /dev/null +++ b/java/include/org_forstdb_OptionsUtil.h @@ -0,0 +1,45 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_OptionsUtil */ + +#ifndef _Included_org_forstdb_OptionsUtil +#define _Included_org_forstdb_OptionsUtil +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_OptionsUtil + * Method: loadLatestOptions + * Signature: (JLjava/lang/String;JLjava/util/List;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_OptionsUtil_loadLatestOptions + (JNIEnv *, jclass, jlong, jstring, jlong, jobject); + +/* + * Class: org_forstdb_OptionsUtil + * Method: loadOptionsFromFile + * Signature: (JLjava/lang/String;JLjava/util/List;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_OptionsUtil_loadOptionsFromFile + (JNIEnv *, jclass, jlong, jstring, jlong, jobject); + +/* + * Class: org_forstdb_OptionsUtil + * Method: getLatestOptionsFileName + * Signature: (Ljava/lang/String;J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_OptionsUtil_getLatestOptionsFileName + (JNIEnv *, jclass, jstring, jlong); + +/* + * Class: org_forstdb_OptionsUtil + * Method: readTableFormatConfig + * Signature: (J)Lorg/forstdb/TableFormatConfig; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_OptionsUtil_readTableFormatConfig + (JNIEnv *, jclass, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_PerfContext.h b/java/include/org_forstdb_PerfContext.h new file mode 100644 index 000000000..50f9155a9 --- /dev/null +++ b/java/include/org_forstdb_PerfContext.h @@ -0,0 +1,805 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_PerfContext */ + +#ifndef _Included_org_forstdb_PerfContext +#define _Included_org_forstdb_PerfContext +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_PerfContext + * Method: reset + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_PerfContext_reset + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getUserKeyComparisonCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getUserKeyComparisonCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockCacheHitCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockCacheHitCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockReadCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockReadCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockReadByte + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockReadByte + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockReadTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockReadTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockReadCpuTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockReadCpuTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockCacheIndexHitCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockCacheIndexHitCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockCacheStandaloneHandleCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockCacheStandaloneHandleCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockCacheRealHandleCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockCacheRealHandleCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getIndexBlockReadCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getIndexBlockReadCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockCacheFilterHitCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockCacheFilterHitCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getFilterBlockReadCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFilterBlockReadCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getCompressionDictBlockReadCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getCompressionDictBlockReadCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getSecondaryCacheHitCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSecondaryCacheHitCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getCompressedSecCacheInsertRealCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getCompressedSecCacheInsertRealCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getCompressedSecCacheInsertDummyCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getCompressedSecCacheInsertDummyCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getCompressedSecCacheUncompressedBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getCompressedSecCacheUncompressedBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getCompressedSecCacheCompressedBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getCompressedSecCacheCompressedBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockChecksumTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockChecksumTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockDecompressTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockDecompressTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getReadBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getReadBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getMultigetReadBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getMultigetReadBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getIterReadBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getIterReadBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlobCacheHitCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobCacheHitCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlobReadCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobReadCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlobReadByte + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobReadByte + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlobReadTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobReadTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlobChecksumTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobChecksumTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlobDecompressTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobDecompressTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getInternalKeySkippedCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalKeySkippedCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getInternalDeleteSkippedCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalDeleteSkippedCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getInternalRecentSkippedCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalRecentSkippedCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getInternalMergeCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalMergeCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getInternalMergePointLookupCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalMergePointLookupCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getInternalRangeDelReseekCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalRangeDelReseekCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getSnapshotTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSnapshotTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getFromMemtableTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFromMemtableTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getFromMemtableCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFromMemtableCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getPostProcessTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getPostProcessTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getFromOutputFilesTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFromOutputFilesTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getSeekOnMemtableTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekOnMemtableTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getSeekOnMemtableCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekOnMemtableCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getNextOnMemtableCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getNextOnMemtableCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getPrevOnMemtableCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getPrevOnMemtableCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getSeekChildSeekTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekChildSeekTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getSeekChildSeekCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekChildSeekCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getSeekMinHeapTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekMinHeapTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getSeekMaxHeapTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekMaxHeapTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getSeekInternalSeekTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekInternalSeekTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getFindNextUserEntryTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFindNextUserEntryTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getWriteWalTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWriteWalTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getWriteMemtableTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWriteMemtableTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getWriteDelayTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWriteDelayTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getWriteSchedulingFlushesCompactionsTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWriteSchedulingFlushesCompactionsTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getWritePreAndPostProcessTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWritePreAndPostProcessTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getWriteThreadWaitNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWriteThreadWaitNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getDbMutexLockNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getDbMutexLockNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getDbConditionWaitNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getDbConditionWaitNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getMergeOperatorTimeNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getMergeOperatorTimeNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getReadIndexBlockNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getReadIndexBlockNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getReadFilterBlockNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getReadFilterBlockNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getNewTableBlockIterNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getNewTableBlockIterNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getNewTableIteratorNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getNewTableIteratorNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBlockSeekNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockSeekNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getFindTableNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFindTableNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBloomMemtableHitCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBloomMemtableHitCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBloomMemtableMissCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBloomMemtableMissCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBloomSstHitCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBloomSstHitCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getBloomSstMissCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBloomSstMissCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getKeyLockWaitTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getKeyLockWaitTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getKeyLockWaitCount + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getKeyLockWaitCount + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvNewSequentialFileNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewSequentialFileNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvNewRandomAccessFileNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewRandomAccessFileNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvNewWritableFileNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewWritableFileNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvReuseWritableFileNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvReuseWritableFileNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvNewRandomRwFileNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewRandomRwFileNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvNewDirectoryNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewDirectoryNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvFileExistsNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvFileExistsNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvGetChildrenNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvGetChildrenNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvGetChildrenFileAttributesNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvGetChildrenFileAttributesNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvDeleteFileNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvDeleteFileNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvCreateDirNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvCreateDirNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvCreateDirIfMissingNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvCreateDirIfMissingNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvDeleteDirNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvDeleteDirNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvGetFileSizeNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvGetFileSizeNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvGetFileModificationTimeNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvGetFileModificationTimeNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvRenameFileNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvRenameFileNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvLinkFileNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvLinkFileNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvLockFileNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvLockFileNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvUnlockFileNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvUnlockFileNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEnvNewLoggerNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewLoggerNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getGetCpuNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getGetCpuNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getIterNextCpuNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getIterNextCpuNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getIterPrevCpuNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getIterPrevCpuNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getIterSeekCpuNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getIterSeekCpuNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getEncryptDataNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEncryptDataNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getDecryptDataNanos + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getDecryptDataNanos + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_PerfContext + * Method: getNumberAsyncSeek + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getNumberAsyncSeek + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_PersistentCache.h b/java/include/org_forstdb_PersistentCache.h new file mode 100644 index 000000000..a0358f656 --- /dev/null +++ b/java/include/org_forstdb_PersistentCache.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_PersistentCache */ + +#ifndef _Included_org_forstdb_PersistentCache +#define _Included_org_forstdb_PersistentCache +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_PersistentCache + * Method: newPersistentCache + * Signature: (JLjava/lang/String;JJZ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PersistentCache_newPersistentCache + (JNIEnv *, jclass, jlong, jstring, jlong, jlong, jboolean); + +/* + * Class: org_forstdb_PersistentCache + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_PersistentCache_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_PlainTableConfig.h b/java/include/org_forstdb_PlainTableConfig.h new file mode 100644 index 000000000..5be3e76aa --- /dev/null +++ b/java/include/org_forstdb_PlainTableConfig.h @@ -0,0 +1,35 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_PlainTableConfig */ + +#ifndef _Included_org_forstdb_PlainTableConfig +#define _Included_org_forstdb_PlainTableConfig +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_PlainTableConfig_VARIABLE_LENGTH +#define org_forstdb_PlainTableConfig_VARIABLE_LENGTH 0L +#undef org_forstdb_PlainTableConfig_DEFAULT_BLOOM_BITS_PER_KEY +#define org_forstdb_PlainTableConfig_DEFAULT_BLOOM_BITS_PER_KEY 10L +#undef org_forstdb_PlainTableConfig_DEFAULT_HASH_TABLE_RATIO +#define org_forstdb_PlainTableConfig_DEFAULT_HASH_TABLE_RATIO 0.75 +#undef org_forstdb_PlainTableConfig_DEFAULT_INDEX_SPARSENESS +#define org_forstdb_PlainTableConfig_DEFAULT_INDEX_SPARSENESS 16L +#undef org_forstdb_PlainTableConfig_DEFAULT_HUGE_TLB_SIZE +#define org_forstdb_PlainTableConfig_DEFAULT_HUGE_TLB_SIZE 0L +#undef org_forstdb_PlainTableConfig_DEFAULT_FULL_SCAN_MODE +#define org_forstdb_PlainTableConfig_DEFAULT_FULL_SCAN_MODE 0L +#undef org_forstdb_PlainTableConfig_DEFAULT_STORE_INDEX_IN_FILE +#define org_forstdb_PlainTableConfig_DEFAULT_STORE_INDEX_IN_FILE 0L +/* + * Class: org_forstdb_PlainTableConfig + * Method: newTableFactoryHandle + * Signature: (IIDIIBZZ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_PlainTableConfig_newTableFactoryHandle + (JNIEnv *, jobject, jint, jint, jdouble, jint, jint, jbyte, jboolean, jboolean); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_RateLimiter.h b/java/include/org_forstdb_RateLimiter.h new file mode 100644 index 000000000..8cdab2a11 --- /dev/null +++ b/java/include/org_forstdb_RateLimiter.h @@ -0,0 +1,83 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_RateLimiter */ + +#ifndef _Included_org_forstdb_RateLimiter +#define _Included_org_forstdb_RateLimiter +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_RateLimiter_DEFAULT_REFILL_PERIOD_MICROS +#define org_forstdb_RateLimiter_DEFAULT_REFILL_PERIOD_MICROS 100000LL +#undef org_forstdb_RateLimiter_DEFAULT_FAIRNESS +#define org_forstdb_RateLimiter_DEFAULT_FAIRNESS 10L +#undef org_forstdb_RateLimiter_DEFAULT_AUTOTUNE +#define org_forstdb_RateLimiter_DEFAULT_AUTOTUNE 0L +/* + * Class: org_forstdb_RateLimiter + * Method: newRateLimiterHandle + * Signature: (JJIBZ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RateLimiter_newRateLimiterHandle + (JNIEnv *, jclass, jlong, jlong, jint, jbyte, jboolean); + +/* + * Class: org_forstdb_RateLimiter + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RateLimiter_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RateLimiter + * Method: setBytesPerSecond + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RateLimiter_setBytesPerSecond + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RateLimiter + * Method: getBytesPerSecond + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RateLimiter_getBytesPerSecond + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RateLimiter + * Method: request + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RateLimiter_request + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RateLimiter + * Method: getSingleBurstBytes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RateLimiter_getSingleBurstBytes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RateLimiter + * Method: getTotalBytesThrough + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RateLimiter_getTotalBytesThrough + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RateLimiter + * Method: getTotalRequests + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RateLimiter_getTotalRequests + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_ReadOptions.h b/java/include/org_forstdb_ReadOptions.h new file mode 100644 index 000000000..7082dc8c1 --- /dev/null +++ b/java/include/org_forstdb_ReadOptions.h @@ -0,0 +1,389 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_ReadOptions */ + +#ifndef _Included_org_forstdb_ReadOptions +#define _Included_org_forstdb_ReadOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_ReadOptions + * Method: newReadOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_newReadOptions__ + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_ReadOptions + * Method: newReadOptions + * Signature: (ZZ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_newReadOptions__ZZ + (JNIEnv *, jclass, jboolean, jboolean); + +/* + * Class: org_forstdb_ReadOptions + * Method: copyReadOptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_copyReadOptions + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: verifyChecksums + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_verifyChecksums + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setVerifyChecksums + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setVerifyChecksums + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ReadOptions + * Method: fillCache + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_fillCache + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setFillCache + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setFillCache + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ReadOptions + * Method: snapshot + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_snapshot + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setSnapshot + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setSnapshot + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: readTier + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_ReadOptions_readTier + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setReadTier + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setReadTier + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_ReadOptions + * Method: tailing + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_tailing + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setTailing + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setTailing + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ReadOptions + * Method: managed + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_managed + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setManaged + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setManaged + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ReadOptions + * Method: totalOrderSeek + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_totalOrderSeek + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setTotalOrderSeek + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setTotalOrderSeek + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ReadOptions + * Method: prefixSameAsStart + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_prefixSameAsStart + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setPrefixSameAsStart + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setPrefixSameAsStart + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ReadOptions + * Method: pinData + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_pinData + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setPinData + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setPinData + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ReadOptions + * Method: backgroundPurgeOnIteratorCleanup + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_backgroundPurgeOnIteratorCleanup + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setBackgroundPurgeOnIteratorCleanup + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setBackgroundPurgeOnIteratorCleanup + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ReadOptions + * Method: readaheadSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_readaheadSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setReadaheadSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setReadaheadSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: maxSkippableInternalKeys + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_maxSkippableInternalKeys + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setMaxSkippableInternalKeys + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setMaxSkippableInternalKeys + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: ignoreRangeDeletions + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_ignoreRangeDeletions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setIgnoreRangeDeletions + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setIgnoreRangeDeletions + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ReadOptions + * Method: setIterateUpperBound + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setIterateUpperBound + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: iterateUpperBound + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_iterateUpperBound + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setIterateLowerBound + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setIterateLowerBound + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: iterateLowerBound + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_iterateLowerBound + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setTableFilter + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setTableFilter + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: autoPrefixMode + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_autoPrefixMode + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setAutoPrefixMode + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setAutoPrefixMode + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_ReadOptions + * Method: timestamp + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_timestamp + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setTimestamp + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setTimestamp + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: iterStartTs + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_iterStartTs + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setIterStartTs + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setIterStartTs + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: deadline + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_deadline + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setDeadline + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setDeadline + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: ioTimeout + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_ioTimeout + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setIoTimeout + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setIoTimeout + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: valueSizeSoftLimit + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_valueSizeSoftLimit + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_ReadOptions + * Method: setValueSizeSoftLimit + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setValueSizeSoftLimit + (JNIEnv *, jobject, jlong, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_RemoveEmptyValueCompactionFilter.h b/java/include/org_forstdb_RemoveEmptyValueCompactionFilter.h new file mode 100644 index 000000000..0fdf0786d --- /dev/null +++ b/java/include/org_forstdb_RemoveEmptyValueCompactionFilter.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_RemoveEmptyValueCompactionFilter */ + +#ifndef _Included_org_forstdb_RemoveEmptyValueCompactionFilter +#define _Included_org_forstdb_RemoveEmptyValueCompactionFilter +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_RemoveEmptyValueCompactionFilter + * Method: createNewRemoveEmptyValueCompactionFilter0 + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RemoveEmptyValueCompactionFilter_createNewRemoveEmptyValueCompactionFilter0 + (JNIEnv *, jclass); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_RestoreOptions.h b/java/include/org_forstdb_RestoreOptions.h new file mode 100644 index 000000000..cb0cfaa96 --- /dev/null +++ b/java/include/org_forstdb_RestoreOptions.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_RestoreOptions */ + +#ifndef _Included_org_forstdb_RestoreOptions +#define _Included_org_forstdb_RestoreOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_RestoreOptions + * Method: newRestoreOptions + * Signature: (Z)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RestoreOptions_newRestoreOptions + (JNIEnv *, jclass, jboolean); + +/* + * Class: org_forstdb_RestoreOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RestoreOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_RocksCallbackObject.h b/java/include/org_forstdb_RocksCallbackObject.h new file mode 100644 index 000000000..edd63d253 --- /dev/null +++ b/java/include/org_forstdb_RocksCallbackObject.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_RocksCallbackObject */ + +#ifndef _Included_org_forstdb_RocksCallbackObject +#define _Included_org_forstdb_RocksCallbackObject +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_RocksCallbackObject + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksCallbackObject_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_RocksDB.h b/java/include/org_forstdb_RocksDB.h new file mode 100644 index 000000000..43248af59 --- /dev/null +++ b/java/include/org_forstdb_RocksDB.h @@ -0,0 +1,935 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_RocksDB */ + +#ifndef _Included_org_forstdb_RocksDB +#define _Included_org_forstdb_RocksDB +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_RocksDB_NOT_FOUND +#define org_forstdb_RocksDB_NOT_FOUND -1L +/* + * Class: org_forstdb_RocksDB + * Method: open + * Signature: (JLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_open__JLjava_lang_String_2 + (JNIEnv *, jclass, jlong, jstring); + +/* + * Class: org_forstdb_RocksDB + * Method: open + * Signature: (JLjava/lang/String;[[B[J)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_open__JLjava_lang_String_2_3_3B_3J + (JNIEnv *, jclass, jlong, jstring, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_RocksDB + * Method: openROnly + * Signature: (JLjava/lang/String;Z)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_openROnly__JLjava_lang_String_2Z + (JNIEnv *, jclass, jlong, jstring, jboolean); + +/* + * Class: org_forstdb_RocksDB + * Method: openROnly + * Signature: (JLjava/lang/String;[[B[JZ)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_openROnly__JLjava_lang_String_2_3_3B_3JZ + (JNIEnv *, jclass, jlong, jstring, jobjectArray, jlongArray, jboolean); + +/* + * Class: org_forstdb_RocksDB + * Method: openAsSecondary + * Signature: (JLjava/lang/String;Ljava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_openAsSecondary__JLjava_lang_String_2Ljava_lang_String_2 + (JNIEnv *, jclass, jlong, jstring, jstring); + +/* + * Class: org_forstdb_RocksDB + * Method: openAsSecondary + * Signature: (JLjava/lang/String;Ljava/lang/String;[[B[J)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_openAsSecondary__JLjava_lang_String_2Ljava_lang_String_2_3_3B_3J + (JNIEnv *, jclass, jlong, jstring, jstring, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_RocksDB + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: closeDatabase + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_closeDatabase + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: listColumnFamilies + * Signature: (JLjava/lang/String;)[[B + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_listColumnFamilies + (JNIEnv *, jclass, jlong, jstring); + +/* + * Class: org_forstdb_RocksDB + * Method: createColumnFamily + * Signature: (J[BIJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_createColumnFamily + (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: createColumnFamilies + * Signature: (JJ[[B)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_createColumnFamilies__JJ_3_3B + (JNIEnv *, jobject, jlong, jlong, jobjectArray); + +/* + * Class: org_forstdb_RocksDB + * Method: createColumnFamilies + * Signature: (J[J[[B)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_createColumnFamilies__J_3J_3_3B + (JNIEnv *, jobject, jlong, jlongArray, jobjectArray); + +/* + * Class: org_forstdb_RocksDB + * Method: createColumnFamilyWithImport + * Signature: (J[BIJJ[J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_createColumnFamilyWithImport + (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong, jlong, jlongArray); + +/* + * Class: org_forstdb_RocksDB + * Method: dropColumnFamily + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_dropColumnFamily + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: dropColumnFamilies + * Signature: (J[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_dropColumnFamilies + (JNIEnv *, jobject, jlong, jlongArray); + +/* + * Class: org_forstdb_RocksDB + * Method: put + * Signature: (J[BII[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_put__J_3BII_3BII + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: put + * Signature: (J[BII[BIIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_put__J_3BII_3BIIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: put + * Signature: (JJ[BII[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_put__JJ_3BII_3BII + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: put + * Signature: (JJ[BII[BIIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_put__JJ_3BII_3BIIJ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: delete + * Signature: (J[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_delete__J_3BII + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: delete + * Signature: (J[BIIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_delete__J_3BIIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: delete + * Signature: (JJ[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_delete__JJ_3BII + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: delete + * Signature: (JJ[BIIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_delete__JJ_3BIIJ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: singleDelete + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_singleDelete__J_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: singleDelete + * Signature: (J[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_singleDelete__J_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: singleDelete + * Signature: (JJ[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_singleDelete__JJ_3BI + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: singleDelete + * Signature: (JJ[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_singleDelete__JJ_3BIJ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: deleteRange + * Signature: (J[BII[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteRange__J_3BII_3BII + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: deleteRange + * Signature: (J[BII[BIIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteRange__J_3BII_3BIIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: deleteRange + * Signature: (JJ[BII[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteRange__JJ_3BII_3BII + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: deleteRange + * Signature: (JJ[BII[BIIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteRange__JJ_3BII_3BIIJ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: clipColumnFamily + * Signature: (JJ[BII[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_clipColumnFamily + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: merge + * Signature: (J[BII[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_merge__J_3BII_3BII + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: merge + * Signature: (J[BII[BIIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_merge__J_3BII_3BIIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: merge + * Signature: (JJ[BII[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_merge__JJ_3BII_3BII + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: merge + * Signature: (JJ[BII[BIIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_merge__JJ_3BII_3BIIJ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: mergeDirect + * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_mergeDirect + (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jobject, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: write0 + * Signature: (JJJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_write0 + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: write1 + * Signature: (JJJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_write1 + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: get + * Signature: (J[BII[BII)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_get__J_3BII_3BII + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: get + * Signature: (J[BII[BIIJ)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_get__J_3BII_3BIIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: get + * Signature: (JJ[BII[BII)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_get__JJ_3BII_3BII + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: get + * Signature: (JJ[BII[BIIJ)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_get__JJ_3BII_3BIIJ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: get + * Signature: (J[BII)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksDB_get__J_3BII + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: get + * Signature: (J[BIIJ)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksDB_get__J_3BIIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: get + * Signature: (JJ[BII)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksDB_get__JJ_3BII + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: get + * Signature: (JJ[BIIJ)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksDB_get__JJ_3BIIJ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: multiGet + * Signature: (J[[B[I[I)[[B + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_multiGet__J_3_3B_3I_3I + (JNIEnv *, jobject, jlong, jobjectArray, jintArray, jintArray); + +/* + * Class: org_forstdb_RocksDB + * Method: multiGet + * Signature: (J[[B[I[I[J)[[B + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_multiGet__J_3_3B_3I_3I_3J + (JNIEnv *, jobject, jlong, jobjectArray, jintArray, jintArray, jlongArray); + +/* + * Class: org_forstdb_RocksDB + * Method: multiGet + * Signature: (JJ[[B[I[I)[[B + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_multiGet__JJ_3_3B_3I_3I + (JNIEnv *, jobject, jlong, jlong, jobjectArray, jintArray, jintArray); + +/* + * Class: org_forstdb_RocksDB + * Method: multiGet + * Signature: (JJ[[B[I[I[J)[[B + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_multiGet__JJ_3_3B_3I_3I_3J + (JNIEnv *, jobject, jlong, jlong, jobjectArray, jintArray, jintArray, jlongArray); + +/* + * Class: org_forstdb_RocksDB + * Method: multiGet + * Signature: (JJ[J[Ljava/nio/ByteBuffer;[I[I[Ljava/nio/ByteBuffer;[I[Lorg/forstdb/Status;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_multiGet__JJ_3J_3Ljava_nio_ByteBuffer_2_3I_3I_3Ljava_nio_ByteBuffer_2_3I_3Lorg_forstdb_Status_2 + (JNIEnv *, jobject, jlong, jlong, jlongArray, jobjectArray, jintArray, jintArray, jobjectArray, jintArray, jobjectArray); + +/* + * Class: org_forstdb_RocksDB + * Method: keyExists + * Signature: (JJJ[BII)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_RocksDB_keyExists + (JNIEnv *, jobject, jlong, jlong, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: keyExistsDirect + * Signature: (JJJLjava/nio/ByteBuffer;II)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_RocksDB_keyExistsDirect + (JNIEnv *, jobject, jlong, jlong, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: keyMayExist + * Signature: (JJJ[BII)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_RocksDB_keyMayExist + (JNIEnv *, jobject, jlong, jlong, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: keyMayExistFoundValue + * Signature: (JJJ[BII)[[B + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_keyMayExistFoundValue + (JNIEnv *, jobject, jlong, jlong, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: putDirect + * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_putDirect + (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jobject, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: iterator + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_iterator + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: iterators + * Signature: (J[JJ)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_iterators + (JNIEnv *, jobject, jlong, jlongArray, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getSnapshot + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getSnapshot + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: releaseSnapshot + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_releaseSnapshot + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getProperty + * Signature: (JJLjava/lang/String;I)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_RocksDB_getProperty + (JNIEnv *, jobject, jlong, jlong, jstring, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: getMapProperty + * Signature: (JJLjava/lang/String;I)Ljava/util/Map; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_RocksDB_getMapProperty + (JNIEnv *, jobject, jlong, jlong, jstring, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: getDirect + * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_getDirect + (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jobject, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: keyMayExistDirect + * Signature: (JJJLjava/nio/ByteBuffer;II)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_RocksDB_keyMayExistDirect + (JNIEnv *, jobject, jlong, jlong, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: keyMayExistDirectFoundValue + * Signature: (JJJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)[I + */ +JNIEXPORT jintArray JNICALL Java_org_forstdb_RocksDB_keyMayExistDirectFoundValue + (JNIEnv *, jobject, jlong, jlong, jlong, jobject, jint, jint, jobject, jint, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: deleteDirect + * Signature: (JJLjava/nio/ByteBuffer;IIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteDirect + (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getLongProperty + * Signature: (JJLjava/lang/String;I)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getLongProperty + (JNIEnv *, jobject, jlong, jlong, jstring, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: resetStats + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_resetStats + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getAggregatedLongProperty + * Signature: (JLjava/lang/String;I)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getAggregatedLongProperty + (JNIEnv *, jobject, jlong, jstring, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: getApproximateSizes + * Signature: (JJ[JB)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_getApproximateSizes + (JNIEnv *, jobject, jlong, jlong, jlongArray, jbyte); + +/* + * Class: org_forstdb_RocksDB + * Method: getApproximateMemTableStats + * Signature: (JJJJ)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_getApproximateMemTableStats + (JNIEnv *, jobject, jlong, jlong, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: compactRange + * Signature: (J[BI[BIJJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_compactRange + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: setOptions + * Signature: (JJ[Ljava/lang/String;[Ljava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_setOptions + (JNIEnv *, jobject, jlong, jlong, jobjectArray, jobjectArray); + +/* + * Class: org_forstdb_RocksDB + * Method: getOptions + * Signature: (JJ)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_RocksDB_getOptions + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: setDBOptions + * Signature: (J[Ljava/lang/String;[Ljava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_setDBOptions + (JNIEnv *, jobject, jlong, jobjectArray, jobjectArray); + +/* + * Class: org_forstdb_RocksDB + * Method: getDBOptions + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_RocksDB_getDBOptions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: setPerfLevel + * Signature: (B)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_setPerfLevel + (JNIEnv *, jobject, jbyte); + +/* + * Class: org_forstdb_RocksDB + * Method: getPerfLevelNative + * Signature: ()B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_RocksDB_getPerfLevelNative + (JNIEnv *, jobject); + +/* + * Class: org_forstdb_RocksDB + * Method: getPerfContextNative + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getPerfContextNative + (JNIEnv *, jobject); + +/* + * Class: org_forstdb_RocksDB + * Method: compactFiles + * Signature: (JJJ[Ljava/lang/String;IIJ)[Ljava/lang/String; + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_compactFiles + (JNIEnv *, jobject, jlong, jlong, jlong, jobjectArray, jint, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: cancelAllBackgroundWork + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_cancelAllBackgroundWork + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_RocksDB + * Method: pauseBackgroundWork + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_pauseBackgroundWork + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: continueBackgroundWork + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_continueBackgroundWork + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: enableAutoCompaction + * Signature: (J[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_enableAutoCompaction + (JNIEnv *, jobject, jlong, jlongArray); + +/* + * Class: org_forstdb_RocksDB + * Method: numberLevels + * Signature: (JJ)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_numberLevels + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: maxMemCompactionLevel + * Signature: (JJ)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_maxMemCompactionLevel + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: level0StopWriteTrigger + * Signature: (JJ)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_level0StopWriteTrigger + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getName + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_RocksDB_getName + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getEnv + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getEnv + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: flush + * Signature: (JJ[J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_flush + (JNIEnv *, jobject, jlong, jlong, jlongArray); + +/* + * Class: org_forstdb_RocksDB + * Method: flushWal + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_flushWal + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_RocksDB + * Method: syncWal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_syncWal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getLatestSequenceNumber + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getLatestSequenceNumber + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: disableFileDeletions + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_disableFileDeletions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: enableFileDeletions + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_enableFileDeletions + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_RocksDB + * Method: getLiveFiles + * Signature: (JZ)[Ljava/lang/String; + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_getLiveFiles + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_RocksDB + * Method: getSortedWalFiles + * Signature: (J)[Lorg/forstdb/LogFile; + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_getSortedWalFiles + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getUpdatesSince + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getUpdatesSince + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: deleteFile + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteFile + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_RocksDB + * Method: getLiveFilesMetaData + * Signature: (J)[Lorg/forstdb/LiveFileMetaData; + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_getLiveFilesMetaData + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getColumnFamilyMetaData + * Signature: (JJ)Lorg/forstdb/ColumnFamilyMetaData; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_RocksDB_getColumnFamilyMetaData + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: ingestExternalFile + * Signature: (JJ[Ljava/lang/String;IJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_ingestExternalFile + (JNIEnv *, jobject, jlong, jlong, jobjectArray, jint, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: verifyChecksum + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_verifyChecksum + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getDefaultColumnFamily + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getDefaultColumnFamily + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getPropertiesOfAllTables + * Signature: (JJ)Ljava/util/Map; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_RocksDB_getPropertiesOfAllTables + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: getPropertiesOfTablesInRange + * Signature: (JJ[J)Ljava/util/Map; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_RocksDB_getPropertiesOfTablesInRange + (JNIEnv *, jobject, jlong, jlong, jlongArray); + +/* + * Class: org_forstdb_RocksDB + * Method: suggestCompactRange + * Signature: (JJ)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_suggestCompactRange + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: promoteL0 + * Signature: (JJI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_promoteL0 + (JNIEnv *, jobject, jlong, jlong, jint); + +/* + * Class: org_forstdb_RocksDB + * Method: startTrace + * Signature: (JJJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_startTrace + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: endTrace + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_endTrace + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: tryCatchUpWithPrimary + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_tryCatchUpWithPrimary + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: deleteFilesInRanges + * Signature: (JJ[[BZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteFilesInRanges + (JNIEnv *, jobject, jlong, jlong, jobjectArray, jboolean); + +/* + * Class: org_forstdb_RocksDB + * Method: destroyDB + * Signature: (Ljava/lang/String;J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_destroyDB + (JNIEnv *, jclass, jstring, jlong); + +/* + * Class: org_forstdb_RocksDB + * Method: version + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_version + (JNIEnv *, jclass); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_RocksDBExceptionTest.h b/java/include/org_forstdb_RocksDBExceptionTest.h new file mode 100644 index 000000000..0b707eff1 --- /dev/null +++ b/java/include/org_forstdb_RocksDBExceptionTest.h @@ -0,0 +1,61 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_RocksDBExceptionTest */ + +#ifndef _Included_org_forstdb_RocksDBExceptionTest +#define _Included_org_forstdb_RocksDBExceptionTest +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_RocksDBExceptionTest + * Method: raiseException + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseException + (JNIEnv *, jobject); + +/* + * Class: org_forstdb_RocksDBExceptionTest + * Method: raiseExceptionWithStatusCode + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseExceptionWithStatusCode + (JNIEnv *, jobject); + +/* + * Class: org_forstdb_RocksDBExceptionTest + * Method: raiseExceptionNoMsgWithStatusCode + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseExceptionNoMsgWithStatusCode + (JNIEnv *, jobject); + +/* + * Class: org_forstdb_RocksDBExceptionTest + * Method: raiseExceptionWithStatusCodeSubCode + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseExceptionWithStatusCodeSubCode + (JNIEnv *, jobject); + +/* + * Class: org_forstdb_RocksDBExceptionTest + * Method: raiseExceptionNoMsgWithStatusCodeSubCode + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseExceptionNoMsgWithStatusCodeSubCode + (JNIEnv *, jobject); + +/* + * Class: org_forstdb_RocksDBExceptionTest + * Method: raiseExceptionWithStatusCodeState + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseExceptionWithStatusCodeState + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_RocksEnv.h b/java/include/org_forstdb_RocksEnv.h new file mode 100644 index 000000000..6c9bc74c3 --- /dev/null +++ b/java/include/org_forstdb_RocksEnv.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_RocksEnv */ + +#ifndef _Included_org_forstdb_RocksEnv +#define _Included_org_forstdb_RocksEnv +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_RocksEnv + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksEnv_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_RocksIterator.h b/java/include/org_forstdb_RocksIterator.h new file mode 100644 index 000000000..f89e51591 --- /dev/null +++ b/java/include/org_forstdb_RocksIterator.h @@ -0,0 +1,173 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_RocksIterator */ + +#ifndef _Included_org_forstdb_RocksIterator +#define _Included_org_forstdb_RocksIterator +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_RocksIterator + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksIterator + * Method: isValid0 + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_RocksIterator_isValid0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksIterator + * Method: seekToFirst0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekToFirst0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksIterator + * Method: seekToLast0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekToLast0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksIterator + * Method: next0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_next0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksIterator + * Method: prev0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_prev0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksIterator + * Method: refresh0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_refresh0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksIterator + * Method: seek0 + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seek0 + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_RocksIterator + * Method: seekForPrev0 + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekForPrev0 + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_RocksIterator + * Method: seekDirect0 + * Signature: (JLjava/nio/ByteBuffer;II)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekDirect0 + (JNIEnv *, jobject, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_RocksIterator + * Method: seekByteArray0 + * Signature: (J[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekByteArray0 + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksIterator + * Method: seekForPrevDirect0 + * Signature: (JLjava/nio/ByteBuffer;II)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekForPrevDirect0 + (JNIEnv *, jobject, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_RocksIterator + * Method: seekForPrevByteArray0 + * Signature: (J[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekForPrevByteArray0 + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksIterator + * Method: status0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_status0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksIterator + * Method: key0 + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksIterator_key0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksIterator + * Method: value0 + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksIterator_value0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_RocksIterator + * Method: keyDirect0 + * Signature: (JLjava/nio/ByteBuffer;II)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksIterator_keyDirect0 + (JNIEnv *, jobject, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_RocksIterator + * Method: keyByteArray0 + * Signature: (J[BII)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksIterator_keyByteArray0 + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_RocksIterator + * Method: valueDirect0 + * Signature: (JLjava/nio/ByteBuffer;II)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksIterator_valueDirect0 + (JNIEnv *, jobject, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_RocksIterator + * Method: valueByteArray0 + * Signature: (J[BII)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_RocksIterator_valueByteArray0 + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_RocksMemEnv.h b/java/include/org_forstdb_RocksMemEnv.h new file mode 100644 index 000000000..b4a080847 --- /dev/null +++ b/java/include/org_forstdb_RocksMemEnv.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_RocksMemEnv */ + +#ifndef _Included_org_forstdb_RocksMemEnv +#define _Included_org_forstdb_RocksMemEnv +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_RocksMemEnv + * Method: createMemEnv + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_RocksMemEnv_createMemEnv + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_RocksMemEnv + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_RocksMemEnv_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_SkipListMemTableConfig.h b/java/include/org_forstdb_SkipListMemTableConfig.h new file mode 100644 index 000000000..43a6f1946 --- /dev/null +++ b/java/include/org_forstdb_SkipListMemTableConfig.h @@ -0,0 +1,23 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_SkipListMemTableConfig */ + +#ifndef _Included_org_forstdb_SkipListMemTableConfig +#define _Included_org_forstdb_SkipListMemTableConfig +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_SkipListMemTableConfig_DEFAULT_LOOKAHEAD +#define org_forstdb_SkipListMemTableConfig_DEFAULT_LOOKAHEAD 0LL +/* + * Class: org_forstdb_SkipListMemTableConfig + * Method: newMemTableFactoryHandle0 + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_SkipListMemTableConfig_newMemTableFactoryHandle0 + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_Slice.h b/java/include/org_forstdb_Slice.h new file mode 100644 index 000000000..45fae672a --- /dev/null +++ b/java/include/org_forstdb_Slice.h @@ -0,0 +1,61 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_Slice */ + +#ifndef _Included_org_forstdb_Slice +#define _Included_org_forstdb_Slice +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_Slice + * Method: data0 + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_Slice_data0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Slice + * Method: createNewSlice0 + * Signature: ([BI)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Slice_createNewSlice0 + (JNIEnv *, jclass, jbyteArray, jint); + +/* + * Class: org_forstdb_Slice + * Method: createNewSlice1 + * Signature: ([B)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Slice_createNewSlice1 + (JNIEnv *, jclass, jbyteArray); + +/* + * Class: org_forstdb_Slice + * Method: clear0 + * Signature: (JZJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Slice_clear0 + (JNIEnv *, jobject, jlong, jboolean, jlong); + +/* + * Class: org_forstdb_Slice + * Method: removePrefix0 + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Slice_removePrefix0 + (JNIEnv *, jobject, jlong, jint); + +/* + * Class: org_forstdb_Slice + * Method: disposeInternalBuf + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Slice_disposeInternalBuf + (JNIEnv *, jobject, jlong, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_Snapshot.h b/java/include/org_forstdb_Snapshot.h new file mode 100644 index 000000000..595a18e68 --- /dev/null +++ b/java/include/org_forstdb_Snapshot.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_Snapshot */ + +#ifndef _Included_org_forstdb_Snapshot +#define _Included_org_forstdb_Snapshot +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_Snapshot + * Method: getSequenceNumber + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Snapshot_getSequenceNumber + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_SstFileManager.h b/java/include/org_forstdb_SstFileManager.h new file mode 100644 index 000000000..25fe9e0db --- /dev/null +++ b/java/include/org_forstdb_SstFileManager.h @@ -0,0 +1,117 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_SstFileManager */ + +#ifndef _Included_org_forstdb_SstFileManager +#define _Included_org_forstdb_SstFileManager +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_SstFileManager_RATE_BYTES_PER_SEC_DEFAULT +#define org_forstdb_SstFileManager_RATE_BYTES_PER_SEC_DEFAULT 0LL +#undef org_forstdb_SstFileManager_DELETE_EXISTING_TRASH_DEFAULT +#define org_forstdb_SstFileManager_DELETE_EXISTING_TRASH_DEFAULT 1L +#undef org_forstdb_SstFileManager_MAX_TRASH_DB_RATION_DEFAULT +#define org_forstdb_SstFileManager_MAX_TRASH_DB_RATION_DEFAULT 0.25 +#undef org_forstdb_SstFileManager_BYTES_MAX_DELETE_CHUNK_DEFAULT +#define org_forstdb_SstFileManager_BYTES_MAX_DELETE_CHUNK_DEFAULT 67108864LL +/* + * Class: org_forstdb_SstFileManager + * Method: newSstFileManager + * Signature: (JJJDJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileManager_newSstFileManager + (JNIEnv *, jclass, jlong, jlong, jlong, jdouble, jlong); + +/* + * Class: org_forstdb_SstFileManager + * Method: setMaxAllowedSpaceUsage + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileManager_setMaxAllowedSpaceUsage + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_SstFileManager + * Method: setCompactionBufferSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileManager_setCompactionBufferSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_SstFileManager + * Method: isMaxAllowedSpaceReached + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_SstFileManager_isMaxAllowedSpaceReached + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileManager + * Method: isMaxAllowedSpaceReachedIncludingCompactions + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_SstFileManager_isMaxAllowedSpaceReachedIncludingCompactions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileManager + * Method: getTotalSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileManager_getTotalSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileManager + * Method: getTrackedFiles + * Signature: (J)Ljava/util/Map; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_SstFileManager_getTrackedFiles + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileManager + * Method: getDeleteRateBytesPerSecond + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileManager_getDeleteRateBytesPerSecond + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileManager + * Method: setDeleteRateBytesPerSecond + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileManager_setDeleteRateBytesPerSecond + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_SstFileManager + * Method: getMaxTrashDBRatio + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_org_forstdb_SstFileManager_getMaxTrashDBRatio + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileManager + * Method: setMaxTrashDBRatio + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileManager_setMaxTrashDBRatio + (JNIEnv *, jobject, jlong, jdouble); + +/* + * Class: org_forstdb_SstFileManager + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileManager_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_SstFileReader.h b/java/include/org_forstdb_SstFileReader.h new file mode 100644 index 000000000..688f87a4e --- /dev/null +++ b/java/include/org_forstdb_SstFileReader.h @@ -0,0 +1,61 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_SstFileReader */ + +#ifndef _Included_org_forstdb_SstFileReader +#define _Included_org_forstdb_SstFileReader +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_SstFileReader + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReader_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReader + * Method: newIterator + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileReader_newIterator + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_SstFileReader + * Method: open + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReader_open + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_SstFileReader + * Method: newSstFileReader + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileReader_newSstFileReader + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_SstFileReader + * Method: verifyChecksum + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReader_verifyChecksum + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReader + * Method: getTableProperties + * Signature: (J)Lorg/forstdb/TableProperties; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_SstFileReader_getTableProperties + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_SstFileReaderIterator.h b/java/include/org_forstdb_SstFileReaderIterator.h new file mode 100644 index 000000000..e8fde1efb --- /dev/null +++ b/java/include/org_forstdb_SstFileReaderIterator.h @@ -0,0 +1,173 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_SstFileReaderIterator */ + +#ifndef _Included_org_forstdb_SstFileReaderIterator +#define _Included_org_forstdb_SstFileReaderIterator +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: isValid0 + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_SstFileReaderIterator_isValid0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: seekToFirst0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekToFirst0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: seekToLast0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekToLast0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: next0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_next0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: prev0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_prev0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: refresh0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_refresh0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: seek0 + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seek0 + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: seekForPrev0 + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekForPrev0 + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: status0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_status0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: seekDirect0 + * Signature: (JLjava/nio/ByteBuffer;II)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekDirect0 + (JNIEnv *, jobject, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: seekForPrevDirect0 + * Signature: (JLjava/nio/ByteBuffer;II)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekForPrevDirect0 + (JNIEnv *, jobject, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: seekByteArray0 + * Signature: (J[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekByteArray0 + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: seekForPrevByteArray0 + * Signature: (J[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekForPrevByteArray0 + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: key0 + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_SstFileReaderIterator_key0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: value0 + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_SstFileReaderIterator_value0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: keyDirect0 + * Signature: (JLjava/nio/ByteBuffer;II)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_SstFileReaderIterator_keyDirect0 + (JNIEnv *, jobject, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: keyByteArray0 + * Signature: (J[BII)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_SstFileReaderIterator_keyByteArray0 + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: valueDirect0 + * Signature: (JLjava/nio/ByteBuffer;II)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_SstFileReaderIterator_valueDirect0 + (JNIEnv *, jobject, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_SstFileReaderIterator + * Method: valueByteArray0 + * Signature: (J[BII)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_SstFileReaderIterator_valueByteArray0 + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_SstFileWriter.h b/java/include/org_forstdb_SstFileWriter.h new file mode 100644 index 000000000..58af1dd58 --- /dev/null +++ b/java/include/org_forstdb_SstFileWriter.h @@ -0,0 +1,117 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_SstFileWriter */ + +#ifndef _Included_org_forstdb_SstFileWriter +#define _Included_org_forstdb_SstFileWriter +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_SstFileWriter + * Method: newSstFileWriter + * Signature: (JJJB)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileWriter_newSstFileWriter__JJJB + (JNIEnv *, jclass, jlong, jlong, jlong, jbyte); + +/* + * Class: org_forstdb_SstFileWriter + * Method: newSstFileWriter + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileWriter_newSstFileWriter__JJ + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_SstFileWriter + * Method: open + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_open + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_SstFileWriter + * Method: put + * Signature: (JJJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_put__JJJ + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_SstFileWriter + * Method: put + * Signature: (J[B[B)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_put__J_3B_3B + (JNIEnv *, jobject, jlong, jbyteArray, jbyteArray); + +/* + * Class: org_forstdb_SstFileWriter + * Method: putDirect + * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_putDirect + (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint); + +/* + * Class: org_forstdb_SstFileWriter + * Method: fileSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileWriter_fileSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileWriter + * Method: merge + * Signature: (JJJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_merge__JJJ + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_SstFileWriter + * Method: merge + * Signature: (J[B[B)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_merge__J_3B_3B + (JNIEnv *, jobject, jlong, jbyteArray, jbyteArray); + +/* + * Class: org_forstdb_SstFileWriter + * Method: delete + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_delete__JJ + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_SstFileWriter + * Method: delete + * Signature: (J[B)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_delete__J_3B + (JNIEnv *, jobject, jlong, jbyteArray); + +/* + * Class: org_forstdb_SstFileWriter + * Method: finish + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_finish + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_SstFileWriter + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_SstPartitionerFixedPrefixFactory.h b/java/include/org_forstdb_SstPartitionerFixedPrefixFactory.h new file mode 100644 index 000000000..13b7db72e --- /dev/null +++ b/java/include/org_forstdb_SstPartitionerFixedPrefixFactory.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_SstPartitionerFixedPrefixFactory */ + +#ifndef _Included_org_forstdb_SstPartitionerFixedPrefixFactory +#define _Included_org_forstdb_SstPartitionerFixedPrefixFactory +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_SstPartitionerFixedPrefixFactory + * Method: newSstPartitionerFixedPrefixFactory0 + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_SstPartitionerFixedPrefixFactory_newSstPartitionerFixedPrefixFactory0 + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_SstPartitionerFixedPrefixFactory + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_SstPartitionerFixedPrefixFactory_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_Statistics.h b/java/include/org_forstdb_Statistics.h new file mode 100644 index 000000000..de20acdc6 --- /dev/null +++ b/java/include/org_forstdb_Statistics.h @@ -0,0 +1,117 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_Statistics */ + +#ifndef _Included_org_forstdb_Statistics +#define _Included_org_forstdb_Statistics +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_Statistics + * Method: newStatistics + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_newStatistics__ + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_Statistics + * Method: newStatistics + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_newStatistics__J + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_Statistics + * Method: newStatistics + * Signature: ([B)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_newStatistics___3B + (JNIEnv *, jclass, jbyteArray); + +/* + * Class: org_forstdb_Statistics + * Method: newStatistics + * Signature: ([BJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_newStatistics___3BJ + (JNIEnv *, jclass, jbyteArray, jlong); + +/* + * Class: org_forstdb_Statistics + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Statistics_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Statistics + * Method: statsLevel + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Statistics_statsLevel + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Statistics + * Method: setStatsLevel + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Statistics_setStatsLevel + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Statistics + * Method: getTickerCount + * Signature: (JB)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_getTickerCount + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Statistics + * Method: getAndResetTickerCount + * Signature: (JB)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_getAndResetTickerCount + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Statistics + * Method: getHistogramData + * Signature: (JB)Lorg/forstdb/HistogramData; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_Statistics_getHistogramData + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Statistics + * Method: getHistogramString + * Signature: (JB)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_Statistics_getHistogramString + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_Statistics + * Method: reset + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Statistics_reset + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Statistics + * Method: toString + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_Statistics_toString + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_StringAppendOperator.h b/java/include/org_forstdb_StringAppendOperator.h new file mode 100644 index 000000000..b4a7fa77c --- /dev/null +++ b/java/include/org_forstdb_StringAppendOperator.h @@ -0,0 +1,37 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_StringAppendOperator */ + +#ifndef _Included_org_forstdb_StringAppendOperator +#define _Included_org_forstdb_StringAppendOperator +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_StringAppendOperator + * Method: newSharedStringAppendOperator + * Signature: (C)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_StringAppendOperator_newSharedStringAppendOperator__C + (JNIEnv *, jclass, jchar); + +/* + * Class: org_forstdb_StringAppendOperator + * Method: newSharedStringAppendOperator + * Signature: (Ljava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_StringAppendOperator_newSharedStringAppendOperator__Ljava_lang_String_2 + (JNIEnv *, jclass, jstring); + +/* + * Class: org_forstdb_StringAppendOperator + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_StringAppendOperator_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_ThreadStatus.h b/java/include/org_forstdb_ThreadStatus.h new file mode 100644 index 000000000..6c358e4e2 --- /dev/null +++ b/java/include/org_forstdb_ThreadStatus.h @@ -0,0 +1,69 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_ThreadStatus */ + +#ifndef _Included_org_forstdb_ThreadStatus +#define _Included_org_forstdb_ThreadStatus +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_ThreadStatus + * Method: getThreadTypeName + * Signature: (B)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_getThreadTypeName + (JNIEnv *, jclass, jbyte); + +/* + * Class: org_forstdb_ThreadStatus + * Method: getOperationName + * Signature: (B)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_getOperationName + (JNIEnv *, jclass, jbyte); + +/* + * Class: org_forstdb_ThreadStatus + * Method: microsToStringNative + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_microsToStringNative + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_ThreadStatus + * Method: getOperationStageName + * Signature: (B)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_getOperationStageName + (JNIEnv *, jclass, jbyte); + +/* + * Class: org_forstdb_ThreadStatus + * Method: getOperationPropertyName + * Signature: (BI)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_getOperationPropertyName + (JNIEnv *, jclass, jbyte, jint); + +/* + * Class: org_forstdb_ThreadStatus + * Method: interpretOperationProperties + * Signature: (B[J)Ljava/util/Map; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_ThreadStatus_interpretOperationProperties + (JNIEnv *, jclass, jbyte, jlongArray); + +/* + * Class: org_forstdb_ThreadStatus + * Method: getStateName + * Signature: (B)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_getStateName + (JNIEnv *, jclass, jbyte); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_TimedEnv.h b/java/include/org_forstdb_TimedEnv.h new file mode 100644 index 000000000..9fbc7ae94 --- /dev/null +++ b/java/include/org_forstdb_TimedEnv.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_TimedEnv */ + +#ifndef _Included_org_forstdb_TimedEnv +#define _Included_org_forstdb_TimedEnv +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_TimedEnv + * Method: createTimedEnv + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TimedEnv_createTimedEnv + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_TimedEnv + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TimedEnv_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_Transaction.h b/java/include/org_forstdb_Transaction.h new file mode 100644 index 000000000..eeb9dc73e --- /dev/null +++ b/java/include/org_forstdb_Transaction.h @@ -0,0 +1,613 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_Transaction */ + +#ifndef _Included_org_forstdb_Transaction +#define _Included_org_forstdb_Transaction +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_Transaction + * Method: setSnapshot + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setSnapshot + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: setSnapshotOnNextOperation + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setSnapshotOnNextOperation__J + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: setSnapshotOnNextOperation + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setSnapshotOnNextOperation__JJ + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getSnapshot + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getSnapshot + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: clearSnapshot + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_clearSnapshot + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: prepare + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_prepare + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: commit + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_commit + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: rollback + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_rollback + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: setSavePoint + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setSavePoint + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: rollbackToSavePoint + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_rollbackToSavePoint + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: get + * Signature: (JJ[BIIJ)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_Transaction_get__JJ_3BIIJ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: get + * Signature: (JJ[BII[BIIJ)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Transaction_get__JJ_3BII_3BIIJ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getDirect + * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Transaction_getDirect + (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jobject, jint, jint, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: multiGet + * Signature: (JJ[[B[J)[[B + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Transaction_multiGet__JJ_3_3B_3J + (JNIEnv *, jobject, jlong, jlong, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_Transaction + * Method: multiGet + * Signature: (JJ[[B)[[B + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Transaction_multiGet__JJ_3_3B + (JNIEnv *, jobject, jlong, jlong, jobjectArray); + +/* + * Class: org_forstdb_Transaction + * Method: getForUpdate + * Signature: (JJ[BIIJZZ)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_Transaction_getForUpdate__JJ_3BIIJZZ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jlong, jboolean, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: getForUpdate + * Signature: (JJ[BII[BIIJZZ)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Transaction_getForUpdate__JJ_3BII_3BIIJZZ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong, jboolean, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: getDirectForUpdate + * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJZZ)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_Transaction_getDirectForUpdate + (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jobject, jint, jint, jlong, jboolean, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: multiGetForUpdate + * Signature: (JJ[[B[J)[[B + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Transaction_multiGetForUpdate__JJ_3_3B_3J + (JNIEnv *, jobject, jlong, jlong, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_Transaction + * Method: multiGetForUpdate + * Signature: (JJ[[B)[[B + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Transaction_multiGetForUpdate__JJ_3_3B + (JNIEnv *, jobject, jlong, jlong, jobjectArray); + +/* + * Class: org_forstdb_Transaction + * Method: getIterator + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getIterator + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: put + * Signature: (J[BII[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_put__J_3BII_3BII + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_Transaction + * Method: put + * Signature: (J[BII[BIIJZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_put__J_3BII_3BIIJZ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: put + * Signature: (J[[BI[[BIJZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_put__J_3_3BI_3_3BIJZ + (JNIEnv *, jobject, jlong, jobjectArray, jint, jobjectArray, jint, jlong, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: put + * Signature: (J[[BI[[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_put__J_3_3BI_3_3BI + (JNIEnv *, jobject, jlong, jobjectArray, jint, jobjectArray, jint); + +/* + * Class: org_forstdb_Transaction + * Method: putDirect + * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2IIJZ + (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint, jlong, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: putDirect + * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2II + (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint); + +/* + * Class: org_forstdb_Transaction + * Method: merge + * Signature: (J[BII[BIIJZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_merge__J_3BII_3BIIJZ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: mergeDirect + * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_mergeDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2IIJZ + (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint, jlong, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: mergeDirect + * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_mergeDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2II + (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint); + +/* + * Class: org_forstdb_Transaction + * Method: merge + * Signature: (J[BII[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_merge__J_3BII_3BII + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_Transaction + * Method: delete + * Signature: (J[BIJZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_delete__J_3BIJZ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: delete + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_delete__J_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_Transaction + * Method: delete + * Signature: (J[[BIJZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_delete__J_3_3BIJZ + (JNIEnv *, jobject, jlong, jobjectArray, jint, jlong, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: delete + * Signature: (J[[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_delete__J_3_3BI + (JNIEnv *, jobject, jlong, jobjectArray, jint); + +/* + * Class: org_forstdb_Transaction + * Method: singleDelete + * Signature: (J[BIJZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_singleDelete__J_3BIJZ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: singleDelete + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_singleDelete__J_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_Transaction + * Method: singleDelete + * Signature: (J[[BIJZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_singleDelete__J_3_3BIJZ + (JNIEnv *, jobject, jlong, jobjectArray, jint, jlong, jboolean); + +/* + * Class: org_forstdb_Transaction + * Method: singleDelete + * Signature: (J[[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_singleDelete__J_3_3BI + (JNIEnv *, jobject, jlong, jobjectArray, jint); + +/* + * Class: org_forstdb_Transaction + * Method: putUntracked + * Signature: (J[BI[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putUntracked__J_3BI_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: putUntracked + * Signature: (J[BI[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putUntracked__J_3BI_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); + +/* + * Class: org_forstdb_Transaction + * Method: putUntracked + * Signature: (J[[BI[[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putUntracked__J_3_3BI_3_3BIJ + (JNIEnv *, jobject, jlong, jobjectArray, jint, jobjectArray, jint, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: putUntracked + * Signature: (J[[BI[[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putUntracked__J_3_3BI_3_3BI + (JNIEnv *, jobject, jlong, jobjectArray, jint, jobjectArray, jint); + +/* + * Class: org_forstdb_Transaction + * Method: mergeUntracked + * Signature: (J[BII[BIIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_mergeUntracked + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: mergeUntrackedDirect + * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_mergeUntrackedDirect + (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: deleteUntracked + * Signature: (J[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_deleteUntracked__J_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: deleteUntracked + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_deleteUntracked__J_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_Transaction + * Method: deleteUntracked + * Signature: (J[[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_deleteUntracked__J_3_3BIJ + (JNIEnv *, jobject, jlong, jobjectArray, jint, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: deleteUntracked + * Signature: (J[[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_deleteUntracked__J_3_3BI + (JNIEnv *, jobject, jlong, jobjectArray, jint); + +/* + * Class: org_forstdb_Transaction + * Method: putLogData + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putLogData + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_Transaction + * Method: disableIndexing + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_disableIndexing + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: enableIndexing + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_enableIndexing + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getNumKeys + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getNumKeys + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getNumPuts + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getNumPuts + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getNumDeletes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getNumDeletes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getNumMerges + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getNumMerges + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getElapsedTime + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getElapsedTime + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getWriteBatch + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getWriteBatch + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: setLockTimeout + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setLockTimeout + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getWriteOptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getWriteOptions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: setWriteOptions + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setWriteOptions + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: undoGetForUpdate + * Signature: (J[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_undoGetForUpdate__J_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: undoGetForUpdate + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_undoGetForUpdate__J_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_Transaction + * Method: rebuildFromWriteBatch + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_rebuildFromWriteBatch + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getCommitTimeWriteBatch + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getCommitTimeWriteBatch + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: setLogNumber + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setLogNumber + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getLogNumber + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getLogNumber + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: setName + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setName + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_Transaction + * Method: getName + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_forstdb_Transaction_getName + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getID + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getID + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: isDeadlockDetect + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_Transaction_isDeadlockDetect + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getWaitingTxns + * Signature: (J)Lorg/forstdb/Transaction/WaitingTransactions; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_Transaction_getWaitingTxns + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getState + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_Transaction_getState + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: getId + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getId + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_Transaction + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_Transaction_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_TransactionDB.h b/java/include/org_forstdb_TransactionDB.h new file mode 100644 index 000000000..6e71740dd --- /dev/null +++ b/java/include/org_forstdb_TransactionDB.h @@ -0,0 +1,119 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_TransactionDB */ + +#ifndef _Included_org_forstdb_TransactionDB +#define _Included_org_forstdb_TransactionDB +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_TransactionDB_NOT_FOUND +#define org_forstdb_TransactionDB_NOT_FOUND -1L +/* + * Class: org_forstdb_TransactionDB + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionDB_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionDB + * Method: open + * Signature: (JJLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_open__JJLjava_lang_String_2 + (JNIEnv *, jclass, jlong, jlong, jstring); + +/* + * Class: org_forstdb_TransactionDB + * Method: open + * Signature: (JJLjava/lang/String;[[B[J)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_TransactionDB_open__JJLjava_lang_String_2_3_3B_3J + (JNIEnv *, jclass, jlong, jlong, jstring, jobjectArray, jlongArray); + +/* + * Class: org_forstdb_TransactionDB + * Method: closeDatabase + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionDB_closeDatabase + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_TransactionDB + * Method: beginTransaction + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_beginTransaction__JJ + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_TransactionDB + * Method: beginTransaction + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_beginTransaction__JJJ + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_TransactionDB + * Method: beginTransaction_withOld + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_beginTransaction_1withOld__JJJ + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_forstdb_TransactionDB + * Method: beginTransaction_withOld + * Signature: (JJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_beginTransaction_1withOld__JJJJ + (JNIEnv *, jobject, jlong, jlong, jlong, jlong); + +/* + * Class: org_forstdb_TransactionDB + * Method: getTransactionByName + * Signature: (JLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_getTransactionByName + (JNIEnv *, jobject, jlong, jstring); + +/* + * Class: org_forstdb_TransactionDB + * Method: getAllPreparedTransactions + * Signature: (J)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_TransactionDB_getAllPreparedTransactions + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionDB + * Method: getLockStatusData + * Signature: (J)Ljava/util/Map; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_TransactionDB_getLockStatusData + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionDB + * Method: getDeadlockInfoBuffer + * Signature: (J)[Lorg/forstdb/TransactionDB/DeadlockPath; + */ +JNIEXPORT jobjectArray JNICALL Java_org_forstdb_TransactionDB_getDeadlockInfoBuffer + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionDB + * Method: setDeadlockInfoBufferSize + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionDB_setDeadlockInfoBufferSize + (JNIEnv *, jobject, jlong, jint); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_TransactionDBOptions.h b/java/include/org_forstdb_TransactionDBOptions.h new file mode 100644 index 000000000..2fd6def68 --- /dev/null +++ b/java/include/org_forstdb_TransactionDBOptions.h @@ -0,0 +1,109 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_TransactionDBOptions */ + +#ifndef _Included_org_forstdb_TransactionDBOptions +#define _Included_org_forstdb_TransactionDBOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_TransactionDBOptions + * Method: newTransactionDBOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDBOptions_newTransactionDBOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_TransactionDBOptions + * Method: getMaxNumLocks + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDBOptions_getMaxNumLocks + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionDBOptions + * Method: setMaxNumLocks + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_setMaxNumLocks + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_TransactionDBOptions + * Method: getNumStripes + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDBOptions_getNumStripes + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionDBOptions + * Method: setNumStripes + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_setNumStripes + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_TransactionDBOptions + * Method: getTransactionLockTimeout + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDBOptions_getTransactionLockTimeout + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionDBOptions + * Method: setTransactionLockTimeout + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_setTransactionLockTimeout + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_TransactionDBOptions + * Method: getDefaultLockTimeout + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDBOptions_getDefaultLockTimeout + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionDBOptions + * Method: setDefaultLockTimeout + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_setDefaultLockTimeout + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_TransactionDBOptions + * Method: getWritePolicy + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_org_forstdb_TransactionDBOptions_getWritePolicy + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionDBOptions + * Method: setWritePolicy + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_setWritePolicy + (JNIEnv *, jobject, jlong, jbyte); + +/* + * Class: org_forstdb_TransactionDBOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_TransactionLogIterator.h b/java/include/org_forstdb_TransactionLogIterator.h new file mode 100644 index 000000000..ee8c79d99 --- /dev/null +++ b/java/include/org_forstdb_TransactionLogIterator.h @@ -0,0 +1,53 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_TransactionLogIterator */ + +#ifndef _Included_org_forstdb_TransactionLogIterator +#define _Included_org_forstdb_TransactionLogIterator +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_TransactionLogIterator + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionLogIterator_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionLogIterator + * Method: isValid + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_TransactionLogIterator_isValid + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionLogIterator + * Method: next + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionLogIterator_next + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionLogIterator + * Method: status + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionLogIterator_status + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionLogIterator + * Method: getBatch + * Signature: (J)Lorg/forstdb/TransactionLogIterator/BatchResult; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_TransactionLogIterator_getBatch + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_TransactionOptions.h b/java/include/org_forstdb_TransactionOptions.h new file mode 100644 index 000000000..673a41c5f --- /dev/null +++ b/java/include/org_forstdb_TransactionOptions.h @@ -0,0 +1,125 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_TransactionOptions */ + +#ifndef _Included_org_forstdb_TransactionOptions +#define _Included_org_forstdb_TransactionOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_TransactionOptions + * Method: newTransactionOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionOptions_newTransactionOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_TransactionOptions + * Method: isSetSnapshot + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_TransactionOptions_isSetSnapshot + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionOptions + * Method: setSetSnapshot + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setSetSnapshot + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_TransactionOptions + * Method: isDeadlockDetect + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_TransactionOptions_isDeadlockDetect + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionOptions + * Method: setDeadlockDetect + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setDeadlockDetect + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_TransactionOptions + * Method: getLockTimeout + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionOptions_getLockTimeout + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionOptions + * Method: setLockTimeout + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setLockTimeout + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_TransactionOptions + * Method: getExpiration + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionOptions_getExpiration + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionOptions + * Method: setExpiration + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setExpiration + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_TransactionOptions + * Method: getDeadlockDetectDepth + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionOptions_getDeadlockDetectDepth + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionOptions + * Method: setDeadlockDetectDepth + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setDeadlockDetectDepth + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_TransactionOptions + * Method: getMaxWriteBatchSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionOptions_getMaxWriteBatchSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TransactionOptions + * Method: setMaxWriteBatchSize + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setMaxWriteBatchSize + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_TransactionOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_TtlDB.h b/java/include/org_forstdb_TtlDB.h new file mode 100644 index 000000000..9f77960ed --- /dev/null +++ b/java/include/org_forstdb_TtlDB.h @@ -0,0 +1,55 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_TtlDB */ + +#ifndef _Included_org_forstdb_TtlDB +#define _Included_org_forstdb_TtlDB +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_TtlDB_NOT_FOUND +#define org_forstdb_TtlDB_NOT_FOUND -1L +/* + * Class: org_forstdb_TtlDB + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TtlDB_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_TtlDB + * Method: open + * Signature: (JLjava/lang/String;IZ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TtlDB_open + (JNIEnv *, jclass, jlong, jstring, jint, jboolean); + +/* + * Class: org_forstdb_TtlDB + * Method: openCF + * Signature: (JLjava/lang/String;[[B[J[IZ)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_TtlDB_openCF + (JNIEnv *, jclass, jlong, jstring, jobjectArray, jlongArray, jintArray, jboolean); + +/* + * Class: org_forstdb_TtlDB + * Method: createColumnFamilyWithTtl + * Signature: (J[BJI)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_TtlDB_createColumnFamilyWithTtl + (JNIEnv *, jobject, jlong, jbyteArray, jlong, jint); + +/* + * Class: org_forstdb_TtlDB + * Method: closeDatabase + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_TtlDB_closeDatabase + (JNIEnv *, jclass, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_UInt64AddOperator.h b/java/include/org_forstdb_UInt64AddOperator.h new file mode 100644 index 000000000..930b61362 --- /dev/null +++ b/java/include/org_forstdb_UInt64AddOperator.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_UInt64AddOperator */ + +#ifndef _Included_org_forstdb_UInt64AddOperator +#define _Included_org_forstdb_UInt64AddOperator +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_UInt64AddOperator + * Method: newSharedUInt64AddOperator + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_UInt64AddOperator_newSharedUInt64AddOperator + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_UInt64AddOperator + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_UInt64AddOperator_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_VectorMemTableConfig.h b/java/include/org_forstdb_VectorMemTableConfig.h new file mode 100644 index 000000000..b25ed0fbb --- /dev/null +++ b/java/include/org_forstdb_VectorMemTableConfig.h @@ -0,0 +1,23 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_VectorMemTableConfig */ + +#ifndef _Included_org_forstdb_VectorMemTableConfig +#define _Included_org_forstdb_VectorMemTableConfig +#ifdef __cplusplus +extern "C" { +#endif +#undef org_forstdb_VectorMemTableConfig_DEFAULT_RESERVED_SIZE +#define org_forstdb_VectorMemTableConfig_DEFAULT_RESERVED_SIZE 0L +/* + * Class: org_forstdb_VectorMemTableConfig + * Method: newMemTableFactoryHandle + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_VectorMemTableConfig_newMemTableFactoryHandle + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_WBWIRocksIterator.h b/java/include/org_forstdb_WBWIRocksIterator.h new file mode 100644 index 000000000..d42e5b6b8 --- /dev/null +++ b/java/include/org_forstdb_WBWIRocksIterator.h @@ -0,0 +1,133 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_WBWIRocksIterator */ + +#ifndef _Included_org_forstdb_WBWIRocksIterator +#define _Included_org_forstdb_WBWIRocksIterator +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: isValid0 + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WBWIRocksIterator_isValid0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: seekToFirst0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekToFirst0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: seekToLast0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekToLast0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: next0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_next0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: prev0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_prev0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: refresh0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_refresh0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: seek0 + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seek0 + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: seekForPrev0 + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekForPrev0 + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: status0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_status0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: seekDirect0 + * Signature: (JLjava/nio/ByteBuffer;II)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekDirect0 + (JNIEnv *, jobject, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: seekForPrevDirect0 + * Signature: (JLjava/nio/ByteBuffer;II)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekForPrevDirect0 + (JNIEnv *, jobject, jlong, jobject, jint, jint); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: seekByteArray0 + * Signature: (J[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekByteArray0 + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: seekForPrevByteArray0 + * Signature: (J[BII)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekForPrevByteArray0 + (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); + +/* + * Class: org_forstdb_WBWIRocksIterator + * Method: entry1 + * Signature: (J)[J + */ +JNIEXPORT jlongArray JNICALL Java_org_forstdb_WBWIRocksIterator_entry1 + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_WriteBatch.h b/java/include/org_forstdb_WriteBatch.h new file mode 100644 index 000000000..b485ce83a --- /dev/null +++ b/java/include/org_forstdb_WriteBatch.h @@ -0,0 +1,301 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_WriteBatch */ + +#ifndef _Included_org_forstdb_WriteBatch +#define _Included_org_forstdb_WriteBatch +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_WriteBatch + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: count0 + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_WriteBatch_count0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: put + * Signature: (J[BI[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_put__J_3BI_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatch + * Method: put + * Signature: (J[BI[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_put__J_3BI_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: putDirect + * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_putDirect + (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: merge + * Signature: (J[BI[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_merge__J_3BI_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatch + * Method: merge + * Signature: (J[BI[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_merge__J_3BI_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: delete + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_delete__J_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatch + * Method: delete + * Signature: (J[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_delete__J_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: singleDelete + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_singleDelete__J_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatch + * Method: singleDelete + * Signature: (J[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_singleDelete__J_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: deleteDirect + * Signature: (JLjava/nio/ByteBuffer;IIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_deleteDirect + (JNIEnv *, jobject, jlong, jobject, jint, jint, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: deleteRange + * Signature: (J[BI[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_deleteRange__J_3BI_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatch + * Method: deleteRange + * Signature: (J[BI[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_deleteRange__J_3BI_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: putLogData + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_putLogData + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatch + * Method: clear0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_clear0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: setSavePoint0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_setSavePoint0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: rollbackToSavePoint0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_rollbackToSavePoint0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: popSavePoint + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_popSavePoint + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: setMaxBytes + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_setMaxBytes + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: newWriteBatch + * Signature: (I)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatch_newWriteBatch__I + (JNIEnv *, jclass, jint); + +/* + * Class: org_forstdb_WriteBatch + * Method: newWriteBatch + * Signature: ([BI)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatch_newWriteBatch___3BI + (JNIEnv *, jclass, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatch + * Method: iterate + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_iterate + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: data + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatch_data + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: getDataSize + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatch_getDataSize + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: hasPut + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasPut + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: hasDelete + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasDelete + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: hasSingleDelete + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasSingleDelete + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: hasDeleteRange + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasDeleteRange + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: hasMerge + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasMerge + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: hasBeginPrepare + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasBeginPrepare + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: hasEndPrepare + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasEndPrepare + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: hasCommit + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasCommit + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: hasRollback + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasRollback + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: markWalTerminationPoint + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_markWalTerminationPoint + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatch + * Method: getWalTerminationPoint + * Signature: (J)Lorg/forstdb/WriteBatch/SavePoint; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_WriteBatch_getWalTerminationPoint + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_WriteBatchTest.h b/java/include/org_forstdb_WriteBatchTest.h new file mode 100644 index 000000000..2bb6651d4 --- /dev/null +++ b/java/include/org_forstdb_WriteBatchTest.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_WriteBatchTest */ + +#ifndef _Included_org_forstdb_WriteBatchTest +#define _Included_org_forstdb_WriteBatchTest +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_WriteBatchTest + * Method: getContents + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatchTest_getContents + (JNIEnv *, jclass, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_WriteBatchTestInternalHelper.h b/java/include/org_forstdb_WriteBatchTestInternalHelper.h new file mode 100644 index 000000000..15d6e041f --- /dev/null +++ b/java/include/org_forstdb_WriteBatchTestInternalHelper.h @@ -0,0 +1,37 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_WriteBatchTestInternalHelper */ + +#ifndef _Included_org_forstdb_WriteBatchTestInternalHelper +#define _Included_org_forstdb_WriteBatchTestInternalHelper +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_WriteBatchTestInternalHelper + * Method: setSequence + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchTestInternalHelper_setSequence + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_forstdb_WriteBatchTestInternalHelper + * Method: sequence + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchTestInternalHelper_sequence + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_WriteBatchTestInternalHelper + * Method: append + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchTestInternalHelper_append + (JNIEnv *, jclass, jlong, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_WriteBatchWithIndex.h b/java/include/org_forstdb_WriteBatchWithIndex.h new file mode 100644 index 000000000..a39427580 --- /dev/null +++ b/java/include/org_forstdb_WriteBatchWithIndex.h @@ -0,0 +1,261 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_WriteBatchWithIndex */ + +#ifndef _Included_org_forstdb_WriteBatchWithIndex +#define _Included_org_forstdb_WriteBatchWithIndex +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: count0 + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_forstdb_WriteBatchWithIndex_count0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: put + * Signature: (J[BI[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_put__J_3BI_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: put + * Signature: (J[BI[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_put__J_3BI_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: putDirect + * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_putDirect + (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: merge + * Signature: (J[BI[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_merge__J_3BI_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: merge + * Signature: (J[BI[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_merge__J_3BI_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: delete + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_delete__J_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: delete + * Signature: (J[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_delete__J_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: singleDelete + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_singleDelete__J_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: singleDelete + * Signature: (J[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_singleDelete__J_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: deleteDirect + * Signature: (JLjava/nio/ByteBuffer;IIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_deleteDirect + (JNIEnv *, jobject, jlong, jobject, jint, jint, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: deleteRange + * Signature: (J[BI[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_deleteRange__J_3BI_3BI + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: deleteRange + * Signature: (J[BI[BIJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_deleteRange__J_3BI_3BIJ + (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: putLogData + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_putLogData + (JNIEnv *, jobject, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: clear0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_clear0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: setSavePoint0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_setSavePoint0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: rollbackToSavePoint0 + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_rollbackToSavePoint0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: popSavePoint + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_popSavePoint + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: setMaxBytes + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_setMaxBytes + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: getWriteBatch + * Signature: (J)Lorg/forstdb/WriteBatch; + */ +JNIEXPORT jobject JNICALL Java_org_forstdb_WriteBatchWithIndex_getWriteBatch + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: newWriteBatchWithIndex + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_newWriteBatchWithIndex__ + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: newWriteBatchWithIndex + * Signature: (Z)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_newWriteBatchWithIndex__Z + (JNIEnv *, jclass, jboolean); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: newWriteBatchWithIndex + * Signature: (JBIZ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_newWriteBatchWithIndex__JBIZ + (JNIEnv *, jclass, jlong, jbyte, jint, jboolean); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: iterator0 + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_iterator0 + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: iterator1 + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_iterator1 + (JNIEnv *, jobject, jlong, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: iteratorWithBase + * Signature: (JJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_iteratorWithBase + (JNIEnv *, jobject, jlong, jlong, jlong, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: getFromBatch + * Signature: (JJ[BI)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatchWithIndex_getFromBatch__JJ_3BI + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: getFromBatch + * Signature: (JJ[BIJ)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatchWithIndex_getFromBatch__JJ_3BIJ + (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jlong); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: getFromBatchAndDB + * Signature: (JJJ[BI)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BI + (JNIEnv *, jobject, jlong, jlong, jlong, jbyteArray, jint); + +/* + * Class: org_forstdb_WriteBatchWithIndex + * Method: getFromBatchAndDB + * Signature: (JJJ[BIJ)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BIJ + (JNIEnv *, jobject, jlong, jlong, jlong, jbyteArray, jint, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_WriteBatch_Handler.h b/java/include/org_forstdb_WriteBatch_Handler.h new file mode 100644 index 000000000..1015031f2 --- /dev/null +++ b/java/include/org_forstdb_WriteBatch_Handler.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_WriteBatch_Handler */ + +#ifndef _Included_org_forstdb_WriteBatch_Handler +#define _Included_org_forstdb_WriteBatch_Handler +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_WriteBatch_Handler + * Method: createNewHandler0 + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatch_00024Handler_createNewHandler0 + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_WriteBufferManager.h b/java/include/org_forstdb_WriteBufferManager.h new file mode 100644 index 000000000..0af6a74bd --- /dev/null +++ b/java/include/org_forstdb_WriteBufferManager.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_WriteBufferManager */ + +#ifndef _Included_org_forstdb_WriteBufferManager +#define _Included_org_forstdb_WriteBufferManager +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_WriteBufferManager + * Method: newWriteBufferManager + * Signature: (JJZ)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBufferManager_newWriteBufferManager + (JNIEnv *, jclass, jlong, jlong, jboolean); + +/* + * Class: org_forstdb_WriteBufferManager + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteBufferManager_disposeInternal + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_WriteOptions.h b/java/include/org_forstdb_WriteOptions.h new file mode 100644 index 000000000..01ecfa9df --- /dev/null +++ b/java/include/org_forstdb_WriteOptions.h @@ -0,0 +1,133 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_WriteOptions */ + +#ifndef _Included_org_forstdb_WriteOptions +#define _Included_org_forstdb_WriteOptions +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_WriteOptions + * Method: newWriteOptions + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteOptions_newWriteOptions + (JNIEnv *, jclass); + +/* + * Class: org_forstdb_WriteOptions + * Method: copyWriteOptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_forstdb_WriteOptions_copyWriteOptions + (JNIEnv *, jclass, jlong); + +/* + * Class: org_forstdb_WriteOptions + * Method: disposeInternal + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_disposeInternal + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteOptions + * Method: setSync + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setSync + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_WriteOptions + * Method: sync + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_sync + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteOptions + * Method: setDisableWAL + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setDisableWAL + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_WriteOptions + * Method: disableWAL + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_disableWAL + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteOptions + * Method: setIgnoreMissingColumnFamilies + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setIgnoreMissingColumnFamilies + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_WriteOptions + * Method: ignoreMissingColumnFamilies + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_ignoreMissingColumnFamilies + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteOptions + * Method: setNoSlowdown + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setNoSlowdown + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_WriteOptions + * Method: noSlowdown + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_noSlowdown + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteOptions + * Method: setLowPri + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setLowPri + (JNIEnv *, jobject, jlong, jboolean); + +/* + * Class: org_forstdb_WriteOptions + * Method: lowPri + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_lowPri + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteOptions + * Method: memtableInsertHintPerBatch + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_memtableInsertHintPerBatch + (JNIEnv *, jobject, jlong); + +/* + * Class: org_forstdb_WriteOptions + * Method: setMemtableInsertHintPerBatch + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setMemtableInsertHintPerBatch + (JNIEnv *, jobject, jlong, jboolean); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/include/org_forstdb_test_TestableEventListener.h b/java/include/org_forstdb_test_TestableEventListener.h new file mode 100644 index 000000000..4e9d36df5 --- /dev/null +++ b/java/include/org_forstdb_test_TestableEventListener.h @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_forstdb_test_TestableEventListener */ + +#ifndef _Included_org_forstdb_test_TestableEventListener +#define _Included_org_forstdb_test_TestableEventListener +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_forstdb_test_TestableEventListener + * Method: invokeAllCallbacks + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_forstdb_test_TestableEventListener_invokeAllCallbacks + (JNIEnv *, jclass, jlong); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jmh/pom.xml b/java/jmh/pom.xml index 3016aefa7..6c606f6bd 100644 --- a/java/jmh/pom.xml +++ b/java/jmh/pom.xml @@ -4,7 +4,7 @@ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 4.0.0 - org.rocksdb + org.forstdb rocksdbjni-jmh 1.0-SNAPSHOT @@ -48,7 +48,7 @@ - org.rocksdb + org.forstdb rocksdbjni 7.9.0-SNAPSHOT diff --git a/java/jmh/src/main/java/org/rocksdb/jmh/ComparatorBenchmarks.java b/java/jmh/src/main/java/org/rocksdb/jmh/ComparatorBenchmarks.java index 1973b5487..e0c9a437c 100644 --- a/java/jmh/src/main/java/org/rocksdb/jmh/ComparatorBenchmarks.java +++ b/java/jmh/src/main/java/org/rocksdb/jmh/ComparatorBenchmarks.java @@ -4,20 +4,20 @@ * COPYING file in the root directory) and Apache 2.0 License * (found in the LICENSE.Apache file in the root directory). */ -package org.rocksdb.jmh; +package org.forstdb.jmh; import org.openjdk.jmh.annotations.*; -import org.rocksdb.*; -import org.rocksdb.util.BytewiseComparator; -import org.rocksdb.util.FileUtils; -import org.rocksdb.util.ReverseBytewiseComparator; +import org.forstdb.*; +import org.forstdb.util.BytewiseComparator; +import org.forstdb.util.FileUtils; +import org.forstdb.util.ReverseBytewiseComparator; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.util.concurrent.atomic.AtomicInteger; -import static org.rocksdb.util.KVUtils.ba; +import static org.forstdb.util.KVUtils.ba; @State(Scope.Benchmark) public class ComparatorBenchmarks { diff --git a/java/jmh/src/main/java/org/rocksdb/jmh/GetBenchmarks.java b/java/jmh/src/main/java/org/rocksdb/jmh/GetBenchmarks.java index 1c4329b3a..6155585e2 100644 --- a/java/jmh/src/main/java/org/rocksdb/jmh/GetBenchmarks.java +++ b/java/jmh/src/main/java/org/rocksdb/jmh/GetBenchmarks.java @@ -4,9 +4,9 @@ * COPYING file in the root directory) and Apache 2.0 License * (found in the LICENSE.Apache file in the root directory). */ -package org.rocksdb.jmh; +package org.forstdb.jmh; -import static org.rocksdb.util.KVUtils.ba; +import static org.forstdb.util.KVUtils.ba; import java.io.IOException; import java.nio.ByteBuffer; @@ -17,8 +17,8 @@ import java.util.List; import java.util.concurrent.atomic.AtomicInteger; import org.openjdk.jmh.annotations.*; -import org.rocksdb.*; -import org.rocksdb.util.FileUtils; +import org.forstdb.*; +import org.forstdb.util.FileUtils; @State(Scope.Benchmark) public class GetBenchmarks { diff --git a/java/jmh/src/main/java/org/rocksdb/jmh/MultiGetBenchmarks.java b/java/jmh/src/main/java/org/rocksdb/jmh/MultiGetBenchmarks.java index d37447716..933906cde 100644 --- a/java/jmh/src/main/java/org/rocksdb/jmh/MultiGetBenchmarks.java +++ b/java/jmh/src/main/java/org/rocksdb/jmh/MultiGetBenchmarks.java @@ -4,10 +4,10 @@ * COPYING file in the root directory) and Apache 2.0 License * (found in the LICENSE.Apache file in the root directory). */ -package org.rocksdb.jmh; +package org.forstdb.jmh; -import static org.rocksdb.util.KVUtils.ba; -import static org.rocksdb.util.KVUtils.keys; +import static org.forstdb.util.KVUtils.ba; +import static org.forstdb.util.KVUtils.keys; import java.io.IOException; import java.nio.ByteBuffer; @@ -21,8 +21,8 @@ import org.openjdk.jmh.runner.Runner; import org.openjdk.jmh.runner.RunnerException; import org.openjdk.jmh.runner.options.OptionsBuilder; -import org.rocksdb.*; -import org.rocksdb.util.FileUtils; +import org.forstdb.*; +import org.forstdb.util.FileUtils; @State(Scope.Thread) public class MultiGetBenchmarks { diff --git a/java/jmh/src/main/java/org/rocksdb/jmh/PutBenchmarks.java b/java/jmh/src/main/java/org/rocksdb/jmh/PutBenchmarks.java index cf82401c1..705e57fb8 100644 --- a/java/jmh/src/main/java/org/rocksdb/jmh/PutBenchmarks.java +++ b/java/jmh/src/main/java/org/rocksdb/jmh/PutBenchmarks.java @@ -4,9 +4,9 @@ * COPYING file in the root directory) and Apache 2.0 License * (found in the LICENSE.Apache file in the root directory). */ -package org.rocksdb.jmh; +package org.forstdb.jmh; -import static org.rocksdb.util.KVUtils.ba; +import static org.forstdb.util.KVUtils.ba; import java.io.IOException; import java.nio.ByteBuffer; @@ -17,8 +17,8 @@ import java.util.List; import java.util.concurrent.atomic.AtomicInteger; import org.openjdk.jmh.annotations.*; -import org.rocksdb.*; -import org.rocksdb.util.FileUtils; +import org.forstdb.*; +import org.forstdb.util.FileUtils; @State(Scope.Benchmark) public class PutBenchmarks { diff --git a/java/jmh/src/main/java/org/rocksdb/util/FileUtils.java b/java/jmh/src/main/java/org/rocksdb/util/FileUtils.java index 63744a14f..6c66f0c13 100644 --- a/java/jmh/src/main/java/org/rocksdb/util/FileUtils.java +++ b/java/jmh/src/main/java/org/rocksdb/util/FileUtils.java @@ -4,7 +4,7 @@ * COPYING file in the root directory) and Apache 2.0 License * (found in the LICENSE.Apache file in the root directory). */ -package org.rocksdb.util; +package org.forstdb.util; import java.io.IOException; import java.nio.file.FileVisitResult; diff --git a/java/jmh/src/main/java/org/rocksdb/util/KVUtils.java b/java/jmh/src/main/java/org/rocksdb/util/KVUtils.java index 5077291c8..a419ba78c 100644 --- a/java/jmh/src/main/java/org/rocksdb/util/KVUtils.java +++ b/java/jmh/src/main/java/org/rocksdb/util/KVUtils.java @@ -4,7 +4,7 @@ * COPYING file in the root directory) and Apache 2.0 License * (found in the LICENSE.Apache file in the root directory). */ -package org.rocksdb.util; +package org.forstdb.util; import static java.nio.charset.StandardCharsets.UTF_8; diff --git a/java/samples/src/main/java/OptimisticTransactionSample.java b/java/samples/src/main/java/OptimisticTransactionSample.java index 7e7a22e94..63c09d23b 100644 --- a/java/samples/src/main/java/OptimisticTransactionSample.java +++ b/java/samples/src/main/java/OptimisticTransactionSample.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -import org.rocksdb.*; +import org.forstdb.*; import static java.nio.charset.StandardCharsets.UTF_8; diff --git a/java/samples/src/main/java/RocksDBColumnFamilySample.java b/java/samples/src/main/java/RocksDBColumnFamilySample.java index 72f5731a1..8aaa8a793 100644 --- a/java/samples/src/main/java/RocksDBColumnFamilySample.java +++ b/java/samples/src/main/java/RocksDBColumnFamilySample.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -import org.rocksdb.*; +import org.forstdb.*; import java.util.ArrayList; import java.util.List; diff --git a/java/samples/src/main/java/RocksDBSample.java b/java/samples/src/main/java/RocksDBSample.java index 8ab9b2de3..3f8960093 100644 --- a/java/samples/src/main/java/RocksDBSample.java +++ b/java/samples/src/main/java/RocksDBSample.java @@ -9,8 +9,8 @@ import java.util.Map; import java.util.ArrayList; -import org.rocksdb.*; -import org.rocksdb.util.SizeUnit; +import org.forstdb.*; +import org.forstdb.util.SizeUnit; public class RocksDBSample { static { diff --git a/java/samples/src/main/java/TransactionSample.java b/java/samples/src/main/java/TransactionSample.java index b88a68f12..81102d972 100644 --- a/java/samples/src/main/java/TransactionSample.java +++ b/java/samples/src/main/java/TransactionSample.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -import org.rocksdb.*; +import org.forstdb.*; import static java.nio.charset.StandardCharsets.UTF_8; diff --git a/java/spotbugs-exclude.xml b/java/spotbugs-exclude.xml index bc3d5ea9a..0c8d44929 100644 --- a/java/spotbugs-exclude.xml +++ b/java/spotbugs-exclude.xml @@ -3,136 +3,136 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + @@ -146,6 +146,6 @@ - + \ No newline at end of file diff --git a/java/src/main/java/org/rocksdb/AbstractCompactionFilter.java b/java/src/main/java/org/forstdb/AbstractCompactionFilter.java similarity index 98% rename from java/src/main/java/org/rocksdb/AbstractCompactionFilter.java rename to java/src/main/java/org/forstdb/AbstractCompactionFilter.java index fd7eef4d4..fc401252e 100644 --- a/java/src/main/java/org/rocksdb/AbstractCompactionFilter.java +++ b/java/src/main/java/org/forstdb/AbstractCompactionFilter.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; /** * A CompactionFilter allows an application to modify/delete a key-value at diff --git a/java/src/main/java/org/rocksdb/AbstractCompactionFilterFactory.java b/java/src/main/java/org/forstdb/AbstractCompactionFilterFactory.java similarity index 99% rename from java/src/main/java/org/rocksdb/AbstractCompactionFilterFactory.java rename to java/src/main/java/org/forstdb/AbstractCompactionFilterFactory.java index 728cda8c1..0fbfcb839 100644 --- a/java/src/main/java/org/rocksdb/AbstractCompactionFilterFactory.java +++ b/java/src/main/java/org/forstdb/AbstractCompactionFilterFactory.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Each compaction will create a new {@link AbstractCompactionFilter} diff --git a/java/src/main/java/org/rocksdb/AbstractComparator.java b/java/src/main/java/org/forstdb/AbstractComparator.java similarity index 99% rename from java/src/main/java/org/rocksdb/AbstractComparator.java rename to java/src/main/java/org/forstdb/AbstractComparator.java index 83e0f0676..f66a663ce 100644 --- a/java/src/main/java/org/rocksdb/AbstractComparator.java +++ b/java/src/main/java/org/forstdb/AbstractComparator.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; diff --git a/java/src/main/java/org/rocksdb/AbstractComparatorJniBridge.java b/java/src/main/java/org/forstdb/AbstractComparatorJniBridge.java similarity index 98% rename from java/src/main/java/org/rocksdb/AbstractComparatorJniBridge.java rename to java/src/main/java/org/forstdb/AbstractComparatorJniBridge.java index d0ceef93d..c7e1fa1df 100644 --- a/java/src/main/java/org/rocksdb/AbstractComparatorJniBridge.java +++ b/java/src/main/java/org/forstdb/AbstractComparatorJniBridge.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; @@ -15,7 +15,7 @@ * * Placing these bridge methods in this * class keeps the API of the - * {@link org.rocksdb.AbstractComparator} clean. + * {@link org.forstdb.AbstractComparator} clean. */ class AbstractComparatorJniBridge { /** diff --git a/java/src/main/java/org/rocksdb/AbstractEventListener.java b/java/src/main/java/org/forstdb/AbstractEventListener.java similarity index 99% rename from java/src/main/java/org/rocksdb/AbstractEventListener.java rename to java/src/main/java/org/forstdb/AbstractEventListener.java index c9371c45e..d03a599be 100644 --- a/java/src/main/java/org/rocksdb/AbstractEventListener.java +++ b/java/src/main/java/org/forstdb/AbstractEventListener.java @@ -3,9 +3,9 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; -import static org.rocksdb.AbstractEventListener.EnabledEventCallback.*; +import static org.forstdb.AbstractEventListener.EnabledEventCallback.*; /** * Base class for Event Listeners. diff --git a/java/src/main/java/org/rocksdb/AbstractImmutableNativeReference.java b/java/src/main/java/org/forstdb/AbstractImmutableNativeReference.java similarity index 99% rename from java/src/main/java/org/rocksdb/AbstractImmutableNativeReference.java rename to java/src/main/java/org/forstdb/AbstractImmutableNativeReference.java index 173d63e90..7e667bbea 100644 --- a/java/src/main/java/org/rocksdb/AbstractImmutableNativeReference.java +++ b/java/src/main/java/org/forstdb/AbstractImmutableNativeReference.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.concurrent.atomic.AtomicBoolean; diff --git a/java/src/main/java/org/rocksdb/AbstractMutableOptions.java b/java/src/main/java/org/forstdb/AbstractMutableOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/AbstractMutableOptions.java rename to java/src/main/java/org/forstdb/AbstractMutableOptions.java index ff9b8569f..802ca7c81 100644 --- a/java/src/main/java/org/rocksdb/AbstractMutableOptions.java +++ b/java/src/main/java/org/forstdb/AbstractMutableOptions.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; import java.util.*; diff --git a/java/src/main/java/org/rocksdb/AbstractNativeReference.java b/java/src/main/java/org/forstdb/AbstractNativeReference.java similarity index 98% rename from java/src/main/java/org/rocksdb/AbstractNativeReference.java rename to java/src/main/java/org/forstdb/AbstractNativeReference.java index 1ce54fcba..b0cc585d1 100644 --- a/java/src/main/java/org/rocksdb/AbstractNativeReference.java +++ b/java/src/main/java/org/forstdb/AbstractNativeReference.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * AbstractNativeReference is the base-class of all RocksDB classes that have diff --git a/java/src/main/java/org/rocksdb/AbstractRocksIterator.java b/java/src/main/java/org/forstdb/AbstractRocksIterator.java similarity index 98% rename from java/src/main/java/org/rocksdb/AbstractRocksIterator.java rename to java/src/main/java/org/forstdb/AbstractRocksIterator.java index 1aade1b89..a68b63157 100644 --- a/java/src/main/java/org/rocksdb/AbstractRocksIterator.java +++ b/java/src/main/java/org/forstdb/AbstractRocksIterator.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; @@ -19,7 +19,7 @@ * @param

The type of the Parent Object from which the Rocks Iterator was * created. This is used by disposeInternal to avoid double-free * issues with the underlying C++ object. - * @see org.rocksdb.RocksObject + * @see org.forstdb.RocksObject */ public abstract class AbstractRocksIterator

extends RocksObject implements RocksIteratorInterface { diff --git a/java/src/main/java/org/rocksdb/AbstractSlice.java b/java/src/main/java/org/forstdb/AbstractSlice.java similarity index 93% rename from java/src/main/java/org/rocksdb/AbstractSlice.java rename to java/src/main/java/org/forstdb/AbstractSlice.java index f321b9910..afc6b3e70 100644 --- a/java/src/main/java/org/rocksdb/AbstractSlice.java +++ b/java/src/main/java/org/forstdb/AbstractSlice.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Slices are used by RocksDB to provide @@ -11,18 +11,18 @@ *

* This class is package private, implementers * should extend either of the public abstract classes: - * @see org.rocksdb.Slice - * @see org.rocksdb.DirectSlice + * @see org.forstdb.Slice + * @see org.forstdb.DirectSlice * * Regards the lifecycle of Java Slices in RocksDB: * At present when you configure a Comparator from Java, it creates an * instance of a C++ BaseComparatorJniCallback subclass and * passes that to RocksDB as the comparator. That subclass of * BaseComparatorJniCallback creates the Java - * @see org.rocksdb.AbstractSlice subclass Objects. When you dispose - * the Java @see org.rocksdb.AbstractComparator subclass, it disposes the + * @see org.forstdb.AbstractSlice subclass Objects. When you dispose + * the Java @see org.forstdb.AbstractComparator subclass, it disposes the * C++ BaseComparatorJniCallback subclass, which in turn destroys the - * Java @see org.rocksdb.AbstractSlice subclass Objects. + * Java @see org.forstdb.AbstractSlice subclass Objects. */ public abstract class AbstractSlice extends RocksMutableObject { @@ -39,7 +39,7 @@ protected AbstractSlice(final long nativeHandle) { * * @return The slice data. Note, the type of access is * determined by the subclass - * @see org.rocksdb.AbstractSlice#data0(long) + * @see org.forstdb.AbstractSlice#data0(long) */ public T data() { return data0(getNativeHandle()); diff --git a/java/src/main/java/org/rocksdb/AbstractTableFilter.java b/java/src/main/java/org/forstdb/AbstractTableFilter.java similarity index 95% rename from java/src/main/java/org/rocksdb/AbstractTableFilter.java rename to java/src/main/java/org/forstdb/AbstractTableFilter.java index c696c3e13..d83a9839f 100644 --- a/java/src/main/java/org/rocksdb/AbstractTableFilter.java +++ b/java/src/main/java/org/forstdb/AbstractTableFilter.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; /** * Base class for Table Filters. diff --git a/java/src/main/java/org/rocksdb/AbstractTraceWriter.java b/java/src/main/java/org/forstdb/AbstractTraceWriter.java similarity index 99% rename from java/src/main/java/org/rocksdb/AbstractTraceWriter.java rename to java/src/main/java/org/forstdb/AbstractTraceWriter.java index e235c9296..aee94cf94 100644 --- a/java/src/main/java/org/rocksdb/AbstractTraceWriter.java +++ b/java/src/main/java/org/forstdb/AbstractTraceWriter.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Base class for TraceWriters. diff --git a/java/src/main/java/org/rocksdb/AbstractTransactionNotifier.java b/java/src/main/java/org/forstdb/AbstractTransactionNotifier.java similarity index 98% rename from java/src/main/java/org/rocksdb/AbstractTransactionNotifier.java rename to java/src/main/java/org/forstdb/AbstractTransactionNotifier.java index b117e5cc2..d0c98eab2 100644 --- a/java/src/main/java/org/rocksdb/AbstractTransactionNotifier.java +++ b/java/src/main/java/org/forstdb/AbstractTransactionNotifier.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Provides notification to the caller of SetSnapshotOnNextOperation when diff --git a/java/src/main/java/org/rocksdb/AbstractWalFilter.java b/java/src/main/java/org/forstdb/AbstractWalFilter.java similarity index 98% rename from java/src/main/java/org/rocksdb/AbstractWalFilter.java rename to java/src/main/java/org/forstdb/AbstractWalFilter.java index 92180f90e..2a1cb9095 100644 --- a/java/src/main/java/org/rocksdb/AbstractWalFilter.java +++ b/java/src/main/java/org/forstdb/AbstractWalFilter.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Base class for WAL Filters. diff --git a/java/src/main/java/org/rocksdb/AbstractWriteBatch.java b/java/src/main/java/org/forstdb/AbstractWriteBatch.java similarity index 99% rename from java/src/main/java/org/rocksdb/AbstractWriteBatch.java rename to java/src/main/java/org/forstdb/AbstractWriteBatch.java index 41d967f53..2bb2ec324 100644 --- a/java/src/main/java/org/rocksdb/AbstractWriteBatch.java +++ b/java/src/main/java/org/forstdb/AbstractWriteBatch.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; diff --git a/java/src/main/java/org/rocksdb/AccessHint.java b/java/src/main/java/org/forstdb/AccessHint.java similarity index 98% rename from java/src/main/java/org/rocksdb/AccessHint.java rename to java/src/main/java/org/forstdb/AccessHint.java index b7ccadd84..a70968f7c 100644 --- a/java/src/main/java/org/rocksdb/AccessHint.java +++ b/java/src/main/java/org/forstdb/AccessHint.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * File access pattern once a compaction has started diff --git a/java/src/main/java/org/rocksdb/AdvancedColumnFamilyOptionsInterface.java b/java/src/main/java/org/forstdb/AdvancedColumnFamilyOptionsInterface.java similarity index 98% rename from java/src/main/java/org/rocksdb/AdvancedColumnFamilyOptionsInterface.java rename to java/src/main/java/org/forstdb/AdvancedColumnFamilyOptionsInterface.java index d1d1123dd..27c5f9f47 100644 --- a/java/src/main/java/org/rocksdb/AdvancedColumnFamilyOptionsInterface.java +++ b/java/src/main/java/org/forstdb/AdvancedColumnFamilyOptionsInterface.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.List; @@ -192,7 +192,7 @@ T setInplaceUpdateSupport( *

Default: empty

* * @param compressionLevels list of - * {@link org.rocksdb.CompressionType} instances. + * {@link org.forstdb.CompressionType} instances. * * @return the reference to the current options. */ @@ -200,12 +200,12 @@ T setCompressionPerLevel( List compressionLevels); /** - *

Return the currently set {@link org.rocksdb.CompressionType} + *

Return the currently set {@link org.forstdb.CompressionType} * per instances.

* *

See: {@link #setCompressionPerLevel(java.util.List)}

* - * @return list of {@link org.rocksdb.CompressionType} + * @return list of {@link org.forstdb.CompressionType} * instances. */ List compressionPerLevel(); diff --git a/java/src/main/java/org/rocksdb/AdvancedMutableColumnFamilyOptionsInterface.java b/java/src/main/java/org/forstdb/AdvancedMutableColumnFamilyOptionsInterface.java similarity index 99% rename from java/src/main/java/org/rocksdb/AdvancedMutableColumnFamilyOptionsInterface.java rename to java/src/main/java/org/forstdb/AdvancedMutableColumnFamilyOptionsInterface.java index c8fc84173..1b6717e19 100644 --- a/java/src/main/java/org/rocksdb/AdvancedMutableColumnFamilyOptionsInterface.java +++ b/java/src/main/java/org/forstdb/AdvancedMutableColumnFamilyOptionsInterface.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Advanced Column Family Options which are mutable diff --git a/java/src/main/java/org/rocksdb/BackgroundErrorReason.java b/java/src/main/java/org/forstdb/BackgroundErrorReason.java similarity index 98% rename from java/src/main/java/org/rocksdb/BackgroundErrorReason.java rename to java/src/main/java/org/forstdb/BackgroundErrorReason.java index eec593d35..11d6431af 100644 --- a/java/src/main/java/org/rocksdb/BackgroundErrorReason.java +++ b/java/src/main/java/org/forstdb/BackgroundErrorReason.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public enum BackgroundErrorReason { FLUSH((byte) 0x0), diff --git a/java/src/main/java/org/rocksdb/BackupEngine.java b/java/src/main/java/org/forstdb/BackupEngine.java similarity index 99% rename from java/src/main/java/org/rocksdb/BackupEngine.java rename to java/src/main/java/org/forstdb/BackupEngine.java index 3ab220683..7f4298d1d 100644 --- a/java/src/main/java/org/rocksdb/BackupEngine.java +++ b/java/src/main/java/org/forstdb/BackupEngine.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import java.util.List; diff --git a/java/src/main/java/org/rocksdb/BackupEngineOptions.java b/java/src/main/java/org/forstdb/BackupEngineOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/BackupEngineOptions.java rename to java/src/main/java/org/forstdb/BackupEngineOptions.java index 7747b944f..8f5bf6f0f 100644 --- a/java/src/main/java/org/rocksdb/BackupEngineOptions.java +++ b/java/src/main/java/org/forstdb/BackupEngineOptions.java @@ -3,18 +3,18 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.io.File; /** *

BackupEngineOptions controls the behavior of a - * {@link org.rocksdb.BackupEngine}. + * {@link org.forstdb.BackupEngine}. *

*

Note that dispose() must be called before an Options instance * become out-of-scope to release the allocated memory in c++.

* - * @see org.rocksdb.BackupEngine + * @see org.forstdb.BackupEngine */ public class BackupEngineOptions extends RocksObject { private Env backupEnv = null; diff --git a/java/src/main/java/org/rocksdb/BackupInfo.java b/java/src/main/java/org/forstdb/BackupInfo.java similarity index 93% rename from java/src/main/java/org/rocksdb/BackupInfo.java rename to java/src/main/java/org/forstdb/BackupInfo.java index 9581b098f..24179123c 100644 --- a/java/src/main/java/org/rocksdb/BackupInfo.java +++ b/java/src/main/java/org/forstdb/BackupInfo.java @@ -2,17 +2,17 @@ // 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). -package org.rocksdb; +package org.forstdb; /** * Instances of this class describe a Backup made by - * {@link org.rocksdb.BackupEngine}. + * {@link org.forstdb.BackupEngine}. */ public class BackupInfo { /** * Package private constructor used to create instances - * of BackupInfo by {@link org.rocksdb.BackupEngine} + * of BackupInfo by {@link org.forstdb.BackupEngine} * * @param backupId id of backup * @param timestamp timestamp of backup diff --git a/java/src/main/java/org/rocksdb/BlockBasedTableConfig.java b/java/src/main/java/org/forstdb/BlockBasedTableConfig.java similarity index 98% rename from java/src/main/java/org/rocksdb/BlockBasedTableConfig.java rename to java/src/main/java/org/forstdb/BlockBasedTableConfig.java index c82c3ea10..9723eb3d9 100644 --- a/java/src/main/java/org/rocksdb/BlockBasedTableConfig.java +++ b/java/src/main/java/org/forstdb/BlockBasedTableConfig.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; /** * The config for block based table sst format. @@ -205,7 +205,7 @@ public IndexType indexType() { /** * Sets the index type to used with this table. * - * @param indexType {@link org.rocksdb.IndexType} value + * @param indexType {@link org.forstdb.IndexType} value * @return the reference to the current option. */ public BlockBasedTableConfig setIndexType( @@ -226,7 +226,7 @@ public DataBlockIndexType dataBlockIndexType() { /** * Sets the data block index type to used with this table. * - * @param dataBlockIndexType {@link org.rocksdb.DataBlockIndexType} value + * @param dataBlockIndexType {@link org.forstdb.DataBlockIndexType} value * @return the reference to the current option. */ public BlockBasedTableConfig setDataBlockIndexType( @@ -270,7 +270,7 @@ public ChecksumType checksumType() { /** * Sets * - * @param checksumType {@link org.rocksdb.ChecksumType} value. + * @param checksumType {@link org.forstdb.ChecksumType} value. * @return the reference to the current option. */ public BlockBasedTableConfig setChecksumType( @@ -307,13 +307,13 @@ public BlockBasedTableConfig setNoBlockCache(final boolean noBlockCache) { * Use the specified cache for blocks. * When not null this take precedence even if the user sets a block cache size. *

- * {@link org.rocksdb.Cache} should not be disposed before options instances + * {@link org.forstdb.Cache} should not be disposed before options instances * using this cache is disposed. *

- * {@link org.rocksdb.Cache} instance can be re-used in multiple options + * {@link org.forstdb.Cache} instance can be re-used in multiple options * instances. * - * @param blockCache {@link org.rocksdb.Cache} Cache java instance + * @param blockCache {@link org.forstdb.Cache} Cache java instance * (e.g. LRUCache). * * @return the reference to the current config. @@ -571,13 +571,13 @@ public Filter filterPolicy() { /** * Use the specified filter policy to reduce disk reads. *

- * {@link org.rocksdb.Filter} should not be closed before options instances + * {@link org.forstdb.Filter} should not be closed before options instances * using this filter are closed. *

- * {@link org.rocksdb.Filter} instance can be re-used in multiple options + * {@link org.forstdb.Filter} instance can be re-used in multiple options * instances. * - * @param filterPolicy {@link org.rocksdb.Filter} Filter Policy java instance. + * @param filterPolicy {@link org.forstdb.Filter} Filter Policy java instance. * @return the reference to the current config. */ public BlockBasedTableConfig setFilterPolicy( diff --git a/java/src/main/java/org/rocksdb/BloomFilter.java b/java/src/main/java/org/forstdb/BloomFilter.java similarity index 99% rename from java/src/main/java/org/rocksdb/BloomFilter.java rename to java/src/main/java/org/forstdb/BloomFilter.java index c08966c0e..ea1ebdce5 100644 --- a/java/src/main/java/org/rocksdb/BloomFilter.java +++ b/java/src/main/java/org/forstdb/BloomFilter.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/BuiltinComparator.java b/java/src/main/java/org/forstdb/BuiltinComparator.java similarity index 96% rename from java/src/main/java/org/rocksdb/BuiltinComparator.java rename to java/src/main/java/org/forstdb/BuiltinComparator.java index 2c89bf218..89faa1611 100644 --- a/java/src/main/java/org/rocksdb/BuiltinComparator.java +++ b/java/src/main/java/org/forstdb/BuiltinComparator.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Builtin RocksDB comparators diff --git a/java/src/main/java/org/rocksdb/ByteBufferGetStatus.java b/java/src/main/java/org/forstdb/ByteBufferGetStatus.java similarity index 98% rename from java/src/main/java/org/rocksdb/ByteBufferGetStatus.java rename to java/src/main/java/org/forstdb/ByteBufferGetStatus.java index 4ab9e8475..4ead43026 100644 --- a/java/src/main/java/org/rocksdb/ByteBufferGetStatus.java +++ b/java/src/main/java/org/forstdb/ByteBufferGetStatus.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; import java.util.List; diff --git a/java/src/main/java/org/rocksdb/Cache.java b/java/src/main/java/org/forstdb/Cache.java similarity index 97% rename from java/src/main/java/org/rocksdb/Cache.java rename to java/src/main/java/org/forstdb/Cache.java index 04bd3fcaa..3db3ef10f 100644 --- a/java/src/main/java/org/rocksdb/Cache.java +++ b/java/src/main/java/org/forstdb/Cache.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public abstract class Cache extends RocksObject { diff --git a/java/src/main/java/org/rocksdb/CassandraCompactionFilter.java b/java/src/main/java/org/forstdb/CassandraCompactionFilter.java similarity index 97% rename from java/src/main/java/org/rocksdb/CassandraCompactionFilter.java rename to java/src/main/java/org/forstdb/CassandraCompactionFilter.java index 12854c510..58fc0c7f2 100644 --- a/java/src/main/java/org/rocksdb/CassandraCompactionFilter.java +++ b/java/src/main/java/org/forstdb/CassandraCompactionFilter.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Just a Java wrapper around CassandraCompactionFilter implemented in C++ diff --git a/java/src/main/java/org/rocksdb/CassandraValueMergeOperator.java b/java/src/main/java/org/forstdb/CassandraValueMergeOperator.java similarity index 97% rename from java/src/main/java/org/rocksdb/CassandraValueMergeOperator.java rename to java/src/main/java/org/forstdb/CassandraValueMergeOperator.java index 732faee20..202a59c55 100644 --- a/java/src/main/java/org/rocksdb/CassandraValueMergeOperator.java +++ b/java/src/main/java/org/forstdb/CassandraValueMergeOperator.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * CassandraValueMergeOperator is a merge operator that merges two cassandra wide column diff --git a/java/src/main/java/org/rocksdb/Checkpoint.java b/java/src/main/java/org/forstdb/Checkpoint.java similarity index 99% rename from java/src/main/java/org/rocksdb/Checkpoint.java rename to java/src/main/java/org/forstdb/Checkpoint.java index 347221df6..47bc74294 100644 --- a/java/src/main/java/org/rocksdb/Checkpoint.java +++ b/java/src/main/java/org/forstdb/Checkpoint.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Provides Checkpoint functionality. Checkpoints diff --git a/java/src/main/java/org/rocksdb/ChecksumType.java b/java/src/main/java/org/forstdb/ChecksumType.java similarity index 97% rename from java/src/main/java/org/rocksdb/ChecksumType.java rename to java/src/main/java/org/forstdb/ChecksumType.java index 5b3d22492..8623f2541 100644 --- a/java/src/main/java/org/rocksdb/ChecksumType.java +++ b/java/src/main/java/org/forstdb/ChecksumType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Checksum types used in conjunction with BlockBasedTable. diff --git a/java/src/main/java/org/rocksdb/ClockCache.java b/java/src/main/java/org/forstdb/ClockCache.java similarity index 99% rename from java/src/main/java/org/rocksdb/ClockCache.java rename to java/src/main/java/org/forstdb/ClockCache.java index f9f6da74c..4ed6f7077 100644 --- a/java/src/main/java/org/rocksdb/ClockCache.java +++ b/java/src/main/java/org/forstdb/ClockCache.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Similar to {@link LRUCache}, but based on the CLOCK algorithm with diff --git a/java/src/main/java/org/rocksdb/ColumnFamilyDescriptor.java b/java/src/main/java/org/forstdb/ColumnFamilyDescriptor.java similarity index 99% rename from java/src/main/java/org/rocksdb/ColumnFamilyDescriptor.java rename to java/src/main/java/org/forstdb/ColumnFamilyDescriptor.java index dd9567829..ec2c99fa0 100644 --- a/java/src/main/java/org/rocksdb/ColumnFamilyDescriptor.java +++ b/java/src/main/java/org/forstdb/ColumnFamilyDescriptor.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Arrays; diff --git a/java/src/main/java/org/rocksdb/ColumnFamilyHandle.java b/java/src/main/java/org/forstdb/ColumnFamilyHandle.java similarity index 99% rename from java/src/main/java/org/rocksdb/ColumnFamilyHandle.java rename to java/src/main/java/org/forstdb/ColumnFamilyHandle.java index 9fd63e768..4f07375bd 100644 --- a/java/src/main/java/org/rocksdb/ColumnFamilyHandle.java +++ b/java/src/main/java/org/forstdb/ColumnFamilyHandle.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Arrays; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/ColumnFamilyMetaData.java b/java/src/main/java/org/forstdb/ColumnFamilyMetaData.java similarity index 98% rename from java/src/main/java/org/rocksdb/ColumnFamilyMetaData.java rename to java/src/main/java/org/forstdb/ColumnFamilyMetaData.java index 9b6d1a70c..7c2734ec4 100644 --- a/java/src/main/java/org/rocksdb/ColumnFamilyMetaData.java +++ b/java/src/main/java/org/forstdb/ColumnFamilyMetaData.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Arrays; import java.util.List; diff --git a/java/src/main/java/org/rocksdb/ColumnFamilyOptions.java b/java/src/main/java/org/forstdb/ColumnFamilyOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/ColumnFamilyOptions.java rename to java/src/main/java/org/forstdb/ColumnFamilyOptions.java index 607a17936..a7105806b 100644 --- a/java/src/main/java/org/rocksdb/ColumnFamilyOptions.java +++ b/java/src/main/java/org/forstdb/ColumnFamilyOptions.java @@ -3,14 +3,14 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.file.Paths; import java.util.*; /** * ColumnFamilyOptions to control the behavior of a database. It will be used - * during the creation of a {@link org.rocksdb.RocksDB} (i.e., RocksDB.open()). + * during the creation of a {@link org.forstdb.RocksDB} (i.e., RocksDB.open()). *

* As a descendant of {@link AbstractNativeReference}, this class is {@link AutoCloseable} * and will be automatically released if opened in the preamble of a try with resources block. @@ -85,7 +85,7 @@ public ColumnFamilyOptions(final Options options) { * * @param properties {@link java.util.Properties} instance. * - * @return {@link org.rocksdb.ColumnFamilyOptions instance} + * @return {@link org.forstdb.ColumnFamilyOptions instance} * or null. * * @throws java.lang.IllegalArgumentException if null or empty @@ -116,7 +116,7 @@ public static ColumnFamilyOptions getColumnFamilyOptionsFromProps( * @param cfgOpts ConfigOptions controlling how the properties are parsed. * @param properties {@link java.util.Properties} instance. * - * @return {@link org.rocksdb.ColumnFamilyOptions instance} + * @return {@link org.forstdb.ColumnFamilyOptions instance} * or null. * * @throws java.lang.IllegalArgumentException if null or empty diff --git a/java/src/main/java/org/rocksdb/ColumnFamilyOptionsInterface.java b/java/src/main/java/org/forstdb/ColumnFamilyOptionsInterface.java similarity index 99% rename from java/src/main/java/org/rocksdb/ColumnFamilyOptionsInterface.java rename to java/src/main/java/org/forstdb/ColumnFamilyOptionsInterface.java index 4776773bd..06db0ffeb 100644 --- a/java/src/main/java/org/rocksdb/ColumnFamilyOptionsInterface.java +++ b/java/src/main/java/org/forstdb/ColumnFamilyOptionsInterface.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Collection; import java.util.List; @@ -370,7 +370,7 @@ T setMaxTableFilesSizeFIFO( * Memtable format can be set using setTableFormatConfig. * * @return the name of the currently-used memtable factory. - * @see #setTableFormatConfig(org.rocksdb.TableFormatConfig) + * @see #setTableFormatConfig(org.forstdb.TableFormatConfig) */ String memTableFactoryName(); diff --git a/java/src/main/java/org/rocksdb/CompactRangeOptions.java b/java/src/main/java/org/forstdb/CompactRangeOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/CompactRangeOptions.java rename to java/src/main/java/org/forstdb/CompactRangeOptions.java index 616a77572..823be4e1f 100644 --- a/java/src/main/java/org/rocksdb/CompactRangeOptions.java +++ b/java/src/main/java/org/forstdb/CompactRangeOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/CompactionJobInfo.java b/java/src/main/java/org/forstdb/CompactionJobInfo.java similarity index 99% rename from java/src/main/java/org/rocksdb/CompactionJobInfo.java rename to java/src/main/java/org/forstdb/CompactionJobInfo.java index cf04bde24..2a5c8c4f5 100644 --- a/java/src/main/java/org/rocksdb/CompactionJobInfo.java +++ b/java/src/main/java/org/forstdb/CompactionJobInfo.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Arrays; import java.util.List; diff --git a/java/src/main/java/org/rocksdb/CompactionJobStats.java b/java/src/main/java/org/forstdb/CompactionJobStats.java similarity index 99% rename from java/src/main/java/org/rocksdb/CompactionJobStats.java rename to java/src/main/java/org/forstdb/CompactionJobStats.java index 3d53b5565..a10998a3a 100644 --- a/java/src/main/java/org/rocksdb/CompactionJobStats.java +++ b/java/src/main/java/org/forstdb/CompactionJobStats.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public class CompactionJobStats extends RocksObject { diff --git a/java/src/main/java/org/rocksdb/CompactionOptions.java b/java/src/main/java/org/forstdb/CompactionOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/CompactionOptions.java rename to java/src/main/java/org/forstdb/CompactionOptions.java index 2c7e391fb..69b11eb87 100644 --- a/java/src/main/java/org/rocksdb/CompactionOptions.java +++ b/java/src/main/java/org/forstdb/CompactionOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.List; diff --git a/java/src/main/java/org/rocksdb/CompactionOptionsFIFO.java b/java/src/main/java/org/forstdb/CompactionOptionsFIFO.java similarity index 99% rename from java/src/main/java/org/rocksdb/CompactionOptionsFIFO.java rename to java/src/main/java/org/forstdb/CompactionOptionsFIFO.java index 92b21fc50..0b321a32e 100644 --- a/java/src/main/java/org/rocksdb/CompactionOptionsFIFO.java +++ b/java/src/main/java/org/forstdb/CompactionOptionsFIFO.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Options for FIFO Compaction diff --git a/java/src/main/java/org/rocksdb/CompactionOptionsUniversal.java b/java/src/main/java/org/forstdb/CompactionOptionsUniversal.java similarity index 99% rename from java/src/main/java/org/rocksdb/CompactionOptionsUniversal.java rename to java/src/main/java/org/forstdb/CompactionOptionsUniversal.java index 4d2ebdb1f..10e974e43 100644 --- a/java/src/main/java/org/rocksdb/CompactionOptionsUniversal.java +++ b/java/src/main/java/org/forstdb/CompactionOptionsUniversal.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Options for Universal Compaction diff --git a/java/src/main/java/org/rocksdb/CompactionPriority.java b/java/src/main/java/org/forstdb/CompactionPriority.java similarity index 96% rename from java/src/main/java/org/rocksdb/CompactionPriority.java rename to java/src/main/java/org/forstdb/CompactionPriority.java index eda05942e..1ba172dfc 100644 --- a/java/src/main/java/org/rocksdb/CompactionPriority.java +++ b/java/src/main/java/org/forstdb/CompactionPriority.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Compaction Priorities @@ -64,7 +64,7 @@ public byte getValue() { * * @param value byte representation of CompactionPriority. * - * @return {@link org.rocksdb.CompactionPriority} instance or null. + * @return {@link org.forstdb.CompactionPriority} instance or null. * @throws java.lang.IllegalArgumentException if an invalid * value is provided. */ diff --git a/java/src/main/java/org/rocksdb/CompactionReason.java b/java/src/main/java/org/forstdb/CompactionReason.java similarity index 99% rename from java/src/main/java/org/rocksdb/CompactionReason.java rename to java/src/main/java/org/forstdb/CompactionReason.java index 46ec33f3f..4e6b19860 100644 --- a/java/src/main/java/org/rocksdb/CompactionReason.java +++ b/java/src/main/java/org/forstdb/CompactionReason.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public enum CompactionReason { kUnknown((byte)0x0), diff --git a/java/src/main/java/org/rocksdb/CompactionStopStyle.java b/java/src/main/java/org/forstdb/CompactionStopStyle.java similarity index 93% rename from java/src/main/java/org/rocksdb/CompactionStopStyle.java rename to java/src/main/java/org/forstdb/CompactionStopStyle.java index f6e63209c..fe1abf2a0 100644 --- a/java/src/main/java/org/rocksdb/CompactionStopStyle.java +++ b/java/src/main/java/org/forstdb/CompactionStopStyle.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; /** * Algorithm used to make a compaction request stop picking new files @@ -38,7 +38,7 @@ public byte getValue() { * * @param value byte representation of CompactionStopStyle. * - * @return {@link org.rocksdb.CompactionStopStyle} instance or null. + * @return {@link org.forstdb.CompactionStopStyle} instance or null. * @throws java.lang.IllegalArgumentException if an invalid * value is provided. */ diff --git a/java/src/main/java/org/rocksdb/CompactionStyle.java b/java/src/main/java/org/forstdb/CompactionStyle.java similarity index 99% rename from java/src/main/java/org/rocksdb/CompactionStyle.java rename to java/src/main/java/org/forstdb/CompactionStyle.java index 7b955a7a2..cf6047e26 100644 --- a/java/src/main/java/org/rocksdb/CompactionStyle.java +++ b/java/src/main/java/org/forstdb/CompactionStyle.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Enum CompactionStyle diff --git a/java/src/main/java/org/rocksdb/ComparatorOptions.java b/java/src/main/java/org/forstdb/ComparatorOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/ComparatorOptions.java rename to java/src/main/java/org/forstdb/ComparatorOptions.java index ee5beb8f6..d14ffc095 100644 --- a/java/src/main/java/org/rocksdb/ComparatorOptions.java +++ b/java/src/main/java/org/forstdb/ComparatorOptions.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; /** * This class controls the behaviour diff --git a/java/src/main/java/org/rocksdb/ComparatorType.java b/java/src/main/java/org/forstdb/ComparatorType.java similarity index 98% rename from java/src/main/java/org/rocksdb/ComparatorType.java rename to java/src/main/java/org/forstdb/ComparatorType.java index 199980b6e..a2585ecfc 100644 --- a/java/src/main/java/org/rocksdb/ComparatorType.java +++ b/java/src/main/java/org/forstdb/ComparatorType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; enum ComparatorType { JAVA_COMPARATOR((byte)0x0), diff --git a/java/src/main/java/org/rocksdb/CompressionOptions.java b/java/src/main/java/org/forstdb/CompressionOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/CompressionOptions.java rename to java/src/main/java/org/forstdb/CompressionOptions.java index 2e1ee5731..2cce1622a 100644 --- a/java/src/main/java/org/rocksdb/CompressionOptions.java +++ b/java/src/main/java/org/forstdb/CompressionOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Options for Compression diff --git a/java/src/main/java/org/rocksdb/CompressionType.java b/java/src/main/java/org/forstdb/CompressionType.java similarity index 99% rename from java/src/main/java/org/rocksdb/CompressionType.java rename to java/src/main/java/org/forstdb/CompressionType.java index d1ecf0ac8..52003386d 100644 --- a/java/src/main/java/org/rocksdb/CompressionType.java +++ b/java/src/main/java/org/forstdb/CompressionType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Enum CompressionType diff --git a/java/src/main/java/org/rocksdb/ConcurrentTaskLimiter.java b/java/src/main/java/org/forstdb/ConcurrentTaskLimiter.java similarity index 98% rename from java/src/main/java/org/rocksdb/ConcurrentTaskLimiter.java rename to java/src/main/java/org/forstdb/ConcurrentTaskLimiter.java index b4e34303b..ee3d854c5 100644 --- a/java/src/main/java/org/rocksdb/ConcurrentTaskLimiter.java +++ b/java/src/main/java/org/forstdb/ConcurrentTaskLimiter.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public abstract class ConcurrentTaskLimiter extends RocksObject { protected ConcurrentTaskLimiter(final long nativeHandle) { diff --git a/java/src/main/java/org/rocksdb/ConcurrentTaskLimiterImpl.java b/java/src/main/java/org/forstdb/ConcurrentTaskLimiterImpl.java similarity index 98% rename from java/src/main/java/org/rocksdb/ConcurrentTaskLimiterImpl.java rename to java/src/main/java/org/forstdb/ConcurrentTaskLimiterImpl.java index d28b9060a..b41f5e1d1 100644 --- a/java/src/main/java/org/rocksdb/ConcurrentTaskLimiterImpl.java +++ b/java/src/main/java/org/forstdb/ConcurrentTaskLimiterImpl.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public class ConcurrentTaskLimiterImpl extends ConcurrentTaskLimiter { public ConcurrentTaskLimiterImpl(final String name, final int maxOutstandingTask) { diff --git a/java/src/main/java/org/rocksdb/ConfigOptions.java b/java/src/main/java/org/forstdb/ConfigOptions.java similarity index 98% rename from java/src/main/java/org/rocksdb/ConfigOptions.java rename to java/src/main/java/org/forstdb/ConfigOptions.java index b3b5423c8..0ea711e3d 100644 --- a/java/src/main/java/org/rocksdb/ConfigOptions.java +++ b/java/src/main/java/org/forstdb/ConfigOptions.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public class ConfigOptions extends RocksObject { /** diff --git a/java/src/main/java/org/rocksdb/DBOptions.java b/java/src/main/java/org/forstdb/DBOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/DBOptions.java rename to java/src/main/java/org/forstdb/DBOptions.java index de10c0585..dd2722cdc 100644 --- a/java/src/main/java/org/rocksdb/DBOptions.java +++ b/java/src/main/java/org/forstdb/DBOptions.java @@ -3,14 +3,14 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.file.Paths; import java.util.*; /** * DBOptions to control the behavior of a database. It will be used - * during the creation of a {@link org.rocksdb.RocksDB} (i.e., RocksDB.open()). + * during the creation of a {@link org.forstdb.RocksDB} (i.e., RocksDB.open()). *

* As a descendent of {@link AbstractNativeReference}, this class is {@link AutoCloseable} * and will be automatically released if opened in the preamble of a try with resources block. @@ -70,7 +70,7 @@ public DBOptions(final Options options) { * @param cfgOpts The ConfigOptions to control how the string is processed. * @param properties {@link java.util.Properties} instance. * - * @return {@link org.rocksdb.DBOptions instance} + * @return {@link org.forstdb.DBOptions instance} * or null. * * @throws java.lang.IllegalArgumentException if null or empty @@ -100,7 +100,7 @@ public static DBOptions getDBOptionsFromProps( * * @param properties {@link java.util.Properties} instance. * - * @return {@link org.rocksdb.DBOptions instance} + * @return {@link org.forstdb.DBOptions instance} * or null. * * @throws java.lang.IllegalArgumentException if null or empty diff --git a/java/src/main/java/org/rocksdb/DBOptionsInterface.java b/java/src/main/java/org/forstdb/DBOptionsInterface.java similarity index 99% rename from java/src/main/java/org/rocksdb/DBOptionsInterface.java rename to java/src/main/java/org/forstdb/DBOptionsInterface.java index 084a399cd..648502cc7 100644 --- a/java/src/main/java/org/rocksdb/DBOptionsInterface.java +++ b/java/src/main/java/org/forstdb/DBOptionsInterface.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Collection; import java.util.List; @@ -55,10 +55,10 @@ public interface DBOptionsInterface> { * Default: false * * @param flag a flag indicating whether to create a database the - * specified database in {@link RocksDB#open(org.rocksdb.Options, String)} operation + * specified database in {@link RocksDB#open(org.forstdb.Options, String)} operation * is missing. * @return the instance of the current Options - * @see RocksDB#open(org.rocksdb.Options, String) + * @see RocksDB#open(org.forstdb.Options, String) */ T setCreateIfMissing(boolean flag); @@ -101,7 +101,7 @@ public interface DBOptionsInterface> { * @param errorIfExists if true, an exception will be thrown * during {@code RocksDB.open()} if the database already exists. * @return the reference to the current option. - * @see RocksDB#open(org.rocksdb.Options, String) + * @see RocksDB#open(org.forstdb.Options, String) */ T setErrorIfExists(boolean errorIfExists); @@ -150,7 +150,7 @@ public interface DBOptionsInterface> { * priority than compaction. Rate limiting is disabled if nullptr. * Default: nullptr * - * @param rateLimiter {@link org.rocksdb.RateLimiter} instance. + * @param rateLimiter {@link org.forstdb.RateLimiter} instance. * @return the instance of the current object. * * @since 3.10.0 @@ -200,7 +200,7 @@ public interface DBOptionsInterface> { /** *

Returns currently set log level.

- * @return {@link org.rocksdb.InfoLogLevel} instance. + * @return {@link org.forstdb.InfoLogLevel} instance. */ InfoLogLevel infoLogLevel(); @@ -238,7 +238,7 @@ public interface DBOptionsInterface> { * * @return the instance of the current object. * - * @see RocksDB#open(org.rocksdb.Options, String) + * @see RocksDB#open(org.forstdb.Options, String) */ T setStatistics(final Statistics statistics); diff --git a/java/src/main/java/org/rocksdb/DataBlockIndexType.java b/java/src/main/java/org/forstdb/DataBlockIndexType.java similarity index 96% rename from java/src/main/java/org/rocksdb/DataBlockIndexType.java rename to java/src/main/java/org/forstdb/DataBlockIndexType.java index 513e5b429..446ee21e8 100644 --- a/java/src/main/java/org/rocksdb/DataBlockIndexType.java +++ b/java/src/main/java/org/forstdb/DataBlockIndexType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** diff --git a/java/src/main/java/org/rocksdb/DbPath.java b/java/src/main/java/org/forstdb/DbPath.java similarity index 98% rename from java/src/main/java/org/rocksdb/DbPath.java rename to java/src/main/java/org/forstdb/DbPath.java index 3f0b67557..b7d511206 100644 --- a/java/src/main/java/org/rocksdb/DbPath.java +++ b/java/src/main/java/org/forstdb/DbPath.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.file.Path; diff --git a/java/src/main/java/org/rocksdb/DirectSlice.java b/java/src/main/java/org/forstdb/DirectSlice.java similarity index 98% rename from java/src/main/java/org/rocksdb/DirectSlice.java rename to java/src/main/java/org/forstdb/DirectSlice.java index 5aa0866ff..af76395ef 100644 --- a/java/src/main/java/org/rocksdb/DirectSlice.java +++ b/java/src/main/java/org/forstdb/DirectSlice.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; @@ -13,7 +13,7 @@ *

* ByteBuffer backed slices typically perform better with * larger keys and values. When using smaller keys and - * values consider using @see org.rocksdb.Slice + * values consider using @see org.forstdb.Slice */ public class DirectSlice extends AbstractSlice { public static final DirectSlice NONE = new DirectSlice(); diff --git a/java/src/main/java/org/rocksdb/EncodingType.java b/java/src/main/java/org/forstdb/EncodingType.java similarity index 98% rename from java/src/main/java/org/rocksdb/EncodingType.java rename to java/src/main/java/org/forstdb/EncodingType.java index e93ffcc23..77244d63d 100644 --- a/java/src/main/java/org/rocksdb/EncodingType.java +++ b/java/src/main/java/org/forstdb/EncodingType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * EncodingType diff --git a/java/src/main/java/org/rocksdb/Env.java b/java/src/main/java/org/forstdb/Env.java similarity index 98% rename from java/src/main/java/org/rocksdb/Env.java rename to java/src/main/java/org/forstdb/Env.java index 6783d8158..15b99fd7a 100644 --- a/java/src/main/java/org/rocksdb/Env.java +++ b/java/src/main/java/org/forstdb/Env.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Arrays; import java.util.List; @@ -24,7 +24,7 @@ public abstract class Env extends RocksObject { * have the ownership of its c++ resource, and calling its dispose()/close() * will be no-op.

* - * @return the default {@link org.rocksdb.RocksEnv} instance. + * @return the default {@link org.forstdb.RocksEnv} instance. */ @SuppressWarnings({"PMD.CloseResource", "PMD.AssignmentInOperand"}) public static Env getDefault() { diff --git a/java/src/main/java/org/rocksdb/EnvFlinkTestSuite.java b/java/src/main/java/org/forstdb/EnvFlinkTestSuite.java similarity index 98% rename from java/src/main/java/org/rocksdb/EnvFlinkTestSuite.java rename to java/src/main/java/org/forstdb/EnvFlinkTestSuite.java index 92e503509..469528059 100644 --- a/java/src/main/java/org/rocksdb/EnvFlinkTestSuite.java +++ b/java/src/main/java/org/forstdb/EnvFlinkTestSuite.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.rocksdb; +package org.forstdb; /** * The test suite used for flink-env interfaces testing. You could define and implement test diff --git a/java/src/main/java/org/rocksdb/EnvOptions.java b/java/src/main/java/org/forstdb/EnvOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/EnvOptions.java rename to java/src/main/java/org/forstdb/EnvOptions.java index fd56bc49e..99c3005b8 100644 --- a/java/src/main/java/org/rocksdb/EnvOptions.java +++ b/java/src/main/java/org/forstdb/EnvOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Options while opening a file to read/write diff --git a/java/src/main/java/org/rocksdb/EventListener.java b/java/src/main/java/org/forstdb/EventListener.java similarity index 99% rename from java/src/main/java/org/rocksdb/EventListener.java rename to java/src/main/java/org/forstdb/EventListener.java index a26325806..48244331b 100644 --- a/java/src/main/java/org/rocksdb/EventListener.java +++ b/java/src/main/java/org/forstdb/EventListener.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * EventListener class contains a set of callback functions that will diff --git a/java/src/main/java/org/rocksdb/Experimental.java b/java/src/main/java/org/forstdb/Experimental.java similarity index 97% rename from java/src/main/java/org/rocksdb/Experimental.java rename to java/src/main/java/org/forstdb/Experimental.java index 64b404d6f..b39272d3e 100644 --- a/java/src/main/java/org/rocksdb/Experimental.java +++ b/java/src/main/java/org/forstdb/Experimental.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.lang.annotation.ElementType; import java.lang.annotation.Documented; diff --git a/java/src/main/java/org/rocksdb/ExportImportFilesMetaData.java b/java/src/main/java/org/forstdb/ExportImportFilesMetaData.java similarity index 96% rename from java/src/main/java/org/rocksdb/ExportImportFilesMetaData.java rename to java/src/main/java/org/forstdb/ExportImportFilesMetaData.java index 1589f631c..a2bac70c9 100644 --- a/java/src/main/java/org/rocksdb/ExportImportFilesMetaData.java +++ b/java/src/main/java/org/forstdb/ExportImportFilesMetaData.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The metadata that describes a column family. diff --git a/java/src/main/java/org/rocksdb/ExternalFileIngestionInfo.java b/java/src/main/java/org/forstdb/ExternalFileIngestionInfo.java similarity index 99% rename from java/src/main/java/org/rocksdb/ExternalFileIngestionInfo.java rename to java/src/main/java/org/forstdb/ExternalFileIngestionInfo.java index 7a99dd6bf..ab92c64d5 100644 --- a/java/src/main/java/org/rocksdb/ExternalFileIngestionInfo.java +++ b/java/src/main/java/org/forstdb/ExternalFileIngestionInfo.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/FileOperationInfo.java b/java/src/main/java/org/forstdb/FileOperationInfo.java similarity index 99% rename from java/src/main/java/org/rocksdb/FileOperationInfo.java rename to java/src/main/java/org/forstdb/FileOperationInfo.java index fae9cd5de..9f3f8d50a 100644 --- a/java/src/main/java/org/rocksdb/FileOperationInfo.java +++ b/java/src/main/java/org/forstdb/FileOperationInfo.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/Filter.java b/java/src/main/java/org/forstdb/Filter.java similarity index 98% rename from java/src/main/java/org/rocksdb/Filter.java rename to java/src/main/java/org/forstdb/Filter.java index 7f490cf59..94cd7e527 100644 --- a/java/src/main/java/org/rocksdb/Filter.java +++ b/java/src/main/java/org/forstdb/Filter.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Filters are stored in rocksdb and are consulted automatically diff --git a/java/src/main/java/org/rocksdb/FilterPolicyType.java b/java/src/main/java/org/forstdb/FilterPolicyType.java similarity index 98% rename from java/src/main/java/org/rocksdb/FilterPolicyType.java rename to java/src/main/java/org/forstdb/FilterPolicyType.java index 6a693ee40..36621e152 100644 --- a/java/src/main/java/org/rocksdb/FilterPolicyType.java +++ b/java/src/main/java/org/forstdb/FilterPolicyType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * IndexType used in conjunction with BlockBasedTable. diff --git a/java/src/main/java/org/rocksdb/FlinkCompactionFilter.java b/java/src/main/java/org/forstdb/FlinkCompactionFilter.java similarity index 99% rename from java/src/main/java/org/rocksdb/FlinkCompactionFilter.java rename to java/src/main/java/org/forstdb/FlinkCompactionFilter.java index ee575d5ba..40e867b23 100644 --- a/java/src/main/java/org/rocksdb/FlinkCompactionFilter.java +++ b/java/src/main/java/org/forstdb/FlinkCompactionFilter.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Just a Java wrapper around FlinkCompactionFilter implemented in C++. diff --git a/java/src/main/java/org/rocksdb/FlinkEnv.java b/java/src/main/java/org/forstdb/FlinkEnv.java similarity index 98% rename from java/src/main/java/org/rocksdb/FlinkEnv.java rename to java/src/main/java/org/forstdb/FlinkEnv.java index 91e6d46b6..758e72952 100644 --- a/java/src/main/java/org/rocksdb/FlinkEnv.java +++ b/java/src/main/java/org/forstdb/FlinkEnv.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.rocksdb; +package org.forstdb; /** * Flink Env which proxy all filesystem access to Flink FileSystem. diff --git a/java/src/main/java/org/rocksdb/FlushJobInfo.java b/java/src/main/java/org/forstdb/FlushJobInfo.java similarity index 99% rename from java/src/main/java/org/rocksdb/FlushJobInfo.java rename to java/src/main/java/org/forstdb/FlushJobInfo.java index 414d3a2f3..c58f5d3f0 100644 --- a/java/src/main/java/org/rocksdb/FlushJobInfo.java +++ b/java/src/main/java/org/forstdb/FlushJobInfo.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/FlushOptions.java b/java/src/main/java/org/forstdb/FlushOptions.java similarity index 98% rename from java/src/main/java/org/rocksdb/FlushOptions.java rename to java/src/main/java/org/forstdb/FlushOptions.java index be8c4bc94..27de9dfef 100644 --- a/java/src/main/java/org/rocksdb/FlushOptions.java +++ b/java/src/main/java/org/forstdb/FlushOptions.java @@ -3,11 +3,11 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * FlushOptions to be passed to flush operations of - * {@link org.rocksdb.RocksDB}. + * {@link org.forstdb.RocksDB}. */ public class FlushOptions extends RocksObject { /** diff --git a/java/src/main/java/org/rocksdb/FlushReason.java b/java/src/main/java/org/forstdb/FlushReason.java similarity index 98% rename from java/src/main/java/org/rocksdb/FlushReason.java rename to java/src/main/java/org/forstdb/FlushReason.java index 9d486cda1..093b97b12 100644 --- a/java/src/main/java/org/rocksdb/FlushReason.java +++ b/java/src/main/java/org/forstdb/FlushReason.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public enum FlushReason { OTHERS((byte) 0x00), diff --git a/java/src/main/java/org/rocksdb/GetStatus.java b/java/src/main/java/org/forstdb/GetStatus.java similarity index 98% rename from java/src/main/java/org/rocksdb/GetStatus.java rename to java/src/main/java/org/forstdb/GetStatus.java index a2afafe39..2e82c13e1 100644 --- a/java/src/main/java/org/rocksdb/GetStatus.java +++ b/java/src/main/java/org/forstdb/GetStatus.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The result for a fetch diff --git a/java/src/main/java/org/rocksdb/HashLinkedListMemTableConfig.java b/java/src/main/java/org/forstdb/HashLinkedListMemTableConfig.java similarity index 99% rename from java/src/main/java/org/rocksdb/HashLinkedListMemTableConfig.java rename to java/src/main/java/org/forstdb/HashLinkedListMemTableConfig.java index a9868df57..0acb02a89 100644 --- a/java/src/main/java/org/rocksdb/HashLinkedListMemTableConfig.java +++ b/java/src/main/java/org/forstdb/HashLinkedListMemTableConfig.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; /** * The config for hash linked list memtable representation diff --git a/java/src/main/java/org/rocksdb/HashSkipListMemTableConfig.java b/java/src/main/java/org/forstdb/HashSkipListMemTableConfig.java similarity index 99% rename from java/src/main/java/org/rocksdb/HashSkipListMemTableConfig.java rename to java/src/main/java/org/forstdb/HashSkipListMemTableConfig.java index 80d6b7115..cc2680121 100644 --- a/java/src/main/java/org/rocksdb/HashSkipListMemTableConfig.java +++ b/java/src/main/java/org/forstdb/HashSkipListMemTableConfig.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; /** * The config for hash skip-list mem-table representation. diff --git a/java/src/main/java/org/rocksdb/HistogramData.java b/java/src/main/java/org/forstdb/HistogramData.java similarity index 98% rename from java/src/main/java/org/rocksdb/HistogramData.java rename to java/src/main/java/org/forstdb/HistogramData.java index 81d890883..439f89a19 100644 --- a/java/src/main/java/org/rocksdb/HistogramData.java +++ b/java/src/main/java/org/forstdb/HistogramData.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public class HistogramData { private final double median_; diff --git a/java/src/main/java/org/rocksdb/HistogramType.java b/java/src/main/java/org/forstdb/HistogramType.java similarity index 98% rename from java/src/main/java/org/rocksdb/HistogramType.java rename to java/src/main/java/org/forstdb/HistogramType.java index 41fe241ad..342c44991 100644 --- a/java/src/main/java/org/rocksdb/HistogramType.java +++ b/java/src/main/java/org/forstdb/HistogramType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public enum HistogramType { @@ -208,7 +208,7 @@ public byte getValue() { * * @param value byte representation of HistogramType. * - * @return {@link org.rocksdb.HistogramType} instance. + * @return {@link org.forstdb.HistogramType} instance. * @throws java.lang.IllegalArgumentException if an invalid * value is provided. */ diff --git a/java/src/main/java/org/rocksdb/Holder.java b/java/src/main/java/org/forstdb/Holder.java similarity index 97% rename from java/src/main/java/org/rocksdb/Holder.java rename to java/src/main/java/org/forstdb/Holder.java index 716a0bda0..ffe1759a4 100644 --- a/java/src/main/java/org/rocksdb/Holder.java +++ b/java/src/main/java/org/forstdb/Holder.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Simple instance reference wrapper. diff --git a/java/src/main/java/org/rocksdb/HyperClockCache.java b/java/src/main/java/org/forstdb/HyperClockCache.java similarity index 96% rename from java/src/main/java/org/rocksdb/HyperClockCache.java rename to java/src/main/java/org/forstdb/HyperClockCache.java index f8fe42be7..2ad072e39 100644 --- a/java/src/main/java/org/rocksdb/HyperClockCache.java +++ b/java/src/main/java/org/forstdb/HyperClockCache.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * HyperClockCache - A lock-free Cache alternative for RocksDB block cache diff --git a/java/src/main/java/org/rocksdb/ImportColumnFamilyOptions.java b/java/src/main/java/org/forstdb/ImportColumnFamilyOptions.java similarity index 98% rename from java/src/main/java/org/rocksdb/ImportColumnFamilyOptions.java rename to java/src/main/java/org/forstdb/ImportColumnFamilyOptions.java index 652bd19dc..26e1c8db3 100644 --- a/java/src/main/java/org/rocksdb/ImportColumnFamilyOptions.java +++ b/java/src/main/java/org/forstdb/ImportColumnFamilyOptions.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * ImportColumnFamilyOptions is used by diff --git a/java/src/main/java/org/rocksdb/IndexShorteningMode.java b/java/src/main/java/org/forstdb/IndexShorteningMode.java similarity index 99% rename from java/src/main/java/org/rocksdb/IndexShorteningMode.java rename to java/src/main/java/org/forstdb/IndexShorteningMode.java index a68346c38..bc2c79b83 100644 --- a/java/src/main/java/org/rocksdb/IndexShorteningMode.java +++ b/java/src/main/java/org/forstdb/IndexShorteningMode.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; /** * This enum allows trading off increased index size for improved iterator diff --git a/java/src/main/java/org/rocksdb/IndexType.java b/java/src/main/java/org/forstdb/IndexType.java similarity index 98% rename from java/src/main/java/org/rocksdb/IndexType.java rename to java/src/main/java/org/forstdb/IndexType.java index 5615e929b..0e838fe51 100644 --- a/java/src/main/java/org/rocksdb/IndexType.java +++ b/java/src/main/java/org/forstdb/IndexType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * IndexType used in conjunction with BlockBasedTable. diff --git a/java/src/main/java/org/rocksdb/InfoLogLevel.java b/java/src/main/java/org/forstdb/InfoLogLevel.java similarity index 93% rename from java/src/main/java/org/rocksdb/InfoLogLevel.java rename to java/src/main/java/org/forstdb/InfoLogLevel.java index 197bd89da..3edbc5602 100644 --- a/java/src/main/java/org/rocksdb/InfoLogLevel.java +++ b/java/src/main/java/org/forstdb/InfoLogLevel.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; /** * RocksDB log levels. @@ -33,7 +33,7 @@ public byte getValue() { * * @param value byte representation of InfoLogLevel. * - * @return {@link org.rocksdb.InfoLogLevel} instance. + * @return {@link org.forstdb.InfoLogLevel} instance. * @throws java.lang.IllegalArgumentException if an invalid * value is provided. */ diff --git a/java/src/main/java/org/rocksdb/IngestExternalFileOptions.java b/java/src/main/java/org/forstdb/IngestExternalFileOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/IngestExternalFileOptions.java rename to java/src/main/java/org/forstdb/IngestExternalFileOptions.java index 1a6a5fccd..7718c2082 100644 --- a/java/src/main/java/org/rocksdb/IngestExternalFileOptions.java +++ b/java/src/main/java/org/forstdb/IngestExternalFileOptions.java @@ -1,4 +1,4 @@ -package org.rocksdb; +package org.forstdb; // 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 diff --git a/java/src/main/java/org/rocksdb/KeyMayExist.java b/java/src/main/java/org/forstdb/KeyMayExist.java similarity index 97% rename from java/src/main/java/org/rocksdb/KeyMayExist.java rename to java/src/main/java/org/forstdb/KeyMayExist.java index 6149b8529..31edabb99 100644 --- a/java/src/main/java/org/rocksdb/KeyMayExist.java +++ b/java/src/main/java/org/forstdb/KeyMayExist.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/LRUCache.java b/java/src/main/java/org/forstdb/LRUCache.java similarity index 99% rename from java/src/main/java/org/rocksdb/LRUCache.java rename to java/src/main/java/org/forstdb/LRUCache.java index 0a9d02e87..1799c2bfc 100644 --- a/java/src/main/java/org/rocksdb/LRUCache.java +++ b/java/src/main/java/org/forstdb/LRUCache.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Least Recently Used Cache diff --git a/java/src/main/java/org/rocksdb/LevelMetaData.java b/java/src/main/java/org/forstdb/LevelMetaData.java similarity index 98% rename from java/src/main/java/org/rocksdb/LevelMetaData.java rename to java/src/main/java/org/forstdb/LevelMetaData.java index 424bcb026..28a0d3a89 100644 --- a/java/src/main/java/org/rocksdb/LevelMetaData.java +++ b/java/src/main/java/org/forstdb/LevelMetaData.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Arrays; import java.util.List; diff --git a/java/src/main/java/org/rocksdb/LiveFileMetaData.java b/java/src/main/java/org/forstdb/LiveFileMetaData.java similarity index 99% rename from java/src/main/java/org/rocksdb/LiveFileMetaData.java rename to java/src/main/java/org/forstdb/LiveFileMetaData.java index 5242496a3..0b2af8b12 100644 --- a/java/src/main/java/org/rocksdb/LiveFileMetaData.java +++ b/java/src/main/java/org/forstdb/LiveFileMetaData.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The full set of metadata associated with each SST file. diff --git a/java/src/main/java/org/rocksdb/LogFile.java b/java/src/main/java/org/forstdb/LogFile.java similarity index 98% rename from java/src/main/java/org/rocksdb/LogFile.java rename to java/src/main/java/org/forstdb/LogFile.java index 5ee2c9fcc..7a1503b77 100644 --- a/java/src/main/java/org/rocksdb/LogFile.java +++ b/java/src/main/java/org/forstdb/LogFile.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; @SuppressWarnings("PMD.MissingStaticMethodInNonInstantiatableClass") public class LogFile { diff --git a/java/src/main/java/org/rocksdb/Logger.java b/java/src/main/java/org/forstdb/Logger.java similarity index 84% rename from java/src/main/java/org/rocksdb/Logger.java rename to java/src/main/java/org/forstdb/Logger.java index 614a7fa50..deea5d740 100644 --- a/java/src/main/java/org/rocksdb/Logger.java +++ b/java/src/main/java/org/forstdb/Logger.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** *

This class provides a custom logger functionality @@ -20,7 +20,7 @@ *

* *

- * A log level can be set using {@link org.rocksdb.Options} or + * A log level can be set using {@link org.forstdb.Options} or * {@link Logger#setInfoLogLevel(InfoLogLevel)}. The set log level * influences the underlying native code. Each log message is * checked against the set log level and if the log level is more @@ -31,8 +31,8 @@ *

Every log message which will be emitted by native code will * trigger expensive native to Java transitions. So the preferred * setting for production use is either - * {@link org.rocksdb.InfoLogLevel#ERROR_LEVEL} or - * {@link org.rocksdb.InfoLogLevel#FATAL_LEVEL}. + * {@link org.forstdb.InfoLogLevel#ERROR_LEVEL} or + * {@link org.forstdb.InfoLogLevel#FATAL_LEVEL}. *

*/ public abstract class Logger extends RocksCallbackObject { @@ -43,10 +43,10 @@ public abstract class Logger extends RocksCallbackObject { *

AbstractLogger constructor.

* *

Important: the log level set within - * the {@link org.rocksdb.Options} instance will be used as + * the {@link org.forstdb.Options} instance will be used as * maximum log level of RocksDB.

* - * @param options {@link org.rocksdb.Options} instance. + * @param options {@link org.forstdb.Options} instance. */ public Logger(final Options options) { super(options.nativeHandle_, WITH_OPTIONS); @@ -57,10 +57,10 @@ public Logger(final Options options) { *

AbstractLogger constructor.

* *

Important: the log level set within - * the {@link org.rocksdb.DBOptions} instance will be used + * the {@link org.forstdb.DBOptions} instance will be used * as maximum log level of RocksDB.

* - * @param dboptions {@link org.rocksdb.DBOptions} instance. + * @param dboptions {@link org.forstdb.DBOptions} instance. */ public Logger(final DBOptions dboptions) { super(dboptions.nativeHandle_, WITH_DBOPTIONS); @@ -78,9 +78,9 @@ protected long initializeNative(final long... nativeParameterHandles) { } /** - * Set {@link org.rocksdb.InfoLogLevel} to AbstractLogger. + * Set {@link org.forstdb.InfoLogLevel} to AbstractLogger. * - * @param infoLogLevel {@link org.rocksdb.InfoLogLevel} instance. + * @param infoLogLevel {@link org.forstdb.InfoLogLevel} instance. */ public void setInfoLogLevel(final InfoLogLevel infoLogLevel) { setInfoLogLevel(nativeHandle_, infoLogLevel.getValue()); @@ -89,7 +89,7 @@ public void setInfoLogLevel(final InfoLogLevel infoLogLevel) { /** * Return the loggers log level. * - * @return {@link org.rocksdb.InfoLogLevel} instance. + * @return {@link org.forstdb.InfoLogLevel} instance. */ public InfoLogLevel infoLogLevel() { return InfoLogLevel.getInfoLogLevel( diff --git a/java/src/main/java/org/rocksdb/MemTableConfig.java b/java/src/main/java/org/forstdb/MemTableConfig.java similarity index 98% rename from java/src/main/java/org/rocksdb/MemTableConfig.java rename to java/src/main/java/org/forstdb/MemTableConfig.java index 17033d251..a9076b5aa 100644 --- a/java/src/main/java/org/rocksdb/MemTableConfig.java +++ b/java/src/main/java/org/forstdb/MemTableConfig.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; /** * MemTableConfig is used to config the internal mem-table of a RocksDB. diff --git a/java/src/main/java/org/rocksdb/MemTableInfo.java b/java/src/main/java/org/forstdb/MemTableInfo.java similarity index 99% rename from java/src/main/java/org/rocksdb/MemTableInfo.java rename to java/src/main/java/org/forstdb/MemTableInfo.java index 3d429035a..8c738afe3 100644 --- a/java/src/main/java/org/rocksdb/MemTableInfo.java +++ b/java/src/main/java/org/forstdb/MemTableInfo.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/MemoryUsageType.java b/java/src/main/java/org/forstdb/MemoryUsageType.java similarity index 98% rename from java/src/main/java/org/rocksdb/MemoryUsageType.java rename to java/src/main/java/org/forstdb/MemoryUsageType.java index 40e6d1716..18c707ac3 100644 --- a/java/src/main/java/org/rocksdb/MemoryUsageType.java +++ b/java/src/main/java/org/forstdb/MemoryUsageType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * MemoryUsageType diff --git a/java/src/main/java/org/rocksdb/MemoryUtil.java b/java/src/main/java/org/forstdb/MemoryUtil.java similarity index 99% rename from java/src/main/java/org/rocksdb/MemoryUtil.java rename to java/src/main/java/org/forstdb/MemoryUtil.java index dac6d9b84..01a87dada 100644 --- a/java/src/main/java/org/rocksdb/MemoryUtil.java +++ b/java/src/main/java/org/forstdb/MemoryUtil.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.*; diff --git a/java/src/main/java/org/rocksdb/MergeOperator.java b/java/src/main/java/org/forstdb/MergeOperator.java similarity index 96% rename from java/src/main/java/org/rocksdb/MergeOperator.java rename to java/src/main/java/org/forstdb/MergeOperator.java index c299f6221..ea0430594 100644 --- a/java/src/main/java/org/rocksdb/MergeOperator.java +++ b/java/src/main/java/org/forstdb/MergeOperator.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * MergeOperator holds an operator to be applied when compacting diff --git a/java/src/main/java/org/rocksdb/MutableColumnFamilyOptions.java b/java/src/main/java/org/forstdb/MutableColumnFamilyOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/MutableColumnFamilyOptions.java rename to java/src/main/java/org/forstdb/MutableColumnFamilyOptions.java index e54db7171..50b0fe8b1 100644 --- a/java/src/main/java/org/rocksdb/MutableColumnFamilyOptions.java +++ b/java/src/main/java/org/forstdb/MutableColumnFamilyOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.*; diff --git a/java/src/main/java/org/rocksdb/MutableColumnFamilyOptionsInterface.java b/java/src/main/java/org/forstdb/MutableColumnFamilyOptionsInterface.java similarity index 99% rename from java/src/main/java/org/rocksdb/MutableColumnFamilyOptionsInterface.java rename to java/src/main/java/org/forstdb/MutableColumnFamilyOptionsInterface.java index 729b0e882..59a5c5dfa 100644 --- a/java/src/main/java/org/rocksdb/MutableColumnFamilyOptionsInterface.java +++ b/java/src/main/java/org/forstdb/MutableColumnFamilyOptionsInterface.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public interface MutableColumnFamilyOptionsInterface< T extends MutableColumnFamilyOptionsInterface> diff --git a/java/src/main/java/org/rocksdb/MutableDBOptions.java b/java/src/main/java/org/forstdb/MutableDBOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/MutableDBOptions.java rename to java/src/main/java/org/forstdb/MutableDBOptions.java index 927e80522..051303e6c 100644 --- a/java/src/main/java/org/rocksdb/MutableDBOptions.java +++ b/java/src/main/java/org/forstdb/MutableDBOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.HashMap; import java.util.List; diff --git a/java/src/main/java/org/rocksdb/MutableDBOptionsInterface.java b/java/src/main/java/org/forstdb/MutableDBOptionsInterface.java similarity index 99% rename from java/src/main/java/org/rocksdb/MutableDBOptionsInterface.java rename to java/src/main/java/org/forstdb/MutableDBOptionsInterface.java index 1521fb4d0..f8bb3f5b5 100644 --- a/java/src/main/java/org/rocksdb/MutableDBOptionsInterface.java +++ b/java/src/main/java/org/forstdb/MutableDBOptionsInterface.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; public interface MutableDBOptionsInterface> { /** diff --git a/java/src/main/java/org/rocksdb/MutableOptionKey.java b/java/src/main/java/org/forstdb/MutableOptionKey.java similarity index 92% rename from java/src/main/java/org/rocksdb/MutableOptionKey.java rename to java/src/main/java/org/forstdb/MutableOptionKey.java index ec1b9ff3b..315f78c43 100644 --- a/java/src/main/java/org/rocksdb/MutableOptionKey.java +++ b/java/src/main/java/org/forstdb/MutableOptionKey.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; public interface MutableOptionKey { enum ValueType { diff --git a/java/src/main/java/org/rocksdb/MutableOptionValue.java b/java/src/main/java/org/forstdb/MutableOptionValue.java similarity index 99% rename from java/src/main/java/org/rocksdb/MutableOptionValue.java rename to java/src/main/java/org/forstdb/MutableOptionValue.java index fe689b5d0..b2bdca0f1 100644 --- a/java/src/main/java/org/rocksdb/MutableOptionValue.java +++ b/java/src/main/java/org/forstdb/MutableOptionValue.java @@ -1,7 +1,7 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; -import static org.rocksdb.AbstractMutableOptions.INT_ARRAY_INT_SEPARATOR; +import static org.forstdb.AbstractMutableOptions.INT_ARRAY_INT_SEPARATOR; public abstract class MutableOptionValue { diff --git a/java/src/main/java/org/rocksdb/NativeComparatorWrapper.java b/java/src/main/java/org/forstdb/NativeComparatorWrapper.java similarity index 98% rename from java/src/main/java/org/rocksdb/NativeComparatorWrapper.java rename to java/src/main/java/org/forstdb/NativeComparatorWrapper.java index b270b8d36..1db25332b 100644 --- a/java/src/main/java/org/rocksdb/NativeComparatorWrapper.java +++ b/java/src/main/java/org/forstdb/NativeComparatorWrapper.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; diff --git a/java/src/main/java/org/rocksdb/NativeLibraryLoader.java b/java/src/main/java/org/forstdb/NativeLibraryLoader.java similarity index 97% rename from java/src/main/java/org/rocksdb/NativeLibraryLoader.java rename to java/src/main/java/org/forstdb/NativeLibraryLoader.java index 6fe97994d..955ddc6bb 100644 --- a/java/src/main/java/org/rocksdb/NativeLibraryLoader.java +++ b/java/src/main/java/org/forstdb/NativeLibraryLoader.java @@ -1,11 +1,11 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; import java.io.*; import java.nio.file.Files; import java.nio.file.StandardCopyOption; -import org.rocksdb.util.Environment; +import org.forstdb.util.Environment; /** * This class is used to load the RocksDB shared library from within the jar. @@ -43,7 +43,7 @@ public static NativeLibraryLoader getInstance() { * Firstly attempts to load the library from java.library.path, * if that fails then it falls back to extracting * the library from the classpath - * {@link org.rocksdb.NativeLibraryLoader#loadLibraryFromJar(java.lang.String)} + * {@link org.forstdb.NativeLibraryLoader#loadLibraryFromJar(java.lang.String)} * * @param tmpDir A temporary directory to use * to copy the native library to when loading from the classpath. diff --git a/java/src/main/java/org/rocksdb/OperationStage.java b/java/src/main/java/org/forstdb/OperationStage.java similarity index 98% rename from java/src/main/java/org/rocksdb/OperationStage.java rename to java/src/main/java/org/forstdb/OperationStage.java index 6ac0a15a2..10c49c8ce 100644 --- a/java/src/main/java/org/rocksdb/OperationStage.java +++ b/java/src/main/java/org/forstdb/OperationStage.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The operation stage. diff --git a/java/src/main/java/org/rocksdb/OperationType.java b/java/src/main/java/org/forstdb/OperationType.java similarity index 98% rename from java/src/main/java/org/rocksdb/OperationType.java rename to java/src/main/java/org/forstdb/OperationType.java index bf7353468..9227427d7 100644 --- a/java/src/main/java/org/rocksdb/OperationType.java +++ b/java/src/main/java/org/forstdb/OperationType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The type used to refer to a thread operation. diff --git a/java/src/main/java/org/rocksdb/OptimisticTransactionDB.java b/java/src/main/java/org/forstdb/OptimisticTransactionDB.java similarity index 98% rename from java/src/main/java/org/rocksdb/OptimisticTransactionDB.java rename to java/src/main/java/org/forstdb/OptimisticTransactionDB.java index 283f19a31..4ae26d3d9 100644 --- a/java/src/main/java/org/rocksdb/OptimisticTransactionDB.java +++ b/java/src/main/java/org/forstdb/OptimisticTransactionDB.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.List; @@ -27,7 +27,7 @@ private OptimisticTransactionDB(final long nativeHandle) { * Open an OptimisticTransactionDB similar to * {@link RocksDB#open(Options, String)}. * - * @param options {@link org.rocksdb.Options} instance. + * @param options {@link org.forstdb.Options} instance. * @param path the path to the rocksdb. * * @return a {@link OptimisticTransactionDB} instance on success, null if the @@ -52,7 +52,7 @@ public static OptimisticTransactionDB open(final Options options, * Open an OptimisticTransactionDB similar to * {@link RocksDB#open(DBOptions, String, List, List)}. * - * @param dbOptions {@link org.rocksdb.DBOptions} instance. + * @param dbOptions {@link org.forstdb.DBOptions} instance. * @param path the path to the rocksdb. * @param columnFamilyDescriptors list of column family descriptors * @param columnFamilyHandles will be filled with ColumnFamilyHandle instances diff --git a/java/src/main/java/org/rocksdb/OptimisticTransactionOptions.java b/java/src/main/java/org/forstdb/OptimisticTransactionOptions.java similarity index 98% rename from java/src/main/java/org/rocksdb/OptimisticTransactionOptions.java rename to java/src/main/java/org/forstdb/OptimisticTransactionOptions.java index a2f5d85ab..f1740105d 100644 --- a/java/src/main/java/org/rocksdb/OptimisticTransactionOptions.java +++ b/java/src/main/java/org/forstdb/OptimisticTransactionOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public class OptimisticTransactionOptions extends RocksObject implements TransactionalOptions { diff --git a/java/src/main/java/org/rocksdb/OptionString.java b/java/src/main/java/org/forstdb/OptionString.java similarity index 99% rename from java/src/main/java/org/rocksdb/OptionString.java rename to java/src/main/java/org/forstdb/OptionString.java index bcbf1d152..f26b72cc9 100644 --- a/java/src/main/java/org/rocksdb/OptionString.java +++ b/java/src/main/java/org/forstdb/OptionString.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.ArrayList; import java.util.List; diff --git a/java/src/main/java/org/rocksdb/Options.java b/java/src/main/java/org/forstdb/Options.java similarity index 99% rename from java/src/main/java/org/rocksdb/Options.java rename to java/src/main/java/org/forstdb/Options.java index 29f5e8e0d..c65978324 100644 --- a/java/src/main/java/org/rocksdb/Options.java +++ b/java/src/main/java/org/forstdb/Options.java @@ -3,14 +3,14 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.file.Paths; import java.util.*; /** * Options to control the behavior of a database. It will be used - * during the creation of a {@link org.rocksdb.RocksDB} (i.e., RocksDB.open()). + * during the creation of a {@link org.forstdb.RocksDB} (i.e., RocksDB.open()). *

* As a descendent of {@link AbstractNativeReference}, this class is {@link AutoCloseable} * and will be automatically released if opened in the preamble of a try with resources block. @@ -52,8 +52,8 @@ public Options() { * Construct options for opening a RocksDB. Reusing database options * and column family options. * - * @param dbOptions {@link org.rocksdb.DBOptions} instance - * @param columnFamilyOptions {@link org.rocksdb.ColumnFamilyOptions} + * @param dbOptions {@link org.forstdb.DBOptions} instance + * @param columnFamilyOptions {@link org.forstdb.ColumnFamilyOptions} * instance */ public Options(final DBOptions dbOptions, diff --git a/java/src/main/java/org/rocksdb/OptionsUtil.java b/java/src/main/java/org/forstdb/OptionsUtil.java similarity index 90% rename from java/src/main/java/org/rocksdb/OptionsUtil.java rename to java/src/main/java/org/forstdb/OptionsUtil.java index 4168921f2..b41d45049 100644 --- a/java/src/main/java/org/rocksdb/OptionsUtil.java +++ b/java/src/main/java/org/forstdb/OptionsUtil.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.List; @@ -35,10 +35,10 @@ public class OptionsUtil { * BlockBasedTableOptions and making necessary changes. * * @param dbPath the path to the RocksDB. - * @param configOptions {@link org.rocksdb.ConfigOptions} instance. - * @param dbOptions {@link org.rocksdb.DBOptions} instance. This will be + * @param configOptions {@link org.forstdb.ConfigOptions} instance. + * @param dbOptions {@link org.forstdb.DBOptions} instance. This will be * filled and returned. - * @param cfDescs A list of {@link org.rocksdb.ColumnFamilyDescriptor}'s be + * @param cfDescs A list of {@link org.forstdb.ColumnFamilyDescriptor}'s be * returned. * @throws RocksDBException thrown if error happens in underlying * native library. @@ -56,10 +56,10 @@ public static void loadLatestOptions(final ConfigOptions configOptions, final St * See LoadLatestOptions above. * * @param optionsFileName the RocksDB options file path. - * @param configOptions {@link org.rocksdb.ConfigOptions} instance. - * @param dbOptions {@link org.rocksdb.DBOptions} instance. This will be + * @param configOptions {@link org.forstdb.ConfigOptions} instance. + * @param dbOptions {@link org.forstdb.DBOptions} instance. This will be * filled and returned. - * @param cfDescs A list of {@link org.rocksdb.ColumnFamilyDescriptor}'s be + * @param cfDescs A list of {@link org.forstdb.ColumnFamilyDescriptor}'s be * returned. * @throws RocksDBException thrown if error happens in underlying * native library. @@ -76,7 +76,7 @@ public static void loadOptionsFromFile(final ConfigOptions configOptions, * Returns the latest options file name under the specified RocksDB path. * * @param dbPath the path to the RocksDB. - * @param env {@link org.rocksdb.Env} instance. + * @param env {@link org.forstdb.Env} instance. * @return the latest options file name under the db path. * * @throws RocksDBException thrown if error happens in underlying diff --git a/java/src/main/java/org/rocksdb/PerfContext.java b/java/src/main/java/org/forstdb/PerfContext.java similarity index 99% rename from java/src/main/java/org/rocksdb/PerfContext.java rename to java/src/main/java/org/forstdb/PerfContext.java index 3934e4115..2b7ba6750 100644 --- a/java/src/main/java/org/rocksdb/PerfContext.java +++ b/java/src/main/java/org/forstdb/PerfContext.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public class PerfContext extends RocksObject { protected PerfContext(final long nativeHandle) { diff --git a/java/src/main/java/org/rocksdb/PerfLevel.java b/java/src/main/java/org/forstdb/PerfLevel.java similarity index 98% rename from java/src/main/java/org/rocksdb/PerfLevel.java rename to java/src/main/java/org/forstdb/PerfLevel.java index 332e6d7d9..2d90366e6 100644 --- a/java/src/main/java/org/rocksdb/PerfLevel.java +++ b/java/src/main/java/org/forstdb/PerfLevel.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public enum PerfLevel { /** diff --git a/java/src/main/java/org/rocksdb/PersistentCache.java b/java/src/main/java/org/forstdb/PersistentCache.java similarity index 97% rename from java/src/main/java/org/rocksdb/PersistentCache.java rename to java/src/main/java/org/forstdb/PersistentCache.java index 5297111e6..a349a9461 100644 --- a/java/src/main/java/org/rocksdb/PersistentCache.java +++ b/java/src/main/java/org/forstdb/PersistentCache.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Persistent cache for caching IO pages on a persistent medium. The diff --git a/java/src/main/java/org/rocksdb/PlainTableConfig.java b/java/src/main/java/org/forstdb/PlainTableConfig.java similarity index 98% rename from java/src/main/java/org/rocksdb/PlainTableConfig.java rename to java/src/main/java/org/forstdb/PlainTableConfig.java index 46077ba56..6c62e589a 100644 --- a/java/src/main/java/org/rocksdb/PlainTableConfig.java +++ b/java/src/main/java/org/forstdb/PlainTableConfig.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; /** * The config for plain table sst format. @@ -163,7 +163,7 @@ public int hugePageTlbSize() { * different encoding types can co-exist in the same DB and * can be read.

* - * @param encodingType {@link org.rocksdb.EncodingType} value. + * @param encodingType {@link org.forstdb.EncodingType} value. * @return the reference to the current config. */ public PlainTableConfig setEncodingType(final EncodingType encodingType) { diff --git a/java/src/main/java/org/rocksdb/PrepopulateBlobCache.java b/java/src/main/java/org/forstdb/PrepopulateBlobCache.java similarity index 99% rename from java/src/main/java/org/rocksdb/PrepopulateBlobCache.java rename to java/src/main/java/org/forstdb/PrepopulateBlobCache.java index f1237aa7c..0a4329289 100644 --- a/java/src/main/java/org/rocksdb/PrepopulateBlobCache.java +++ b/java/src/main/java/org/forstdb/PrepopulateBlobCache.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Enum PrepopulateBlobCache diff --git a/java/src/main/java/org/rocksdb/Priority.java b/java/src/main/java/org/forstdb/Priority.java similarity index 93% rename from java/src/main/java/org/rocksdb/Priority.java rename to java/src/main/java/org/forstdb/Priority.java index 34a56edcb..2077739e8 100644 --- a/java/src/main/java/org/rocksdb/Priority.java +++ b/java/src/main/java/org/forstdb/Priority.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The Thread Pool priority. @@ -34,7 +34,7 @@ byte getValue() { * * @param value byte representation of Priority. * - * @return {@link org.rocksdb.Priority} instance. + * @return {@link org.forstdb.Priority} instance. * @throws java.lang.IllegalArgumentException if an invalid * value is provided. */ diff --git a/java/src/main/java/org/rocksdb/Range.java b/java/src/main/java/org/forstdb/Range.java similarity index 95% rename from java/src/main/java/org/rocksdb/Range.java rename to java/src/main/java/org/forstdb/Range.java index 74c85e5f0..48f32a1ad 100644 --- a/java/src/main/java/org/rocksdb/Range.java +++ b/java/src/main/java/org/forstdb/Range.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Range from start to limit. diff --git a/java/src/main/java/org/rocksdb/RateLimiter.java b/java/src/main/java/org/forstdb/RateLimiter.java similarity index 99% rename from java/src/main/java/org/rocksdb/RateLimiter.java rename to java/src/main/java/org/forstdb/RateLimiter.java index c2b8a0fd9..ace2b9500 100644 --- a/java/src/main/java/org/rocksdb/RateLimiter.java +++ b/java/src/main/java/org/forstdb/RateLimiter.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * RateLimiter, which is used to control write rate of flush and diff --git a/java/src/main/java/org/rocksdb/RateLimiterMode.java b/java/src/main/java/org/forstdb/RateLimiterMode.java similarity index 98% rename from java/src/main/java/org/rocksdb/RateLimiterMode.java rename to java/src/main/java/org/forstdb/RateLimiterMode.java index 4b029d816..87615fa10 100644 --- a/java/src/main/java/org/rocksdb/RateLimiterMode.java +++ b/java/src/main/java/org/forstdb/RateLimiterMode.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Mode for {@link RateLimiter#RateLimiter(long, long, int, RateLimiterMode)}. diff --git a/java/src/main/java/org/rocksdb/ReadOptions.java b/java/src/main/java/org/forstdb/ReadOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/ReadOptions.java rename to java/src/main/java/org/forstdb/ReadOptions.java index c444ae167..5da35981c 100644 --- a/java/src/main/java/org/rocksdb/ReadOptions.java +++ b/java/src/main/java/org/forstdb/ReadOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The class that controls the get behavior. diff --git a/java/src/main/java/org/rocksdb/ReadTier.java b/java/src/main/java/org/forstdb/ReadTier.java similarity index 93% rename from java/src/main/java/org/rocksdb/ReadTier.java rename to java/src/main/java/org/forstdb/ReadTier.java index 78f83f6ad..7970918cd 100644 --- a/java/src/main/java/org/rocksdb/ReadTier.java +++ b/java/src/main/java/org/forstdb/ReadTier.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * RocksDB {@link ReadOptions} read tiers. @@ -34,7 +34,7 @@ public byte getValue() { * * @param value byte representation of ReadTier. * - * @return {@link org.rocksdb.ReadTier} instance or null. + * @return {@link org.forstdb.ReadTier} instance or null. * @throws java.lang.IllegalArgumentException if an invalid * value is provided. */ diff --git a/java/src/main/java/org/rocksdb/RemoveEmptyValueCompactionFilter.java b/java/src/main/java/org/forstdb/RemoveEmptyValueCompactionFilter.java similarity index 96% rename from java/src/main/java/org/rocksdb/RemoveEmptyValueCompactionFilter.java rename to java/src/main/java/org/forstdb/RemoveEmptyValueCompactionFilter.java index e96694313..20e187205 100644 --- a/java/src/main/java/org/rocksdb/RemoveEmptyValueCompactionFilter.java +++ b/java/src/main/java/org/forstdb/RemoveEmptyValueCompactionFilter.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Just a Java wrapper around EmptyValueCompactionFilter implemented in C++ diff --git a/java/src/main/java/org/rocksdb/RestoreOptions.java b/java/src/main/java/org/forstdb/RestoreOptions.java similarity index 98% rename from java/src/main/java/org/rocksdb/RestoreOptions.java rename to java/src/main/java/org/forstdb/RestoreOptions.java index a6b43d476..6c60981a6 100644 --- a/java/src/main/java/org/rocksdb/RestoreOptions.java +++ b/java/src/main/java/org/forstdb/RestoreOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * RestoreOptions to control the behavior of restore. diff --git a/java/src/main/java/org/rocksdb/ReusedSynchronisationType.java b/java/src/main/java/org/forstdb/ReusedSynchronisationType.java similarity index 95% rename from java/src/main/java/org/rocksdb/ReusedSynchronisationType.java rename to java/src/main/java/org/forstdb/ReusedSynchronisationType.java index 2709a5d59..a3590fabc 100644 --- a/java/src/main/java/org/rocksdb/ReusedSynchronisationType.java +++ b/java/src/main/java/org/forstdb/ReusedSynchronisationType.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; /** * Determines the type of synchronisation primitive used @@ -47,7 +47,7 @@ public byte getValue() { * * @param value byte representation of ReusedSynchronisationType. * - * @return {@link org.rocksdb.ReusedSynchronisationType} instance. + * @return {@link org.forstdb.ReusedSynchronisationType} instance. * @throws java.lang.IllegalArgumentException if an invalid * value is provided. */ diff --git a/java/src/main/java/org/rocksdb/RocksCallbackObject.java b/java/src/main/java/org/forstdb/RocksCallbackObject.java similarity index 99% rename from java/src/main/java/org/rocksdb/RocksCallbackObject.java rename to java/src/main/java/org/forstdb/RocksCallbackObject.java index 2c4547b12..4daf14277 100644 --- a/java/src/main/java/org/rocksdb/RocksCallbackObject.java +++ b/java/src/main/java/org/forstdb/RocksCallbackObject.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.List; diff --git a/java/src/main/java/org/rocksdb/RocksDB.java b/java/src/main/java/org/forstdb/RocksDB.java similarity index 98% rename from java/src/main/java/org/rocksdb/RocksDB.java rename to java/src/main/java/org/forstdb/RocksDB.java index 839d01877..76f74609a 100644 --- a/java/src/main/java/org/rocksdb/RocksDB.java +++ b/java/src/main/java/org/forstdb/RocksDB.java @@ -3,16 +3,16 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static java.nio.charset.StandardCharsets.UTF_8; -import static org.rocksdb.util.BufferUtil.CheckBounds; +import static org.forstdb.util.BufferUtil.CheckBounds; import java.io.IOException; import java.nio.ByteBuffer; import java.util.*; import java.util.concurrent.atomic.AtomicReference; -import org.rocksdb.util.Environment; +import org.forstdb.util.Environment; /** * A RocksDB is a persistent ordered map from keys to values. It is safe for @@ -241,7 +241,7 @@ public static RocksDB open(final String path, * with new Options instance as underlying native statistics instance does not * use any locks to prevent concurrent updates.

* - * @param options {@link org.rocksdb.Options} instance. + * @param options {@link org.forstdb.Options} instance. * @param path the path to the rocksdb. * @return a {@link RocksDB} instance on success, null if the specified * {@link RocksDB} can not be opened. @@ -285,7 +285,7 @@ public static RocksDB open(final Options options, final String path) * ColumnFamily handles are disposed when the RocksDB instance is disposed. *

* - * @param options {@link org.rocksdb.DBOptions} instance. + * @param options {@link org.forstdb.DBOptions} instance. * @param path the path to the rocksdb. * @param columnFamilyDescriptors list of column family descriptors * @param columnFamilyHandles will be filled with ColumnFamilyHandle instances @@ -697,7 +697,7 @@ public static List listColumnFamilies(final Options options, * The ColumnFamilyHandle is automatically disposed with DB disposal. * * @param columnFamilyDescriptor column family to be created. - * @return {@link org.rocksdb.ColumnFamilyHandle} instance. + * @return {@link org.forstdb.ColumnFamilyHandle} instance. * * @throws RocksDBException thrown if error happens in underlying * native library. @@ -781,7 +781,7 @@ public List createColumnFamilies( * The ColumnFamilyHandle is automatically disposed with DB disposal. * * @param columnFamilyDescriptor column family to be created. - * @return {@link org.rocksdb.ColumnFamilyHandle} instance. + * @return {@link org.forstdb.ColumnFamilyHandle} instance. * * @throws RocksDBException thrown if error happens in underlying * native library. @@ -819,7 +819,7 @@ public ColumnFamilyHandle createColumnFamilyWithImport( * only records a drop record in the manifest and prevents the column * family from flushing and compacting. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * * @throws RocksDBException thrown if error happens in underlying @@ -904,7 +904,7 @@ public void put(final byte[] key, final int offset, final int len, * Set the database entry for "key" to "value" in the specified * column family. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key the specified key to be inserted. * @param value the value associated with the specified key. @@ -924,7 +924,7 @@ public void put(final ColumnFamilyHandle columnFamilyHandle, * Set the database entry for "key" to "value" in the specified * column family. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key The specified key to be inserted * @param offset the offset of the "key" array to be used, must @@ -954,7 +954,7 @@ public void put(final ColumnFamilyHandle columnFamilyHandle, /** * Set the database entry for "key" to "value". * - * @param writeOpts {@link org.rocksdb.WriteOptions} instance. + * @param writeOpts {@link org.forstdb.WriteOptions} instance. * @param key the specified key to be inserted. * @param value the value associated with the specified key. * @@ -970,7 +970,7 @@ public void put(final WriteOptions writeOpts, final byte[] key, /** * Set the database entry for "key" to "value". * - * @param writeOpts {@link org.rocksdb.WriteOptions} instance. + * @param writeOpts {@link org.forstdb.WriteOptions} instance. * @param key The specified key to be inserted * @param offset the offset of the "key" array to be used, must be * non-negative and no larger than "key".length @@ -1000,9 +1000,9 @@ public void put(final WriteOptions writeOpts, * Set the database entry for "key" to "value" for the specified * column family. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance - * @param writeOpts {@link org.rocksdb.WriteOptions} instance. + * @param writeOpts {@link org.forstdb.WriteOptions} instance. * @param key the specified key to be inserted. * @param value the value associated with the specified key. *

@@ -1023,9 +1023,9 @@ public void put(final ColumnFamilyHandle columnFamilyHandle, * Set the database entry for "key" to "value" for the specified * column family. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance - * @param writeOpts {@link org.rocksdb.WriteOptions} instance. + * @param writeOpts {@link org.forstdb.WriteOptions} instance. * @param key the specified key to be inserted. Position and limit is used. * Supports direct buffer only. * @param value the value associated with the specified key. Position and limit is used. @@ -1058,7 +1058,7 @@ public void put(final ColumnFamilyHandle columnFamilyHandle, final WriteOptions /** * Set the database entry for "key" to "value". * - * @param writeOpts {@link org.rocksdb.WriteOptions} instance. + * @param writeOpts {@link org.forstdb.WriteOptions} instance. * @param key the specified key to be inserted. Position and limit is used. * Supports direct buffer only. * @param value the value associated with the specified key. Position and limit is used. @@ -1092,9 +1092,9 @@ public void put(final WriteOptions writeOpts, final ByteBuffer key, final ByteBu * Set the database entry for "key" to "value" for the specified * column family. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance - * @param writeOpts {@link org.rocksdb.WriteOptions} instance. + * @param writeOpts {@link org.forstdb.WriteOptions} instance. * @param key The specified key to be inserted * @param offset the offset of the "key" array to be used, must be * non-negative and no larger than "key".length @@ -1159,7 +1159,7 @@ public void delete(final byte[] key, final int offset, final int len) * success, and a non-OK status on error. It is not an error if "key" * did not exist in the database. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key Key to delete within database * @@ -1176,7 +1176,7 @@ public void delete(final ColumnFamilyHandle columnFamilyHandle, * success, and a non-OK status on error. It is not an error if "key" * did not exist in the database. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key Key to delete within database * @param offset the offset of the "key" array to be used, @@ -1234,7 +1234,7 @@ public void delete(final WriteOptions writeOpt, final byte[] key, * success, and a non-OK status on error. It is not an error if "key" * did not exist in the database. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param writeOpt WriteOptions to be used with delete operation * @param key Key to delete within database @@ -1254,7 +1254,7 @@ public void delete(final ColumnFamilyHandle columnFamilyHandle, * success, and a non-OK status on error. It is not an error if "key" * did not exist in the database. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param writeOpt WriteOptions to be used with delete operation * @param key Key to delete within database @@ -1276,7 +1276,7 @@ public void delete(final ColumnFamilyHandle columnFamilyHandle, /** * Get the value associated with the specified key within column family. * - * @param opt {@link org.rocksdb.ReadOptions} instance. + * @param opt {@link org.forstdb.ReadOptions} instance. * @param key the key to retrieve the value. It is using position and limit. * Supports direct buffer only. * @param value the out-value to receive the retrieved value. @@ -1316,9 +1316,9 @@ public int get(final ReadOptions opt, final ByteBuffer key, final ByteBuffer val /** * Get the value associated with the specified key within column family. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance - * @param opt {@link org.rocksdb.ReadOptions} instance. + * @param opt {@link org.forstdb.ReadOptions} instance. * @param key the key to retrieve the value. It is using position and limit. * Supports direct buffer only. * @param value the out-value to receive the retrieved value. @@ -1493,7 +1493,7 @@ public void deleteRange(final byte[] beginKey, final byte[] endKey) * non-OK status on error. It is not an error if "key" did not exist in the * database. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} instance + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} instance * @param beginKey First key to delete within database (inclusive) * @param endKey Last key to delete within database (exclusive) * @@ -1537,7 +1537,7 @@ public void deleteRange(final WriteOptions writeOpt, final byte[] beginKey, * non-OK status on error. It is not an error if "key" did not exist in the * database. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} instance + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} instance * @param writeOpt WriteOptions to be used with delete operation * @param beginKey First key to delete within database (included) * @param endKey Last key to delete within database (excluded) @@ -1748,7 +1748,7 @@ public void delete(final WriteOptions writeOpt, final ByteBuffer key) throws Roc * success, and a non-OK status on error. It is not an error if "key" * did not exist in the database. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param writeOpt WriteOptions to be used with delete operation * @param key Key to delete within database. It is using position and limit. @@ -1904,7 +1904,7 @@ public int get(final byte[] key, final int offset, final int len, /** * Get the value associated with the specified key within column family. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key the key to retrieve the value. * @param value the out-value to receive the retrieved value. @@ -1927,7 +1927,7 @@ public int get(final ColumnFamilyHandle columnFamilyHandle, final byte[] key, /** * Get the value associated with the specified key within column family. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key the key to retrieve the value. * @param offset the offset of the "key" array to be used, must be @@ -1962,7 +1962,7 @@ public int get(final ColumnFamilyHandle columnFamilyHandle, final byte[] key, /** * Get the value associated with the specified key. * - * @param opt {@link org.rocksdb.ReadOptions} instance. + * @param opt {@link org.forstdb.ReadOptions} instance. * @param key the key to retrieve the value. * @param value the out-value to receive the retrieved value. * @return The size of the actual value that matches the specified @@ -1984,7 +1984,7 @@ public int get(final ReadOptions opt, final byte[] key, /** * Get the value associated with the specified key. * - * @param opt {@link org.rocksdb.ReadOptions} instance. + * @param opt {@link org.forstdb.ReadOptions} instance. * @param key the key to retrieve the value. * @param offset the offset of the "key" array to be used, must be * non-negative and no larger than "key".length @@ -2017,9 +2017,9 @@ public int get(final ReadOptions opt, final byte[] key, final int offset, /** * Get the value associated with the specified key within column family. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance - * @param opt {@link org.rocksdb.ReadOptions} instance. + * @param opt {@link org.forstdb.ReadOptions} instance. * @param key the key to retrieve the value. * @param value the out-value to receive the retrieved value. * @return The size of the actual value that matches the specified @@ -2042,9 +2042,9 @@ public int get(final ColumnFamilyHandle columnFamilyHandle, /** * Get the value associated with the specified key within column family. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance - * @param opt {@link org.rocksdb.ReadOptions} instance. + * @param opt {@link org.forstdb.ReadOptions} instance. * @param key the key to retrieve the value. * @param offset the offset of the "key" array to be used, must be * non-negative and no larger than "key".length @@ -2118,7 +2118,7 @@ public byte[] get(final byte[] key, final int offset, * the value associated with the specified input key if any. null will be * returned if the specified key is not found. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key the key retrieve the value. * @return a byte array storing the value associated with the input key if @@ -2138,7 +2138,7 @@ public byte[] get(final ColumnFamilyHandle columnFamilyHandle, * the value associated with the specified input key if any. null will be * returned if the specified key is not found. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key the key retrieve the value. * @param offset the offset of the "key" array to be used, must be @@ -2205,7 +2205,7 @@ public byte[] get(final ReadOptions opt, final byte[] key, final int offset, * the value associated with the specified input key if any. null will be * returned if the specified key is not found. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key the key retrieve the value. * @param opt Read options. @@ -2226,7 +2226,7 @@ public byte[] get(final ColumnFamilyHandle columnFamilyHandle, * the value associated with the specified input key if any. null will be * returned if the specified key is not found. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key the key retrieve the value. * @param offset the offset of the "key" array to be used, must be @@ -2283,7 +2283,7 @@ public List multiGetAsList(final List keys) *

* * @param columnFamilyHandleList {@link java.util.List} containing - * {@link org.rocksdb.ColumnFamilyHandle} instances. + * {@link org.forstdb.ColumnFamilyHandle} instances. * @param keys List of keys for which values need to be retrieved. * @return List of values for the given list of keys. List will contain * null for keys which could not be found. @@ -2357,7 +2357,7 @@ public List multiGetAsList(final ReadOptions opt, * * @param opt Read options. * @param columnFamilyHandleList {@link java.util.List} containing - * {@link org.rocksdb.ColumnFamilyHandle} instances. + * {@link org.forstdb.ColumnFamilyHandle} instances. * @param keys of keys for which values need to be retrieved. * @return List of values for the given list of keys. List will contain * null for keys which could not be found. @@ -2440,7 +2440,7 @@ public List multiGetByteBuffers(final ReadOptions readOptio *

* * @param columnFamilyHandleList {@link java.util.List} containing - * {@link org.rocksdb.ColumnFamilyHandle} instances. + * {@link org.forstdb.ColumnFamilyHandle} instances. * @param keys list of keys for which values need to be retrieved. * @param values list of buffers to return retrieved values in * @throws RocksDBException if error happens in underlying native library. @@ -2465,7 +2465,7 @@ public List multiGetByteBuffers( * * @param readOptions Read options * @param columnFamilyHandleList {@link java.util.List} containing - * {@link org.rocksdb.ColumnFamilyHandle} instances. + * {@link org.forstdb.ColumnFamilyHandle} instances. * @param keys list of keys for which values need to be retrieved. * @param values list of buffers to return retrieved values in * @throws RocksDBException if error happens in underlying native library. @@ -3272,7 +3272,7 @@ public RocksIterator newIterator(final ReadOptions readOptions) { * The returned iterator should be closed before this db is closed. *

* - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @return instance of iterator object. */ @@ -3293,7 +3293,7 @@ public RocksIterator newIterator( * The returned iterator should be closed before this db is closed. *

* - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param readOptions {@link ReadOptions} instance. * @return instance of iterator object. @@ -3310,8 +3310,8 @@ public RocksIterator newIterator(final ColumnFamilyHandle columnFamilyHandle, * before the db is deleted * * @param columnFamilyHandleList {@link java.util.List} containing - * {@link org.rocksdb.ColumnFamilyHandle} instances. - * @return {@link java.util.List} containing {@link org.rocksdb.RocksIterator} + * {@link org.forstdb.ColumnFamilyHandle} instances. + * @return {@link java.util.List} containing {@link org.forstdb.RocksIterator} * instances * * @throws RocksDBException thrown if error happens in underlying @@ -3329,9 +3329,9 @@ public List newIterators( * before the db is deleted * * @param columnFamilyHandleList {@link java.util.List} containing - * {@link org.rocksdb.ColumnFamilyHandle} instances. + * {@link org.forstdb.ColumnFamilyHandle} instances. * @param readOptions {@link ReadOptions} instance. - * @return {@link java.util.List} containing {@link org.rocksdb.RocksIterator} + * @return {@link java.util.List} containing {@link org.forstdb.RocksIterator} * instances * * @throws RocksDBException thrown if error happens in underlying @@ -3409,7 +3409,7 @@ public void releaseSnapshot(final Snapshot snapshot) { * of the sstables that make up the db contents. * * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance, or null for the default column family. * @param property to be fetched. See above for examples * @return property value @@ -3470,7 +3470,7 @@ public Map getMapProperty(final String property) /** * Gets a property map. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance, or null for the default column family. * @param property to be fetched. * @@ -3528,7 +3528,7 @@ public long getLongProperty(final String property) throws RocksDBException { *

Java 8: In Java 8 the value should be treated as * unsigned long using provided methods of type {@link Long}.

* - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance, or null for the default column family * @param property to be fetched. * @@ -3594,7 +3594,7 @@ public long getAggregatedLongProperty(final String property) * should include the recently written data in the mem-tables (if * the mem-table type supports it), data serialized to disk, or both. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance, or null for the default column family * @param ranges the ranges over which to approximate sizes * @param sizeApproximationFlags flags to determine what to include in the @@ -3656,7 +3656,7 @@ public CountAndSize(final long count, final long size) { * {@link #getApproximateSizes(ColumnFamilyHandle, List, SizeApproximationFlag...)}, * except that it returns approximate number of records and size in memtables. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance, or null for the default column family * @param range the ranges over which to get the memtable stats * @@ -3717,7 +3717,7 @@ public void compactRange() throws RocksDBException { * * * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance, or null for the default column family. * * @throws RocksDBException thrown if an error occurs within the native @@ -3763,7 +3763,7 @@ public void compactRange(final byte[] begin, final byte[] end) *
  • {@link #compactRange(ColumnFamilyHandle)}
    • * * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance, or null for the default column family. * @param begin start of key range (included in range) * @param end end of key range (excluded from range) @@ -3786,7 +3786,7 @@ public void compactRange( * all data will have been pushed down to the last level containing * any data.

    * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} instance. + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} instance. * @param begin start of key range (included in range) * @param end end of key range (excluded from range) * @param compactRangeOptions options for the compaction @@ -3811,7 +3811,7 @@ public void compactRange( * Any entries outside this range will be completely deleted (including * tombstones). * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} instance + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} instance * @param beginKey First key to clip within database (inclusive) * @param endKey Last key to clip within database (exclusive) * @@ -3828,7 +3828,7 @@ public void clipColumnFamily(final ColumnFamilyHandle columnFamilyHandle, final /** * Change the options for the column family handle. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance, or null for the default column family. * @param mutableColumnFamilyOptions the options. * @@ -3879,7 +3879,7 @@ public PerfContext getPerfContext() { /** * Get the options for the column family handle * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance, or null for the default column family. * * @return the options parsed from the options string return by RocksDB @@ -4175,7 +4175,7 @@ public Env getEnv() { * is not GC'ed before this method finishes. If the wait parameter is * set to false, flush processing is asynchronous.

    * - * @param flushOptions {@link org.rocksdb.FlushOptions} instance. + * @param flushOptions {@link org.forstdb.FlushOptions} instance. * @throws RocksDBException thrown if an error occurs within the native * part of the library. */ @@ -4191,8 +4191,8 @@ public void flush(final FlushOptions flushOptions) * is not GC'ed before this method finishes. If the wait parameter is * set to false, flush processing is asynchronous.

    * - * @param flushOptions {@link org.rocksdb.FlushOptions} instance. - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} instance. + * @param flushOptions {@link org.forstdb.FlushOptions} instance. + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} instance. * @throws RocksDBException thrown if an error occurs within the native * part of the library. */ @@ -4213,7 +4213,7 @@ public void flush(final FlushOptions flushOptions, * specified up to the latest sequence number at the time when flush is * requested. * - * @param flushOptions {@link org.rocksdb.FlushOptions} instance. + * @param flushOptions {@link org.forstdb.FlushOptions} instance. * @param columnFamilyHandles column family handles. * @throws RocksDBException thrown if an error occurs within the native * part of the library. @@ -4394,9 +4394,9 @@ public List getSortedWalFiles() throws RocksDBException { * * @param sequenceNumber sequence number offset * - * @return {@link org.rocksdb.TransactionLogIterator} instance. + * @return {@link org.forstdb.TransactionLogIterator} instance. * - * @throws org.rocksdb.RocksDBException if iterator cannot be retrieved + * @throws org.forstdb.RocksDBException if iterator cannot be retrieved * from native-side. */ public TransactionLogIterator getUpdatesSince(final long sequenceNumber) @@ -4737,7 +4737,7 @@ public void deleteFilesInRanges(final ColumnFamilyHandle columnFamily, final Lis * Be very careful using this method. * * @param path the path to the Rocksdb database. - * @param options {@link org.rocksdb.Options} instance. + * @param options {@link org.forstdb.Options} instance. * * @throws RocksDBException thrown if error happens in underlying * native library. diff --git a/java/src/main/java/org/rocksdb/RocksDBException.java b/java/src/main/java/org/forstdb/RocksDBException.java similarity index 98% rename from java/src/main/java/org/rocksdb/RocksDBException.java rename to java/src/main/java/org/forstdb/RocksDBException.java index 9df411d12..c1f698d5a 100644 --- a/java/src/main/java/org/rocksdb/RocksDBException.java +++ b/java/src/main/java/org/forstdb/RocksDBException.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * A RocksDBException encapsulates the error of an operation. This exception diff --git a/java/src/main/java/org/rocksdb/RocksEnv.java b/java/src/main/java/org/forstdb/RocksEnv.java similarity index 98% rename from java/src/main/java/org/rocksdb/RocksEnv.java rename to java/src/main/java/org/forstdb/RocksEnv.java index ca010c9f9..5d6d1a639 100644 --- a/java/src/main/java/org/rocksdb/RocksEnv.java +++ b/java/src/main/java/org/forstdb/RocksEnv.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** *

    A RocksEnv is an interface used by the rocksdb implementation to access diff --git a/java/src/main/java/org/rocksdb/RocksIterator.java b/java/src/main/java/org/forstdb/RocksIterator.java similarity index 98% rename from java/src/main/java/org/rocksdb/RocksIterator.java rename to java/src/main/java/org/forstdb/RocksIterator.java index b35dea2af..8127ff157 100644 --- a/java/src/main/java/org/rocksdb/RocksIterator.java +++ b/java/src/main/java/org/forstdb/RocksIterator.java @@ -3,9 +3,9 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; -import static org.rocksdb.util.BufferUtil.CheckBounds; +import static org.forstdb.util.BufferUtil.CheckBounds; import java.nio.ByteBuffer; @@ -20,7 +20,7 @@ * non-const method, all threads accessing the same RocksIterator must use * external synchronization.

    * - * @see org.rocksdb.RocksObject + * @see org.forstdb.RocksObject */ public class RocksIterator extends AbstractRocksIterator { protected RocksIterator(final RocksDB rocksDB, final long nativeHandle) { diff --git a/java/src/main/java/org/rocksdb/RocksIteratorInterface.java b/java/src/main/java/org/forstdb/RocksIteratorInterface.java similarity index 98% rename from java/src/main/java/org/rocksdb/RocksIteratorInterface.java rename to java/src/main/java/org/forstdb/RocksIteratorInterface.java index 819c21c2c..9d344c22b 100644 --- a/java/src/main/java/org/rocksdb/RocksIteratorInterface.java +++ b/java/src/main/java/org/forstdb/RocksIteratorInterface.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; @@ -18,7 +18,7 @@ * non-const method, all threads accessing the same RocksIterator must use * external synchronization.

    * - * @see org.rocksdb.RocksObject + * @see org.forstdb.RocksObject */ public interface RocksIteratorInterface { diff --git a/java/src/main/java/org/rocksdb/RocksMemEnv.java b/java/src/main/java/org/forstdb/RocksMemEnv.java similarity index 97% rename from java/src/main/java/org/rocksdb/RocksMemEnv.java rename to java/src/main/java/org/forstdb/RocksMemEnv.java index 39a6f6e1c..05db05900 100644 --- a/java/src/main/java/org/rocksdb/RocksMemEnv.java +++ b/java/src/main/java/org/forstdb/RocksMemEnv.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Memory environment. diff --git a/java/src/main/java/org/rocksdb/RocksMutableObject.java b/java/src/main/java/org/forstdb/RocksMutableObject.java similarity index 99% rename from java/src/main/java/org/rocksdb/RocksMutableObject.java rename to java/src/main/java/org/forstdb/RocksMutableObject.java index eb3215290..7840cc14b 100644 --- a/java/src/main/java/org/rocksdb/RocksMutableObject.java +++ b/java/src/main/java/org/forstdb/RocksMutableObject.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * RocksMutableObject is an implementation of {@link AbstractNativeReference} diff --git a/java/src/main/java/org/rocksdb/RocksObject.java b/java/src/main/java/org/forstdb/RocksObject.java similarity index 98% rename from java/src/main/java/org/rocksdb/RocksObject.java rename to java/src/main/java/org/forstdb/RocksObject.java index f07e1018a..7abd061fa 100644 --- a/java/src/main/java/org/rocksdb/RocksObject.java +++ b/java/src/main/java/org/forstdb/RocksObject.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * RocksObject is an implementation of {@link AbstractNativeReference} which diff --git a/java/src/main/java/org/rocksdb/SanityLevel.java b/java/src/main/java/org/forstdb/SanityLevel.java similarity index 98% rename from java/src/main/java/org/rocksdb/SanityLevel.java rename to java/src/main/java/org/forstdb/SanityLevel.java index 30568c363..4487d7d59 100644 --- a/java/src/main/java/org/rocksdb/SanityLevel.java +++ b/java/src/main/java/org/forstdb/SanityLevel.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public enum SanityLevel { NONE((byte) 0x0), diff --git a/java/src/main/java/org/rocksdb/SizeApproximationFlag.java b/java/src/main/java/org/forstdb/SizeApproximationFlag.java similarity index 96% rename from java/src/main/java/org/rocksdb/SizeApproximationFlag.java rename to java/src/main/java/org/forstdb/SizeApproximationFlag.java index fe3c2dd05..c39824925 100644 --- a/java/src/main/java/org/rocksdb/SizeApproximationFlag.java +++ b/java/src/main/java/org/forstdb/SizeApproximationFlag.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; import java.util.List; diff --git a/java/src/main/java/org/rocksdb/SkipListMemTableConfig.java b/java/src/main/java/org/forstdb/SkipListMemTableConfig.java similarity index 98% rename from java/src/main/java/org/rocksdb/SkipListMemTableConfig.java rename to java/src/main/java/org/forstdb/SkipListMemTableConfig.java index e2c1b97d8..5e6f7090c 100644 --- a/java/src/main/java/org/rocksdb/SkipListMemTableConfig.java +++ b/java/src/main/java/org/forstdb/SkipListMemTableConfig.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; /** * The config for skip-list memtable representation. diff --git a/java/src/main/java/org/rocksdb/Slice.java b/java/src/main/java/org/forstdb/Slice.java similarity index 96% rename from java/src/main/java/org/rocksdb/Slice.java rename to java/src/main/java/org/forstdb/Slice.java index 6a01374d6..386ab4740 100644 --- a/java/src/main/java/org/rocksdb/Slice.java +++ b/java/src/main/java/org/forstdb/Slice.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** *

    Base class for slices which will receive @@ -11,7 +11,7 @@ * *

    byte[] backed slices typically perform better with * small keys and values. When using larger keys and - * values consider using {@link org.rocksdb.DirectSlice}

    + * values consider using {@link org.forstdb.DirectSlice}

    */ public class Slice extends AbstractSlice { @@ -27,7 +27,7 @@ public class Slice extends AbstractSlice { * at creation time.

    * *

    Note: You should be aware that - * {@see org.rocksdb.RocksObject#disOwnNativeHandle()} is intentionally + * {@see org.forstdb.RocksObject#disOwnNativeHandle()} is intentionally * called from the default Slice constructor, and that it is marked as * private. This is so that developers cannot construct their own default * Slice objects (at present). As developers cannot construct their own diff --git a/java/src/main/java/org/rocksdb/Snapshot.java b/java/src/main/java/org/forstdb/Snapshot.java similarity index 98% rename from java/src/main/java/org/rocksdb/Snapshot.java rename to java/src/main/java/org/forstdb/Snapshot.java index 1f471bd31..af5bb1ef8 100644 --- a/java/src/main/java/org/rocksdb/Snapshot.java +++ b/java/src/main/java/org/forstdb/Snapshot.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Snapshot of database diff --git a/java/src/main/java/org/rocksdb/SstFileManager.java b/java/src/main/java/org/forstdb/SstFileManager.java similarity index 99% rename from java/src/main/java/org/rocksdb/SstFileManager.java rename to java/src/main/java/org/forstdb/SstFileManager.java index 0b9a60061..ad51d753f 100644 --- a/java/src/main/java/org/rocksdb/SstFileManager.java +++ b/java/src/main/java/org/forstdb/SstFileManager.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Map; diff --git a/java/src/main/java/org/rocksdb/SstFileMetaData.java b/java/src/main/java/org/forstdb/SstFileMetaData.java similarity index 99% rename from java/src/main/java/org/rocksdb/SstFileMetaData.java rename to java/src/main/java/org/forstdb/SstFileMetaData.java index 6025d0b42..4fa210a9a 100644 --- a/java/src/main/java/org/rocksdb/SstFileMetaData.java +++ b/java/src/main/java/org/forstdb/SstFileMetaData.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The metadata that describes a SST file. diff --git a/java/src/main/java/org/rocksdb/SstFileReader.java b/java/src/main/java/org/forstdb/SstFileReader.java similarity index 99% rename from java/src/main/java/org/rocksdb/SstFileReader.java rename to java/src/main/java/org/forstdb/SstFileReader.java index 939d39375..2134f3d24 100644 --- a/java/src/main/java/org/rocksdb/SstFileReader.java +++ b/java/src/main/java/org/forstdb/SstFileReader.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public class SstFileReader extends RocksObject { public SstFileReader(final Options options) { diff --git a/java/src/main/java/org/rocksdb/SstFileReaderIterator.java b/java/src/main/java/org/forstdb/SstFileReaderIterator.java similarity index 99% rename from java/src/main/java/org/rocksdb/SstFileReaderIterator.java rename to java/src/main/java/org/forstdb/SstFileReaderIterator.java index a4a08167b..c1eac960d 100644 --- a/java/src/main/java/org/rocksdb/SstFileReaderIterator.java +++ b/java/src/main/java/org/forstdb/SstFileReaderIterator.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; diff --git a/java/src/main/java/org/rocksdb/SstFileWriter.java b/java/src/main/java/org/forstdb/SstFileWriter.java similarity index 98% rename from java/src/main/java/org/rocksdb/SstFileWriter.java rename to java/src/main/java/org/forstdb/SstFileWriter.java index d5766bffb..8e87b55ed 100644 --- a/java/src/main/java/org/rocksdb/SstFileWriter.java +++ b/java/src/main/java/org/forstdb/SstFileWriter.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; @@ -16,8 +16,8 @@ public class SstFileWriter extends RocksObject { /** * SstFileWriter Constructor. * - * @param envOptions {@link org.rocksdb.EnvOptions} instance. - * @param options {@link org.rocksdb.Options} instance. + * @param envOptions {@link org.forstdb.EnvOptions} instance. + * @param options {@link org.forstdb.Options} instance. */ public SstFileWriter(final EnvOptions envOptions, final Options options) { super(newSstFileWriter( diff --git a/java/src/main/java/org/rocksdb/SstPartitionerFactory.java b/java/src/main/java/org/forstdb/SstPartitionerFactory.java similarity index 96% rename from java/src/main/java/org/rocksdb/SstPartitionerFactory.java rename to java/src/main/java/org/forstdb/SstPartitionerFactory.java index ea6f13565..9fa9e32a5 100644 --- a/java/src/main/java/org/rocksdb/SstPartitionerFactory.java +++ b/java/src/main/java/org/forstdb/SstPartitionerFactory.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Handle to factory for SstPartitioner. It is used in {@link ColumnFamilyOptions} diff --git a/java/src/main/java/org/rocksdb/SstPartitionerFixedPrefixFactory.java b/java/src/main/java/org/forstdb/SstPartitionerFixedPrefixFactory.java similarity index 97% rename from java/src/main/java/org/rocksdb/SstPartitionerFixedPrefixFactory.java rename to java/src/main/java/org/forstdb/SstPartitionerFixedPrefixFactory.java index b1ccf08c1..c86eda32b 100644 --- a/java/src/main/java/org/rocksdb/SstPartitionerFixedPrefixFactory.java +++ b/java/src/main/java/org/forstdb/SstPartitionerFixedPrefixFactory.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Fixed prefix factory. It partitions SST files using fixed prefix of the key. diff --git a/java/src/main/java/org/rocksdb/StateType.java b/java/src/main/java/org/forstdb/StateType.java similarity index 98% rename from java/src/main/java/org/rocksdb/StateType.java rename to java/src/main/java/org/forstdb/StateType.java index 803fa37d9..2e81a1b73 100644 --- a/java/src/main/java/org/rocksdb/StateType.java +++ b/java/src/main/java/org/forstdb/StateType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The type used to refer to a thread state. diff --git a/java/src/main/java/org/rocksdb/Statistics.java b/java/src/main/java/org/forstdb/Statistics.java similarity index 99% rename from java/src/main/java/org/rocksdb/Statistics.java rename to java/src/main/java/org/forstdb/Statistics.java index 09e08ee56..33bfd2e21 100644 --- a/java/src/main/java/org/rocksdb/Statistics.java +++ b/java/src/main/java/org/forstdb/Statistics.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.EnumSet; diff --git a/java/src/main/java/org/rocksdb/StatisticsCollector.java b/java/src/main/java/org/forstdb/StatisticsCollector.java similarity index 99% rename from java/src/main/java/org/rocksdb/StatisticsCollector.java rename to java/src/main/java/org/forstdb/StatisticsCollector.java index dd0d98fe5..8b698188c 100644 --- a/java/src/main/java/org/rocksdb/StatisticsCollector.java +++ b/java/src/main/java/org/forstdb/StatisticsCollector.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.List; import java.util.concurrent.Executors; diff --git a/java/src/main/java/org/rocksdb/StatisticsCollectorCallback.java b/java/src/main/java/org/forstdb/StatisticsCollectorCallback.java similarity index 98% rename from java/src/main/java/org/rocksdb/StatisticsCollectorCallback.java rename to java/src/main/java/org/forstdb/StatisticsCollectorCallback.java index bed7828e0..8504b06ac 100644 --- a/java/src/main/java/org/rocksdb/StatisticsCollectorCallback.java +++ b/java/src/main/java/org/forstdb/StatisticsCollectorCallback.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Callback interface provided to StatisticsCollector. diff --git a/java/src/main/java/org/rocksdb/StatsCollectorInput.java b/java/src/main/java/org/forstdb/StatsCollectorInput.java similarity index 97% rename from java/src/main/java/org/rocksdb/StatsCollectorInput.java rename to java/src/main/java/org/forstdb/StatsCollectorInput.java index 5bf43ade5..331957064 100644 --- a/java/src/main/java/org/rocksdb/StatsCollectorInput.java +++ b/java/src/main/java/org/forstdb/StatsCollectorInput.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Contains all information necessary to collect statistics from one instance diff --git a/java/src/main/java/org/rocksdb/StatsLevel.java b/java/src/main/java/org/forstdb/StatsLevel.java similarity index 95% rename from java/src/main/java/org/rocksdb/StatsLevel.java rename to java/src/main/java/org/forstdb/StatsLevel.java index 8190e503a..8ce3910bf 100644 --- a/java/src/main/java/org/rocksdb/StatsLevel.java +++ b/java/src/main/java/org/forstdb/StatsLevel.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The level of Statistics to report. @@ -49,7 +49,7 @@ public byte getValue() { * * @param value byte representation of StatsLevel. * - * @return {@link org.rocksdb.StatsLevel} instance. + * @return {@link org.forstdb.StatsLevel} instance. * @throws java.lang.IllegalArgumentException if an invalid * value is provided. */ diff --git a/java/src/main/java/org/rocksdb/Status.java b/java/src/main/java/org/forstdb/Status.java similarity index 99% rename from java/src/main/java/org/rocksdb/Status.java rename to java/src/main/java/org/forstdb/Status.java index 5f751f422..db7223ee3 100644 --- a/java/src/main/java/org/rocksdb/Status.java +++ b/java/src/main/java/org/forstdb/Status.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.io.Serializable; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/StringAppendOperator.java b/java/src/main/java/org/forstdb/StringAppendOperator.java similarity index 97% rename from java/src/main/java/org/rocksdb/StringAppendOperator.java rename to java/src/main/java/org/forstdb/StringAppendOperator.java index 547371e7c..befb215c1 100644 --- a/java/src/main/java/org/rocksdb/StringAppendOperator.java +++ b/java/src/main/java/org/forstdb/StringAppendOperator.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * StringAppendOperator is a merge operator that concatenates diff --git a/java/src/main/java/org/rocksdb/TableFileCreationBriefInfo.java b/java/src/main/java/org/forstdb/TableFileCreationBriefInfo.java similarity index 99% rename from java/src/main/java/org/rocksdb/TableFileCreationBriefInfo.java rename to java/src/main/java/org/forstdb/TableFileCreationBriefInfo.java index 8dc56796a..5246a868c 100644 --- a/java/src/main/java/org/rocksdb/TableFileCreationBriefInfo.java +++ b/java/src/main/java/org/forstdb/TableFileCreationBriefInfo.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/TableFileCreationInfo.java b/java/src/main/java/org/forstdb/TableFileCreationInfo.java similarity index 99% rename from java/src/main/java/org/rocksdb/TableFileCreationInfo.java rename to java/src/main/java/org/forstdb/TableFileCreationInfo.java index 5654603c3..f9c3c368e 100644 --- a/java/src/main/java/org/rocksdb/TableFileCreationInfo.java +++ b/java/src/main/java/org/forstdb/TableFileCreationInfo.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/TableFileCreationReason.java b/java/src/main/java/org/forstdb/TableFileCreationReason.java similarity index 98% rename from java/src/main/java/org/rocksdb/TableFileCreationReason.java rename to java/src/main/java/org/forstdb/TableFileCreationReason.java index d3984663d..13cfb832f 100644 --- a/java/src/main/java/org/rocksdb/TableFileCreationReason.java +++ b/java/src/main/java/org/forstdb/TableFileCreationReason.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public enum TableFileCreationReason { FLUSH((byte) 0x00), diff --git a/java/src/main/java/org/rocksdb/TableFileDeletionInfo.java b/java/src/main/java/org/forstdb/TableFileDeletionInfo.java similarity index 99% rename from java/src/main/java/org/rocksdb/TableFileDeletionInfo.java rename to java/src/main/java/org/forstdb/TableFileDeletionInfo.java index 9a777e333..61a3fdba6 100644 --- a/java/src/main/java/org/rocksdb/TableFileDeletionInfo.java +++ b/java/src/main/java/org/forstdb/TableFileDeletionInfo.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/TableFilter.java b/java/src/main/java/org/forstdb/TableFilter.java similarity index 97% rename from java/src/main/java/org/rocksdb/TableFilter.java rename to java/src/main/java/org/forstdb/TableFilter.java index a39a329fb..0b4e8b400 100644 --- a/java/src/main/java/org/rocksdb/TableFilter.java +++ b/java/src/main/java/org/forstdb/TableFilter.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; /** * Filter for iterating a table. diff --git a/java/src/main/java/org/rocksdb/TableFormatConfig.java b/java/src/main/java/org/forstdb/TableFormatConfig.java similarity index 97% rename from java/src/main/java/org/rocksdb/TableFormatConfig.java rename to java/src/main/java/org/forstdb/TableFormatConfig.java index 726c6f122..891b3cb72 100644 --- a/java/src/main/java/org/rocksdb/TableFormatConfig.java +++ b/java/src/main/java/org/forstdb/TableFormatConfig.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; /** * TableFormatConfig is used to config the internal Table format of a RocksDB. diff --git a/java/src/main/java/org/rocksdb/TableProperties.java b/java/src/main/java/org/forstdb/TableProperties.java similarity index 99% rename from java/src/main/java/org/rocksdb/TableProperties.java rename to java/src/main/java/org/forstdb/TableProperties.java index 7fb1bcc77..4243ce9fe 100644 --- a/java/src/main/java/org/rocksdb/TableProperties.java +++ b/java/src/main/java/org/forstdb/TableProperties.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; import java.util.Arrays; import java.util.Map; diff --git a/java/src/main/java/org/rocksdb/ThreadStatus.java b/java/src/main/java/org/forstdb/ThreadStatus.java similarity index 99% rename from java/src/main/java/org/rocksdb/ThreadStatus.java rename to java/src/main/java/org/forstdb/ThreadStatus.java index 4211453d1..f1a9e5c98 100644 --- a/java/src/main/java/org/rocksdb/ThreadStatus.java +++ b/java/src/main/java/org/forstdb/ThreadStatus.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Map; diff --git a/java/src/main/java/org/rocksdb/ThreadType.java b/java/src/main/java/org/forstdb/ThreadType.java similarity index 98% rename from java/src/main/java/org/rocksdb/ThreadType.java rename to java/src/main/java/org/forstdb/ThreadType.java index cc329f442..4f324c338 100644 --- a/java/src/main/java/org/rocksdb/ThreadType.java +++ b/java/src/main/java/org/forstdb/ThreadType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The type of a thread. diff --git a/java/src/main/java/org/rocksdb/TickerType.java b/java/src/main/java/org/forstdb/TickerType.java similarity index 98% rename from java/src/main/java/org/rocksdb/TickerType.java rename to java/src/main/java/org/forstdb/TickerType.java index f2ca42776..aef29e31a 100644 --- a/java/src/main/java/org/rocksdb/TickerType.java +++ b/java/src/main/java/org/forstdb/TickerType.java @@ -3,16 +3,16 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The logical mapping of tickers defined in rocksdb::Tickers. *

    * Java byte value mappings don't align 1:1 to the c++ values. c++ rocksdb::Tickers enumeration type - * is uint32_t and java org.rocksdb.TickerType is byte, this causes mapping issues when + * is uint32_t and java org.forstdb.TickerType is byte, this causes mapping issues when * rocksdb::Tickers value is greater then 127 (0x7F) for jbyte jni interface as range greater is not * available. Without breaking interface in minor versions, value mappings for - * org.rocksdb.TickerType leverage full byte range [-128 (-0x80), (0x7F)]. Newer tickers added + * org.forstdb.TickerType leverage full byte range [-128 (-0x80), (0x7F)]. Newer tickers added * should descend into negative values until TICKER_ENUM_MAX reaches -128 (-0x80). */ public enum TickerType { @@ -798,7 +798,7 @@ public byte getValue() { * * @param value byte representation of TickerType. * - * @return {@link org.rocksdb.TickerType} instance. + * @return {@link org.forstdb.TickerType} instance. * @throws java.lang.IllegalArgumentException if an invalid * value is provided. */ diff --git a/java/src/main/java/org/rocksdb/TimedEnv.java b/java/src/main/java/org/forstdb/TimedEnv.java similarity index 97% rename from java/src/main/java/org/rocksdb/TimedEnv.java rename to java/src/main/java/org/forstdb/TimedEnv.java index dc8b5d6ef..d8d703db7 100644 --- a/java/src/main/java/org/rocksdb/TimedEnv.java +++ b/java/src/main/java/org/forstdb/TimedEnv.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Timed environment. diff --git a/java/src/main/java/org/rocksdb/TraceOptions.java b/java/src/main/java/org/forstdb/TraceOptions.java similarity index 97% rename from java/src/main/java/org/rocksdb/TraceOptions.java rename to java/src/main/java/org/forstdb/TraceOptions.java index cf5f7bbe1..45eb80624 100644 --- a/java/src/main/java/org/rocksdb/TraceOptions.java +++ b/java/src/main/java/org/forstdb/TraceOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * TraceOptions is used for diff --git a/java/src/main/java/org/rocksdb/TraceWriter.java b/java/src/main/java/org/forstdb/TraceWriter.java similarity index 97% rename from java/src/main/java/org/rocksdb/TraceWriter.java rename to java/src/main/java/org/forstdb/TraceWriter.java index cb0234e9b..baaa640c9 100644 --- a/java/src/main/java/org/rocksdb/TraceWriter.java +++ b/java/src/main/java/org/forstdb/TraceWriter.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * TraceWriter allows exporting RocksDB traces to any system, diff --git a/java/src/main/java/org/rocksdb/Transaction.java b/java/src/main/java/org/forstdb/Transaction.java similarity index 98% rename from java/src/main/java/org/rocksdb/Transaction.java rename to java/src/main/java/org/forstdb/Transaction.java index cab7ed287..f5bc2de3c 100644 --- a/java/src/main/java/org/rocksdb/Transaction.java +++ b/java/src/main/java/org/forstdb/Transaction.java @@ -3,9 +3,9 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; -import static org.rocksdb.RocksDB.PERFORMANCE_OPTIMIZATION_FOR_A_VERY_SPECIFIC_WORKLOAD; +import static org.forstdb.RocksDB.PERFORMANCE_OPTIMIZATION_FOR_A_VERY_SPECIFIC_WORKLOAD; import java.nio.ByteBuffer; import java.util.ArrayList; @@ -19,8 +19,8 @@ * {@link OptimisticTransactionDB} or a {@link TransactionDB} * * To create a transaction, use - * {@link OptimisticTransactionDB#beginTransaction(org.rocksdb.WriteOptions)} or - * {@link TransactionDB#beginTransaction(org.rocksdb.WriteOptions)} + * {@link OptimisticTransactionDB#beginTransaction(org.forstdb.WriteOptions)} or + * {@link TransactionDB#beginTransaction(org.forstdb.WriteOptions)} * * It is up to the caller to synchronize access to this object. *

    @@ -40,8 +40,8 @@ public class Transaction extends RocksObject { /** * Intentionally package private * as this is called from - * {@link OptimisticTransactionDB#beginTransaction(org.rocksdb.WriteOptions)} - * or {@link TransactionDB#beginTransaction(org.rocksdb.WriteOptions)} + * {@link OptimisticTransactionDB#beginTransaction(org.forstdb.WriteOptions)} + * or {@link TransactionDB#beginTransaction(org.forstdb.WriteOptions)} * * @param parent This must be either {@link TransactionDB} or * {@link OptimisticTransactionDB} @@ -273,7 +273,7 @@ public void rollbackToSavePoint() throws RocksDBException { * transaction (the keys in this transaction do not yet belong to any snapshot * and will be fetched regardless). * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} instance + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} instance * @param readOptions Read options. * @param key the key to retrieve the value for. * @@ -308,7 +308,7 @@ public byte[] get(final ColumnFamilyHandle columnFamilyHandle, final ReadOptions * and will be fetched regardless). * * @param readOptions Read options. - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} instance + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} instance * @param key the key to retrieve the value for. * * @return a byte array storing the value associated with the input key if @@ -359,7 +359,7 @@ public byte[] get(final ReadOptions readOptions, final byte[] key) /** * Get the value associated with the specified key in the default column family * - * @param opt {@link org.rocksdb.ReadOptions} instance. + * @param opt {@link org.forstdb.ReadOptions} instance. * @param key the key to retrieve the value. * @param value the out-value to receive the retrieved value. * @return A {@link GetStatus} wrapping the result status and the return value size. @@ -388,7 +388,7 @@ public GetStatus get(final ReadOptions opt, final byte[] key, final byte[] value /** * Get the value associated with the specified key in a specified column family * - * @param opt {@link org.rocksdb.ReadOptions} instance. + * @param opt {@link org.forstdb.ReadOptions} instance. * @param columnFamilyHandle the column family to find the key in * @param key the key to retrieve the value. * @param value the out-value to receive the retrieved value. @@ -418,7 +418,7 @@ public GetStatus get(final ReadOptions opt, final ColumnFamilyHandle columnFamil /** * Get the value associated with the specified key within the specified column family. * - * @param opt {@link org.rocksdb.ReadOptions} instance. + * @param opt {@link org.forstdb.ReadOptions} instance. * @param columnFamilyHandle the column family in which to find the key. * @param key the key to retrieve the value. It is using position and limit. * Supports direct buffer only. @@ -466,7 +466,7 @@ public GetStatus get(final ReadOptions opt, final ColumnFamilyHandle columnFamil /** * Get the value associated with the specified key within the default column family. * - * @param opt {@link org.rocksdb.ReadOptions} instance. + * @param opt {@link org.forstdb.ReadOptions} instance. * @param key the key to retrieve the value. It is using position and limit. * Supports direct buffer only. * @param value the out-value to receive the retrieved value. @@ -507,7 +507,7 @@ public GetStatus get(final ReadOptions opt, final ByteBuffer key, final ByteBuff * * @param readOptions Read options. * @param columnFamilyHandles {@link java.util.List} containing - * {@link org.rocksdb.ColumnFamilyHandle} instances. + * {@link org.forstdb.ColumnFamilyHandle} instances. * @param keys of keys for which values need to be retrieved. * * @return Array of values, one for each key @@ -557,7 +557,7 @@ public byte[][] multiGet(final ReadOptions readOptions, * * @param readOptions Read options. * @param columnFamilyHandles {@link java.util.List} containing - * {@link org.rocksdb.ColumnFamilyHandle} instances. + * {@link org.forstdb.ColumnFamilyHandle} instances. * @param keys of keys for which values need to be retrieved. * * @return Array of values, one for each key @@ -606,7 +606,7 @@ public List multiGetAsList(final ReadOptions readOptions, * and will be fetched regardless). * * @param readOptions Read options.= - * {@link org.rocksdb.ColumnFamilyHandle} instances. + * {@link org.forstdb.ColumnFamilyHandle} instances. * @param keys of keys for which values need to be retrieved. * * @return Array of values, one for each key @@ -643,7 +643,7 @@ public byte[][] multiGet(final ReadOptions readOptions, final byte[][] keys) * and will be fetched regardless). * * @param readOptions Read options.= - * {@link org.rocksdb.ColumnFamilyHandle} instances. + * {@link org.forstdb.ColumnFamilyHandle} instances. * @param keys of keys for which values need to be retrieved. * * @return Array of values, one for each key @@ -695,7 +695,7 @@ public List multiGetAsList(final ReadOptions readOptions, final List * * @param readOptions Read options. - * @param columnFamilyHandles {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandles {@link org.forstdb.ColumnFamilyHandle} * instances * @param keys the keys to retrieve the values for. * @@ -1196,7 +1196,7 @@ public byte[][] multiGetForUpdate(final ReadOptions readOptions, *

    * * @param readOptions Read options. - * @param columnFamilyHandles {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandles {@link org.forstdb.ColumnFamilyHandle} * instances * @param keys the keys to retrieve the values for. * @@ -1339,7 +1339,7 @@ public RocksIterator getIterator(final ReadOptions readOptions) { * {@link #rollback()}, or {@link #rollbackToSavePoint()} is called. * * @param readOptions Read options. - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * * @return instance of iterator object. @@ -1367,7 +1367,7 @@ public RocksIterator getIterator(final ReadOptions readOptions, * The returned iterator is only valid until {@link #commit()}, * {@link #rollback()}, or {@link #rollbackToSavePoint()} is called. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * * @return instance of iterator object. @@ -1475,7 +1475,7 @@ public void put(final byte[] key, final byte[] value) put(nativeHandle_, key, 0, key.length, value, 0, value.length); } - //TODO(AR) refactor if we implement org.rocksdb.SliceParts in future + //TODO(AR) refactor if we implement org.forstdb.SliceParts in future /** * Similar to {@link #put(ColumnFamilyHandle, byte[], byte[])} but allows * you to specify the key and value in several parts that will be @@ -1613,7 +1613,7 @@ public void put(final ColumnFamilyHandle columnFamilyHandle, final ByteBuffer ke put(columnFamilyHandle, key, value, false); } - // TODO(AR) refactor if we implement org.rocksdb.SliceParts in future + // TODO(AR) refactor if we implement org.forstdb.SliceParts in future /** * Similar to {@link #put(byte[], byte[])} but allows * you to specify the key and value in several parts that will be @@ -1927,7 +1927,7 @@ public void delete(final byte[] key) throws RocksDBException { delete(nativeHandle_, key, key.length); } - //TODO(AR) refactor if we implement org.rocksdb.SliceParts in future + //TODO(AR) refactor if we implement org.forstdb.SliceParts in future /** * Similar to {@link #delete(ColumnFamilyHandle, byte[])} but allows * you to specify the key in several parts that will be @@ -1972,7 +1972,7 @@ public void delete(final ColumnFamilyHandle columnFamilyHandle, columnFamilyHandle.nativeHandle_, false); } - //TODO(AR) refactor if we implement org.rocksdb.SliceParts in future + //TODO(AR) refactor if we implement org.forstdb.SliceParts in future /** * Similar to {@link #delete(byte[])} but allows * you to specify key the in several parts that will be @@ -2082,7 +2082,7 @@ public void singleDelete(final byte[] key) throws RocksDBException { singleDelete(nativeHandle_, key, key.length); } - //TODO(AR) refactor if we implement org.rocksdb.SliceParts in future + //TODO(AR) refactor if we implement org.forstdb.SliceParts in future /** * Similar to {@link #singleDelete(ColumnFamilyHandle, byte[])} but allows * you to specify the key in several parts that will be @@ -2128,7 +2128,7 @@ public void singleDelete(final ColumnFamilyHandle columnFamilyHandle, final byte columnFamilyHandle.nativeHandle_, false); } - //TODO(AR) refactor if we implement org.rocksdb.SliceParts in future + //TODO(AR) refactor if we implement org.forstdb.SliceParts in future /** * Similar to {@link #singleDelete(byte[])} but allows * you to specify the key in several parts that will be @@ -2197,7 +2197,7 @@ public void putUntracked(final byte[] key, final byte[] value) putUntracked(nativeHandle_, key, key.length, value, value.length); } - //TODO(AR) refactor if we implement org.rocksdb.SliceParts in future + //TODO(AR) refactor if we implement org.forstdb.SliceParts in future /** * Similar to {@link #putUntracked(ColumnFamilyHandle, byte[], byte[])} but * allows you to specify the key and value in several parts that will be @@ -2218,7 +2218,7 @@ public void putUntracked(final ColumnFamilyHandle columnFamilyHandle, valueParts.length, columnFamilyHandle.nativeHandle_); } - //TODO(AR) refactor if we implement org.rocksdb.SliceParts in future + //TODO(AR) refactor if we implement org.forstdb.SliceParts in future /** * Similar to {@link #putUntracked(byte[], byte[])} but * allows you to specify the key and value in several parts that will be @@ -2399,7 +2399,7 @@ public void deleteUntracked(final byte[] key) throws RocksDBException { deleteUntracked(nativeHandle_, key, key.length); } - //TODO(AR) refactor if we implement org.rocksdb.SliceParts in future + //TODO(AR) refactor if we implement org.forstdb.SliceParts in future /** * Similar to {@link #deleteUntracked(ColumnFamilyHandle, byte[])} but allows * you to specify the key in several parts that will be @@ -2418,7 +2418,7 @@ public void deleteUntracked(final ColumnFamilyHandle columnFamilyHandle, columnFamilyHandle.nativeHandle_); } - //TODO(AR) refactor if we implement org.rocksdb.SliceParts in future + //TODO(AR) refactor if we implement org.forstdb.SliceParts in future /** * Similar to {@link #deleteUntracked(byte[])} but allows * you to specify the key in several parts that will be @@ -2606,7 +2606,7 @@ public void setWriteOptions(final WriteOptions writeOptions) { * calling {@code #undoGetForUpdate(ColumnFamilyHandle, byte[])} may release * any held locks for this key. * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key the key to retrieve the value for. */ @@ -2804,7 +2804,7 @@ public enum TransactionState { * * @param value byte representation of TransactionState. * - * @return {@link org.rocksdb.Transaction.TransactionState} instance or null. + * @return {@link org.forstdb.Transaction.TransactionState} instance or null. * @throws java.lang.IllegalArgumentException if an invalid * value is provided. */ diff --git a/java/src/main/java/org/rocksdb/TransactionDB.java b/java/src/main/java/org/forstdb/TransactionDB.java similarity index 98% rename from java/src/main/java/org/rocksdb/TransactionDB.java rename to java/src/main/java/org/forstdb/TransactionDB.java index a4ee951dc..ef4b36c7f 100644 --- a/java/src/main/java/org/rocksdb/TransactionDB.java +++ b/java/src/main/java/org/forstdb/TransactionDB.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.ArrayList; import java.util.List; @@ -29,8 +29,8 @@ private TransactionDB(final long nativeHandle) { /** * Open a TransactionDB, similar to {@link RocksDB#open(Options, String)}. * - * @param options {@link org.rocksdb.Options} instance. - * @param transactionDbOptions {@link org.rocksdb.TransactionDBOptions} + * @param options {@link org.forstdb.Options} instance. + * @param transactionDbOptions {@link org.forstdb.TransactionDBOptions} * instance. * @param path the path to the rocksdb. * @@ -59,8 +59,8 @@ public static TransactionDB open(final Options options, * Open a TransactionDB, similar to * {@link RocksDB#open(DBOptions, String, List, List)}. * - * @param dbOptions {@link org.rocksdb.DBOptions} instance. - * @param transactionDbOptions {@link org.rocksdb.TransactionDBOptions} + * @param dbOptions {@link org.forstdb.DBOptions} instance. + * @param transactionDbOptions {@link org.forstdb.TransactionDBOptions} * instance. * @param path the path to the rocksdb. * @param columnFamilyDescriptors list of column family descriptors diff --git a/java/src/main/java/org/rocksdb/TransactionDBOptions.java b/java/src/main/java/org/forstdb/TransactionDBOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/TransactionDBOptions.java rename to java/src/main/java/org/forstdb/TransactionDBOptions.java index 391025d6a..0ee96e10a 100644 --- a/java/src/main/java/org/rocksdb/TransactionDBOptions.java +++ b/java/src/main/java/org/forstdb/TransactionDBOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public class TransactionDBOptions extends RocksObject { diff --git a/java/src/main/java/org/rocksdb/TransactionLogIterator.java b/java/src/main/java/org/forstdb/TransactionLogIterator.java similarity index 89% rename from java/src/main/java/org/rocksdb/TransactionLogIterator.java rename to java/src/main/java/org/forstdb/TransactionLogIterator.java index 5d9ec58d7..078191ea2 100644 --- a/java/src/main/java/org/rocksdb/TransactionLogIterator.java +++ b/java/src/main/java/org/forstdb/TransactionLogIterator.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; /** *

    A TransactionLogIterator is used to iterate over the transactions in a db. @@ -30,7 +30,7 @@ public void next() { /** *

    Throws RocksDBException if something went wrong.

    * - * @throws org.rocksdb.RocksDBException if something went + * @throws org.forstdb.RocksDBException if something went * wrong in the underlying C++ code. */ public void status() throws RocksDBException { @@ -44,7 +44,7 @@ public void status() throws RocksDBException { * *

    ONLY use if Valid() is true and status() is OK.

    * - * @return {@link org.rocksdb.TransactionLogIterator.BatchResult} + * @return {@link org.forstdb.TransactionLogIterator.BatchResult} * instance. */ public BatchResult getBatch() { @@ -71,7 +71,7 @@ public static final class BatchResult { *

    Constructor of BatchResult class.

    * * @param sequenceNumber related to this BatchResult instance. - * @param nativeHandle to {@link org.rocksdb.WriteBatch} + * @param nativeHandle to {@link org.forstdb.WriteBatch} * native instance. */ public BatchResult(final long sequenceNumber, @@ -90,10 +90,10 @@ public long sequenceNumber() { } /** - *

    Return contained {@link org.rocksdb.WriteBatch} + *

    Return contained {@link org.forstdb.WriteBatch} * instance

    * - * @return {@link org.rocksdb.WriteBatch} instance. + * @return {@link org.forstdb.WriteBatch} instance. */ public WriteBatch writeBatch() { return writeBatch_; diff --git a/java/src/main/java/org/rocksdb/TransactionOptions.java b/java/src/main/java/org/forstdb/TransactionOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/TransactionOptions.java rename to java/src/main/java/org/forstdb/TransactionOptions.java index f93d3cb3c..311403053 100644 --- a/java/src/main/java/org/rocksdb/TransactionOptions.java +++ b/java/src/main/java/org/forstdb/TransactionOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public class TransactionOptions extends RocksObject implements TransactionalOptions { diff --git a/java/src/main/java/org/rocksdb/TransactionalDB.java b/java/src/main/java/org/forstdb/TransactionalDB.java similarity index 99% rename from java/src/main/java/org/rocksdb/TransactionalDB.java rename to java/src/main/java/org/forstdb/TransactionalDB.java index 1ba955496..ccf34720b 100644 --- a/java/src/main/java/org/rocksdb/TransactionalDB.java +++ b/java/src/main/java/org/forstdb/TransactionalDB.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; interface TransactionalDB> extends AutoCloseable { /** diff --git a/java/src/main/java/org/rocksdb/TransactionalOptions.java b/java/src/main/java/org/forstdb/TransactionalOptions.java similarity index 97% rename from java/src/main/java/org/rocksdb/TransactionalOptions.java rename to java/src/main/java/org/forstdb/TransactionalOptions.java index 2175693fd..cd7173789 100644 --- a/java/src/main/java/org/rocksdb/TransactionalOptions.java +++ b/java/src/main/java/org/forstdb/TransactionalOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; interface TransactionalOptions> diff --git a/java/src/main/java/org/rocksdb/TtlDB.java b/java/src/main/java/org/forstdb/TtlDB.java similarity index 97% rename from java/src/main/java/org/rocksdb/TtlDB.java rename to java/src/main/java/org/forstdb/TtlDB.java index 9a90ba358..83ed89ae0 100644 --- a/java/src/main/java/org/rocksdb/TtlDB.java +++ b/java/src/main/java/org/forstdb/TtlDB.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.List; @@ -55,7 +55,7 @@ public class TtlDB extends RocksDB { * *

    Database is opened in read-write mode without default TTL.

    * - * @param options {@link org.rocksdb.Options} instance. + * @param options {@link org.forstdb.Options} instance. * @param db_path path to database. * * @return TtlDB instance. @@ -71,7 +71,7 @@ public static TtlDB open(final Options options, final String db_path) /** *

    Opens a TtlDB.

    * - * @param options {@link org.rocksdb.Options} instance. + * @param options {@link org.forstdb.Options} instance. * @param db_path path to database. * @param ttl time to live for new entries. * @param readOnly boolean value indicating if database if db is @@ -90,7 +90,7 @@ public static TtlDB open(final Options options, final String db_path, /** *

    Opens a TtlDB.

    * - * @param options {@link org.rocksdb.Options} instance. + * @param options {@link org.forstdb.Options} instance. * @param db_path path to database. * @param columnFamilyDescriptors list of column family descriptors * @param columnFamilyHandles will be filled with ColumnFamilyHandle instances @@ -201,7 +201,7 @@ public void close() { * @param columnFamilyDescriptor column family to be created. * @param ttl TTL to set for this column family. * - * @return {@link org.rocksdb.ColumnFamilyHandle} instance. + * @return {@link org.forstdb.ColumnFamilyHandle} instance. * * @throws RocksDBException thrown if error happens in underlying * native library. diff --git a/java/src/main/java/org/rocksdb/TxnDBWritePolicy.java b/java/src/main/java/org/forstdb/TxnDBWritePolicy.java similarity index 98% rename from java/src/main/java/org/rocksdb/TxnDBWritePolicy.java rename to java/src/main/java/org/forstdb/TxnDBWritePolicy.java index 28cb8556b..b51dd4103 100644 --- a/java/src/main/java/org/rocksdb/TxnDBWritePolicy.java +++ b/java/src/main/java/org/forstdb/TxnDBWritePolicy.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; /** * The transaction db write policy. diff --git a/java/src/main/java/org/rocksdb/UInt64AddOperator.java b/java/src/main/java/org/forstdb/UInt64AddOperator.java similarity index 96% rename from java/src/main/java/org/rocksdb/UInt64AddOperator.java rename to java/src/main/java/org/forstdb/UInt64AddOperator.java index 0cffdce8c..2435eafa7 100644 --- a/java/src/main/java/org/rocksdb/UInt64AddOperator.java +++ b/java/src/main/java/org/forstdb/UInt64AddOperator.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Uint64AddOperator is a merge operator that accumlates a long diff --git a/java/src/main/java/org/rocksdb/VectorMemTableConfig.java b/java/src/main/java/org/forstdb/VectorMemTableConfig.java similarity index 98% rename from java/src/main/java/org/rocksdb/VectorMemTableConfig.java rename to java/src/main/java/org/forstdb/VectorMemTableConfig.java index fb1e7a948..039c68a1b 100644 --- a/java/src/main/java/org/rocksdb/VectorMemTableConfig.java +++ b/java/src/main/java/org/forstdb/VectorMemTableConfig.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; /** * The config for vector memtable representation. diff --git a/java/src/main/java/org/rocksdb/WALRecoveryMode.java b/java/src/main/java/org/forstdb/WALRecoveryMode.java similarity index 99% rename from java/src/main/java/org/rocksdb/WALRecoveryMode.java rename to java/src/main/java/org/forstdb/WALRecoveryMode.java index b8c098f94..c82b741db 100644 --- a/java/src/main/java/org/rocksdb/WALRecoveryMode.java +++ b/java/src/main/java/org/forstdb/WALRecoveryMode.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * The WAL Recover Mode diff --git a/java/src/main/java/org/rocksdb/WBWIRocksIterator.java b/java/src/main/java/org/forstdb/WBWIRocksIterator.java similarity index 95% rename from java/src/main/java/org/rocksdb/WBWIRocksIterator.java rename to java/src/main/java/org/forstdb/WBWIRocksIterator.java index 25d6e6f9d..1e44fadb8 100644 --- a/java/src/main/java/org/rocksdb/WBWIRocksIterator.java +++ b/java/src/main/java/org/forstdb/WBWIRocksIterator.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; @@ -101,11 +101,11 @@ public void close() { /** * Represents an entry returned by - * {@link org.rocksdb.WBWIRocksIterator#entry()} + * {@link org.forstdb.WBWIRocksIterator#entry()} * * It is worth noting that a WriteEntry with - * the type {@link org.rocksdb.WBWIRocksIterator.WriteType#DELETE} - * or {@link org.rocksdb.WBWIRocksIterator.WriteType#LOG} + * the type {@link org.forstdb.WBWIRocksIterator.WriteType#DELETE} + * or {@link org.forstdb.WBWIRocksIterator.WriteType#LOG} * will not have a value. */ public static class WriteEntry implements AutoCloseable { @@ -118,7 +118,7 @@ public static class WriteEntry implements AutoCloseable { * should only be instantiated in * this manner by the outer WBWIRocksIterator * class; The class members are then modified - * by calling {@link org.rocksdb.WBWIRocksIterator#entry()} + * by calling {@link org.forstdb.WBWIRocksIterator#entry()} */ private WriteEntry() { key = new DirectSlice(); diff --git a/java/src/main/java/org/rocksdb/WalFileType.java b/java/src/main/java/org/forstdb/WalFileType.java similarity index 98% rename from java/src/main/java/org/rocksdb/WalFileType.java rename to java/src/main/java/org/forstdb/WalFileType.java index fed27ed11..117c59aa4 100644 --- a/java/src/main/java/org/rocksdb/WalFileType.java +++ b/java/src/main/java/org/forstdb/WalFileType.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public enum WalFileType { /** diff --git a/java/src/main/java/org/rocksdb/WalFilter.java b/java/src/main/java/org/forstdb/WalFilter.java similarity index 99% rename from java/src/main/java/org/rocksdb/WalFilter.java rename to java/src/main/java/org/forstdb/WalFilter.java index a2836634a..330d20c88 100644 --- a/java/src/main/java/org/rocksdb/WalFilter.java +++ b/java/src/main/java/org/forstdb/WalFilter.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Map; diff --git a/java/src/main/java/org/rocksdb/WalProcessingOption.java b/java/src/main/java/org/forstdb/WalProcessingOption.java similarity index 98% rename from java/src/main/java/org/rocksdb/WalProcessingOption.java rename to java/src/main/java/org/forstdb/WalProcessingOption.java index 3a9c2be0e..36ee14c99 100644 --- a/java/src/main/java/org/rocksdb/WalProcessingOption.java +++ b/java/src/main/java/org/forstdb/WalProcessingOption.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public enum WalProcessingOption { /* diff --git a/java/src/main/java/org/rocksdb/WriteBatch.java b/java/src/main/java/org/forstdb/WriteBatch.java similarity index 99% rename from java/src/main/java/org/rocksdb/WriteBatch.java rename to java/src/main/java/org/forstdb/WriteBatch.java index 49e1f7f20..1cc7736ca 100644 --- a/java/src/main/java/org/rocksdb/WriteBatch.java +++ b/java/src/main/java/org/forstdb/WriteBatch.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; diff --git a/java/src/main/java/org/rocksdb/WriteBatchInterface.java b/java/src/main/java/org/forstdb/WriteBatchInterface.java similarity index 98% rename from java/src/main/java/org/rocksdb/WriteBatchInterface.java rename to java/src/main/java/org/forstdb/WriteBatchInterface.java index 32cd8d1e7..6c7166875 100644 --- a/java/src/main/java/org/rocksdb/WriteBatchInterface.java +++ b/java/src/main/java/org/forstdb/WriteBatchInterface.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; @@ -33,7 +33,7 @@ public interface WriteBatchInterface { *

    Store the mapping "key->value" within given column * family.

    * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key the specified key to be inserted. * @param value the value associated with the specified key. @@ -58,7 +58,7 @@ void put(ColumnFamilyHandle columnFamilyHandle, byte[] key, byte[] value) *

    Store the mapping "key->value" within given column * family.

    * - * @param columnFamilyHandle {@link org.rocksdb.ColumnFamilyHandle} + * @param columnFamilyHandle {@link org.forstdb.ColumnFamilyHandle} * instance * @param key the specified key to be inserted. It is using position and limit. * Supports direct buffer only. diff --git a/java/src/main/java/org/rocksdb/WriteBatchWithIndex.java b/java/src/main/java/org/forstdb/WriteBatchWithIndex.java similarity index 94% rename from java/src/main/java/org/rocksdb/WriteBatchWithIndex.java rename to java/src/main/java/org/forstdb/WriteBatchWithIndex.java index d41be5856..02a3be8fb 100644 --- a/java/src/main/java/org/rocksdb/WriteBatchWithIndex.java +++ b/java/src/main/java/org/forstdb/WriteBatchWithIndex.java @@ -3,20 +3,20 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.ByteBuffer; /** - * Similar to {@link org.rocksdb.WriteBatch} but with a binary searchable + * Similar to {@link org.forstdb.WriteBatch} but with a binary searchable * index built for all the keys inserted. *

    * Calling put, merge, remove or putLogData calls the same function - * as with {@link org.rocksdb.WriteBatch} whilst also building an index. + * as with {@link org.forstdb.WriteBatch} whilst also building an index. *

    - * A user can call {@link org.rocksdb.WriteBatchWithIndex#newIterator()} to + * A user can call {@link org.forstdb.WriteBatchWithIndex#newIterator()} to * create an iterator over the write batch or - * {@link org.rocksdb.WriteBatchWithIndex#newIteratorWithBase(org.rocksdb.RocksIterator)} + * {@link org.forstdb.WriteBatchWithIndex#newIteratorWithBase(org.forstdb.RocksIterator)} * to get an iterator for the database with Read-Your-Own-Writes like capability */ public class WriteBatchWithIndex extends AbstractWriteBatch { @@ -80,7 +80,7 @@ public WriteBatchWithIndex( /** * Create an iterator of a column family. User can call - * {@link org.rocksdb.RocksIteratorInterface#seek(byte[])} to + * {@link org.forstdb.RocksIteratorInterface#seek(byte[])} to * search to the next entry of or after a key. Keys will be iterated in the * order given by index_comparator. For multiple updates on the same key, * each update will be returned as a separate entry, in the order of update @@ -98,7 +98,7 @@ public WBWIRocksIterator newIterator( /** * Create an iterator of the default column family. User can call - * {@link org.rocksdb.RocksIteratorInterface#seek(byte[])} to + * {@link org.forstdb.RocksIteratorInterface#seek(byte[])} to * search to the next entry of or after a key. Keys will be iterated in the * order given by index_comparator. For multiple updates on the same key, * each update will be returned as a separate entry, in the order of update @@ -112,7 +112,7 @@ public WBWIRocksIterator newIterator() { /** * Provides Read-Your-Own-Writes like functionality by - * creating a new Iterator that will use {@link org.rocksdb.WBWIRocksIterator} + * creating a new Iterator that will use {@link org.forstdb.WBWIRocksIterator} * as a delta and baseIterator as a base *

    * Updating write batch with the current key of the iterator is not safe. @@ -123,7 +123,7 @@ public WBWIRocksIterator newIterator() { * * @param columnFamilyHandle The column family to iterate over * @param baseIterator The base iterator, - * e.g. {@link org.rocksdb.RocksDB#newIterator()} + * e.g. {@link org.forstdb.RocksDB#newIterator()} * @return An iterator which shows a view comprised of both the database * point-in-time from baseIterator and modifications made in this write batch. */ @@ -135,7 +135,7 @@ public RocksIterator newIteratorWithBase( /** * Provides Read-Your-Own-Writes like functionality by - * creating a new Iterator that will use {@link org.rocksdb.WBWIRocksIterator} + * creating a new Iterator that will use {@link org.forstdb.WBWIRocksIterator} * as a delta and baseIterator as a base *

    * Updating write batch with the current key of the iterator is not safe. @@ -146,7 +146,7 @@ public RocksIterator newIteratorWithBase( * * @param columnFamilyHandle The column family to iterate over * @param baseIterator The base iterator, - * e.g. {@link org.rocksdb.RocksDB#newIterator()} + * e.g. {@link org.forstdb.RocksDB#newIterator()} * @param readOptions the read options, or null * @return An iterator which shows a view comprised of both the database * point-in-time from baseIterator and modifications made in this write batch. @@ -165,12 +165,12 @@ public RocksIterator newIteratorWithBase(final ColumnFamilyHandle columnFamilyHa /** * Provides Read-Your-Own-Writes like functionality by - * creating a new Iterator that will use {@link org.rocksdb.WBWIRocksIterator} + * creating a new Iterator that will use {@link org.forstdb.WBWIRocksIterator} * as a delta and baseIterator as a base. Operates on the default column * family. * * @param baseIterator The base iterator, - * e.g. {@link org.rocksdb.RocksDB#newIterator()} + * e.g. {@link org.forstdb.RocksDB#newIterator()} * @return An iterator which shows a view comprised of both the database * point-in-time from baseIterator and modifications made in this write batch. */ @@ -180,12 +180,12 @@ public RocksIterator newIteratorWithBase(final RocksIterator baseIterator) { /** * Provides Read-Your-Own-Writes like functionality by - * creating a new Iterator that will use {@link org.rocksdb.WBWIRocksIterator} + * creating a new Iterator that will use {@link org.forstdb.WBWIRocksIterator} * as a delta and baseIterator as a base. Operates on the default column * family. * * @param baseIterator The base iterator, - * e.g. {@link org.rocksdb.RocksDB#newIterator()} + * e.g. {@link org.forstdb.RocksDB#newIterator()} * @param readOptions the read options, or null * @return An iterator which shows a view comprised of both the database * point-in-time from baseIterator and modifications made in this write batch. diff --git a/java/src/main/java/org/rocksdb/WriteBufferManager.java b/java/src/main/java/org/forstdb/WriteBufferManager.java similarity index 98% rename from java/src/main/java/org/rocksdb/WriteBufferManager.java rename to java/src/main/java/org/forstdb/WriteBufferManager.java index 40176aba4..18ecfea2b 100644 --- a/java/src/main/java/org/rocksdb/WriteBufferManager.java +++ b/java/src/main/java/org/forstdb/WriteBufferManager.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Java wrapper over native write_buffer_manager class diff --git a/java/src/main/java/org/rocksdb/WriteOptions.java b/java/src/main/java/org/forstdb/WriteOptions.java similarity index 99% rename from java/src/main/java/org/rocksdb/WriteOptions.java rename to java/src/main/java/org/forstdb/WriteOptions.java index 7c184b094..26598d72e 100644 --- a/java/src/main/java/org/rocksdb/WriteOptions.java +++ b/java/src/main/java/org/forstdb/WriteOptions.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Options that control write operations. diff --git a/java/src/main/java/org/rocksdb/WriteStallCondition.java b/java/src/main/java/org/forstdb/WriteStallCondition.java similarity index 98% rename from java/src/main/java/org/rocksdb/WriteStallCondition.java rename to java/src/main/java/org/forstdb/WriteStallCondition.java index 98d9e2ce4..acc0dcdba 100644 --- a/java/src/main/java/org/rocksdb/WriteStallCondition.java +++ b/java/src/main/java/org/forstdb/WriteStallCondition.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public enum WriteStallCondition { DELAYED((byte) 0x0), diff --git a/java/src/main/java/org/rocksdb/WriteStallInfo.java b/java/src/main/java/org/forstdb/WriteStallInfo.java similarity index 99% rename from java/src/main/java/org/rocksdb/WriteStallInfo.java rename to java/src/main/java/org/forstdb/WriteStallInfo.java index 1cade0acb..dd48eb434 100644 --- a/java/src/main/java/org/rocksdb/WriteStallInfo.java +++ b/java/src/main/java/org/forstdb/WriteStallInfo.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Objects; diff --git a/java/src/main/java/org/rocksdb/util/BufferUtil.java b/java/src/main/java/org/forstdb/util/BufferUtil.java similarity index 95% rename from java/src/main/java/org/rocksdb/util/BufferUtil.java rename to java/src/main/java/org/forstdb/util/BufferUtil.java index 54be3e693..8bec35922 100644 --- a/java/src/main/java/org/rocksdb/util/BufferUtil.java +++ b/java/src/main/java/org/forstdb/util/BufferUtil.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; public class BufferUtil { public static void CheckBounds(final int offset, final int len, final int size) { diff --git a/java/src/main/java/org/rocksdb/util/ByteUtil.java b/java/src/main/java/org/forstdb/util/ByteUtil.java similarity index 98% rename from java/src/main/java/org/rocksdb/util/ByteUtil.java rename to java/src/main/java/org/forstdb/util/ByteUtil.java index 5d64d5dcf..c42c4b690 100644 --- a/java/src/main/java/org/rocksdb/util/ByteUtil.java +++ b/java/src/main/java/org/forstdb/util/ByteUtil.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; import java.nio.ByteBuffer; diff --git a/java/src/main/java/org/rocksdb/util/BytewiseComparator.java b/java/src/main/java/org/forstdb/util/BytewiseComparator.java similarity index 95% rename from java/src/main/java/org/rocksdb/util/BytewiseComparator.java rename to java/src/main/java/org/forstdb/util/BytewiseComparator.java index 202241d3b..50c5fde9f 100644 --- a/java/src/main/java/org/rocksdb/util/BytewiseComparator.java +++ b/java/src/main/java/org/forstdb/util/BytewiseComparator.java @@ -3,13 +3,13 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; -import org.rocksdb.*; +import org.forstdb.*; import java.nio.ByteBuffer; -import static org.rocksdb.util.ByteUtil.memcmp; +import static org.forstdb.util.ByteUtil.memcmp; /** * This is a Java Native implementation of the C++ @@ -19,7 +19,7 @@ * less than their C++ counterparts due to the bridging overhead, * as such you likely don't want to use this apart from benchmarking * and you most likely instead wanted - * {@link org.rocksdb.BuiltinComparator#BYTEWISE_COMPARATOR} + * {@link org.forstdb.BuiltinComparator#BYTEWISE_COMPARATOR} */ public final class BytewiseComparator extends AbstractComparator { diff --git a/java/src/main/java/org/rocksdb/util/Environment.java b/java/src/main/java/org/forstdb/util/Environment.java similarity index 99% rename from java/src/main/java/org/rocksdb/util/Environment.java rename to java/src/main/java/org/forstdb/util/Environment.java index 78b73dc5d..57217a653 100644 --- a/java/src/main/java/org/rocksdb/util/Environment.java +++ b/java/src/main/java/org/forstdb/util/Environment.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb.util; +package org.forstdb.util; import java.io.File; import java.io.IOException; diff --git a/java/src/main/java/org/rocksdb/util/IntComparator.java b/java/src/main/java/org/forstdb/util/IntComparator.java similarity index 94% rename from java/src/main/java/org/rocksdb/util/IntComparator.java rename to java/src/main/java/org/forstdb/util/IntComparator.java index 2caf0c601..44dfa9f73 100644 --- a/java/src/main/java/org/rocksdb/util/IntComparator.java +++ b/java/src/main/java/org/forstdb/util/IntComparator.java @@ -3,10 +3,10 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; -import org.rocksdb.AbstractComparator; -import org.rocksdb.ComparatorOptions; +import org.forstdb.AbstractComparator; +import org.forstdb.ComparatorOptions; import java.nio.ByteBuffer; diff --git a/java/src/main/java/org/rocksdb/util/ReverseBytewiseComparator.java b/java/src/main/java/org/forstdb/util/ReverseBytewiseComparator.java similarity index 93% rename from java/src/main/java/org/rocksdb/util/ReverseBytewiseComparator.java rename to java/src/main/java/org/forstdb/util/ReverseBytewiseComparator.java index 3d3c42941..87a8fb4e8 100644 --- a/java/src/main/java/org/rocksdb/util/ReverseBytewiseComparator.java +++ b/java/src/main/java/org/forstdb/util/ReverseBytewiseComparator.java @@ -3,12 +3,12 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; -import org.rocksdb.AbstractComparator; -import org.rocksdb.BuiltinComparator; -import org.rocksdb.ComparatorOptions; -import org.rocksdb.Slice; +import org.forstdb.AbstractComparator; +import org.forstdb.BuiltinComparator; +import org.forstdb.ComparatorOptions; +import org.forstdb.Slice; import java.nio.ByteBuffer; diff --git a/java/src/main/java/org/rocksdb/util/SizeUnit.java b/java/src/main/java/org/forstdb/util/SizeUnit.java similarity index 95% rename from java/src/main/java/org/rocksdb/util/SizeUnit.java rename to java/src/main/java/org/forstdb/util/SizeUnit.java index 0f717e8d4..313db8d44 100644 --- a/java/src/main/java/org/rocksdb/util/SizeUnit.java +++ b/java/src/main/java/org/forstdb/util/SizeUnit.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; public class SizeUnit { public static final long KB = 1024L; diff --git a/java/src/test/java/org/rocksdb/AbstractTransactionTest.java b/java/src/test/java/org/forstdb/AbstractTransactionTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/AbstractTransactionTest.java rename to java/src/test/java/org/forstdb/AbstractTransactionTest.java index 2977d78fd..09f69ba2c 100644 --- a/java/src/test/java/org/rocksdb/AbstractTransactionTest.java +++ b/java/src/test/java/org/forstdb/AbstractTransactionTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static java.nio.charset.StandardCharsets.UTF_8; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/BackupEngineOptionsTest.java b/java/src/test/java/org/forstdb/BackupEngineOptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/BackupEngineOptionsTest.java rename to java/src/test/java/org/forstdb/BackupEngineOptionsTest.java index b07f8d33c..e9f6087f3 100644 --- a/java/src/test/java/org/rocksdb/BackupEngineOptionsTest.java +++ b/java/src/test/java/org/forstdb/BackupEngineOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/BackupEngineTest.java b/java/src/test/java/org/forstdb/BackupEngineTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/BackupEngineTest.java rename to java/src/test/java/org/forstdb/BackupEngineTest.java index 67145f846..9b136a527 100644 --- a/java/src/test/java/org/rocksdb/BackupEngineTest.java +++ b/java/src/test/java/org/forstdb/BackupEngineTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; diff --git a/java/src/test/java/org/rocksdb/BlobOptionsTest.java b/java/src/test/java/org/forstdb/BlobOptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/BlobOptionsTest.java rename to java/src/test/java/org/forstdb/BlobOptionsTest.java index a0a2af84a..a7895fe34 100644 --- a/java/src/test/java/org/rocksdb/BlobOptionsTest.java +++ b/java/src/test/java/org/forstdb/BlobOptionsTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import static java.nio.charset.StandardCharsets.UTF_8; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/BlockBasedTableConfigTest.java b/java/src/test/java/org/forstdb/BlockBasedTableConfigTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/BlockBasedTableConfigTest.java rename to java/src/test/java/org/forstdb/BlockBasedTableConfigTest.java index 13247d1e6..51b23ede8 100644 --- a/java/src/test/java/org/rocksdb/BlockBasedTableConfigTest.java +++ b/java/src/test/java/org/forstdb/BlockBasedTableConfigTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; diff --git a/java/src/test/java/org/rocksdb/BuiltinComparatorTest.java b/java/src/test/java/org/forstdb/BuiltinComparatorTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/BuiltinComparatorTest.java rename to java/src/test/java/org/forstdb/BuiltinComparatorTest.java index e238ae07b..70e7ccf17 100644 --- a/java/src/test/java/org/rocksdb/BuiltinComparatorTest.java +++ b/java/src/test/java/org/forstdb/BuiltinComparatorTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; diff --git a/java/src/test/java/org/rocksdb/ByteBufferUnsupportedOperationTest.java b/java/src/test/java/org/forstdb/ByteBufferUnsupportedOperationTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/ByteBufferUnsupportedOperationTest.java rename to java/src/test/java/org/forstdb/ByteBufferUnsupportedOperationTest.java index f596f573f..b8d38cbd2 100644 --- a/java/src/test/java/org/rocksdb/ByteBufferUnsupportedOperationTest.java +++ b/java/src/test/java/org/forstdb/ByteBufferUnsupportedOperationTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.nio.charset.StandardCharsets; import java.util.*; @@ -12,7 +12,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.util.ReverseBytewiseComparator; +import org.forstdb.util.ReverseBytewiseComparator; public class ByteBufferUnsupportedOperationTest { @ClassRule diff --git a/java/src/test/java/org/rocksdb/BytewiseComparatorRegressionTest.java b/java/src/test/java/org/forstdb/BytewiseComparatorRegressionTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/BytewiseComparatorRegressionTest.java rename to java/src/test/java/org/forstdb/BytewiseComparatorRegressionTest.java index 13aa6c2bd..84cfeace5 100644 --- a/java/src/test/java/org/rocksdb/BytewiseComparatorRegressionTest.java +++ b/java/src/test/java/org/forstdb/BytewiseComparatorRegressionTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.junit.Assert.assertArrayEquals; @@ -14,7 +14,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.util.BytewiseComparator; +import org.forstdb.util.BytewiseComparator; /** * This test confirms that the following issues were in fact resolved diff --git a/java/src/test/java/org/rocksdb/CheckPointTest.java b/java/src/test/java/org/forstdb/CheckPointTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/CheckPointTest.java rename to java/src/test/java/org/forstdb/CheckPointTest.java index 3b0b5d86a..eb846e492 100644 --- a/java/src/test/java/org/rocksdb/CheckPointTest.java +++ b/java/src/test/java/org/forstdb/CheckPointTest.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; diff --git a/java/src/test/java/org/rocksdb/ClockCacheTest.java b/java/src/test/java/org/forstdb/ClockCacheTest.java similarity index 96% rename from java/src/test/java/org/rocksdb/ClockCacheTest.java rename to java/src/test/java/org/forstdb/ClockCacheTest.java index 718c24f70..8e466e1f4 100644 --- a/java/src/test/java/org/rocksdb/ClockCacheTest.java +++ b/java/src/test/java/org/forstdb/ClockCacheTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/ColumnFamilyOptionsTest.java b/java/src/test/java/org/forstdb/ColumnFamilyOptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/ColumnFamilyOptionsTest.java rename to java/src/test/java/org/forstdb/ColumnFamilyOptionsTest.java index 35a04a697..aac9e0f24 100644 --- a/java/src/test/java/org/rocksdb/ColumnFamilyOptionsTest.java +++ b/java/src/test/java/org/forstdb/ColumnFamilyOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertEquals; @@ -13,7 +13,7 @@ import java.util.*; import org.junit.ClassRule; import org.junit.Test; -import org.rocksdb.test.RemoveEmptyValueCompactionFilterFactory; +import org.forstdb.test.RemoveEmptyValueCompactionFilterFactory; public class ColumnFamilyOptionsTest { diff --git a/java/src/test/java/org/rocksdb/ColumnFamilyTest.java b/java/src/test/java/org/forstdb/ColumnFamilyTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/ColumnFamilyTest.java rename to java/src/test/java/org/forstdb/ColumnFamilyTest.java index fb8a45085..a629ccc95 100644 --- a/java/src/test/java/org/rocksdb/ColumnFamilyTest.java +++ b/java/src/test/java/org/forstdb/ColumnFamilyTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static java.nio.charset.StandardCharsets.UTF_8; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/CompactRangeOptionsTest.java b/java/src/test/java/org/forstdb/CompactRangeOptionsTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/CompactRangeOptionsTest.java rename to java/src/test/java/org/forstdb/CompactRangeOptionsTest.java index 549b74beb..1b7941365 100644 --- a/java/src/test/java/org/rocksdb/CompactRangeOptionsTest.java +++ b/java/src/test/java/org/forstdb/CompactRangeOptionsTest.java @@ -3,10 +3,10 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; -import org.rocksdb.CompactRangeOptions.BottommostLevelCompaction; +import org.forstdb.CompactRangeOptions.BottommostLevelCompaction; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/CompactionFilterFactoryTest.java b/java/src/test/java/org/forstdb/CompactionFilterFactoryTest.java similarity index 96% rename from java/src/test/java/org/rocksdb/CompactionFilterFactoryTest.java rename to java/src/test/java/org/forstdb/CompactionFilterFactoryTest.java index 35a14eb54..7209161f5 100644 --- a/java/src/test/java/org/rocksdb/CompactionFilterFactoryTest.java +++ b/java/src/test/java/org/forstdb/CompactionFilterFactoryTest.java @@ -3,12 +3,12 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.test.RemoveEmptyValueCompactionFilterFactory; +import org.forstdb.test.RemoveEmptyValueCompactionFilterFactory; import java.util.ArrayList; import java.util.Arrays; diff --git a/java/src/test/java/org/rocksdb/CompactionJobInfoTest.java b/java/src/test/java/org/forstdb/CompactionJobInfoTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/CompactionJobInfoTest.java rename to java/src/test/java/org/forstdb/CompactionJobInfoTest.java index c71b0da16..6c38c0c01 100644 --- a/java/src/test/java/org/rocksdb/CompactionJobInfoTest.java +++ b/java/src/test/java/org/forstdb/CompactionJobInfoTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/CompactionJobStatsTest.java b/java/src/test/java/org/forstdb/CompactionJobStatsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/CompactionJobStatsTest.java rename to java/src/test/java/org/forstdb/CompactionJobStatsTest.java index 5c1eb2aab..30df1f4df 100644 --- a/java/src/test/java/org/rocksdb/CompactionJobStatsTest.java +++ b/java/src/test/java/org/forstdb/CompactionJobStatsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/CompactionOptionsFIFOTest.java b/java/src/test/java/org/forstdb/CompactionOptionsFIFOTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/CompactionOptionsFIFOTest.java rename to java/src/test/java/org/forstdb/CompactionOptionsFIFOTest.java index 841615e67..6da11aa52 100644 --- a/java/src/test/java/org/rocksdb/CompactionOptionsFIFOTest.java +++ b/java/src/test/java/org/forstdb/CompactionOptionsFIFOTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/CompactionOptionsTest.java b/java/src/test/java/org/forstdb/CompactionOptionsTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/CompactionOptionsTest.java rename to java/src/test/java/org/forstdb/CompactionOptionsTest.java index 9b7d79694..6f070c4d3 100644 --- a/java/src/test/java/org/rocksdb/CompactionOptionsTest.java +++ b/java/src/test/java/org/forstdb/CompactionOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/CompactionOptionsUniversalTest.java b/java/src/test/java/org/forstdb/CompactionOptionsUniversalTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/CompactionOptionsUniversalTest.java rename to java/src/test/java/org/forstdb/CompactionOptionsUniversalTest.java index 5e2d195b6..6aa0ef2cc 100644 --- a/java/src/test/java/org/rocksdb/CompactionOptionsUniversalTest.java +++ b/java/src/test/java/org/forstdb/CompactionOptionsUniversalTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/CompactionPriorityTest.java b/java/src/test/java/org/forstdb/CompactionPriorityTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/CompactionPriorityTest.java rename to java/src/test/java/org/forstdb/CompactionPriorityTest.java index b078e132f..9902b9c97 100644 --- a/java/src/test/java/org/rocksdb/CompactionPriorityTest.java +++ b/java/src/test/java/org/forstdb/CompactionPriorityTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/CompactionStopStyleTest.java b/java/src/test/java/org/forstdb/CompactionStopStyleTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/CompactionStopStyleTest.java rename to java/src/test/java/org/forstdb/CompactionStopStyleTest.java index 4c8a20950..978aee632 100644 --- a/java/src/test/java/org/rocksdb/CompactionStopStyleTest.java +++ b/java/src/test/java/org/forstdb/CompactionStopStyleTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/ComparatorOptionsTest.java b/java/src/test/java/org/forstdb/ComparatorOptionsTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/ComparatorOptionsTest.java rename to java/src/test/java/org/forstdb/ComparatorOptionsTest.java index 3e90b9f10..ea6486378 100644 --- a/java/src/test/java/org/rocksdb/ComparatorOptionsTest.java +++ b/java/src/test/java/org/forstdb/ComparatorOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/CompressionOptionsTest.java b/java/src/test/java/org/forstdb/CompressionOptionsTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/CompressionOptionsTest.java rename to java/src/test/java/org/forstdb/CompressionOptionsTest.java index 116552c32..c11c57af9 100644 --- a/java/src/test/java/org/rocksdb/CompressionOptionsTest.java +++ b/java/src/test/java/org/forstdb/CompressionOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/CompressionTypesTest.java b/java/src/test/java/org/forstdb/CompressionTypesTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/CompressionTypesTest.java rename to java/src/test/java/org/forstdb/CompressionTypesTest.java index a983f471a..761d4eec0 100644 --- a/java/src/test/java/org/rocksdb/CompressionTypesTest.java +++ b/java/src/test/java/org/forstdb/CompressionTypesTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/ConcurrentTaskLimiterTest.java b/java/src/test/java/org/forstdb/ConcurrentTaskLimiterTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/ConcurrentTaskLimiterTest.java rename to java/src/test/java/org/forstdb/ConcurrentTaskLimiterTest.java index 165f4f24c..8e6b5b02c 100644 --- a/java/src/test/java/org/rocksdb/ConcurrentTaskLimiterTest.java +++ b/java/src/test/java/org/forstdb/ConcurrentTaskLimiterTest.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.junit.Assert.assertEquals; diff --git a/java/src/test/java/org/rocksdb/DBOptionsTest.java b/java/src/test/java/org/forstdb/DBOptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/DBOptionsTest.java rename to java/src/test/java/org/forstdb/DBOptionsTest.java index cb7eabcfb..ffa22a231 100644 --- a/java/src/test/java/org/rocksdb/DBOptionsTest.java +++ b/java/src/test/java/org/forstdb/DBOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertEquals; diff --git a/java/src/test/java/org/rocksdb/DefaultEnvTest.java b/java/src/test/java/org/forstdb/DefaultEnvTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/DefaultEnvTest.java rename to java/src/test/java/org/forstdb/DefaultEnvTest.java index 3fb563ecb..a53d1de0f 100644 --- a/java/src/test/java/org/rocksdb/DefaultEnvTest.java +++ b/java/src/test/java/org/forstdb/DefaultEnvTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; diff --git a/java/src/test/java/org/rocksdb/DirectSliceTest.java b/java/src/test/java/org/forstdb/DirectSliceTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/DirectSliceTest.java rename to java/src/test/java/org/forstdb/DirectSliceTest.java index 67385345c..c14f4925b 100644 --- a/java/src/test/java/org/rocksdb/DirectSliceTest.java +++ b/java/src/test/java/org/forstdb/DirectSliceTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/EnvOptionsTest.java b/java/src/test/java/org/forstdb/EnvOptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/EnvOptionsTest.java rename to java/src/test/java/org/forstdb/EnvOptionsTest.java index 0f3d8e234..fcf1bcf87 100644 --- a/java/src/test/java/org/rocksdb/EnvOptionsTest.java +++ b/java/src/test/java/org/forstdb/EnvOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/EventListenerTest.java b/java/src/test/java/org/forstdb/EventListenerTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/EventListenerTest.java rename to java/src/test/java/org/forstdb/EventListenerTest.java index 84be232f9..4d5729586 100644 --- a/java/src/test/java/org/rocksdb/EventListenerTest.java +++ b/java/src/test/java/org/forstdb/EventListenerTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; @@ -17,8 +17,8 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.AbstractEventListener.EnabledEventCallback; -import org.rocksdb.test.TestableEventListener; +import org.forstdb.AbstractEventListener.EnabledEventCallback; +import org.forstdb.test.TestableEventListener; public class EventListenerTest { @ClassRule diff --git a/java/src/test/java/org/rocksdb/FilterTest.java b/java/src/test/java/org/forstdb/FilterTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/FilterTest.java rename to java/src/test/java/org/forstdb/FilterTest.java index e308ffefb..d2e93e4e2 100644 --- a/java/src/test/java/org/rocksdb/FilterTest.java +++ b/java/src/test/java/org/forstdb/FilterTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/FlinkCompactionFilterTest.java b/java/src/test/java/org/forstdb/FlinkCompactionFilterTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/FlinkCompactionFilterTest.java rename to java/src/test/java/org/forstdb/FlinkCompactionFilterTest.java index 40320e9d5..87bbb6bbe 100644 --- a/java/src/test/java/org/rocksdb/FlinkCompactionFilterTest.java +++ b/java/src/test/java/org/forstdb/FlinkCompactionFilterTest.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; @@ -31,8 +31,8 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.FlinkCompactionFilter.StateType; -import org.rocksdb.FlinkCompactionFilter.TimeProvider; +import org.forstdb.FlinkCompactionFilter.StateType; +import org.forstdb.FlinkCompactionFilter.TimeProvider; public class FlinkCompactionFilterTest { private static final int LONG_LENGTH = 8; diff --git a/java/src/test/java/org/rocksdb/FlushOptionsTest.java b/java/src/test/java/org/forstdb/FlushOptionsTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/FlushOptionsTest.java rename to java/src/test/java/org/forstdb/FlushOptionsTest.java index f90ae911d..2c0e268b0 100644 --- a/java/src/test/java/org/rocksdb/FlushOptionsTest.java +++ b/java/src/test/java/org/forstdb/FlushOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/FlushTest.java b/java/src/test/java/org/forstdb/FlushTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/FlushTest.java rename to java/src/test/java/org/forstdb/FlushTest.java index 1a354f4ce..358091561 100644 --- a/java/src/test/java/org/rocksdb/FlushTest.java +++ b/java/src/test/java/org/forstdb/FlushTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; diff --git a/java/src/test/java/org/rocksdb/HyperClockCacheTest.java b/java/src/test/java/org/forstdb/HyperClockCacheTest.java similarity index 95% rename from java/src/test/java/org/rocksdb/HyperClockCacheTest.java rename to java/src/test/java/org/forstdb/HyperClockCacheTest.java index 132d69351..5bbc93db8 100644 --- a/java/src/test/java/org/rocksdb/HyperClockCacheTest.java +++ b/java/src/test/java/org/forstdb/HyperClockCacheTest.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/ImportColumnFamilyTest.java b/java/src/test/java/org/forstdb/ImportColumnFamilyTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/ImportColumnFamilyTest.java rename to java/src/test/java/org/forstdb/ImportColumnFamilyTest.java index ee569d497..040f2a14d 100644 --- a/java/src/test/java/org/rocksdb/ImportColumnFamilyTest.java +++ b/java/src/test/java/org/forstdb/ImportColumnFamilyTest.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; @@ -19,7 +19,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.util.BytewiseComparator; +import org.forstdb.util.BytewiseComparator; public class ImportColumnFamilyTest { private static final String SST_FILE_NAME = "test.sst"; diff --git a/java/src/test/java/org/rocksdb/InfoLogLevelTest.java b/java/src/test/java/org/forstdb/InfoLogLevelTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/InfoLogLevelTest.java rename to java/src/test/java/org/forstdb/InfoLogLevelTest.java index 90b0b4e2d..6afd1f783 100644 --- a/java/src/test/java/org/rocksdb/InfoLogLevelTest.java +++ b/java/src/test/java/org/forstdb/InfoLogLevelTest.java @@ -1,11 +1,11 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.util.Environment; +import org.forstdb.util.Environment; import java.io.IOException; diff --git a/java/src/test/java/org/rocksdb/IngestExternalFileOptionsTest.java b/java/src/test/java/org/forstdb/IngestExternalFileOptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/IngestExternalFileOptionsTest.java rename to java/src/test/java/org/forstdb/IngestExternalFileOptionsTest.java index 230694615..535156580 100644 --- a/java/src/test/java/org/rocksdb/IngestExternalFileOptionsTest.java +++ b/java/src/test/java/org/forstdb/IngestExternalFileOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/KeyExistsTest.java b/java/src/test/java/org/forstdb/KeyExistsTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/KeyExistsTest.java rename to java/src/test/java/org/forstdb/KeyExistsTest.java index 1ee9bdce2..150411cb7 100644 --- a/java/src/test/java/org/rocksdb/KeyExistsTest.java +++ b/java/src/test/java/org/forstdb/KeyExistsTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import static java.nio.charset.StandardCharsets.UTF_8; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/KeyMayExistTest.java b/java/src/test/java/org/forstdb/KeyMayExistTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/KeyMayExistTest.java rename to java/src/test/java/org/forstdb/KeyMayExistTest.java index 5a9ffd6eb..387a238a1 100644 --- a/java/src/test/java/org/rocksdb/KeyMayExistTest.java +++ b/java/src/test/java/org/forstdb/KeyMayExistTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import static java.nio.charset.StandardCharsets.UTF_8; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/LRUCacheTest.java b/java/src/test/java/org/forstdb/LRUCacheTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/LRUCacheTest.java rename to java/src/test/java/org/forstdb/LRUCacheTest.java index 4d194e712..e2782720e 100644 --- a/java/src/test/java/org/rocksdb/LRUCacheTest.java +++ b/java/src/test/java/org/forstdb/LRUCacheTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/LoggerTest.java b/java/src/test/java/org/forstdb/LoggerTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/LoggerTest.java rename to java/src/test/java/org/forstdb/LoggerTest.java index b6a7be55e..f91a6c260 100644 --- a/java/src/test/java/org/rocksdb/LoggerTest.java +++ b/java/src/test/java/org/forstdb/LoggerTest.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/MemTableTest.java b/java/src/test/java/org/forstdb/MemTableTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/MemTableTest.java rename to java/src/test/java/org/forstdb/MemTableTest.java index 6ebf9ef51..2cf0ff0ec 100644 --- a/java/src/test/java/org/rocksdb/MemTableTest.java +++ b/java/src/test/java/org/forstdb/MemTableTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/MemoryUtilTest.java b/java/src/test/java/org/forstdb/MemoryUtilTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/MemoryUtilTest.java rename to java/src/test/java/org/forstdb/MemoryUtilTest.java index bfdcb9fe1..555463706 100644 --- a/java/src/test/java/org/rocksdb/MemoryUtilTest.java +++ b/java/src/test/java/org/forstdb/MemoryUtilTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; diff --git a/java/src/test/java/org/rocksdb/MergeCFVariantsTest.java b/java/src/test/java/org/forstdb/MergeCFVariantsTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/MergeCFVariantsTest.java rename to java/src/test/java/org/forstdb/MergeCFVariantsTest.java index 6c4f07ddc..5f3206fc6 100644 --- a/java/src/test/java/org/rocksdb/MergeCFVariantsTest.java +++ b/java/src/test/java/org/forstdb/MergeCFVariantsTest.java @@ -3,11 +3,11 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; -import static org.rocksdb.MergeTest.longFromByteArray; -import static org.rocksdb.MergeTest.longToByteArray; +import static org.forstdb.MergeTest.longFromByteArray; +import static org.forstdb.MergeTest.longToByteArray; import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; diff --git a/java/src/test/java/org/rocksdb/MergeTest.java b/java/src/test/java/org/forstdb/MergeTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/MergeTest.java rename to java/src/test/java/org/forstdb/MergeTest.java index 10ffeb778..2612027a6 100644 --- a/java/src/test/java/org/rocksdb/MergeTest.java +++ b/java/src/test/java/org/forstdb/MergeTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/MergeVariantsTest.java b/java/src/test/java/org/forstdb/MergeVariantsTest.java similarity index 96% rename from java/src/test/java/org/rocksdb/MergeVariantsTest.java rename to java/src/test/java/org/forstdb/MergeVariantsTest.java index 1acedc1e6..bcf9edc1a 100644 --- a/java/src/test/java/org/rocksdb/MergeVariantsTest.java +++ b/java/src/test/java/org/forstdb/MergeVariantsTest.java @@ -3,11 +3,11 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; -import static org.rocksdb.MergeTest.longFromByteArray; -import static org.rocksdb.MergeTest.longToByteArray; +import static org.forstdb.MergeTest.longFromByteArray; +import static org.forstdb.MergeTest.longToByteArray; import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; diff --git a/java/src/test/java/org/rocksdb/MixedOptionsTest.java b/java/src/test/java/org/forstdb/MixedOptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/MixedOptionsTest.java rename to java/src/test/java/org/forstdb/MixedOptionsTest.java index 4e17d04ef..4a1b40d47 100644 --- a/java/src/test/java/org/rocksdb/MixedOptionsTest.java +++ b/java/src/test/java/org/forstdb/MixedOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/MultiColumnRegressionTest.java b/java/src/test/java/org/forstdb/MultiColumnRegressionTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/MultiColumnRegressionTest.java rename to java/src/test/java/org/forstdb/MultiColumnRegressionTest.java index 6087b0260..7902a4af7 100644 --- a/java/src/test/java/org/rocksdb/MultiColumnRegressionTest.java +++ b/java/src/test/java/org/forstdb/MultiColumnRegressionTest.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/MultiGetManyKeysTest.java b/java/src/test/java/org/forstdb/MultiGetManyKeysTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/MultiGetManyKeysTest.java rename to java/src/test/java/org/forstdb/MultiGetManyKeysTest.java index e66eef622..c65e4fd1d 100644 --- a/java/src/test/java/org/rocksdb/MultiGetManyKeysTest.java +++ b/java/src/test/java/org/forstdb/MultiGetManyKeysTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/MultiGetTest.java b/java/src/test/java/org/forstdb/MultiGetTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/MultiGetTest.java rename to java/src/test/java/org/forstdb/MultiGetTest.java index c391d81f6..809ac8ca2 100644 --- a/java/src/test/java/org/rocksdb/MultiGetTest.java +++ b/java/src/test/java/org/forstdb/MultiGetTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.fail; @@ -15,7 +15,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.util.TestUtil; +import org.forstdb.util.TestUtil; public class MultiGetTest { @ClassRule diff --git a/java/src/test/java/org/rocksdb/MutableColumnFamilyOptionsTest.java b/java/src/test/java/org/forstdb/MutableColumnFamilyOptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/MutableColumnFamilyOptionsTest.java rename to java/src/test/java/org/forstdb/MutableColumnFamilyOptionsTest.java index d858a150d..746c219e7 100644 --- a/java/src/test/java/org/rocksdb/MutableColumnFamilyOptionsTest.java +++ b/java/src/test/java/org/forstdb/MutableColumnFamilyOptionsTest.java @@ -2,10 +2,10 @@ // 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). -package org.rocksdb; +package org.forstdb; import org.junit.Test; -import org.rocksdb.MutableColumnFamilyOptions.MutableColumnFamilyOptionsBuilder; +import org.forstdb.MutableColumnFamilyOptions.MutableColumnFamilyOptionsBuilder; import java.util.NoSuchElementException; diff --git a/java/src/test/java/org/rocksdb/MutableDBOptionsTest.java b/java/src/test/java/org/forstdb/MutableDBOptionsTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/MutableDBOptionsTest.java rename to java/src/test/java/org/forstdb/MutableDBOptionsTest.java index 063a8de38..9298181d3 100644 --- a/java/src/test/java/org/rocksdb/MutableDBOptionsTest.java +++ b/java/src/test/java/org/forstdb/MutableDBOptionsTest.java @@ -2,10 +2,10 @@ // 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). -package org.rocksdb; +package org.forstdb; import org.junit.Test; -import org.rocksdb.MutableDBOptions.MutableDBOptionsBuilder; +import org.forstdb.MutableDBOptions.MutableDBOptionsBuilder; import java.util.NoSuchElementException; diff --git a/java/src/test/java/org/rocksdb/MutableOptionsGetSetTest.java b/java/src/test/java/org/forstdb/MutableOptionsGetSetTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/MutableOptionsGetSetTest.java rename to java/src/test/java/org/forstdb/MutableOptionsGetSetTest.java index 6db940619..4628dd417 100644 --- a/java/src/test/java/org/rocksdb/MutableOptionsGetSetTest.java +++ b/java/src/test/java/org/forstdb/MutableOptionsGetSetTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import static java.nio.charset.StandardCharsets.UTF_8; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/NativeComparatorWrapperTest.java b/java/src/test/java/org/forstdb/NativeComparatorWrapperTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/NativeComparatorWrapperTest.java rename to java/src/test/java/org/forstdb/NativeComparatorWrapperTest.java index 1e0ded816..a5aaac158 100644 --- a/java/src/test/java/org/rocksdb/NativeComparatorWrapperTest.java +++ b/java/src/test/java/org/forstdb/NativeComparatorWrapperTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.junit.Assert.assertEquals; diff --git a/java/src/test/java/org/rocksdb/NativeLibraryLoaderTest.java b/java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java similarity index 95% rename from java/src/test/java/org/rocksdb/NativeLibraryLoaderTest.java rename to java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java index 6b954f67e..4a983ae64 100644 --- a/java/src/test/java/org/rocksdb/NativeLibraryLoaderTest.java +++ b/java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java @@ -2,12 +2,12 @@ // 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). -package org.rocksdb; +package org.forstdb; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.util.Environment; +import org.forstdb.util.Environment; import java.io.File; import java.io.IOException; diff --git a/java/src/test/java/org/rocksdb/OptimisticTransactionDBTest.java b/java/src/test/java/org/forstdb/OptimisticTransactionDBTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/OptimisticTransactionDBTest.java rename to java/src/test/java/org/forstdb/OptimisticTransactionDBTest.java index 519b70b1d..20b5d442c 100644 --- a/java/src/test/java/org/rocksdb/OptimisticTransactionDBTest.java +++ b/java/src/test/java/org/forstdb/OptimisticTransactionDBTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Rule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/OptimisticTransactionOptionsTest.java b/java/src/test/java/org/forstdb/OptimisticTransactionOptionsTest.java similarity index 94% rename from java/src/test/java/org/rocksdb/OptimisticTransactionOptionsTest.java rename to java/src/test/java/org/forstdb/OptimisticTransactionOptionsTest.java index ef656b958..2190dc963 100644 --- a/java/src/test/java/org/rocksdb/OptimisticTransactionOptionsTest.java +++ b/java/src/test/java/org/forstdb/OptimisticTransactionOptionsTest.java @@ -3,10 +3,10 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; -import org.rocksdb.util.BytewiseComparator; +import org.forstdb.util.BytewiseComparator; import java.util.Random; diff --git a/java/src/test/java/org/rocksdb/OptimisticTransactionTest.java b/java/src/test/java/org/forstdb/OptimisticTransactionTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/OptimisticTransactionTest.java rename to java/src/test/java/org/forstdb/OptimisticTransactionTest.java index 4959d207b..c8a5f7997 100644 --- a/java/src/test/java/org/rocksdb/OptimisticTransactionTest.java +++ b/java/src/test/java/org/forstdb/OptimisticTransactionTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static java.nio.charset.StandardCharsets.UTF_8; import static org.assertj.core.api.Assertions.*; diff --git a/java/src/test/java/org/rocksdb/OptionsTest.java b/java/src/test/java/org/forstdb/OptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/OptionsTest.java rename to java/src/test/java/org/forstdb/OptionsTest.java index 4b59464b1..898aefc26 100644 --- a/java/src/test/java/org/rocksdb/OptionsTest.java +++ b/java/src/test/java/org/forstdb/OptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.*; @@ -13,7 +13,7 @@ import java.util.concurrent.atomic.AtomicBoolean; import org.junit.ClassRule; import org.junit.Test; -import org.rocksdb.test.RemoveEmptyValueCompactionFilterFactory; +import org.forstdb.test.RemoveEmptyValueCompactionFilterFactory; public class OptionsTest { diff --git a/java/src/test/java/org/rocksdb/OptionsUtilTest.java b/java/src/test/java/org/forstdb/OptionsUtilTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/OptionsUtilTest.java rename to java/src/test/java/org/forstdb/OptionsUtilTest.java index 23949ac06..f9725efd7 100644 --- a/java/src/test/java/org/rocksdb/OptionsUtilTest.java +++ b/java/src/test/java/org/forstdb/OptionsUtilTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; diff --git a/java/src/test/java/org/rocksdb/PerfContextTest.java b/java/src/test/java/org/forstdb/PerfContextTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/PerfContextTest.java rename to java/src/test/java/org/forstdb/PerfContextTest.java index 3145b59e4..84bf3fa92 100644 --- a/java/src/test/java/org/rocksdb/PerfContextTest.java +++ b/java/src/test/java/org/forstdb/PerfContextTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/PerfLevelTest.java b/java/src/test/java/org/forstdb/PerfLevelTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/PerfLevelTest.java rename to java/src/test/java/org/forstdb/PerfLevelTest.java index bb766cbd4..d3c8d6cc0 100644 --- a/java/src/test/java/org/rocksdb/PerfLevelTest.java +++ b/java/src/test/java/org/forstdb/PerfLevelTest.java @@ -3,11 +3,11 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.rocksdb.PerfLevel.*; +import static org.forstdb.PerfLevel.*; import java.util.ArrayList; import java.util.Arrays; diff --git a/java/src/test/java/org/rocksdb/PlainTableConfigTest.java b/java/src/test/java/org/forstdb/PlainTableConfigTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/PlainTableConfigTest.java rename to java/src/test/java/org/forstdb/PlainTableConfigTest.java index 827eb79f9..dca2c4777 100644 --- a/java/src/test/java/org/rocksdb/PlainTableConfigTest.java +++ b/java/src/test/java/org/forstdb/PlainTableConfigTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/PlatformRandomHelper.java b/java/src/test/java/org/forstdb/PlatformRandomHelper.java similarity index 98% rename from java/src/test/java/org/rocksdb/PlatformRandomHelper.java rename to java/src/test/java/org/forstdb/PlatformRandomHelper.java index 80ea4d197..ca1dbe7b7 100644 --- a/java/src/test/java/org/rocksdb/PlatformRandomHelper.java +++ b/java/src/test/java/org/forstdb/PlatformRandomHelper.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Random; diff --git a/java/src/test/java/org/rocksdb/PutCFVariantsTest.java b/java/src/test/java/org/forstdb/PutCFVariantsTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/PutCFVariantsTest.java rename to java/src/test/java/org/forstdb/PutCFVariantsTest.java index 977c74dc8..a76dd975f 100644 --- a/java/src/test/java/org/rocksdb/PutCFVariantsTest.java +++ b/java/src/test/java/org/forstdb/PutCFVariantsTest.java @@ -3,11 +3,11 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; -import static org.rocksdb.MergeTest.longFromByteArray; -import static org.rocksdb.MergeTest.longToByteArray; +import static org.forstdb.MergeTest.longFromByteArray; +import static org.forstdb.MergeTest.longToByteArray; import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; diff --git a/java/src/test/java/org/rocksdb/PutMultiplePartsTest.java b/java/src/test/java/org/forstdb/PutMultiplePartsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/PutMultiplePartsTest.java rename to java/src/test/java/org/forstdb/PutMultiplePartsTest.java index 7835737ae..4846c2537 100644 --- a/java/src/test/java/org/rocksdb/PutMultiplePartsTest.java +++ b/java/src/test/java/org/forstdb/PutMultiplePartsTest.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/PutVariantsTest.java b/java/src/test/java/org/forstdb/PutVariantsTest.java similarity index 96% rename from java/src/test/java/org/rocksdb/PutVariantsTest.java rename to java/src/test/java/org/forstdb/PutVariantsTest.java index 2e0e9b9e3..ce6bbeeda 100644 --- a/java/src/test/java/org/rocksdb/PutVariantsTest.java +++ b/java/src/test/java/org/forstdb/PutVariantsTest.java @@ -3,11 +3,11 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; -import static org.rocksdb.MergeTest.longFromByteArray; -import static org.rocksdb.MergeTest.longToByteArray; +import static org.forstdb.MergeTest.longFromByteArray; +import static org.forstdb.MergeTest.longToByteArray; import java.nio.ByteBuffer; import java.nio.charset.Charset; diff --git a/java/src/test/java/org/rocksdb/RateLimiterTest.java b/java/src/test/java/org/forstdb/RateLimiterTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/RateLimiterTest.java rename to java/src/test/java/org/forstdb/RateLimiterTest.java index e7d6e6c49..5e834bcc0 100644 --- a/java/src/test/java/org/rocksdb/RateLimiterTest.java +++ b/java/src/test/java/org/forstdb/RateLimiterTest.java @@ -2,13 +2,13 @@ // 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). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; import static org.assertj.core.api.Assertions.assertThat; -import static org.rocksdb.RateLimiter.*; +import static org.forstdb.RateLimiter.*; public class RateLimiterTest { diff --git a/java/src/test/java/org/rocksdb/ReadOnlyTest.java b/java/src/test/java/org/forstdb/ReadOnlyTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/ReadOnlyTest.java rename to java/src/test/java/org/forstdb/ReadOnlyTest.java index 99549b61b..573e8307b 100644 --- a/java/src/test/java/org/rocksdb/ReadOnlyTest.java +++ b/java/src/test/java/org/forstdb/ReadOnlyTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/ReadOptionsTest.java b/java/src/test/java/org/forstdb/ReadOptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/ReadOptionsTest.java rename to java/src/test/java/org/forstdb/ReadOptionsTest.java index 1bc24b984..f7f6125d9 100644 --- a/java/src/test/java/org/rocksdb/ReadOptionsTest.java +++ b/java/src/test/java/org/forstdb/ReadOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Arrays; import java.util.Random; diff --git a/java/src/test/java/org/rocksdb/RocksDBExceptionTest.java b/java/src/test/java/org/forstdb/RocksDBExceptionTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/RocksDBExceptionTest.java rename to java/src/test/java/org/forstdb/RocksDBExceptionTest.java index d3bd4ece7..8fb9285d2 100644 --- a/java/src/test/java/org/rocksdb/RocksDBExceptionTest.java +++ b/java/src/test/java/org/forstdb/RocksDBExceptionTest.java @@ -3,12 +3,12 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; -import org.rocksdb.Status.Code; -import org.rocksdb.Status.SubCode; +import org.forstdb.Status.Code; +import org.forstdb.Status.SubCode; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; diff --git a/java/src/test/java/org/rocksdb/RocksDBTest.java b/java/src/test/java/org/forstdb/RocksDBTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/RocksDBTest.java rename to java/src/test/java/org/forstdb/RocksDBTest.java index 74e523c49..b5e6a1eb4 100644 --- a/java/src/test/java/org/rocksdb/RocksDBTest.java +++ b/java/src/test/java/org/forstdb/RocksDBTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import org.junit.*; import org.junit.rules.ExpectedException; diff --git a/java/src/test/java/org/rocksdb/RocksIteratorTest.java b/java/src/test/java/org/forstdb/RocksIteratorTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/RocksIteratorTest.java rename to java/src/test/java/org/forstdb/RocksIteratorTest.java index 90c635f58..34eb5e779 100644 --- a/java/src/test/java/org/rocksdb/RocksIteratorTest.java +++ b/java/src/test/java/org/forstdb/RocksIteratorTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; diff --git a/java/src/test/java/org/rocksdb/RocksMemEnvTest.java b/java/src/test/java/org/forstdb/RocksMemEnvTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/RocksMemEnvTest.java rename to java/src/test/java/org/forstdb/RocksMemEnvTest.java index 40b24ffa3..5f77ce3e3 100644 --- a/java/src/test/java/org/rocksdb/RocksMemEnvTest.java +++ b/java/src/test/java/org/forstdb/RocksMemEnvTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/RocksNativeLibraryResource.java b/java/src/test/java/org/forstdb/RocksNativeLibraryResource.java similarity index 95% rename from java/src/test/java/org/rocksdb/RocksNativeLibraryResource.java rename to java/src/test/java/org/forstdb/RocksNativeLibraryResource.java index 6116f2f92..7f85047ac 100644 --- a/java/src/test/java/org/rocksdb/RocksNativeLibraryResource.java +++ b/java/src/test/java/org/forstdb/RocksNativeLibraryResource.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.rules.ExternalResource; diff --git a/java/src/test/java/org/rocksdb/SecondaryDBTest.java b/java/src/test/java/org/forstdb/SecondaryDBTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/SecondaryDBTest.java rename to java/src/test/java/org/forstdb/SecondaryDBTest.java index 557d4a47d..99a76afbd 100644 --- a/java/src/test/java/org/rocksdb/SecondaryDBTest.java +++ b/java/src/test/java/org/forstdb/SecondaryDBTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/SliceTest.java b/java/src/test/java/org/forstdb/SliceTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/SliceTest.java rename to java/src/test/java/org/forstdb/SliceTest.java index c65b01903..ec83cd419 100644 --- a/java/src/test/java/org/rocksdb/SliceTest.java +++ b/java/src/test/java/org/forstdb/SliceTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/SnapshotTest.java b/java/src/test/java/org/forstdb/SnapshotTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/SnapshotTest.java rename to java/src/test/java/org/forstdb/SnapshotTest.java index 11f0d560a..b6f37ac55 100644 --- a/java/src/test/java/org/rocksdb/SnapshotTest.java +++ b/java/src/test/java/org/forstdb/SnapshotTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; diff --git a/java/src/test/java/org/rocksdb/SstFileManagerTest.java b/java/src/test/java/org/forstdb/SstFileManagerTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/SstFileManagerTest.java rename to java/src/test/java/org/forstdb/SstFileManagerTest.java index 2e136e820..e1976134e 100644 --- a/java/src/test/java/org/rocksdb/SstFileManagerTest.java +++ b/java/src/test/java/org/forstdb/SstFileManagerTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/SstFileReaderTest.java b/java/src/test/java/org/forstdb/SstFileReaderTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/SstFileReaderTest.java rename to java/src/test/java/org/forstdb/SstFileReaderTest.java index ef74b08a7..959558ffe 100644 --- a/java/src/test/java/org/rocksdb/SstFileReaderTest.java +++ b/java/src/test/java/org/forstdb/SstFileReaderTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertEquals; @@ -20,7 +20,7 @@ import org.junit.rules.TemporaryFolder; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; -import org.rocksdb.util.ByteBufferAllocator; +import org.forstdb.util.ByteBufferAllocator; @RunWith(Parameterized.class) public class SstFileReaderTest { diff --git a/java/src/test/java/org/rocksdb/SstFileWriterTest.java b/java/src/test/java/org/forstdb/SstFileWriterTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/SstFileWriterTest.java rename to java/src/test/java/org/forstdb/SstFileWriterTest.java index c0f4ed9f1..7e686eb35 100644 --- a/java/src/test/java/org/rocksdb/SstFileWriterTest.java +++ b/java/src/test/java/org/forstdb/SstFileWriterTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; @@ -18,7 +18,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.util.BytewiseComparator; +import org.forstdb.util.BytewiseComparator; public class SstFileWriterTest { private static final String SST_FILE_NAME = "test.sst"; diff --git a/java/src/test/java/org/rocksdb/SstPartitionerTest.java b/java/src/test/java/org/forstdb/SstPartitionerTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/SstPartitionerTest.java rename to java/src/test/java/org/forstdb/SstPartitionerTest.java index 3ee739053..48b225d32 100644 --- a/java/src/test/java/org/rocksdb/SstPartitionerTest.java +++ b/java/src/test/java/org/forstdb/SstPartitionerTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static java.nio.charset.StandardCharsets.UTF_8; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/StatisticsCollectorTest.java b/java/src/test/java/org/forstdb/StatisticsCollectorTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/StatisticsCollectorTest.java rename to java/src/test/java/org/forstdb/StatisticsCollectorTest.java index 36721c80d..20436b687 100644 --- a/java/src/test/java/org/rocksdb/StatisticsCollectorTest.java +++ b/java/src/test/java/org/forstdb/StatisticsCollectorTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Collections; diff --git a/java/src/test/java/org/rocksdb/StatisticsTest.java b/java/src/test/java/org/forstdb/StatisticsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/StatisticsTest.java rename to java/src/test/java/org/forstdb/StatisticsTest.java index 269cc56a0..3e83fae2c 100644 --- a/java/src/test/java/org/rocksdb/StatisticsTest.java +++ b/java/src/test/java/org/forstdb/StatisticsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/StatsCallbackMock.java b/java/src/test/java/org/forstdb/StatsCallbackMock.java similarity index 96% rename from java/src/test/java/org/rocksdb/StatsCallbackMock.java rename to java/src/test/java/org/forstdb/StatsCallbackMock.java index c6a7294c9..24cafd018 100644 --- a/java/src/test/java/org/rocksdb/StatsCallbackMock.java +++ b/java/src/test/java/org/forstdb/StatsCallbackMock.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; public class StatsCallbackMock implements StatisticsCollectorCallback { public int tickerCallbackCount = 0; diff --git a/java/src/test/java/org/rocksdb/TableFilterTest.java b/java/src/test/java/org/forstdb/TableFilterTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/TableFilterTest.java rename to java/src/test/java/org/forstdb/TableFilterTest.java index 2bd3b1798..c9604f823 100644 --- a/java/src/test/java/org/rocksdb/TableFilterTest.java +++ b/java/src/test/java/org/forstdb/TableFilterTest.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; import org.junit.Rule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/TimedEnvTest.java b/java/src/test/java/org/forstdb/TimedEnvTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/TimedEnvTest.java rename to java/src/test/java/org/forstdb/TimedEnvTest.java index 31bad2e2e..3134a131a 100644 --- a/java/src/test/java/org/rocksdb/TimedEnvTest.java +++ b/java/src/test/java/org/forstdb/TimedEnvTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; diff --git a/java/src/test/java/org/rocksdb/TransactionDBOptionsTest.java b/java/src/test/java/org/forstdb/TransactionDBOptionsTest.java similarity index 98% rename from java/src/test/java/org/rocksdb/TransactionDBOptionsTest.java rename to java/src/test/java/org/forstdb/TransactionDBOptionsTest.java index 7eaa6b16c..303da19ec 100644 --- a/java/src/test/java/org/rocksdb/TransactionDBOptionsTest.java +++ b/java/src/test/java/org/forstdb/TransactionDBOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/TransactionDBTest.java b/java/src/test/java/org/forstdb/TransactionDBTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/TransactionDBTest.java rename to java/src/test/java/org/forstdb/TransactionDBTest.java index 56acb21c7..4e0e3848b 100644 --- a/java/src/test/java/org/rocksdb/TransactionDBTest.java +++ b/java/src/test/java/org/forstdb/TransactionDBTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Rule; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/TransactionLogIteratorTest.java b/java/src/test/java/org/forstdb/TransactionLogIteratorTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/TransactionLogIteratorTest.java rename to java/src/test/java/org/forstdb/TransactionLogIteratorTest.java index 3c4dff7bb..fd96c34ed 100644 --- a/java/src/test/java/org/rocksdb/TransactionLogIteratorTest.java +++ b/java/src/test/java/org/forstdb/TransactionLogIteratorTest.java @@ -1,5 +1,5 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; diff --git a/java/src/test/java/org/rocksdb/TransactionOptionsTest.java b/java/src/test/java/org/forstdb/TransactionOptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/TransactionOptionsTest.java rename to java/src/test/java/org/forstdb/TransactionOptionsTest.java index add0439e0..1b8ccae54 100644 --- a/java/src/test/java/org/rocksdb/TransactionOptionsTest.java +++ b/java/src/test/java/org/forstdb/TransactionOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/TransactionTest.java b/java/src/test/java/org/forstdb/TransactionTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/TransactionTest.java rename to java/src/test/java/org/forstdb/TransactionTest.java index 03a6b4ff6..9f239788a 100644 --- a/java/src/test/java/org/rocksdb/TransactionTest.java +++ b/java/src/test/java/org/forstdb/TransactionTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/TtlDBTest.java b/java/src/test/java/org/forstdb/TtlDBTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/TtlDBTest.java rename to java/src/test/java/org/forstdb/TtlDBTest.java index ebf9e9eaa..6457a5e62 100644 --- a/java/src/test/java/org/rocksdb/TtlDBTest.java +++ b/java/src/test/java/org/forstdb/TtlDBTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; diff --git a/java/src/test/java/org/rocksdb/Types.java b/java/src/test/java/org/forstdb/Types.java similarity index 97% rename from java/src/test/java/org/rocksdb/Types.java rename to java/src/test/java/org/forstdb/Types.java index a6abdecbc..d9a0171c5 100644 --- a/java/src/test/java/org/rocksdb/Types.java +++ b/java/src/test/java/org/forstdb/Types.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; /** * Simple type conversion methods diff --git a/java/src/test/java/org/rocksdb/VerifyChecksumsTest.java b/java/src/test/java/org/forstdb/VerifyChecksumsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/VerifyChecksumsTest.java rename to java/src/test/java/org/forstdb/VerifyChecksumsTest.java index ddc2a456f..fbdffca29 100644 --- a/java/src/test/java/org/rocksdb/VerifyChecksumsTest.java +++ b/java/src/test/java/org/forstdb/VerifyChecksumsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/WALRecoveryModeTest.java b/java/src/test/java/org/forstdb/WALRecoveryModeTest.java similarity index 96% rename from java/src/test/java/org/rocksdb/WALRecoveryModeTest.java rename to java/src/test/java/org/forstdb/WALRecoveryModeTest.java index 2a0133f6b..08ee946a9 100644 --- a/java/src/test/java/org/rocksdb/WALRecoveryModeTest.java +++ b/java/src/test/java/org/forstdb/WALRecoveryModeTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/WalFilterTest.java b/java/src/test/java/org/forstdb/WalFilterTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/WalFilterTest.java rename to java/src/test/java/org/forstdb/WalFilterTest.java index 08bc6eef5..5792b60f8 100644 --- a/java/src/test/java/org/rocksdb/WalFilterTest.java +++ b/java/src/test/java/org/forstdb/WalFilterTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import org.junit.ClassRule; import org.junit.Rule; @@ -16,8 +16,8 @@ import java.util.Map; import static org.assertj.core.api.Assertions.assertThat; -import static org.rocksdb.util.ByteUtil.bytes; -import static org.rocksdb.util.TestUtil.*; +import static org.forstdb.util.ByteUtil.bytes; +import static org.forstdb.util.TestUtil.*; public class WalFilterTest { diff --git a/java/src/test/java/org/rocksdb/WriteBatchHandlerTest.java b/java/src/test/java/org/forstdb/WriteBatchHandlerTest.java similarity index 91% rename from java/src/test/java/org/rocksdb/WriteBatchHandlerTest.java rename to java/src/test/java/org/forstdb/WriteBatchHandlerTest.java index 2826b128f..6b101f980 100644 --- a/java/src/test/java/org/rocksdb/WriteBatchHandlerTest.java +++ b/java/src/test/java/org/forstdb/WriteBatchHandlerTest.java @@ -3,18 +3,18 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import java.util.Arrays; import java.util.List; import org.junit.ClassRule; import org.junit.Test; -import org.rocksdb.util.CapturingWriteBatchHandler; -import org.rocksdb.util.CapturingWriteBatchHandler.Event; +import org.forstdb.util.CapturingWriteBatchHandler; +import org.forstdb.util.CapturingWriteBatchHandler.Event; import static org.assertj.core.api.Assertions.assertThat; -import static org.rocksdb.util.CapturingWriteBatchHandler.Action.*; +import static org.forstdb.util.CapturingWriteBatchHandler.Action.*; public class WriteBatchHandlerTest { diff --git a/java/src/test/java/org/rocksdb/WriteBatchTest.java b/java/src/test/java/org/forstdb/WriteBatchTest.java similarity index 96% rename from java/src/test/java/org/rocksdb/WriteBatchTest.java rename to java/src/test/java/org/forstdb/WriteBatchTest.java index cc3ad26eb..d36944d05 100644 --- a/java/src/test/java/org/rocksdb/WriteBatchTest.java +++ b/java/src/test/java/org/forstdb/WriteBatchTest.java @@ -6,16 +6,16 @@ // Copyright (c) 2011 The LevelDB Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. See the AUTHORS file for names of contributors. -package org.rocksdb; +package org.forstdb; import static java.nio.charset.StandardCharsets.UTF_8; import static org.assertj.core.api.Assertions.assertThat; -import static org.rocksdb.util.CapturingWriteBatchHandler.Action.DELETE; -import static org.rocksdb.util.CapturingWriteBatchHandler.Action.DELETE_RANGE; -import static org.rocksdb.util.CapturingWriteBatchHandler.Action.LOG; -import static org.rocksdb.util.CapturingWriteBatchHandler.Action.MERGE; -import static org.rocksdb.util.CapturingWriteBatchHandler.Action.PUT; -import static org.rocksdb.util.CapturingWriteBatchHandler.Action.SINGLE_DELETE; +import static org.forstdb.util.CapturingWriteBatchHandler.Action.DELETE; +import static org.forstdb.util.CapturingWriteBatchHandler.Action.DELETE_RANGE; +import static org.forstdb.util.CapturingWriteBatchHandler.Action.LOG; +import static org.forstdb.util.CapturingWriteBatchHandler.Action.MERGE; +import static org.forstdb.util.CapturingWriteBatchHandler.Action.PUT; +import static org.forstdb.util.CapturingWriteBatchHandler.Action.SINGLE_DELETE; import java.io.UnsupportedEncodingException; import java.nio.ByteBuffer; @@ -23,9 +23,9 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.util.CapturingWriteBatchHandler; -import org.rocksdb.util.CapturingWriteBatchHandler.Event; -import org.rocksdb.util.WriteBatchGetter; +import org.forstdb.util.CapturingWriteBatchHandler; +import org.forstdb.util.CapturingWriteBatchHandler.Event; +import org.forstdb.util.WriteBatchGetter; /** * This class mimics the db/write_batch_test.cc diff --git a/java/src/test/java/org/rocksdb/WriteBatchThreadedTest.java b/java/src/test/java/org/forstdb/WriteBatchThreadedTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/WriteBatchThreadedTest.java rename to java/src/test/java/org/forstdb/WriteBatchThreadedTest.java index 0321da3fa..ce76c69ae 100644 --- a/java/src/test/java/org/rocksdb/WriteBatchThreadedTest.java +++ b/java/src/test/java/org/forstdb/WriteBatchThreadedTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb; +package org.forstdb; import org.junit.After; import org.junit.Before; diff --git a/java/src/test/java/org/rocksdb/WriteBatchWithIndexTest.java b/java/src/test/java/org/forstdb/WriteBatchWithIndexTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/WriteBatchWithIndexTest.java rename to java/src/test/java/org/forstdb/WriteBatchWithIndexTest.java index b0a0cdc0e..3a6ccf0e9 100644 --- a/java/src/test/java/org/rocksdb/WriteBatchWithIndexTest.java +++ b/java/src/test/java/org/forstdb/WriteBatchWithIndexTest.java @@ -7,7 +7,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. See the AUTHORS file for names of contributors. -package org.rocksdb; +package org.forstdb; import static java.nio.charset.StandardCharsets.UTF_8; import static org.assertj.core.api.Assertions.assertThat; @@ -20,7 +20,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.util.ByteBufferAllocator; +import org.forstdb.util.ByteBufferAllocator; public class WriteBatchWithIndexTest { diff --git a/java/src/test/java/org/rocksdb/WriteOptionsTest.java b/java/src/test/java/org/forstdb/WriteOptionsTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/WriteOptionsTest.java rename to java/src/test/java/org/forstdb/WriteOptionsTest.java index 1e1c93fb5..b4092e17a 100644 --- a/java/src/test/java/org/rocksdb/WriteOptionsTest.java +++ b/java/src/test/java/org/forstdb/WriteOptionsTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb; +package org.forstdb; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/flink/FlinkEnvTest.java b/java/src/test/java/org/forstdb/flink/FlinkEnvTest.java similarity index 92% rename from java/src/test/java/org/rocksdb/flink/FlinkEnvTest.java rename to java/src/test/java/org/forstdb/flink/FlinkEnvTest.java index 5c7166557..805755637 100644 --- a/java/src/test/java/org/rocksdb/flink/FlinkEnvTest.java +++ b/java/src/test/java/org/forstdb/flink/FlinkEnvTest.java @@ -16,14 +16,14 @@ * limitations under the License. */ -package org.rocksdb.flink; +package org.forstdb.flink; import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.EnvFlinkTestSuite; -import org.rocksdb.RocksNativeLibraryResource; +import org.forstdb.EnvFlinkTestSuite; +import org.forstdb.RocksNativeLibraryResource; /** * Unit test for env/flink/env_flink.cc. diff --git a/java/src/test/java/org/rocksdb/test/RemoveEmptyValueCompactionFilterFactory.java b/java/src/test/java/org/forstdb/test/RemoveEmptyValueCompactionFilterFactory.java similarity index 77% rename from java/src/test/java/org/rocksdb/test/RemoveEmptyValueCompactionFilterFactory.java rename to java/src/test/java/org/forstdb/test/RemoveEmptyValueCompactionFilterFactory.java index c4e4f25a0..b93346f8a 100644 --- a/java/src/test/java/org/rocksdb/test/RemoveEmptyValueCompactionFilterFactory.java +++ b/java/src/test/java/org/forstdb/test/RemoveEmptyValueCompactionFilterFactory.java @@ -1,9 +1,9 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb.test; +package org.forstdb.test; -import org.rocksdb.AbstractCompactionFilter; -import org.rocksdb.AbstractCompactionFilterFactory; -import org.rocksdb.RemoveEmptyValueCompactionFilter; +import org.forstdb.AbstractCompactionFilter; +import org.forstdb.AbstractCompactionFilterFactory; +import org.forstdb.RemoveEmptyValueCompactionFilter; /** * Simple CompactionFilterFactory class used in tests. Generates RemoveEmptyValueCompactionFilters. diff --git a/java/src/test/java/org/rocksdb/test/RocksJunitRunner.java b/java/src/test/java/org/forstdb/test/RocksJunitRunner.java similarity index 97% rename from java/src/test/java/org/rocksdb/test/RocksJunitRunner.java rename to java/src/test/java/org/forstdb/test/RocksJunitRunner.java index 42d3148ef..81f9cb3a6 100644 --- a/java/src/test/java/org/rocksdb/test/RocksJunitRunner.java +++ b/java/src/test/java/org/forstdb/test/RocksJunitRunner.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb.test; +package org.forstdb.test; import org.junit.internal.JUnitSystem; import org.junit.internal.RealSystem; @@ -11,7 +11,7 @@ import org.junit.runner.JUnitCore; import org.junit.runner.Result; import org.junit.runner.notification.Failure; -import org.rocksdb.RocksDB; +import org.forstdb.RocksDB; import java.io.PrintStream; import java.text.DecimalFormat; @@ -19,7 +19,7 @@ import java.util.ArrayList; import java.util.List; -import static org.rocksdb.test.RocksJunitRunner.RocksJunitListener.Status.*; +import static org.forstdb.test.RocksJunitRunner.RocksJunitListener.Status.*; /** * Custom Junit Runner to print also Test classes diff --git a/java/src/test/java/org/rocksdb/test/TestableEventListener.java b/java/src/test/java/org/forstdb/test/TestableEventListener.java similarity index 90% rename from java/src/test/java/org/rocksdb/test/TestableEventListener.java rename to java/src/test/java/org/forstdb/test/TestableEventListener.java index 865ad5cf7..8aecc4688 100644 --- a/java/src/test/java/org/rocksdb/test/TestableEventListener.java +++ b/java/src/test/java/org/forstdb/test/TestableEventListener.java @@ -2,9 +2,9 @@ // 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). -package org.rocksdb.test; +package org.forstdb.test; -import org.rocksdb.AbstractEventListener; +import org.forstdb.AbstractEventListener; public class TestableEventListener extends AbstractEventListener { public TestableEventListener() { diff --git a/java/src/test/java/org/rocksdb/util/ByteBufferAllocator.java b/java/src/test/java/org/forstdb/util/ByteBufferAllocator.java similarity index 94% rename from java/src/test/java/org/rocksdb/util/ByteBufferAllocator.java rename to java/src/test/java/org/forstdb/util/ByteBufferAllocator.java index 8d7956cf2..d8967a4fe 100644 --- a/java/src/test/java/org/rocksdb/util/ByteBufferAllocator.java +++ b/java/src/test/java/org/forstdb/util/ByteBufferAllocator.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; import java.nio.ByteBuffer; diff --git a/java/src/test/java/org/rocksdb/util/BytewiseComparatorIntTest.java b/java/src/test/java/org/forstdb/util/BytewiseComparatorIntTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/util/BytewiseComparatorIntTest.java rename to java/src/test/java/org/forstdb/util/BytewiseComparatorIntTest.java index fb7239c92..a5bcd1ff4 100644 --- a/java/src/test/java/org/rocksdb/util/BytewiseComparatorIntTest.java +++ b/java/src/test/java/org/forstdb/util/BytewiseComparatorIntTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; import org.junit.BeforeClass; import org.junit.ClassRule; @@ -14,7 +14,7 @@ import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameter; import org.junit.runners.Parameterized.Parameters; -import org.rocksdb.*; +import org.forstdb.*; import java.nio.ByteBuffer; import java.nio.file.FileSystems; diff --git a/java/src/test/java/org/rocksdb/util/BytewiseComparatorTest.java b/java/src/test/java/org/forstdb/util/BytewiseComparatorTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/util/BytewiseComparatorTest.java rename to java/src/test/java/org/forstdb/util/BytewiseComparatorTest.java index 69f2c282b..6f84e1bcc 100644 --- a/java/src/test/java/org/rocksdb/util/BytewiseComparatorTest.java +++ b/java/src/test/java/org/forstdb/util/BytewiseComparatorTest.java @@ -3,13 +3,13 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.rocksdb.*; +import org.forstdb.*; import java.io.IOException; import java.nio.ByteBuffer; @@ -18,7 +18,7 @@ import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.*; -import static org.rocksdb.util.ByteUtil.bytes; +import static org.forstdb.util.ByteUtil.bytes; /** * This is a direct port of various C++ diff --git a/java/src/test/java/org/rocksdb/util/CapturingWriteBatchHandler.java b/java/src/test/java/org/forstdb/util/CapturingWriteBatchHandler.java similarity index 98% rename from java/src/test/java/org/rocksdb/util/CapturingWriteBatchHandler.java rename to java/src/test/java/org/forstdb/util/CapturingWriteBatchHandler.java index 8ea104332..29f39ab88 100644 --- a/java/src/test/java/org/rocksdb/util/CapturingWriteBatchHandler.java +++ b/java/src/test/java/org/forstdb/util/CapturingWriteBatchHandler.java @@ -1,8 +1,8 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb.util; +package org.forstdb.util; -import org.rocksdb.RocksDBException; -import org.rocksdb.WriteBatch; +import org.forstdb.RocksDBException; +import org.forstdb.WriteBatch; import java.util.ArrayList; import java.util.Arrays; diff --git a/java/src/test/java/org/rocksdb/util/DirectByteBufferAllocator.java b/java/src/test/java/org/forstdb/util/DirectByteBufferAllocator.java similarity index 95% rename from java/src/test/java/org/rocksdb/util/DirectByteBufferAllocator.java rename to java/src/test/java/org/forstdb/util/DirectByteBufferAllocator.java index d26fb578b..b5ac81b26 100644 --- a/java/src/test/java/org/rocksdb/util/DirectByteBufferAllocator.java +++ b/java/src/test/java/org/forstdb/util/DirectByteBufferAllocator.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; import java.nio.ByteBuffer; diff --git a/java/src/test/java/org/rocksdb/util/EnvironmentTest.java b/java/src/test/java/org/forstdb/util/EnvironmentTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/util/EnvironmentTest.java rename to java/src/test/java/org/forstdb/util/EnvironmentTest.java index 5e5369217..dfb150d69 100644 --- a/java/src/test/java/org/rocksdb/util/EnvironmentTest.java +++ b/java/src/test/java/org/forstdb/util/EnvironmentTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb.util; +package org.forstdb.util; import static org.assertj.core.api.Assertions.assertThat; diff --git a/java/src/test/java/org/rocksdb/util/HeapByteBufferAllocator.java b/java/src/test/java/org/forstdb/util/HeapByteBufferAllocator.java similarity index 95% rename from java/src/test/java/org/rocksdb/util/HeapByteBufferAllocator.java rename to java/src/test/java/org/forstdb/util/HeapByteBufferAllocator.java index ad6b8f6f4..46da1826b 100644 --- a/java/src/test/java/org/rocksdb/util/HeapByteBufferAllocator.java +++ b/java/src/test/java/org/forstdb/util/HeapByteBufferAllocator.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; import java.nio.ByteBuffer; diff --git a/java/src/test/java/org/rocksdb/util/IntComparatorTest.java b/java/src/test/java/org/forstdb/util/IntComparatorTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/util/IntComparatorTest.java rename to java/src/test/java/org/forstdb/util/IntComparatorTest.java index dd3288513..f9c4e746d 100644 --- a/java/src/test/java/org/rocksdb/util/IntComparatorTest.java +++ b/java/src/test/java/org/forstdb/util/IntComparatorTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; import org.junit.BeforeClass; import org.junit.ClassRule; @@ -14,7 +14,7 @@ import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameter; import org.junit.runners.Parameterized.Parameters; -import org.rocksdb.*; +import org.forstdb.*; import java.nio.ByteBuffer; import java.nio.file.*; diff --git a/java/src/test/java/org/rocksdb/util/JNIComparatorTest.java b/java/src/test/java/org/forstdb/util/JNIComparatorTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/util/JNIComparatorTest.java rename to java/src/test/java/org/forstdb/util/JNIComparatorTest.java index a962b8d78..78e13f5fd 100644 --- a/java/src/test/java/org/rocksdb/util/JNIComparatorTest.java +++ b/java/src/test/java/org/forstdb/util/JNIComparatorTest.java @@ -4,7 +4,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; import org.junit.ClassRule; import org.junit.Rule; @@ -14,7 +14,7 @@ import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameter; import org.junit.runners.Parameterized.Parameters; -import org.rocksdb.*; +import org.forstdb.*; import java.io.IOException; import java.nio.ByteBuffer; diff --git a/java/src/test/java/org/rocksdb/util/ReverseBytewiseComparatorIntTest.java b/java/src/test/java/org/forstdb/util/ReverseBytewiseComparatorIntTest.java similarity index 99% rename from java/src/test/java/org/rocksdb/util/ReverseBytewiseComparatorIntTest.java rename to java/src/test/java/org/forstdb/util/ReverseBytewiseComparatorIntTest.java index ca08d9de1..ebf98d11b 100644 --- a/java/src/test/java/org/rocksdb/util/ReverseBytewiseComparatorIntTest.java +++ b/java/src/test/java/org/forstdb/util/ReverseBytewiseComparatorIntTest.java @@ -3,7 +3,7 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; import org.junit.BeforeClass; import org.junit.ClassRule; @@ -14,7 +14,7 @@ import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameter; import org.junit.runners.Parameterized.Parameters; -import org.rocksdb.*; +import org.forstdb.*; import java.nio.ByteBuffer; import java.nio.file.FileSystems; diff --git a/java/src/test/java/org/rocksdb/util/SizeUnitTest.java b/java/src/test/java/org/forstdb/util/SizeUnitTest.java similarity index 97% rename from java/src/test/java/org/rocksdb/util/SizeUnitTest.java rename to java/src/test/java/org/forstdb/util/SizeUnitTest.java index 990aa5f47..190e445d6 100644 --- a/java/src/test/java/org/rocksdb/util/SizeUnitTest.java +++ b/java/src/test/java/org/forstdb/util/SizeUnitTest.java @@ -2,7 +2,7 @@ // 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). -package org.rocksdb.util; +package org.forstdb.util; import org.junit.Test; diff --git a/java/src/test/java/org/rocksdb/util/TestUtil.java b/java/src/test/java/org/forstdb/util/TestUtil.java similarity index 93% rename from java/src/test/java/org/rocksdb/util/TestUtil.java rename to java/src/test/java/org/forstdb/util/TestUtil.java index e4f490c8e..a84d97b92 100644 --- a/java/src/test/java/org/rocksdb/util/TestUtil.java +++ b/java/src/test/java/org/forstdb/util/TestUtil.java @@ -3,15 +3,15 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -package org.rocksdb.util; +package org.forstdb.util; import static java.nio.charset.StandardCharsets.UTF_8; import java.nio.ByteBuffer; import java.util.Random; -import org.rocksdb.CompactionPriority; -import org.rocksdb.Options; -import org.rocksdb.WALRecoveryMode; +import org.forstdb.CompactionPriority; +import org.forstdb.Options; +import org.forstdb.WALRecoveryMode; /** * General test utilities. diff --git a/java/src/test/java/org/rocksdb/util/WriteBatchGetter.java b/java/src/test/java/org/forstdb/util/WriteBatchGetter.java similarity index 97% rename from java/src/test/java/org/rocksdb/util/WriteBatchGetter.java rename to java/src/test/java/org/forstdb/util/WriteBatchGetter.java index 2efa16473..3230eed62 100644 --- a/java/src/test/java/org/rocksdb/util/WriteBatchGetter.java +++ b/java/src/test/java/org/forstdb/util/WriteBatchGetter.java @@ -1,8 +1,8 @@ // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -package org.rocksdb.util; +package org.forstdb.util; -import org.rocksdb.RocksDBException; -import org.rocksdb.WriteBatch; +import org.forstdb.RocksDBException; +import org.forstdb.WriteBatch; import java.util.Arrays; diff --git a/logging/auto_roll_logger.cc b/logging/auto_roll_logger.cc index 9e9ad45ae..595e0d246 100644 --- a/logging/auto_roll_logger.cc +++ b/logging/auto_roll_logger.cc @@ -280,7 +280,7 @@ Status CreateLoggerFromOptions(const std::string& dbname, Env* env = options.env; std::string db_absolute_path; Status s = env->GetAbsolutePath(dbname, &db_absolute_path); - TEST_SYNC_POINT_CALLBACK("rocksdb::CreateLoggerFromOptions:AfterGetPath", &s); + TEST_SYNC_POINT_CALLBACK("forstdb::CreateLoggerFromOptions:AfterGetPath", &s); if (!s.ok()) { return s; } diff --git a/src.mk b/src.mk index e168fcd3e..1f596f12d 100644 --- a/src.mk +++ b/src.mk @@ -649,88 +649,88 @@ MICROBENCH_SOURCES = \ microbench/db_basic_bench.cc \ JNI_NATIVE_SOURCES = \ - java/rocksjni/backupenginejni.cc \ - java/rocksjni/backup_engine_options.cc \ - java/rocksjni/checkpoint.cc \ - java/rocksjni/clock_cache.cc \ - java/rocksjni/cache.cc \ - java/rocksjni/columnfamilyhandle.cc \ - java/rocksjni/compact_range_options.cc \ - java/rocksjni/compaction_filter.cc \ - java/rocksjni/compaction_filter_factory.cc \ - java/rocksjni/compaction_filter_factory_jnicallback.cc \ - java/rocksjni/compaction_job_info.cc \ - java/rocksjni/compaction_job_stats.cc \ - java/rocksjni/compaction_options.cc \ - java/rocksjni/compaction_options_fifo.cc \ - java/rocksjni/compaction_options_universal.cc \ - java/rocksjni/comparator.cc \ - java/rocksjni/comparatorjnicallback.cc \ - java/rocksjni/compression_options.cc \ - java/rocksjni/concurrent_task_limiter.cc \ - java/rocksjni/config_options.cc \ - java/rocksjni/export_import_files_metadatajni.cc \ - java/rocksjni/env.cc \ - java/rocksjni/env_flink.cc \ - java/rocksjni/env_flink_test_suite.cc \ - java/rocksjni/env_options.cc \ - java/rocksjni/event_listener.cc \ - java/rocksjni/event_listener_jnicallback.cc \ - java/rocksjni/import_column_family_options.cc \ - java/rocksjni/flink_compactionfilterjni.cc \ - java/rocksjni/ingest_external_file_options.cc \ - java/rocksjni/filter.cc \ - java/rocksjni/hyper_clock_cache.cc \ - java/rocksjni/iterator.cc \ - java/rocksjni/jni_perf_context.cc \ - java/rocksjni/jnicallback.cc \ - java/rocksjni/loggerjnicallback.cc \ - java/rocksjni/lru_cache.cc \ - java/rocksjni/memtablejni.cc \ - java/rocksjni/memory_util.cc \ - java/rocksjni/merge_operator.cc \ - java/rocksjni/native_comparator_wrapper_test.cc \ - java/rocksjni/optimistic_transaction_db.cc \ - java/rocksjni/optimistic_transaction_options.cc \ - java/rocksjni/options.cc \ - java/rocksjni/options_util.cc \ - java/rocksjni/persistent_cache.cc \ - java/rocksjni/ratelimiterjni.cc \ - java/rocksjni/remove_emptyvalue_compactionfilterjni.cc \ - java/rocksjni/cassandra_compactionfilterjni.cc \ - java/rocksjni/cassandra_value_operator.cc \ - java/rocksjni/restorejni.cc \ - java/rocksjni/rocks_callback_object.cc \ - java/rocksjni/rocksjni.cc \ - java/rocksjni/rocksdb_exception_test.cc \ - java/rocksjni/slice.cc \ - java/rocksjni/snapshot.cc \ - java/rocksjni/sst_file_manager.cc \ - java/rocksjni/sst_file_writerjni.cc \ - java/rocksjni/sst_file_readerjni.cc \ - java/rocksjni/sst_file_reader_iterator.cc \ - java/rocksjni/sst_partitioner.cc \ - java/rocksjni/statistics.cc \ - java/rocksjni/statisticsjni.cc \ - java/rocksjni/table.cc \ - java/rocksjni/table_filter.cc \ - java/rocksjni/table_filter_jnicallback.cc \ - java/rocksjni/thread_status.cc \ - java/rocksjni/trace_writer.cc \ - java/rocksjni/trace_writer_jnicallback.cc \ - java/rocksjni/transaction.cc \ - java/rocksjni/transaction_db.cc \ - java/rocksjni/transaction_options.cc \ - java/rocksjni/transaction_db_options.cc \ - java/rocksjni/transaction_log.cc \ - java/rocksjni/transaction_notifier.cc \ - java/rocksjni/transaction_notifier_jnicallback.cc \ - java/rocksjni/ttl.cc \ - java/rocksjni/testable_event_listener.cc \ - java/rocksjni/wal_filter.cc \ - java/rocksjni/wal_filter_jnicallback.cc \ - java/rocksjni/write_batch.cc \ - java/rocksjni/writebatchhandlerjnicallback.cc \ - java/rocksjni/write_batch_test.cc \ - java/rocksjni/write_batch_with_index.cc \ - java/rocksjni/write_buffer_manager.cc + java/forstjni/backupenginejni.cc \ + java/forstjni/backup_engine_options.cc \ + java/forstjni/checkpoint.cc \ + java/forstjni/clock_cache.cc \ + java/forstjni/cache.cc \ + java/forstjni/columnfamilyhandle.cc \ + java/forstjni/compact_range_options.cc \ + java/forstjni/compaction_filter.cc \ + java/forstjni/compaction_filter_factory.cc \ + java/forstjni/compaction_filter_factory_jnicallback.cc \ + java/forstjni/compaction_job_info.cc \ + java/forstjni/compaction_job_stats.cc \ + java/forstjni/compaction_options.cc \ + java/forstjni/compaction_options_fifo.cc \ + java/forstjni/compaction_options_universal.cc \ + java/forstjni/comparator.cc \ + java/forstjni/comparatorjnicallback.cc \ + java/forstjni/compression_options.cc \ + java/forstjni/concurrent_task_limiter.cc \ + java/forstjni/config_options.cc \ + java/forstjni/export_import_files_metadatajni.cc \ + java/forstjni/env.cc \ + java/forstjni/env_flink.cc \ + java/forstjni/env_flink_test_suite.cc \ + java/forstjni/env_options.cc \ + java/forstjni/event_listener.cc \ + java/forstjni/event_listener_jnicallback.cc \ + java/forstjni/import_column_family_options.cc \ + java/forstjni/flink_compactionfilterjni.cc \ + java/forstjni/ingest_external_file_options.cc \ + java/forstjni/filter.cc \ + java/forstjni/hyper_clock_cache.cc \ + java/forstjni/iterator.cc \ + java/forstjni/jni_perf_context.cc \ + java/forstjni/jnicallback.cc \ + java/forstjni/loggerjnicallback.cc \ + java/forstjni/lru_cache.cc \ + java/forstjni/memtablejni.cc \ + java/forstjni/memory_util.cc \ + java/forstjni/merge_operator.cc \ + java/forstjni/native_comparator_wrapper_test.cc \ + java/forstjni/optimistic_transaction_db.cc \ + java/forstjni/optimistic_transaction_options.cc \ + java/forstjni/options.cc \ + java/forstjni/options_util.cc \ + java/forstjni/persistent_cache.cc \ + java/forstjni/ratelimiterjni.cc \ + java/forstjni/remove_emptyvalue_compactionfilterjni.cc \ + java/forstjni/cassandra_compactionfilterjni.cc \ + java/forstjni/cassandra_value_operator.cc \ + java/forstjni/restorejni.cc \ + java/forstjni/rocks_callback_object.cc \ + java/forstjni/rocksjni.cc \ + java/forstjni/rocksdb_exception_test.cc \ + java/forstjni/slice.cc \ + java/forstjni/snapshot.cc \ + java/forstjni/sst_file_manager.cc \ + java/forstjni/sst_file_writerjni.cc \ + java/forstjni/sst_file_readerjni.cc \ + java/forstjni/sst_file_reader_iterator.cc \ + java/forstjni/sst_partitioner.cc \ + java/forstjni/statistics.cc \ + java/forstjni/statisticsjni.cc \ + java/forstjni/table.cc \ + java/forstjni/table_filter.cc \ + java/forstjni/table_filter_jnicallback.cc \ + java/forstjni/thread_status.cc \ + java/forstjni/trace_writer.cc \ + java/forstjni/trace_writer_jnicallback.cc \ + java/forstjni/transaction.cc \ + java/forstjni/transaction_db.cc \ + java/forstjni/transaction_options.cc \ + java/forstjni/transaction_db_options.cc \ + java/forstjni/transaction_log.cc \ + java/forstjni/transaction_notifier.cc \ + java/forstjni/transaction_notifier_jnicallback.cc \ + java/forstjni/ttl.cc \ + java/forstjni/testable_event_listener.cc \ + java/forstjni/wal_filter.cc \ + java/forstjni/wal_filter_jnicallback.cc \ + java/forstjni/write_batch.cc \ + java/forstjni/writebatchhandlerjnicallback.cc \ + java/forstjni/write_batch_test.cc \ + java/forstjni/write_batch_with_index.cc \ + java/forstjni/write_buffer_manager.cc From 44ac6d8d6888a2ebc0f46c522b25389a9621fc9e Mon Sep 17 00:00:00 2001 From: fredia Date: Thu, 26 Sep 2024 15:41:25 +0800 Subject: [PATCH 49/61] [build] Fix platform-related codes --- CMakeLists.txt | 10 +++++----- env/flink/jvm_util.cc | 8 ++++---- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 15f2d133d..f30d92d85 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -727,6 +727,10 @@ set(SOURCES env/env_encryption.cc env/file_system.cc env/file_system_tracer.cc + env/flink/env_flink.cc + env/flink/jvm_util.cc + env/flink/jni_helper.cc + env/flink/env_flink_test_suite.cc env/fs_remap.cc env/mock_env.cc env/unique_id_gen.cc @@ -1019,11 +1023,7 @@ else() port/port_posix.cc env/env_posix.cc env/fs_posix.cc - env/io_posix.cc - env/flink/env_flink.cc - env/flink/jvm_util.cc - env/flink/jni_helper.cc - env/flink/env_flink_test_suite.cc) + env/io_posix.cc) endif() if(USE_FOLLY_LITE) diff --git a/env/flink/jvm_util.cc b/env/flink/jvm_util.cc index ecd6f9677..ab5cc9663 100644 --- a/env/flink/jvm_util.cc +++ b/env/flink/jvm_util.cc @@ -18,14 +18,14 @@ #include "env/flink/jvm_util.h" -#define UNUSED(x) (void)(x) +#define UNUSED_JNI_PARAMETER(x) (void)(x) namespace ROCKSDB_NAMESPACE { std::atomic jvm_ = std::atomic(nullptr); JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { - UNUSED(reserved); + UNUSED_JNI_PARAMETER(reserved); JNIEnv* env = nullptr; if (vm->GetEnv((void**)&env, JNI_VERSION_1_8) != JNI_OK) { return -1; @@ -36,8 +36,8 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { } JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) { - UNUSED(vm); - UNUSED(reserved); + UNUSED_JNI_PARAMETER(vm); + UNUSED_JNI_PARAMETER(reserved); jvm_.store(nullptr); } From fcb30886c2bd1939c9121916d6e7edf21c5c8c97 Mon Sep 17 00:00:00 2001 From: fredia Date: Thu, 26 Sep 2024 18:47:46 +0800 Subject: [PATCH 50/61] [FLINK-35928][build] Rename jclass to forst in portal.h --- java/forstjni/portal.h | 218 ++++++++++++++++++++--------------------- 1 file changed, 109 insertions(+), 109 deletions(-) diff --git a/java/forstjni/portal.h b/java/forstjni/portal.h index 1edb9a0f3..2be3f949f 100644 --- a/java/forstjni/portal.h +++ b/java/forstjni/portal.h @@ -235,7 +235,7 @@ class CodeJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/Status$Code"); + return JavaClass::getJClass(env, "org/forstdb/Status$Code"); } /** @@ -272,7 +272,7 @@ class SubCodeJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/Status$SubCode"); + return JavaClass::getJClass(env, "org/forstdb/Status$SubCode"); } /** @@ -336,7 +336,7 @@ class StatusJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/Status"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/Status"); } /** @@ -355,7 +355,7 @@ class StatusJni } static jmethodID mid = - env->GetMethodID(jclazz, "getCode", "()Lorg/rocksdb/Status$Code;"); + env->GetMethodID(jclazz, "getCode", "()Lorg/forstdb/Status$Code;"); assert(mid != nullptr); return mid; } @@ -376,7 +376,7 @@ class StatusJni } static jmethodID mid = env->GetMethodID(jclazz, "getSubCode", - "()Lorg/rocksdb/Status$SubCode;"); + "()Lorg/forstdb/Status$SubCode;"); assert(mid != nullptr); return mid; } @@ -745,7 +745,7 @@ class RocksDBExceptionJni : public JavaException { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaException::getJClass(env, "org/rocksdb/RocksDBException"); + return JavaException::getJClass(env, "org/forstdb/RocksDBException"); } /** @@ -801,7 +801,7 @@ class RocksDBExceptionJni : public JavaException { // get the constructor of org.rocksdb.RocksDBException jmethodID mid = - env->GetMethodID(jclazz, "", "(Lorg/rocksdb/Status;)V"); + env->GetMethodID(jclazz, "", "(Lorg/forstdb/Status;)V"); if (mid == nullptr) { // exception thrown: NoSuchMethodException or OutOfMemoryError std::cerr @@ -892,7 +892,7 @@ class RocksDBExceptionJni : public JavaException { // get the constructor of org.rocksdb.RocksDBException jmethodID mid = env->GetMethodID( - jclazz, "", "(Ljava/lang/String;Lorg/rocksdb/Status;)V"); + jclazz, "", "(Ljava/lang/String;Lorg/forstdb/Status;)V"); if (mid == nullptr) { // exception thrown: NoSuchMethodException or OutOfMemoryError std::cerr @@ -990,7 +990,7 @@ class RocksDBExceptionJni : public JavaException { } static jmethodID mid = - env->GetMethodID(jclazz, "getStatus", "()Lorg/rocksdb/Status;"); + env->GetMethodID(jclazz, "getStatus", "()Lorg/forstdb/Status;"); assert(mid != nullptr); return mid; } @@ -2810,7 +2810,7 @@ class RocksDBJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/RocksDB"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/RocksDB"); } }; @@ -2828,7 +2828,7 @@ class OptionsJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/Options"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/Options"); } }; @@ -2846,7 +2846,7 @@ class DBOptionsJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/DBOptions"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/DBOptions"); } }; @@ -2866,7 +2866,7 @@ class ColumnFamilyOptionsJni */ static jclass getJClass(JNIEnv* env) { return RocksDBNativeClass::getJClass(env, - "org/rocksdb/ColumnFamilyOptions"); + "org/forstdb/ColumnFamilyOptions"); } /** @@ -2918,7 +2918,7 @@ class WriteOptionsJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/WriteOptions"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/WriteOptions"); } }; @@ -2937,7 +2937,7 @@ class ReadOptionsJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/ReadOptions"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/ReadOptions"); } }; @@ -2955,7 +2955,7 @@ class WriteBatchJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/WriteBatch"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/WriteBatch"); } /** @@ -3005,7 +3005,7 @@ class WriteBatchHandlerJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/WriteBatch$Handler"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/WriteBatch$Handler"); } /** @@ -3402,7 +3402,7 @@ class WriteBatchSavePointJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/WriteBatch$SavePoint"); + return JavaClass::getJClass(env, "org/forstdb/WriteBatch$SavePoint"); } /** @@ -3476,7 +3476,7 @@ class WriteBatchWithIndexJni */ static jclass getJClass(JNIEnv* env) { return RocksDBNativeClass::getJClass(env, - "org/rocksdb/WriteBatchWithIndex"); + "org/forstdb/WriteBatchWithIndex"); } }; @@ -3493,7 +3493,7 @@ class HistogramDataJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/HistogramData"); + return JavaClass::getJClass(env, "org/forstdb/HistogramData"); } /** @@ -3533,7 +3533,7 @@ class BackupEngineOptionsJni */ static jclass getJClass(JNIEnv* env) { return RocksDBNativeClass::getJClass(env, - "org/rocksdb/BackupEngineOptions"); + "org/forstdb/BackupEngineOptions"); } }; @@ -3552,7 +3552,7 @@ class BackupEngineJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/BackupEngine"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/BackupEngine"); } }; @@ -3570,7 +3570,7 @@ class IteratorJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/RocksIterator"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/RocksIterator"); } }; @@ -3596,7 +3596,7 @@ class FilterPolicyJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/FilterPolicy"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/FilterPolicy"); } static jbyte toJavaIndexType(const FilterPolicyTypeJni& filter_policy_type) { @@ -3640,7 +3640,7 @@ class ColumnFamilyHandleJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/ColumnFamilyHandle"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/ColumnFamilyHandle"); } }; @@ -3659,7 +3659,7 @@ class FlushOptionsJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/FlushOptions"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/FlushOptions"); } }; @@ -3679,7 +3679,7 @@ class ComparatorOptionsJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/ComparatorOptions"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/ComparatorOptions"); } }; @@ -3700,7 +3700,7 @@ class AbstractCompactionFilterFactoryJni */ static jclass getJClass(JNIEnv* env) { return RocksDBNativeClass::getJClass( - env, "org/rocksdb/AbstractCompactionFilterFactory"); + env, "org/forstdb/AbstractCompactionFilterFactory"); } /** @@ -3754,7 +3754,7 @@ class AbstractTransactionNotifierJni public: static jclass getJClass(JNIEnv* env) { return RocksDBNativeClass::getJClass( - env, "org/rocksdb/AbstractTransactionNotifier"); + env, "org/forstdb/AbstractTransactionNotifier"); } // Get the java method `snapshotCreated` @@ -3785,7 +3785,7 @@ class AbstractComparatorJniBridge : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/AbstractComparatorJniBridge"); + return JavaClass::getJClass(env, "org/forstdb/AbstractComparatorJniBridge"); } /** @@ -3800,7 +3800,7 @@ class AbstractComparatorJniBridge : public JavaClass { static jmethodID getCompareInternalMethodId(JNIEnv* env, jclass jclazz) { static jmethodID mid = env->GetStaticMethodID(jclazz, "compareInternal", - "(Lorg/rocksdb/AbstractComparator;Ljava/nio/" + "(Lorg/forstdb/AbstractComparator;Ljava/nio/" "ByteBuffer;ILjava/nio/ByteBuffer;I)I"); assert(mid != nullptr); return mid; @@ -3819,7 +3819,7 @@ class AbstractComparatorJniBridge : public JavaClass { jclass jclazz) { static jmethodID mid = env->GetStaticMethodID(jclazz, "findShortestSeparatorInternal", - "(Lorg/rocksdb/AbstractComparator;Ljava/nio/" + "(Lorg/forstdb/AbstractComparator;Ljava/nio/" "ByteBuffer;ILjava/nio/ByteBuffer;I)I"); assert(mid != nullptr); return mid; @@ -3838,7 +3838,7 @@ class AbstractComparatorJniBridge : public JavaClass { jclass jclazz) { static jmethodID mid = env->GetStaticMethodID( jclazz, "findShortSuccessorInternal", - "(Lorg/rocksdb/AbstractComparator;Ljava/nio/ByteBuffer;I)I"); + "(Lorg/forstdb/AbstractComparator;Ljava/nio/ByteBuffer;I)I"); assert(mid != nullptr); return mid; } @@ -3859,7 +3859,7 @@ class AbstractComparatorJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/AbstractComparator"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/AbstractComparator"); } /** @@ -3899,7 +3899,7 @@ class AbstractSliceJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/AbstractSlice"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/AbstractSlice"); } }; @@ -3918,7 +3918,7 @@ class SliceJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/Slice"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/Slice"); } /** @@ -3966,7 +3966,7 @@ class DirectSliceJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/DirectSlice"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/DirectSlice"); } /** @@ -4012,7 +4012,7 @@ class BackupInfoJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/BackupInfo"); + return JavaClass::getJClass(env, "org/forstdb/BackupInfo"); } /** @@ -4156,7 +4156,7 @@ class WBWIRocksIteratorJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/WBWIRocksIterator"); + return JavaClass::getJClass(env, "org/forstdb/WBWIRocksIterator"); } /** @@ -4175,7 +4175,7 @@ class WBWIRocksIteratorJni : public JavaClass { } static jfieldID fid = env->GetFieldID( - jclazz, "entry", "Lorg/rocksdb/WBWIRocksIterator$WriteEntry;"); + jclazz, "entry", "Lorg/forstdb/WBWIRocksIterator$WriteEntry;"); assert(fid != nullptr); return fid; } @@ -4281,7 +4281,7 @@ class WriteTypeJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/WBWIRocksIterator$WriteType"); + return JavaClass::getJClass(env, "org/forstdb/WBWIRocksIterator$WriteType"); } /** @@ -4301,7 +4301,7 @@ class WriteTypeJni : public JavaClass { } jfieldID jfid = env->GetStaticFieldID( - jclazz, name, "Lorg/rocksdb/WBWIRocksIterator$WriteType;"); + jclazz, name, "Lorg/forstdb/WBWIRocksIterator$WriteType;"); if (env->ExceptionCheck()) { // exception occurred while getting field return nullptr; @@ -4329,7 +4329,7 @@ class WriteEntryJni : public JavaClass { */ static jclass getJClass(JNIEnv* env) { return JavaClass::getJClass(env, - "org/rocksdb/WBWIRocksIterator$WriteEntry"); + "org/forstdb/WBWIRocksIterator$WriteEntry"); } }; @@ -4415,7 +4415,7 @@ class InfoLogLevelJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/InfoLogLevel"); + return JavaClass::getJClass(env, "org/forstdb/InfoLogLevel"); } /** @@ -4435,7 +4435,7 @@ class InfoLogLevelJni : public JavaClass { } jfieldID jfid = - env->GetStaticFieldID(jclazz, name, "Lorg/rocksdb/InfoLogLevel;"); + env->GetStaticFieldID(jclazz, name, "Lorg/forstdb/InfoLogLevel;"); if (env->ExceptionCheck()) { // exception occurred while getting field return nullptr; @@ -4455,7 +4455,7 @@ class LoggerJni std::shared_ptr*, LoggerJni> { public: /** - * Get the Java Class org/rocksdb/Logger + * Get the Java Class org/forstdb/Logger * * @param env A pointer to the Java environment * @@ -4464,7 +4464,7 @@ class LoggerJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/Logger"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/Logger"); } /** @@ -4483,7 +4483,7 @@ class LoggerJni } static jmethodID mid = env->GetMethodID( - jclazz, "log", "(Lorg/rocksdb/InfoLogLevel;Ljava/lang/String;)V"); + jclazz, "log", "(Lorg/forstdb/InfoLogLevel;Ljava/lang/String;)V"); assert(mid != nullptr); return mid; } @@ -4503,7 +4503,7 @@ class BatchResultJni : public JavaClass { */ static jclass getJClass(JNIEnv* env) { return JavaClass::getJClass( - env, "org/rocksdb/TransactionLogIterator$BatchResult"); + env, "org/forstdb/TransactionLogIterator$BatchResult"); } /** @@ -6044,7 +6044,7 @@ class TransactionJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/Transaction"); + return JavaClass::getJClass(env, "org/forstdb/Transaction"); } /** @@ -6072,7 +6072,7 @@ class TransactionJni : public JavaClass { jmethodID mid = env->GetMethodID( jclazz, "newWaitingTransactions", - "(JLjava/lang/String;[J)Lorg/rocksdb/Transaction$WaitingTransactions;"); + "(JLjava/lang/String;[J)Lorg/forstdb/Transaction$WaitingTransactions;"); if (mid == nullptr) { // exception thrown: NoSuchMethodException or OutOfMemoryError return nullptr; @@ -6133,7 +6133,7 @@ class TransactionDBJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/TransactionDB"); + return JavaClass::getJClass(env, "org/forstdb/TransactionDB"); } /** @@ -6162,7 +6162,7 @@ class TransactionDBJni : public JavaClass { jmethodID mid = env->GetMethodID( jclazz, "newDeadlockInfo", - "(JJLjava/lang/String;Z)Lorg/rocksdb/TransactionDB$DeadlockInfo;"); + "(JJLjava/lang/String;Z)Lorg/forstdb/TransactionDB$DeadlockInfo;"); if (mid == nullptr) { // exception thrown: NoSuchMethodException or OutOfMemoryError return nullptr; @@ -6238,7 +6238,7 @@ class KeyLockInfoJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/TransactionDB$KeyLockInfo"); + return JavaClass::getJClass(env, "org/forstdb/TransactionDB$KeyLockInfo"); } /** @@ -6309,7 +6309,7 @@ class DeadlockInfoJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/TransactionDB$DeadlockInfo"); + return JavaClass::getJClass(env, "org/forstdb/TransactionDB$DeadlockInfo"); } }; @@ -6326,7 +6326,7 @@ class DeadlockPathJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/TransactionDB$DeadlockPath"); + return JavaClass::getJClass(env, "org/forstdb/TransactionDB$DeadlockPath"); } /** @@ -6384,14 +6384,14 @@ class AbstractTableFilterJni } static jmethodID mid = - env->GetMethodID(jclazz, "filter", "(Lorg/rocksdb/TableProperties;)Z"); + env->GetMethodID(jclazz, "filter", "(Lorg/forstdb/TableProperties;)Z"); assert(mid != nullptr); return mid; } private: static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/TableFilter"); + return JavaClass::getJClass(env, "org/forstdb/TableFilter"); } }; @@ -6567,7 +6567,7 @@ class TablePropertiesJni : public JavaClass { private: static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/TableProperties"); + return JavaClass::getJClass(env, "org/forstdb/TableProperties"); } }; @@ -6583,7 +6583,7 @@ class ColumnFamilyDescriptorJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/ColumnFamilyDescriptor"); + return JavaClass::getJClass(env, "org/forstdb/ColumnFamilyDescriptor"); } /** @@ -6608,7 +6608,7 @@ class ColumnFamilyDescriptorJni : public JavaClass { } jmethodID mid = env->GetMethodID(jclazz, "", - "([BLorg/rocksdb/ColumnFamilyOptions;)V"); + "([BLorg/forstdb/ColumnFamilyOptions;)V"); if (mid == nullptr) { // exception thrown: NoSuchMethodException or OutOfMemoryError env->DeleteLocalRef(jcf_name); @@ -6660,7 +6660,7 @@ class ColumnFamilyDescriptorJni : public JavaClass { } static jmethodID mid = env->GetMethodID( - jclazz, "columnFamilyOptions", "()Lorg/rocksdb/ColumnFamilyOptions;"); + jclazz, "columnFamilyOptions", "()Lorg/forstdb/ColumnFamilyOptions;"); assert(mid != nullptr); return mid; } @@ -7098,7 +7098,7 @@ class ThreadStatusJni : public JavaClass { * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/ThreadStatus"); + return JavaClass::getJClass(env, "org/forstdb/ThreadStatus"); } /** @@ -7422,7 +7422,7 @@ class LogFileJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/LogFile"); + return JavaClass::getJClass(env, "org/forstdb/LogFile"); } }; @@ -7544,7 +7544,7 @@ class LiveFileMetaDataJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/LiveFileMetaData"); + return JavaClass::getJClass(env, "org/forstdb/LiveFileMetaData"); } }; @@ -7651,7 +7651,7 @@ class SstFileMetaDataJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/SstFileMetaData"); + return JavaClass::getJClass(env, "org/forstdb/SstFileMetaData"); } }; @@ -7675,7 +7675,7 @@ class LevelMetaDataJni : public JavaClass { } jmethodID mid = env->GetMethodID(jclazz, "", - "(IJ[Lorg/rocksdb/SstFileMetaData;)V"); + "(IJ[Lorg/forstdb/SstFileMetaData;)V"); if (mid == nullptr) { // exception thrown: NoSuchMethodException or OutOfMemoryError return nullptr; @@ -7717,7 +7717,7 @@ class LevelMetaDataJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/LevelMetaData"); + return JavaClass::getJClass(env, "org/forstdb/LevelMetaData"); } }; @@ -7742,7 +7742,7 @@ class ColumnFamilyMetaDataJni : public JavaClass { } jmethodID mid = env->GetMethodID(jclazz, "", - "(JJ[B[Lorg/rocksdb/LevelMetaData;)V"); + "(JJ[B[Lorg/forstdb/LevelMetaData;)V"); if (mid == nullptr) { // exception thrown: NoSuchMethodException or OutOfMemoryError return nullptr; @@ -7796,7 +7796,7 @@ class ColumnFamilyMetaDataJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/ColumnFamilyMetaData"); + return JavaClass::getJClass(env, "org/forstdb/ColumnFamilyMetaData"); } }; @@ -7817,7 +7817,7 @@ class AbstractTraceWriterJni */ static jclass getJClass(JNIEnv* env) { return RocksDBNativeClass::getJClass(env, - "org/rocksdb/AbstractTraceWriter"); + "org/forstdb/AbstractTraceWriter"); } /** @@ -7896,7 +7896,7 @@ class AbstractWalFilterJni * OutOfMemoryError or ExceptionInInitializerError exceptions is thrown */ static jclass getJClass(JNIEnv* env) { - return RocksDBNativeClass::getJClass(env, "org/rocksdb/AbstractWalFilter"); + return RocksDBNativeClass::getJClass(env, "org/forstdb/AbstractWalFilter"); } /** @@ -8157,7 +8157,7 @@ class AbstractEventListenerJni */ static jclass getJClass(JNIEnv* env) { return RocksDBNativeClass::getJClass(env, - "org/rocksdb/AbstractEventListener"); + "org/forstdb/AbstractEventListener"); } /** @@ -8171,7 +8171,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onFlushCompletedProxy", - "(JLorg/rocksdb/FlushJobInfo;)V"); + "(JLorg/forstdb/FlushJobInfo;)V"); assert(mid != nullptr); return mid; } @@ -8187,7 +8187,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onFlushBeginProxy", - "(JLorg/rocksdb/FlushJobInfo;)V"); + "(JLorg/forstdb/FlushJobInfo;)V"); assert(mid != nullptr); return mid; } @@ -8203,7 +8203,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID( - jclazz, "onTableFileDeleted", "(Lorg/rocksdb/TableFileDeletionInfo;)V"); + jclazz, "onTableFileDeleted", "(Lorg/forstdb/TableFileDeletionInfo;)V"); assert(mid != nullptr); return mid; } @@ -8220,7 +8220,7 @@ class AbstractEventListenerJni assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onCompactionBeginProxy", - "(JLorg/rocksdb/CompactionJobInfo;)V"); + "(JLorg/forstdb/CompactionJobInfo;)V"); assert(mid != nullptr); return mid; } @@ -8237,7 +8237,7 @@ class AbstractEventListenerJni assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onCompactionCompletedProxy", - "(JLorg/rocksdb/CompactionJobInfo;)V"); + "(JLorg/forstdb/CompactionJobInfo;)V"); assert(mid != nullptr); return mid; } @@ -8253,7 +8253,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID( - jclazz, "onTableFileCreated", "(Lorg/rocksdb/TableFileCreationInfo;)V"); + jclazz, "onTableFileCreated", "(Lorg/forstdb/TableFileCreationInfo;)V"); assert(mid != nullptr); return mid; } @@ -8270,7 +8270,7 @@ class AbstractEventListenerJni assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onTableFileCreationStarted", - "(Lorg/rocksdb/TableFileCreationBriefInfo;)V"); + "(Lorg/forstdb/TableFileCreationBriefInfo;)V"); assert(mid != nullptr); return mid; } @@ -8286,7 +8286,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onMemTableSealed", - "(Lorg/rocksdb/MemTableInfo;)V"); + "(Lorg/forstdb/MemTableInfo;)V"); assert(mid != nullptr); return mid; } @@ -8304,7 +8304,7 @@ class AbstractEventListenerJni assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onColumnFamilyHandleDeletionStarted", - "(Lorg/rocksdb/ColumnFamilyHandle;)V"); + "(Lorg/forstdb/ColumnFamilyHandle;)V"); assert(mid != nullptr); return mid; } @@ -8321,7 +8321,7 @@ class AbstractEventListenerJni assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onExternalFileIngestedProxy", - "(JLorg/rocksdb/ExternalFileIngestionInfo;)V"); + "(JLorg/forstdb/ExternalFileIngestionInfo;)V"); assert(mid != nullptr); return mid; } @@ -8337,7 +8337,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onBackgroundErrorProxy", - "(BLorg/rocksdb/Status;)V"); + "(BLorg/forstdb/Status;)V"); assert(mid != nullptr); return mid; } @@ -8353,7 +8353,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onStallConditionsChanged", - "(Lorg/rocksdb/WriteStallInfo;)V"); + "(Lorg/forstdb/WriteStallInfo;)V"); assert(mid != nullptr); return mid; } @@ -8369,7 +8369,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID( - jclazz, "onFileReadFinish", "(Lorg/rocksdb/FileOperationInfo;)V"); + jclazz, "onFileReadFinish", "(Lorg/forstdb/FileOperationInfo;)V"); assert(mid != nullptr); return mid; } @@ -8385,7 +8385,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID( - jclazz, "onFileWriteFinish", "(Lorg/rocksdb/FileOperationInfo;)V"); + jclazz, "onFileWriteFinish", "(Lorg/forstdb/FileOperationInfo;)V"); assert(mid != nullptr); return mid; } @@ -8401,7 +8401,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID( - jclazz, "onFileFlushFinish", "(Lorg/rocksdb/FileOperationInfo;)V"); + jclazz, "onFileFlushFinish", "(Lorg/forstdb/FileOperationInfo;)V"); assert(mid != nullptr); return mid; } @@ -8417,7 +8417,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID( - jclazz, "onFileSyncFinish", "(Lorg/rocksdb/FileOperationInfo;)V"); + jclazz, "onFileSyncFinish", "(Lorg/forstdb/FileOperationInfo;)V"); assert(mid != nullptr); return mid; } @@ -8433,7 +8433,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID( - jclazz, "onFileRangeSyncFinish", "(Lorg/rocksdb/FileOperationInfo;)V"); + jclazz, "onFileRangeSyncFinish", "(Lorg/forstdb/FileOperationInfo;)V"); assert(mid != nullptr); return mid; } @@ -8449,7 +8449,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID( - jclazz, "onFileTruncateFinish", "(Lorg/rocksdb/FileOperationInfo;)V"); + jclazz, "onFileTruncateFinish", "(Lorg/forstdb/FileOperationInfo;)V"); assert(mid != nullptr); return mid; } @@ -8465,7 +8465,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID( - jclazz, "onFileCloseFinish", "(Lorg/rocksdb/FileOperationInfo;)V"); + jclazz, "onFileCloseFinish", "(Lorg/forstdb/FileOperationInfo;)V"); assert(mid != nullptr); return mid; } @@ -8497,7 +8497,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onErrorRecoveryBeginProxy", - "(BLorg/rocksdb/Status;)Z"); + "(BLorg/forstdb/Status;)Z"); assert(mid != nullptr); return mid; } @@ -8513,7 +8513,7 @@ class AbstractEventListenerJni jclass jclazz = getJClass(env); assert(jclazz != nullptr); static jmethodID mid = env->GetMethodID(jclazz, "onErrorRecoveryCompleted", - "(Lorg/rocksdb/Status;)V"); + "(Lorg/forstdb/Status;)V"); assert(mid != nullptr); return mid; } @@ -8567,7 +8567,7 @@ class FlushJobInfoJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/FlushJobInfo"); + return JavaClass::getJClass(env, "org/forstdb/FlushJobInfo"); } static jmethodID getConstructorMethodId(JNIEnv* env, jclass clazz) { @@ -8613,13 +8613,13 @@ class TableFileDeletionInfoJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/TableFileDeletionInfo"); + return JavaClass::getJClass(env, "org/forstdb/TableFileDeletionInfo"); } static jmethodID getConstructorMethodId(JNIEnv* env, jclass clazz) { return env->GetMethodID( clazz, "", - "(Ljava/lang/String;Ljava/lang/String;ILorg/rocksdb/Status;)V"); + "(Ljava/lang/String;Ljava/lang/String;ILorg/forstdb/Status;)V"); } }; @@ -8637,7 +8637,7 @@ class CompactionJobInfoJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/CompactionJobInfo"); + return JavaClass::getJClass(env, "org/forstdb/CompactionJobInfo"); } static jmethodID getConstructorMethodId(JNIEnv* env, jclass clazz) { @@ -8689,13 +8689,13 @@ class TableFileCreationInfoJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/TableFileCreationInfo"); + return JavaClass::getJClass(env, "org/forstdb/TableFileCreationInfo"); } static jmethodID getConstructorMethodId(JNIEnv* env, jclass clazz) { return env->GetMethodID( clazz, "", - "(JLorg/rocksdb/TableProperties;Lorg/rocksdb/Status;Ljava/lang/" + "(JLorg/forstdb/TableProperties;Lorg/forstdb/Status;Ljava/lang/" "String;Ljava/lang/String;Ljava/lang/String;IB)V"); } }; @@ -8729,7 +8729,7 @@ class TableFileCreationBriefInfoJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/TableFileCreationBriefInfo"); + return JavaClass::getJClass(env, "org/forstdb/TableFileCreationBriefInfo"); } static jmethodID getConstructorMethodId(JNIEnv* env, jclass clazz) { @@ -8759,7 +8759,7 @@ class MemTableInfoJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/MemTableInfo"); + return JavaClass::getJClass(env, "org/forstdb/MemTableInfo"); } static jmethodID getConstructorMethodId(JNIEnv* env, jclass clazz) { @@ -8806,13 +8806,13 @@ class ExternalFileIngestionInfoJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/ExternalFileIngestionInfo"); + return JavaClass::getJClass(env, "org/forstdb/ExternalFileIngestionInfo"); } static jmethodID getConstructorMethodId(JNIEnv* env, jclass clazz) { return env->GetMethodID(clazz, "", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/" - "String;JLorg/rocksdb/TableProperties;)V"); + "String;JLorg/forstdb/TableProperties;)V"); } }; @@ -8834,7 +8834,7 @@ class WriteStallInfoJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/WriteStallInfo"); + return JavaClass::getJClass(env, "org/forstdb/WriteStallInfo"); } static jmethodID getConstructorMethodId(JNIEnv* env, jclass clazz) { @@ -8867,12 +8867,12 @@ class FileOperationInfoJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/FileOperationInfo"); + return JavaClass::getJClass(env, "org/forstdb/FileOperationInfo"); } static jmethodID getConstructorMethodId(JNIEnv* env, jclass clazz) { return env->GetMethodID(clazz, "", - "(Ljava/lang/String;JJJJLorg/rocksdb/Status;)V"); + "(Ljava/lang/String;JJJJLorg/forstdb/Status;)V"); } }; @@ -8890,7 +8890,7 @@ class CompactRangeOptionsTimestampJni : public JavaClass { static jclass getJClass(JNIEnv* env) { return JavaClass::getJClass(env, - "org/rocksdb/CompactRangeOptions$Timestamp"); + "org/forstdb/CompactRangeOptions$Timestamp"); } static jmethodID getConstructorMethodId(JNIEnv* env, jclass clazz) { @@ -8914,7 +8914,7 @@ class BlockBasedTableOptionsJni */ static jclass getJClass(JNIEnv* env) { return RocksDBNativeClass::getJClass(env, - "org/rocksdb/BlockBasedTableConfig"); + "org/forstdb/BlockBasedTableConfig"); } /** From 3c86325400bcd2ff7154805beebd55b05d9d427a Mon Sep 17 00:00:00 2001 From: fredia Date: Fri, 27 Sep 2024 12:19:28 +0800 Subject: [PATCH 51/61] [FLINK-35928][build] Rename .so to forst --- Makefile | 80 +++++++++---------- java/Makefile | 28 +++---- .../java/org/forstdb/NativeLibraryLoader.java | 4 +- 3 files changed, 56 insertions(+), 56 deletions(-) diff --git a/Makefile b/Makefile index bd636c840..c5d8f7155 100644 --- a/Makefile +++ b/Makefile @@ -2109,18 +2109,18 @@ ifneq ($(origin JNI_LIBC), undefined) JNI_LIBC_POSTFIX = -$(JNI_LIBC) endif -ifeq (,$(ROCKSDBJNILIB)) +ifeq (,$(FORSTDBJNILIB)) ifneq (,$(filter ppc% s390x arm64 aarch64 riscv64 sparc64 loongarch64, $(MACHINE))) - ROCKSDBJNILIB = librocksdbjni-linux-$(MACHINE)$(JNI_LIBC_POSTFIX).so + FORSTDBJNILIB = libforstdbjni-linux-$(MACHINE)$(JNI_LIBC_POSTFIX).so else - ROCKSDBJNILIB = librocksdbjni-linux$(ARCH)$(JNI_LIBC_POSTFIX).so + FORSTDBJNILIB = libforstdbjni-linux$(ARCH)$(JNI_LIBC_POSTFIX).so endif endif ROCKSDB_JAVA_VERSION ?= $(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH) -ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-linux$(ARCH)$(JNI_LIBC_POSTFIX).jar -ROCKSDB_JAR_ALL = rocksdbjni-$(ROCKSDB_JAVA_VERSION).jar -ROCKSDB_JAVADOCS_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-javadoc.jar -ROCKSDB_SOURCES_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-sources.jar +ROCKSDB_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-linux$(ARCH)$(JNI_LIBC_POSTFIX).jar +ROCKSDB_JAR_ALL = forstdbjni-$(ROCKSDB_JAVA_VERSION).jar +ROCKSDB_JAVADOCS_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-javadoc.jar +ROCKSDB_SOURCES_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-sources.jar SHA256_CMD = sha256sum ZLIB_VER ?= 1.3 @@ -2141,16 +2141,16 @@ ZSTD_DOWNLOAD_BASE ?= https://github.com/facebook/zstd/archive CURL_SSL_OPTS ?= --tlsv1 ifeq ($(PLATFORM), OS_MACOSX) -ifeq (,$(findstring librocksdbjni-osx,$(ROCKSDBJNILIB))) +ifeq (,$(findstring libforstdbjni-osx,$(FORSTDBJNILIB))) ifeq ($(MACHINE),arm64) - ROCKSDBJNILIB = librocksdbjni-osx-arm64.jnilib + FORSTDBJNILIB = libforstdbjni-osx-arm64.jnilib else ifeq ($(MACHINE),x86_64) - ROCKSDBJNILIB = librocksdbjni-osx-x86_64.jnilib + FORSTDBJNILIB = libforstdbjni-osx-x86_64.jnilib else - ROCKSDBJNILIB = librocksdbjni-osx.jnilib + FORSTDBJNILIB = libforstdbjni-osx.jnilib endif endif - ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-osx.jar + ROCKSDB_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-osx.jar SHA256_CMD = openssl sha256 -r ifneq ("$(wildcard $(JAVA_HOME)/include/darwin)","") JAVA_INCLUDE = -I$(JAVA_HOME)/include -I $(JAVA_HOME)/include/darwin @@ -2161,25 +2161,25 @@ endif ifeq ($(PLATFORM), OS_FREEBSD) JAVA_INCLUDE = -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/freebsd - ROCKSDBJNILIB = librocksdbjni-freebsd$(ARCH).so - ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-freebsd$(ARCH).jar + FORSTDBJNILIB = libforstdbjni-freebsd$(ARCH).so + ROCKSDB_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-freebsd$(ARCH).jar endif ifeq ($(PLATFORM), OS_SOLARIS) - ROCKSDBJNILIB = librocksdbjni-solaris$(ARCH).so - ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH)-solaris$(ARCH).jar + FORSTDBJNILIB = libforstdbjni-solaris$(ARCH).so + ROCKSDB_JAR = forstdbjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH)-solaris$(ARCH).jar JAVA_INCLUDE = -I$(JAVA_HOME)/include/ -I$(JAVA_HOME)/include/solaris SHA256_CMD = digest -a sha256 endif ifeq ($(PLATFORM), OS_AIX) JAVA_INCLUDE = -I$(JAVA_HOME)/include/ -I$(JAVA_HOME)/include/aix - ROCKSDBJNILIB = librocksdbjni-aix.so + FORSTDBJNILIB = libforstdbjni-aix.so EXTRACT_SOURCES = gunzip < TAR_GZ | tar xvf - SNAPPY_MAKE_TARGET = libsnappy.la endif ifeq ($(PLATFORM), OS_OPENBSD) JAVA_INCLUDE = -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/openbsd - ROCKSDBJNILIB = librocksdbjni-openbsd$(ARCH).so - ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-openbsd$(ARCH).jar + FORSTDBJNILIB = libforstdbjni-openbsd$(ARCH).so + ROCKSDB_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-openbsd$(ARCH).jar endif export SHA256_CMD @@ -2281,14 +2281,14 @@ endif rocksdbjavastaticosx: rocksdbjavastaticosx_archs cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md - cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) librocksdbjni-osx-x86_64.jnilib librocksdbjni-osx-arm64.jnilib + cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) libforstdbjni-osx-x86_64.jnilib libforstdbjni-osx-arm64.jnilib cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 rocksdbjavastaticosx_ub: rocksdbjavastaticosx_archs - cd java/target; lipo -create -output librocksdbjni-osx.jnilib librocksdbjni-osx-x86_64.jnilib librocksdbjni-osx-arm64.jnilib + cd java/target; lipo -create -output libforstdbjni-osx.jnilib libforstdbjni-osx-x86_64.jnilib libforstdbjni-osx-arm64.jnilib cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md - cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) librocksdbjni-osx.jnilib + cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) libforstdbjni-osx.jnilib cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 @@ -2304,7 +2304,7 @@ endif $(MAKE) clean-rocks ARCHFLAG="-arch $*" $(MAKE) rocksdbjavastatic_deps ARCHFLAG="-arch $*" $(MAKE) rocksdbjavastatic_libobjects - ARCHFLAG="-arch $*" ROCKSDBJNILIB="librocksdbjni-osx-$*.jnilib" $(MAKE) rocksdbjavastatic_javalib + ARCHFLAG="-arch $*" FORSTDBJNILIB="libforstdbjni-osx-$*.jnilib" $(MAKE) rocksdbjavastatic_javalib ifeq ($(JAR_CMD),) ifneq ($(JAVA_HOME),) @@ -2315,18 +2315,18 @@ endif endif rocksdbjavastatic_javalib: cd java; $(MAKE) javalib - rm -f java/target/$(ROCKSDBJNILIB) + rm -f java/target/$(FORSTDBJNILIB) $(CXX) $(CXXFLAGS) -I./java/. $(JAVA_INCLUDE) -shared -fPIC \ - -o ./java/target/$(ROCKSDBJNILIB) $(ALL_JNI_NATIVE_SOURCES) \ + -o ./java/target/$(FORSTDBJNILIB) $(ALL_JNI_NATIVE_SOURCES) \ $(LIB_OBJECTS) $(COVERAGEFLAGS) \ $(JAVA_COMPRESSIONS) $(JAVA_STATIC_LDFLAGS) cd java/target;if [ "$(DEBUG_LEVEL)" == "0" ]; then \ - strip $(STRIPFLAGS) $(ROCKSDBJNILIB); \ + strip $(STRIPFLAGS) $(FORSTDBJNILIB); \ fi rocksdbjava_jar: cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md - cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) $(ROCKSDBJNILIB) + cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) $(FORSTDBJNILIB) cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 @@ -2345,14 +2345,14 @@ rocksdbjavastatic_libobjects: $(LIB_OBJECTS) rocksdbjavastaticrelease: rocksdbjavastaticosx rocksdbjava_javadocs_jar rocksdbjava_sources_jar cd java/crossbuild && (vagrant destroy -f || true) && vagrant up linux32 && vagrant halt linux32 && vagrant up linux64 && vagrant halt linux64 && vagrant up linux64-musl && vagrant halt linux64-musl cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR_ALL) HISTORY*.md - cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) librocksdbjni-*.so librocksdbjni-*.jnilib + cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) libforstdbjni-*.so libforstdbjni-*.jnilib cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR_ALL) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR_ALL) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR_ALL).sha1 rocksdbjavastaticreleasedocker: rocksdbjavastaticosx rocksdbjavastaticdockerx86 rocksdbjavastaticdockerx86_64 rocksdbjavastaticdockerx86musl rocksdbjavastaticdockerx86_64musl rocksdbjava_javadocs_jar rocksdbjava_sources_jar cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR_ALL) HISTORY*.md jar -uf java/target/$(ROCKSDB_JAR_ALL) HISTORY*.md - cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) librocksdbjni-*.so librocksdbjni-*.jnilib librocksdbjni-win64.dll + cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) libforstdbjni-*.so libforstdbjni-*.jnilib libforstdbjni-win64.dll cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR_ALL) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR_ALL) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR_ALL).sha1 @@ -2439,21 +2439,21 @@ rocksdbjavastaticpublishdocker: rocksdbjavastaticreleasedocker rocksdbjavastatic ROCKSDB_JAVA_RELEASE_CLASSIFIERS = javadoc sources linux64 linux32 linux64-musl linux32-musl osx win64 rocksdbjavastaticpublishcentral: rocksdbjavageneratepom - mvn gpg:sign-and-deploy-file -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ -DrepositoryId=sonatype-nexus-staging -DpomFile=java/pom.xml -Dfile=java/target/rocksdbjni-$(ROCKSDB_JAVA_VERSION).jar - $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), mvn gpg:sign-and-deploy-file -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ -DrepositoryId=sonatype-nexus-staging -DpomFile=java/pom.xml -Dfile=java/target/rocksdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar -Dclassifier=$(classifier);) + mvn gpg:sign-and-deploy-file -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ -DrepositoryId=sonatype-nexus-staging -DpomFile=java/pom.xml -Dfile=java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION).jar + $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), mvn gpg:sign-and-deploy-file -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ -DrepositoryId=sonatype-nexus-staging -DpomFile=java/pom.xml -Dfile=java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar -Dclassifier=$(classifier);) rocksdbjavageneratepom: cd java;cat pom.xml.template | sed 's/\$${ROCKSDB_JAVA_VERSION}/$(ROCKSDB_JAVA_VERSION)/' > pom.xml rocksdbjavastaticnexusbundlejar: rocksdbjavageneratepom openssl sha1 -r java/pom.xml | awk '{ print $$1 }' > java/target/pom.xml.sha1 - openssl sha1 -r java/target/rocksdbjni-$(ROCKSDB_JAVA_VERSION).jar | awk '{ print $$1 }' > java/target/rocksdbjni-$(ROCKSDB_JAVA_VERSION).jar.sha1 - $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), openssl sha1 -r java/target/rocksdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar | awk '{ print $$1 }' > java/target/rocksdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.sha1;) + openssl sha1 -r java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION).jar | awk '{ print $$1 }' > java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION).jar.sha1 + $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), openssl sha1 -r java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar | awk '{ print $$1 }' > java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.sha1;) gpg --yes --output java/target/pom.xml.asc -ab java/pom.xml - gpg --yes -ab java/target/rocksdbjni-$(ROCKSDB_JAVA_VERSION).jar - $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), gpg --yes -ab java/target/rocksdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar;) - $(JAR_CMD) cvf java/target/nexus-bundle-rocksdbjni-$(ROCKSDB_JAVA_VERSION).jar -C java pom.xml -C java/target pom.xml.sha1 -C java/target pom.xml.asc -C java/target rocksdbjni-$(ROCKSDB_JAVA_VERSION).jar -C java/target rocksdbjni-$(ROCKSDB_JAVA_VERSION).jar.sha1 -C java/target rocksdbjni-$(ROCKSDB_JAVA_VERSION).jar.asc - $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), $(JAR_CMD) uf java/target/nexus-bundle-rocksdbjni-$(ROCKSDB_JAVA_VERSION).jar -C java/target rocksdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar -C java/target rocksdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.sha1 -C java/target rocksdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.asc;) + gpg --yes -ab java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION).jar + $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), gpg --yes -ab java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar;) + $(JAR_CMD) cvf java/target/nexus-bundle-forstdbjni-$(ROCKSDB_JAVA_VERSION).jar -C java pom.xml -C java/target pom.xml.sha1 -C java/target pom.xml.asc -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION).jar -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION).jar.sha1 -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION).jar.asc + $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), $(JAR_CMD) uf java/target/nexus-bundle-forstdbjni-$(ROCKSDB_JAVA_VERSION).jar -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.sha1 -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.asc;) # A version of each $(LIBOBJECTS) compiled with -fPIC @@ -2466,10 +2466,10 @@ ifeq ($(JAVA_HOME),) $(error JAVA_HOME is not set) endif $(AM_V_GEN)cd java; $(MAKE) javalib; - $(AM_V_at)rm -f ./java/target/$(ROCKSDBJNILIB) - $(AM_V_at)$(CXX) $(CXXFLAGS) -I./java/. -I./java/forstjni $(JAVA_INCLUDE) $(ROCKSDB_PLUGIN_JNI_CXX_INCLUDEFLAGS) -shared -fPIC -o ./java/target/$(ROCKSDBJNILIB) $(ALL_JNI_NATIVE_SOURCES) $(LIB_OBJECTS) $(JAVA_LDFLAGS) $(COVERAGEFLAGS) + $(AM_V_at)rm -f ./java/target/$(FORSTDBJNILIB) + $(AM_V_at)$(CXX) $(CXXFLAGS) -I./java/. -I./java/forstjni $(JAVA_INCLUDE) $(ROCKSDB_PLUGIN_JNI_CXX_INCLUDEFLAGS) -shared -fPIC -o ./java/target/$(FORSTDBJNILIB) $(ALL_JNI_NATIVE_SOURCES) $(LIB_OBJECTS) $(JAVA_LDFLAGS) $(COVERAGEFLAGS) $(AM_V_at)cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md - $(AM_V_at)cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) $(ROCKSDBJNILIB) + $(AM_V_at)cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) $(FORSTDBJNILIB) $(AM_V_at)cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class $(AM_V_at)openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 diff --git a/java/Makefile b/java/Makefile index 7a6915cf0..66a039845 100644 --- a/java/Makefile +++ b/java/Makefile @@ -357,32 +357,32 @@ java: java-version sample: java $(AM_V_GEN)mkdir -p $(SAMPLES_MAIN_CLASSES) $(AM_V_at)$(JAVAC_CMD) $(JAVAC_ARGS) -cp $(MAIN_CLASSES) -d $(SAMPLES_MAIN_CLASSES) $(SAMPLES_MAIN_SRC)/RocksDBSample.java - $(AM_V_at)@rm -rf /tmp/rocksdbjni - $(AM_V_at)@rm -rf /tmp/rocksdbjni_not_found - $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) RocksDBSample /tmp/rocksdbjni - $(AM_V_at)@rm -rf /tmp/rocksdbjni - $(AM_V_at)@rm -rf /tmp/rocksdbjni_not_found + $(AM_V_at)@rm -rf /tmp/forstdbjni + $(AM_V_at)@rm -rf /tmp/forstdbjni_not_found + $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) RocksDBSample /tmp/forstdbjni + $(AM_V_at)@rm -rf /tmp/forstdbjni + $(AM_V_at)@rm -rf /tmp/forstdbjni_not_found column_family_sample: java $(AM_V_GEN)mkdir -p $(SAMPLES_MAIN_CLASSES) $(AM_V_at)$(JAVAC_CMD) $(JAVAC_ARGS) -cp $(MAIN_CLASSES) -d $(SAMPLES_MAIN_CLASSES) $(SAMPLES_MAIN_SRC)/RocksDBColumnFamilySample.java - $(AM_V_at)@rm -rf /tmp/rocksdbjni - $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) RocksDBColumnFamilySample /tmp/rocksdbjni - $(AM_V_at)@rm -rf /tmp/rocksdbjni + $(AM_V_at)@rm -rf /tmp/forstdbjni + $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) RocksDBColumnFamilySample /tmp/forstdbjni + $(AM_V_at)@rm -rf /tmp/forstdbjni transaction_sample: java $(AM_V_GEN)mkdir -p $(SAMPLES_MAIN_CLASSES) $(AM_V_at)$(JAVAC_CMD) -cp $(MAIN_CLASSES) -d $(SAMPLES_MAIN_CLASSES) $(SAMPLES_MAIN_SRC)/TransactionSample.java - $(AM_V_at)@rm -rf /tmp/rocksdbjni - $(JAVA_CMD) -ea -Xcheck:jni -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) TransactionSample /tmp/rocksdbjni - $(AM_V_at)@rm -rf /tmp/rocksdbjni + $(AM_V_at)@rm -rf /tmp/forstdbjni + $(JAVA_CMD) -ea -Xcheck:jni -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) TransactionSample /tmp/forstdbjni + $(AM_V_at)@rm -rf /tmp/forstdbjni optimistic_transaction_sample: java $(AM_V_GEN)mkdir -p $(SAMPLES_MAIN_CLASSES) $(AM_V_at)$(JAVAC_CMD) -cp $(MAIN_CLASSES) -d $(SAMPLES_MAIN_CLASSES) $(SAMPLES_MAIN_SRC)/OptimisticTransactionSample.java - $(AM_V_at)@rm -rf /tmp/rocksdbjni - $(JAVA_CMD) -ea -Xcheck:jni -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) OptimisticTransactionSample /tmp/rocksdbjni - $(AM_V_at)@rm -rf /tmp/rocksdbjni + $(AM_V_at)@rm -rf /tmp/forstdbjni + $(JAVA_CMD) -ea -Xcheck:jni -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) OptimisticTransactionSample /tmp/forstdbjni + $(AM_V_at)@rm -rf /tmp/forstdbjni $(JAVA_TEST_LIBDIR): mkdir -p "$(JAVA_TEST_LIBDIR)" diff --git a/java/src/main/java/org/forstdb/NativeLibraryLoader.java b/java/src/main/java/org/forstdb/NativeLibraryLoader.java index 955ddc6bb..478119dcf 100644 --- a/java/src/main/java/org/forstdb/NativeLibraryLoader.java +++ b/java/src/main/java/org/forstdb/NativeLibraryLoader.java @@ -16,7 +16,7 @@ public class NativeLibraryLoader { private static final NativeLibraryLoader instance = new NativeLibraryLoader(); private static boolean initialized = false; - private static final String ROCKSDB_LIBRARY_NAME = "rocksdb"; + private static final String ROCKSDB_LIBRARY_NAME = "forstdb"; private static final String sharedLibraryName = Environment.getSharedLibraryName(ROCKSDB_LIBRARY_NAME); @@ -27,7 +27,7 @@ public class NativeLibraryLoader { Environment.getJniLibraryFileName(ROCKSDB_LIBRARY_NAME); private static final /* @Nullable */ String fallbackJniLibraryFileName = Environment.getFallbackJniLibraryFileName(ROCKSDB_LIBRARY_NAME); - private static final String tempFilePrefix = "librocksdbjni"; + private static final String tempFilePrefix = "libforstdbjni"; private static final String tempFileSuffix = Environment.getJniLibraryExtension(); /** From 98f5a1a8fe0eb5abd641f54ad207703049905cdd Mon Sep 17 00:00:00 2001 From: fredia Date: Fri, 27 Sep 2024 16:23:00 +0800 Subject: [PATCH 52/61] [FLINK-35928][build] break when loading library is interrupted --- java/src/main/java/org/forstdb/RocksDB.java | 6 ++++-- java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/java/src/main/java/org/forstdb/RocksDB.java b/java/src/main/java/org/forstdb/RocksDB.java index 76f74609a..ede573454 100644 --- a/java/src/main/java/org/forstdb/RocksDB.java +++ b/java/src/main/java/org/forstdb/RocksDB.java @@ -88,7 +88,8 @@ public static void loadLibrary() { try { Thread.sleep(10); } catch(final InterruptedException e) { - //ignore + throw new RuntimeException("Loading the RocksDB shared library is interrupted", + e); } } } @@ -150,7 +151,8 @@ public static void loadLibrary(final List paths) { try { Thread.sleep(10); } catch(final InterruptedException e) { - //ignore + throw new RuntimeException("Loading the RocksDB shared library is interrupted", + e); } } } diff --git a/java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java b/java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java index 4a983ae64..bf383c91f 100644 --- a/java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java +++ b/java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java @@ -25,7 +25,7 @@ public void tempFolder() throws IOException { NativeLibraryLoader.getInstance().loadLibraryFromJarToTemp( temporaryFolder.getRoot().getAbsolutePath()); final Path path = Paths.get(temporaryFolder.getRoot().getAbsolutePath(), - Environment.getJniLibraryFileName("rocksdb")); + Environment.getJniLibraryFileName("forstdb")); assertThat(Files.exists(path)).isTrue(); assertThat(Files.isReadable(path)).isTrue(); } From eef75e6ac77b1b45d399e43aebe2448ae3690883 Mon Sep 17 00:00:00 2001 From: fredia Date: Fri, 27 Sep 2024 18:03:33 +0800 Subject: [PATCH 53/61] [FLINK-35928][build] rename forstdbjni to forstjni --- Makefile | 80 +++++++++---------- java/Makefile | 28 +++---- java/crossbuild/build-linux-alpine.sh | 4 +- java/crossbuild/build-linux-centos.sh | 4 +- java/crossbuild/build-linux.sh | 4 +- java/crossbuild/build-win.bat | 4 +- java/crossbuild/docker-build-linux-alpine.sh | 2 +- java/crossbuild/docker-build-linux-centos.sh | 2 +- .../java/org/forstdb/NativeLibraryLoader.java | 4 +- .../org/forstdb/NativeLibraryLoaderTest.java | 2 +- 10 files changed, 67 insertions(+), 67 deletions(-) diff --git a/Makefile b/Makefile index c5d8f7155..b643f96a1 100644 --- a/Makefile +++ b/Makefile @@ -2109,18 +2109,18 @@ ifneq ($(origin JNI_LIBC), undefined) JNI_LIBC_POSTFIX = -$(JNI_LIBC) endif -ifeq (,$(FORSTDBJNILIB)) +ifeq (,$(FORSTJNILIB)) ifneq (,$(filter ppc% s390x arm64 aarch64 riscv64 sparc64 loongarch64, $(MACHINE))) - FORSTDBJNILIB = libforstdbjni-linux-$(MACHINE)$(JNI_LIBC_POSTFIX).so + FORSTJNILIB = libforstjni-linux-$(MACHINE)$(JNI_LIBC_POSTFIX).so else - FORSTDBJNILIB = libforstdbjni-linux$(ARCH)$(JNI_LIBC_POSTFIX).so + FORSTJNILIB = libforstjni-linux$(ARCH)$(JNI_LIBC_POSTFIX).so endif endif ROCKSDB_JAVA_VERSION ?= $(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH) -ROCKSDB_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-linux$(ARCH)$(JNI_LIBC_POSTFIX).jar -ROCKSDB_JAR_ALL = forstdbjni-$(ROCKSDB_JAVA_VERSION).jar -ROCKSDB_JAVADOCS_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-javadoc.jar -ROCKSDB_SOURCES_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-sources.jar +ROCKSDB_JAR = forstjni-$(ROCKSDB_JAVA_VERSION)-linux$(ARCH)$(JNI_LIBC_POSTFIX).jar +ROCKSDB_JAR_ALL = forstjni-$(ROCKSDB_JAVA_VERSION).jar +ROCKSDB_JAVADOCS_JAR = forstjni-$(ROCKSDB_JAVA_VERSION)-javadoc.jar +ROCKSDB_SOURCES_JAR = forstjni-$(ROCKSDB_JAVA_VERSION)-sources.jar SHA256_CMD = sha256sum ZLIB_VER ?= 1.3 @@ -2141,16 +2141,16 @@ ZSTD_DOWNLOAD_BASE ?= https://github.com/facebook/zstd/archive CURL_SSL_OPTS ?= --tlsv1 ifeq ($(PLATFORM), OS_MACOSX) -ifeq (,$(findstring libforstdbjni-osx,$(FORSTDBJNILIB))) +ifeq (,$(findstring libforstjni-osx,$(FORSTJNILIB))) ifeq ($(MACHINE),arm64) - FORSTDBJNILIB = libforstdbjni-osx-arm64.jnilib + FORSTJNILIB = libforstjni-osx-arm64.jnilib else ifeq ($(MACHINE),x86_64) - FORSTDBJNILIB = libforstdbjni-osx-x86_64.jnilib + FORSTJNILIB = libforstjni-osx-x86_64.jnilib else - FORSTDBJNILIB = libforstdbjni-osx.jnilib + FORSTJNILIB = libforstjni-osx.jnilib endif endif - ROCKSDB_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-osx.jar + ROCKSDB_JAR = forstjni-$(ROCKSDB_JAVA_VERSION)-osx.jar SHA256_CMD = openssl sha256 -r ifneq ("$(wildcard $(JAVA_HOME)/include/darwin)","") JAVA_INCLUDE = -I$(JAVA_HOME)/include -I $(JAVA_HOME)/include/darwin @@ -2161,25 +2161,25 @@ endif ifeq ($(PLATFORM), OS_FREEBSD) JAVA_INCLUDE = -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/freebsd - FORSTDBJNILIB = libforstdbjni-freebsd$(ARCH).so - ROCKSDB_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-freebsd$(ARCH).jar + FORSTJNILIB = libforstjni-freebsd$(ARCH).so + ROCKSDB_JAR = forstjni-$(ROCKSDB_JAVA_VERSION)-freebsd$(ARCH).jar endif ifeq ($(PLATFORM), OS_SOLARIS) - FORSTDBJNILIB = libforstdbjni-solaris$(ARCH).so - ROCKSDB_JAR = forstdbjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH)-solaris$(ARCH).jar + FORSTJNILIB = libforstjni-solaris$(ARCH).so + ROCKSDB_JAR = forstjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH)-solaris$(ARCH).jar JAVA_INCLUDE = -I$(JAVA_HOME)/include/ -I$(JAVA_HOME)/include/solaris SHA256_CMD = digest -a sha256 endif ifeq ($(PLATFORM), OS_AIX) JAVA_INCLUDE = -I$(JAVA_HOME)/include/ -I$(JAVA_HOME)/include/aix - FORSTDBJNILIB = libforstdbjni-aix.so + FORSTJNILIB = libforstjni-aix.so EXTRACT_SOURCES = gunzip < TAR_GZ | tar xvf - SNAPPY_MAKE_TARGET = libsnappy.la endif ifeq ($(PLATFORM), OS_OPENBSD) JAVA_INCLUDE = -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/openbsd - FORSTDBJNILIB = libforstdbjni-openbsd$(ARCH).so - ROCKSDB_JAR = forstdbjni-$(ROCKSDB_JAVA_VERSION)-openbsd$(ARCH).jar + FORSTJNILIB = libforstjni-openbsd$(ARCH).so + ROCKSDB_JAR = forstjni-$(ROCKSDB_JAVA_VERSION)-openbsd$(ARCH).jar endif export SHA256_CMD @@ -2281,14 +2281,14 @@ endif rocksdbjavastaticosx: rocksdbjavastaticosx_archs cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md - cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) libforstdbjni-osx-x86_64.jnilib libforstdbjni-osx-arm64.jnilib + cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) libforstjni-osx-x86_64.jnilib libforstjni-osx-arm64.jnilib cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 rocksdbjavastaticosx_ub: rocksdbjavastaticosx_archs - cd java/target; lipo -create -output libforstdbjni-osx.jnilib libforstdbjni-osx-x86_64.jnilib libforstdbjni-osx-arm64.jnilib + cd java/target; lipo -create -output libforstjni-osx.jnilib libforstjni-osx-x86_64.jnilib libforstjni-osx-arm64.jnilib cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md - cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) libforstdbjni-osx.jnilib + cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) libforstjni-osx.jnilib cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 @@ -2304,7 +2304,7 @@ endif $(MAKE) clean-rocks ARCHFLAG="-arch $*" $(MAKE) rocksdbjavastatic_deps ARCHFLAG="-arch $*" $(MAKE) rocksdbjavastatic_libobjects - ARCHFLAG="-arch $*" FORSTDBJNILIB="libforstdbjni-osx-$*.jnilib" $(MAKE) rocksdbjavastatic_javalib + ARCHFLAG="-arch $*" FORSTJNILIB="libforstjni-osx-$*.jnilib" $(MAKE) rocksdbjavastatic_javalib ifeq ($(JAR_CMD),) ifneq ($(JAVA_HOME),) @@ -2315,18 +2315,18 @@ endif endif rocksdbjavastatic_javalib: cd java; $(MAKE) javalib - rm -f java/target/$(FORSTDBJNILIB) + rm -f java/target/$(FORSTJNILIB) $(CXX) $(CXXFLAGS) -I./java/. $(JAVA_INCLUDE) -shared -fPIC \ - -o ./java/target/$(FORSTDBJNILIB) $(ALL_JNI_NATIVE_SOURCES) \ + -o ./java/target/$(FORSTJNILIB) $(ALL_JNI_NATIVE_SOURCES) \ $(LIB_OBJECTS) $(COVERAGEFLAGS) \ $(JAVA_COMPRESSIONS) $(JAVA_STATIC_LDFLAGS) cd java/target;if [ "$(DEBUG_LEVEL)" == "0" ]; then \ - strip $(STRIPFLAGS) $(FORSTDBJNILIB); \ + strip $(STRIPFLAGS) $(FORSTJNILIB); \ fi rocksdbjava_jar: cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md - cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) $(FORSTDBJNILIB) + cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) $(FORSTJNILIB) cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 @@ -2345,14 +2345,14 @@ rocksdbjavastatic_libobjects: $(LIB_OBJECTS) rocksdbjavastaticrelease: rocksdbjavastaticosx rocksdbjava_javadocs_jar rocksdbjava_sources_jar cd java/crossbuild && (vagrant destroy -f || true) && vagrant up linux32 && vagrant halt linux32 && vagrant up linux64 && vagrant halt linux64 && vagrant up linux64-musl && vagrant halt linux64-musl cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR_ALL) HISTORY*.md - cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) libforstdbjni-*.so libforstdbjni-*.jnilib + cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) libforstjni-*.so libforstjni-*.jnilib cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR_ALL) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR_ALL) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR_ALL).sha1 rocksdbjavastaticreleasedocker: rocksdbjavastaticosx rocksdbjavastaticdockerx86 rocksdbjavastaticdockerx86_64 rocksdbjavastaticdockerx86musl rocksdbjavastaticdockerx86_64musl rocksdbjava_javadocs_jar rocksdbjava_sources_jar cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR_ALL) HISTORY*.md jar -uf java/target/$(ROCKSDB_JAR_ALL) HISTORY*.md - cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) libforstdbjni-*.so libforstdbjni-*.jnilib libforstdbjni-win64.dll + cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR_ALL) libforstjni-*.so libforstjni-*.jnilib libforstjni-win64.dll cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR_ALL) org/forstdb/*.class org/forstdb/util/*.class openssl sha1 java/target/$(ROCKSDB_JAR_ALL) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR_ALL).sha1 @@ -2439,21 +2439,21 @@ rocksdbjavastaticpublishdocker: rocksdbjavastaticreleasedocker rocksdbjavastatic ROCKSDB_JAVA_RELEASE_CLASSIFIERS = javadoc sources linux64 linux32 linux64-musl linux32-musl osx win64 rocksdbjavastaticpublishcentral: rocksdbjavageneratepom - mvn gpg:sign-and-deploy-file -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ -DrepositoryId=sonatype-nexus-staging -DpomFile=java/pom.xml -Dfile=java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION).jar - $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), mvn gpg:sign-and-deploy-file -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ -DrepositoryId=sonatype-nexus-staging -DpomFile=java/pom.xml -Dfile=java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar -Dclassifier=$(classifier);) + mvn gpg:sign-and-deploy-file -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ -DrepositoryId=sonatype-nexus-staging -DpomFile=java/pom.xml -Dfile=java/target/forstjni-$(ROCKSDB_JAVA_VERSION).jar + $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), mvn gpg:sign-and-deploy-file -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ -DrepositoryId=sonatype-nexus-staging -DpomFile=java/pom.xml -Dfile=java/target/forstjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar -Dclassifier=$(classifier);) rocksdbjavageneratepom: cd java;cat pom.xml.template | sed 's/\$${ROCKSDB_JAVA_VERSION}/$(ROCKSDB_JAVA_VERSION)/' > pom.xml rocksdbjavastaticnexusbundlejar: rocksdbjavageneratepom openssl sha1 -r java/pom.xml | awk '{ print $$1 }' > java/target/pom.xml.sha1 - openssl sha1 -r java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION).jar | awk '{ print $$1 }' > java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION).jar.sha1 - $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), openssl sha1 -r java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar | awk '{ print $$1 }' > java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.sha1;) + openssl sha1 -r java/target/forstjni-$(ROCKSDB_JAVA_VERSION).jar | awk '{ print $$1 }' > java/target/forstjni-$(ROCKSDB_JAVA_VERSION).jar.sha1 + $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), openssl sha1 -r java/target/forstjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar | awk '{ print $$1 }' > java/target/forstjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.sha1;) gpg --yes --output java/target/pom.xml.asc -ab java/pom.xml - gpg --yes -ab java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION).jar - $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), gpg --yes -ab java/target/forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar;) - $(JAR_CMD) cvf java/target/nexus-bundle-forstdbjni-$(ROCKSDB_JAVA_VERSION).jar -C java pom.xml -C java/target pom.xml.sha1 -C java/target pom.xml.asc -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION).jar -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION).jar.sha1 -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION).jar.asc - $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), $(JAR_CMD) uf java/target/nexus-bundle-forstdbjni-$(ROCKSDB_JAVA_VERSION).jar -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.sha1 -C java/target forstdbjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.asc;) + gpg --yes -ab java/target/forstjni-$(ROCKSDB_JAVA_VERSION).jar + $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), gpg --yes -ab java/target/forstjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar;) + $(JAR_CMD) cvf java/target/nexus-bundle-forstjni-$(ROCKSDB_JAVA_VERSION).jar -C java pom.xml -C java/target pom.xml.sha1 -C java/target pom.xml.asc -C java/target forstjni-$(ROCKSDB_JAVA_VERSION).jar -C java/target forstjni-$(ROCKSDB_JAVA_VERSION).jar.sha1 -C java/target forstjni-$(ROCKSDB_JAVA_VERSION).jar.asc + $(foreach classifier, $(ROCKSDB_JAVA_RELEASE_CLASSIFIERS), $(JAR_CMD) uf java/target/nexus-bundle-forstjni-$(ROCKSDB_JAVA_VERSION).jar -C java/target forstjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar -C java/target forstjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.sha1 -C java/target forstjni-$(ROCKSDB_JAVA_VERSION)-$(classifier).jar.asc;) # A version of each $(LIBOBJECTS) compiled with -fPIC @@ -2466,10 +2466,10 @@ ifeq ($(JAVA_HOME),) $(error JAVA_HOME is not set) endif $(AM_V_GEN)cd java; $(MAKE) javalib; - $(AM_V_at)rm -f ./java/target/$(FORSTDBJNILIB) - $(AM_V_at)$(CXX) $(CXXFLAGS) -I./java/. -I./java/forstjni $(JAVA_INCLUDE) $(ROCKSDB_PLUGIN_JNI_CXX_INCLUDEFLAGS) -shared -fPIC -o ./java/target/$(FORSTDBJNILIB) $(ALL_JNI_NATIVE_SOURCES) $(LIB_OBJECTS) $(JAVA_LDFLAGS) $(COVERAGEFLAGS) + $(AM_V_at)rm -f ./java/target/$(FORSTJNILIB) + $(AM_V_at)$(CXX) $(CXXFLAGS) -I./java/. -I./java/forstjni $(JAVA_INCLUDE) $(ROCKSDB_PLUGIN_JNI_CXX_INCLUDEFLAGS) -shared -fPIC -o ./java/target/$(FORSTJNILIB) $(ALL_JNI_NATIVE_SOURCES) $(LIB_OBJECTS) $(JAVA_LDFLAGS) $(COVERAGEFLAGS) $(AM_V_at)cd java; $(JAR_CMD) -cf target/$(ROCKSDB_JAR) HISTORY*.md - $(AM_V_at)cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) $(FORSTDBJNILIB) + $(AM_V_at)cd java/target; $(JAR_CMD) -uf $(ROCKSDB_JAR) $(FORSTJNILIB) $(AM_V_at)cd java/target/classes; $(JAR_CMD) -uf ../$(ROCKSDB_JAR) org/forstdb/*.class org/forstdb/util/*.class $(AM_V_at)openssl sha1 java/target/$(ROCKSDB_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAR).sha1 diff --git a/java/Makefile b/java/Makefile index 66a039845..a73288a85 100644 --- a/java/Makefile +++ b/java/Makefile @@ -357,32 +357,32 @@ java: java-version sample: java $(AM_V_GEN)mkdir -p $(SAMPLES_MAIN_CLASSES) $(AM_V_at)$(JAVAC_CMD) $(JAVAC_ARGS) -cp $(MAIN_CLASSES) -d $(SAMPLES_MAIN_CLASSES) $(SAMPLES_MAIN_SRC)/RocksDBSample.java - $(AM_V_at)@rm -rf /tmp/forstdbjni - $(AM_V_at)@rm -rf /tmp/forstdbjni_not_found - $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) RocksDBSample /tmp/forstdbjni - $(AM_V_at)@rm -rf /tmp/forstdbjni - $(AM_V_at)@rm -rf /tmp/forstdbjni_not_found + $(AM_V_at)@rm -rf /tmp/forstjni + $(AM_V_at)@rm -rf /tmp/forstjni_not_found + $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) RocksDBSample /tmp/forstjni + $(AM_V_at)@rm -rf /tmp/forstjni + $(AM_V_at)@rm -rf /tmp/forstjni_not_found column_family_sample: java $(AM_V_GEN)mkdir -p $(SAMPLES_MAIN_CLASSES) $(AM_V_at)$(JAVAC_CMD) $(JAVAC_ARGS) -cp $(MAIN_CLASSES) -d $(SAMPLES_MAIN_CLASSES) $(SAMPLES_MAIN_SRC)/RocksDBColumnFamilySample.java - $(AM_V_at)@rm -rf /tmp/forstdbjni - $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) RocksDBColumnFamilySample /tmp/forstdbjni - $(AM_V_at)@rm -rf /tmp/forstdbjni + $(AM_V_at)@rm -rf /tmp/forstjni + $(JAVA_CMD) $(JAVA_ARGS) -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) RocksDBColumnFamilySample /tmp/forstjni + $(AM_V_at)@rm -rf /tmp/forstjni transaction_sample: java $(AM_V_GEN)mkdir -p $(SAMPLES_MAIN_CLASSES) $(AM_V_at)$(JAVAC_CMD) -cp $(MAIN_CLASSES) -d $(SAMPLES_MAIN_CLASSES) $(SAMPLES_MAIN_SRC)/TransactionSample.java - $(AM_V_at)@rm -rf /tmp/forstdbjni - $(JAVA_CMD) -ea -Xcheck:jni -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) TransactionSample /tmp/forstdbjni - $(AM_V_at)@rm -rf /tmp/forstdbjni + $(AM_V_at)@rm -rf /tmp/forstjni + $(JAVA_CMD) -ea -Xcheck:jni -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) TransactionSample /tmp/forstjni + $(AM_V_at)@rm -rf /tmp/forstjni optimistic_transaction_sample: java $(AM_V_GEN)mkdir -p $(SAMPLES_MAIN_CLASSES) $(AM_V_at)$(JAVAC_CMD) -cp $(MAIN_CLASSES) -d $(SAMPLES_MAIN_CLASSES) $(SAMPLES_MAIN_SRC)/OptimisticTransactionSample.java - $(AM_V_at)@rm -rf /tmp/forstdbjni - $(JAVA_CMD) -ea -Xcheck:jni -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) OptimisticTransactionSample /tmp/forstdbjni - $(AM_V_at)@rm -rf /tmp/forstdbjni + $(AM_V_at)@rm -rf /tmp/forstjni + $(JAVA_CMD) -ea -Xcheck:jni -Djava.library.path=target -cp $(MAIN_CLASSES):$(SAMPLES_MAIN_CLASSES) OptimisticTransactionSample /tmp/forstjni + $(AM_V_at)@rm -rf /tmp/forstjni $(JAVA_TEST_LIBDIR): mkdir -p "$(JAVA_TEST_LIBDIR)" diff --git a/java/crossbuild/build-linux-alpine.sh b/java/crossbuild/build-linux-alpine.sh index 561d34141..646f9bff9 100755 --- a/java/crossbuild/build-linux-alpine.sh +++ b/java/crossbuild/build-linux-alpine.sh @@ -66,5 +66,5 @@ cd /tmp &&\ cd /rocksdb make jclean clean PORTABLE=1 make -j8 rocksdbjavastatic -cp /rocksdb/java/target/librocksdbjni-* /rocksdb-build -cp /rocksdb/java/target/rocksdbjni-* /rocksdb-build +cp /rocksdb/java/target/libforstjni-* /rocksdb-build +cp /rocksdb/java/target/forstjni-* /rocksdb-build diff --git a/java/crossbuild/build-linux-centos.sh b/java/crossbuild/build-linux-centos.sh index 176e3456c..e00729246 100755 --- a/java/crossbuild/build-linux-centos.sh +++ b/java/crossbuild/build-linux-centos.sh @@ -34,5 +34,5 @@ export PATH=$JAVA_HOME:/usr/local/bin:$PATH cd /rocksdb scl enable devtoolset-2 'make clean-not-downloaded' scl enable devtoolset-2 'PORTABLE=1 make -j8 rocksdbjavastatic' -cp /rocksdb/java/target/librocksdbjni-* /rocksdb-build -cp /rocksdb/java/target/rocksdbjni-* /rocksdb-build +cp /rocksdb/java/target/libforstjni-* /rocksdb-build +cp /rocksdb/java/target/forstjni-* /rocksdb-build diff --git a/java/crossbuild/build-linux.sh b/java/crossbuild/build-linux.sh index 74178adb5..34caa57ea 100755 --- a/java/crossbuild/build-linux.sh +++ b/java/crossbuild/build-linux.sh @@ -9,7 +9,7 @@ export JAVA_HOME=$(echo /usr/lib/jvm/java-7-openjdk*) cd /rocksdb make jclean clean make -j 4 rocksdbjavastatic -cp /rocksdb/java/target/librocksdbjni-* /rocksdb-build -cp /rocksdb/java/target/rocksdbjni-* /rocksdb-build +cp /rocksdb/java/target/libforstjni-* /rocksdb-build +cp /rocksdb/java/target/forstjni-* /rocksdb-build sudo shutdown -h now diff --git a/java/crossbuild/build-win.bat b/java/crossbuild/build-win.bat index 2925ec19a..d0bea9f80 100644 --- a/java/crossbuild/build-win.bat +++ b/java/crossbuild/build-win.bat @@ -12,5 +12,5 @@ cmake -G "Visual Studio 15 Win64" -DWITH_JNI=1 .. cd .. -copy build\java\Release\rocksdbjni-shared.dll librocksdbjni-win64.dll -echo Result is in librocksdbjni-win64.dll \ No newline at end of file +copy build\java\Release\forstjni-shared.dll libforstjni-win64.dll +echo Result is in libforstjni-win64.dll \ No newline at end of file diff --git a/java/crossbuild/docker-build-linux-alpine.sh b/java/crossbuild/docker-build-linux-alpine.sh index e3e852efe..fddef0ff1 100755 --- a/java/crossbuild/docker-build-linux-alpine.sh +++ b/java/crossbuild/docker-build-linux-alpine.sh @@ -14,4 +14,4 @@ cd /rocksdb-local-build make clean-not-downloaded PORTABLE=1 make -j2 rocksdbjavastatic -cp java/target/librocksdbjni-linux*.so java/target/rocksdbjni-*-linux*.jar java/target/rocksdbjni-*-linux*.jar.sha1 /rocksdb-java-target +cp java/target/libforstjni-linux*.so java/target/forstjni-*-linux*.jar java/target/forstjni-*-linux*.jar.sha1 /rocksdb-java-target diff --git a/java/crossbuild/docker-build-linux-centos.sh b/java/crossbuild/docker-build-linux-centos.sh index 16581dec7..30ab8c39e 100755 --- a/java/crossbuild/docker-build-linux-centos.sh +++ b/java/crossbuild/docker-build-linux-centos.sh @@ -34,5 +34,5 @@ else PORTABLE=1 make -j2 rocksdbjavastatic fi -cp java/target/librocksdbjni-linux*.so java/target/rocksdbjni-*-linux*.jar java/target/rocksdbjni-*-linux*.jar.sha1 /rocksdb-java-target +cp java/target/libforstjni-linux*.so java/target/forstjni-*-linux*.jar java/target/forstjni-*-linux*.jar.sha1 /rocksdb-java-target diff --git a/java/src/main/java/org/forstdb/NativeLibraryLoader.java b/java/src/main/java/org/forstdb/NativeLibraryLoader.java index 478119dcf..092588fba 100644 --- a/java/src/main/java/org/forstdb/NativeLibraryLoader.java +++ b/java/src/main/java/org/forstdb/NativeLibraryLoader.java @@ -16,7 +16,7 @@ public class NativeLibraryLoader { private static final NativeLibraryLoader instance = new NativeLibraryLoader(); private static boolean initialized = false; - private static final String ROCKSDB_LIBRARY_NAME = "forstdb"; + private static final String ROCKSDB_LIBRARY_NAME = "forst"; private static final String sharedLibraryName = Environment.getSharedLibraryName(ROCKSDB_LIBRARY_NAME); @@ -27,7 +27,7 @@ public class NativeLibraryLoader { Environment.getJniLibraryFileName(ROCKSDB_LIBRARY_NAME); private static final /* @Nullable */ String fallbackJniLibraryFileName = Environment.getFallbackJniLibraryFileName(ROCKSDB_LIBRARY_NAME); - private static final String tempFilePrefix = "libforstdbjni"; + private static final String tempFilePrefix = "libforstjni"; private static final String tempFileSuffix = Environment.getJniLibraryExtension(); /** diff --git a/java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java b/java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java index bf383c91f..4463f51f5 100644 --- a/java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java +++ b/java/src/test/java/org/forstdb/NativeLibraryLoaderTest.java @@ -25,7 +25,7 @@ public void tempFolder() throws IOException { NativeLibraryLoader.getInstance().loadLibraryFromJarToTemp( temporaryFolder.getRoot().getAbsolutePath()); final Path path = Paths.get(temporaryFolder.getRoot().getAbsolutePath(), - Environment.getJniLibraryFileName("forstdb")); + Environment.getJniLibraryFileName("forst")); assertThat(Files.exists(path)).isTrue(); assertThat(Files.isReadable(path)).isTrue(); } From 2faec9e8b543cbf8aace84820ce42f7d47dd34af Mon Sep 17 00:00:00 2001 From: fredia Date: Fri, 18 Oct 2024 14:52:10 +0800 Subject: [PATCH 54/61] [FLINK-35928][build] Rename jclass to forst in *.cc --- java/forstjni/checkpoint.cc | 2 +- java/forstjni/columnfamilyhandle.cc | 2 +- java/forstjni/compact_range_options.cc | 2 +- java/forstjni/compaction_filter.cc | 2 +- java/forstjni/compaction_job_info.cc | 2 +- java/forstjni/env.cc | 2 +- java/forstjni/flink_compactionfilterjni.cc | 10 +++++----- java/forstjni/jnicallback.cc | 2 +- java/forstjni/options.cc | 4 ++-- java/forstjni/options_util.cc | 2 +- java/forstjni/rocks_callback_object.cc | 2 +- java/forstjni/rocksjni.cc | 8 ++++---- java/forstjni/slice.cc | 6 +++--- java/forstjni/statistics.cc | 2 +- java/forstjni/table_filter.cc | 2 +- java/forstjni/transaction.cc | 2 +- java/forstjni/transaction_db.cc | 2 +- java/forstjni/transaction_log.cc | 2 +- java/forstjni/ttl.cc | 2 +- java/forstjni/write_batch.cc | 2 +- java/forstjni/write_batch_with_index.cc | 4 ++-- utilities/flink/flink_compaction_filter_test.cc | 4 ++-- 22 files changed, 34 insertions(+), 34 deletions(-) diff --git a/java/forstjni/checkpoint.cc b/java/forstjni/checkpoint.cc index dd689b5aa..7a2fd3b8d 100644 --- a/java/forstjni/checkpoint.cc +++ b/java/forstjni/checkpoint.cc @@ -73,7 +73,7 @@ void Java_org_forstdb_Checkpoint_createCheckpoint(JNIEnv* env, jobject /*jobj*/, /* * Class: org_forstdb_Checkpoint * Method: exportColumnFamily - * Signature: (JJLjava/lang/String;)Lorg/rocksdb/ExportImportFilesMetaData; + * Signature: (JJLjava/lang/String;)Lorg/forstdb/ExportImportFilesMetaData; */ jlong Java_org_forstdb_Checkpoint_exportColumnFamily( JNIEnv* env, jobject /*jobj*/, jlong jcheckpoint_handle, diff --git a/java/forstjni/columnfamilyhandle.cc b/java/forstjni/columnfamilyhandle.cc index abca5ff5f..e548a1674 100644 --- a/java/forstjni/columnfamilyhandle.cc +++ b/java/forstjni/columnfamilyhandle.cc @@ -42,7 +42,7 @@ jint Java_org_forstdb_ColumnFamilyHandle_getID(JNIEnv* /*env*/, /* * Class: org_forstdb_ColumnFamilyHandle * Method: getDescriptor - * Signature: (J)Lorg/rocksdb/ColumnFamilyDescriptor; + * Signature: (J)Lorg/forstdb/ColumnFamilyDescriptor; */ jobject Java_org_forstdb_ColumnFamilyHandle_getDescriptor(JNIEnv* env, jobject /*jobj*/, diff --git a/java/forstjni/compact_range_options.cc b/java/forstjni/compact_range_options.cc index 89d8a9156..6f3e1c84e 100644 --- a/java/forstjni/compact_range_options.cc +++ b/java/forstjni/compact_range_options.cc @@ -280,7 +280,7 @@ void Java_org_forstdb_CompactRangeOptions_setFullHistoryTSLow(JNIEnv*, jobject, /* * Class: org_forstdb_CompactRangeOptions * Method: fullHistoryTSLow - * Signature: (J)Lorg/rocksdb/CompactRangeOptions/Timestamp; + * Signature: (J)Lorg/forstdb/CompactRangeOptions/Timestamp; */ jobject Java_org_forstdb_CompactRangeOptions_fullHistoryTSLow(JNIEnv* env, jobject, diff --git a/java/forstjni/compaction_filter.cc b/java/forstjni/compaction_filter.cc index f45234896..739447f96 100644 --- a/java/forstjni/compaction_filter.cc +++ b/java/forstjni/compaction_filter.cc @@ -12,7 +12,7 @@ #include "include/org_forstdb_AbstractCompactionFilter.h" -// +// /* * Class: org_forstdb_AbstractCompactionFilter diff --git a/java/forstjni/compaction_job_info.cc b/java/forstjni/compaction_job_info.cc index b6bef26e1..4097876ba 100644 --- a/java/forstjni/compaction_job_info.cc +++ b/java/forstjni/compaction_job_info.cc @@ -51,7 +51,7 @@ jbyteArray Java_org_forstdb_CompactionJobInfo_columnFamilyName(JNIEnv* env, /* * Class: org_forstdb_CompactionJobInfo * Method: status - * Signature: (J)Lorg/rocksdb/Status; + * Signature: (J)Lorg/forstdb/Status; */ jobject Java_org_forstdb_CompactionJobInfo_status(JNIEnv* env, jclass, jlong jhandle) { diff --git a/java/forstjni/env.cc b/java/forstjni/env.cc index bde4ed574..32a9bbe01 100644 --- a/java/forstjni/env.cc +++ b/java/forstjni/env.cc @@ -123,7 +123,7 @@ void Java_org_forstdb_Env_lowerThreadPoolCPUPriority(JNIEnv*, jobject, /* * Class: org_forstdb_Env * Method: getThreadList - * Signature: (J)[Lorg/rocksdb/ThreadStatus; + * Signature: (J)[Lorg/forstdb/ThreadStatus; */ jobjectArray Java_org_forstdb_Env_getThreadList(JNIEnv* env, jobject, jlong jhandle) { diff --git a/java/forstjni/flink_compactionfilterjni.cc b/java/forstjni/flink_compactionfilterjni.cc index 793c56698..0f17cd4b3 100644 --- a/java/forstjni/flink_compactionfilterjni.cc +++ b/java/forstjni/flink_compactionfilterjni.cc @@ -39,7 +39,7 @@ class JavaListElementFilter JavaListElementFilter(JNIEnv* env, jobject jlist_filter) : JniCallbackBase(env, jlist_filter) { jclass jclazz = ROCKSDB_NAMESPACE::JavaClass::getJClass( - env, "org/rocksdb/FlinkCompactionFilter$ListElementFilter"); + env, "org/forstdb/FlinkCompactionFilter$ListElementFilter"); if (jclazz == nullptr) { // exception occurred accessing class return; @@ -82,14 +82,14 @@ class JavaListElemenFilterFactory JavaListElemenFilterFactory(JNIEnv* env, jobject jlist_filter_factory) : JniCallbackBase(env, jlist_filter_factory) { jclass jclazz = ROCKSDB_NAMESPACE::JavaClass::getJClass( - env, "org/rocksdb/FlinkCompactionFilter$ListElementFilterFactory"); + env, "org/forstdb/FlinkCompactionFilter$ListElementFilterFactory"); if (jclazz == nullptr) { // exception occurred accessing class return; } m_jcreate_filter_methodid = env->GetMethodID( jclazz, "createListElementFilter", - "()Lorg/rocksdb/FlinkCompactionFilter$ListElementFilter;"); + "()Lorg/forstdb/FlinkCompactionFilter$ListElementFilter;"); assert(m_jcreate_filter_methodid != nullptr); } @@ -117,7 +117,7 @@ class JavaTimeProvider JavaTimeProvider(JNIEnv* env, jobject jtime_provider) : JniCallbackBase(env, jtime_provider) { jclass jclazz = ROCKSDB_NAMESPACE::JavaClass::getJClass( - env, "org/rocksdb/FlinkCompactionFilter$TimeProvider"); + env, "org/forstdb/FlinkCompactionFilter$TimeProvider"); if (jclazz == nullptr) { // exception occurred accessing class return; @@ -214,7 +214,7 @@ jlong Java_org_forstdb_FlinkCompactionFilter_createNewFlinkCompactionFilter0( /* * Class: org_forstdb_FlinkCompactionFilter * Method: configureFlinkCompactionFilter - * Signature: (JIIJJILorg/rocksdb/FlinkCompactionFilter$ListElementFilter;)Z + * Signature: (JIIJJILorg/forstdb/FlinkCompactionFilter$ListElementFilter;)Z */ jboolean Java_org_forstdb_FlinkCompactionFilter_configureFlinkCompactionFilter( JNIEnv* env, jclass /* jcls */, jlong handle, jint ji_state_type, diff --git a/java/forstjni/jnicallback.cc b/java/forstjni/jnicallback.cc index 51fe1f04c..29db5b960 100644 --- a/java/forstjni/jnicallback.cc +++ b/java/forstjni/jnicallback.cc @@ -4,7 +4,7 @@ // (found in the LICENSE.Apache file in the root directory). // // This file implements the callback "bridge" between Java and C++ for -// JNI Callbacks from C++ to sub-classes or org.rocksdb.RocksCallbackObject +// JNI Callbacks from C++ to sub-classes or org.forstdb.RocksCallbackObject #include "forstjni/jnicallback.h" diff --git a/java/forstjni/options.cc b/java/forstjni/options.cc index bc61f470d..02690f60f 100644 --- a/java/forstjni/options.cc +++ b/java/forstjni/options.cc @@ -1784,7 +1784,7 @@ static jobjectArray rocksdb_get_event_listeners_helper( /* * Class: org_forstdb_Options * Method: eventListeners - * Signature: (J)[Lorg/rocksdb/AbstractEventListener; + * Signature: (J)[Lorg/forstdb/AbstractEventListener; */ jobjectArray Java_org_forstdb_Options_eventListeners(JNIEnv* env, jclass, jlong jhandle) { @@ -7220,7 +7220,7 @@ void Java_org_forstdb_DBOptions_setEventListeners(JNIEnv* env, jclass, /* * Class: org_forstdb_DBOptions * Method: eventListeners - * Signature: (J)[Lorg/rocksdb/AbstractEventListener; + * Signature: (J)[Lorg/forstdb/AbstractEventListener; */ jobjectArray Java_org_forstdb_DBOptions_eventListeners(JNIEnv* env, jclass, jlong jhandle) { diff --git a/java/forstjni/options_util.cc b/java/forstjni/options_util.cc index 99c8328a1..8074c8411 100644 --- a/java/forstjni/options_util.cc +++ b/java/forstjni/options_util.cc @@ -141,7 +141,7 @@ jstring Java_org_forstdb_OptionsUtil_getLatestOptionsFileName( /* * Class: org_forstdb_OptionsUtil * Method: readTableFormatConfig - * Signature: (J)Lorg/rocksdb/TableFormatConfig; + * Signature: (J)Lorg/forstdb/TableFormatConfig; */ jobject Java_org_forstdb_OptionsUtil_readTableFormatConfig(JNIEnv* env, jclass, jlong jcf_options) { diff --git a/java/forstjni/rocks_callback_object.cc b/java/forstjni/rocks_callback_object.cc index 19a32866a..19e8fe948 100644 --- a/java/forstjni/rocks_callback_object.cc +++ b/java/forstjni/rocks_callback_object.cc @@ -4,7 +4,7 @@ // (found in the LICENSE.Apache file in the root directory). // // This file implements the "bridge" between Java and C++ for -// JNI Callbacks from C++ to sub-classes or org.rocksdb.RocksCallbackObject +// JNI Callbacks from C++ to sub-classes or org.forstdb.RocksCallbackObject #include diff --git a/java/forstjni/rocksjni.cc b/java/forstjni/rocksjni.cc index e9c9b7915..52767ece4 100644 --- a/java/forstjni/rocksjni.cc +++ b/java/forstjni/rocksjni.cc @@ -2210,7 +2210,7 @@ jobjectArray Java_org_forstdb_RocksDB_multiGet__JJ_3_3B_3I_3I_3J( * Class: org_forstdb_RocksDB * Method: multiGet * Signature: - * (JJ[J[Ljava/nio/ByteBuffer;[I[I[Ljava/nio/ByteBuffer;[I[Lorg/rocksdb/Status;)V + * (JJ[J[Ljava/nio/ByteBuffer;[I[I[Ljava/nio/ByteBuffer;[I[Lorg/forstdb/Status;)V */ void Java_org_forstdb_RocksDB_multiGet__JJ_3J_3Ljava_nio_ByteBuffer_2_3I_3I_3Ljava_nio_ByteBuffer_2_3I_3Lorg_forstdb_Status_2( JNIEnv* env, jobject jdb, jlong jdb_handle, jlong jropt_handle, @@ -3587,7 +3587,7 @@ jobjectArray Java_org_forstdb_RocksDB_getLiveFiles(JNIEnv* env, jobject, /* * Class: org_forstdb_RocksDB * Method: getSortedWalFiles - * Signature: (J)[Lorg/rocksdb/LogFile; + * Signature: (J)[Lorg/forstdb/LogFile; */ jobjectArray Java_org_forstdb_RocksDB_getSortedWalFiles(JNIEnv* env, jobject, jlong jdb_handle) { @@ -3674,7 +3674,7 @@ void Java_org_forstdb_RocksDB_deleteFile(JNIEnv* env, jobject, jlong jdb_handle, /* * Class: org_forstdb_RocksDB * Method: getLiveFilesMetaData - * Signature: (J)[Lorg/rocksdb/LiveFileMetaData; + * Signature: (J)[Lorg/forstdb/LiveFileMetaData; */ jobjectArray Java_org_forstdb_RocksDB_getLiveFilesMetaData(JNIEnv* env, jobject, jlong jdb_handle) { @@ -3721,7 +3721,7 @@ jobjectArray Java_org_forstdb_RocksDB_getLiveFilesMetaData(JNIEnv* env, jobject, /* * Class: org_forstdb_RocksDB * Method: getColumnFamilyMetaData - * Signature: (JJ)Lorg/rocksdb/ColumnFamilyMetaData; + * Signature: (JJ)Lorg/forstdb/ColumnFamilyMetaData; */ jobject Java_org_forstdb_RocksDB_getColumnFamilyMetaData(JNIEnv* env, jobject, jlong jdb_handle, diff --git a/java/forstjni/slice.cc b/java/forstjni/slice.cc index 3d447562c..a72fa3f24 100644 --- a/java/forstjni/slice.cc +++ b/java/forstjni/slice.cc @@ -20,7 +20,7 @@ #include "forstjni/cplusplus_to_java_convert.h" #include "forstjni/portal.h" -// /* * Class: org_forstdb_AbstractSlice @@ -125,7 +125,7 @@ void Java_org_forstdb_AbstractSlice_disposeInternal(JNIEnv* /*env*/, // -// /* * Class: org_forstdb_Slice @@ -257,7 +257,7 @@ void Java_org_forstdb_Slice_disposeInternalBuf(JNIEnv* /*env*/, // -// /* * Class: org_forstdb_DirectSlice diff --git a/java/forstjni/statistics.cc b/java/forstjni/statistics.cc index c6d0c8257..eff45a3c3 100644 --- a/java/forstjni/statistics.cc +++ b/java/forstjni/statistics.cc @@ -180,7 +180,7 @@ jlong Java_org_forstdb_Statistics_getAndResetTickerCount(JNIEnv*, jobject, /* * Class: org_forstdb_Statistics * Method: getHistogramData - * Signature: (JB)Lorg/rocksdb/HistogramData; + * Signature: (JB)Lorg/forstdb/HistogramData; */ jobject Java_org_forstdb_Statistics_getHistogramData(JNIEnv* env, jobject, jlong jhandle, diff --git a/java/forstjni/table_filter.cc b/java/forstjni/table_filter.cc index ac234d889..208aca21a 100644 --- a/java/forstjni/table_filter.cc +++ b/java/forstjni/table_filter.cc @@ -4,7 +4,7 @@ // (found in the LICENSE.Apache file in the root directory). // // This file implements the "bridge" between Java and C++ for -// org.rocksdb.AbstractTableFilter. +// org.forstdb.AbstractTableFilter. #include diff --git a/java/forstjni/transaction.cc b/java/forstjni/transaction.cc index 5212d2ad8..7b64a7458 100644 --- a/java/forstjni/transaction.cc +++ b/java/forstjni/transaction.cc @@ -1700,7 +1700,7 @@ jboolean Java_org_forstdb_Transaction_isDeadlockDetect(JNIEnv* /*env*/, /* * Class: org_forstdb_Transaction * Method: getWaitingTxns - * Signature: (J)Lorg/rocksdb/Transaction/WaitingTransactions; + * Signature: (J)Lorg/forstdb/Transaction/WaitingTransactions; */ jobject Java_org_forstdb_Transaction_getWaitingTxns(JNIEnv* env, jobject jtransaction_obj, diff --git a/java/forstjni/transaction_db.cc b/java/forstjni/transaction_db.cc index 0d8ae20c6..e7df93ebd 100644 --- a/java/forstjni/transaction_db.cc +++ b/java/forstjni/transaction_db.cc @@ -357,7 +357,7 @@ jobject Java_org_forstdb_TransactionDB_getLockStatusData(JNIEnv* env, jobject, /* * Class: org_forstdb_TransactionDB * Method: getDeadlockInfoBuffer - * Signature: (J)[Lorg/rocksdb/TransactionDB/DeadlockPath; + * Signature: (J)[Lorg/forstdb/TransactionDB/DeadlockPath; */ jobjectArray Java_org_forstdb_TransactionDB_getDeadlockInfoBuffer( JNIEnv* env, jobject jobj, jlong jhandle) { diff --git a/java/forstjni/transaction_log.cc b/java/forstjni/transaction_log.cc index 8ddc64322..1a4719d75 100644 --- a/java/forstjni/transaction_log.cc +++ b/java/forstjni/transaction_log.cc @@ -68,7 +68,7 @@ void Java_org_forstdb_TransactionLogIterator_status(JNIEnv* env, /* * Class: org_forstdb_TransactionLogIterator * Method: getBatch - * Signature: (J)Lorg/rocksdb/TransactionLogIterator$BatchResult + * Signature: (J)Lorg/forstdb/TransactionLogIterator$BatchResult */ jobject Java_org_forstdb_TransactionLogIterator_getBatch(JNIEnv* env, jobject /*jobj*/, diff --git a/java/forstjni/ttl.cc b/java/forstjni/ttl.cc index 4621c245f..98cd83b20 100644 --- a/java/forstjni/ttl.cc +++ b/java/forstjni/ttl.cc @@ -179,7 +179,7 @@ void Java_org_forstdb_TtlDB_closeDatabase(JNIEnv* /* env */, jclass, /* * Class: org_forstdb_TtlDB * Method: createColumnFamilyWithTtl - * Signature: (JLorg/rocksdb/ColumnFamilyDescriptor;[BJI)J; + * Signature: (JLorg/forstdb/ColumnFamilyDescriptor;[BJI)J; */ jlong Java_org_forstdb_TtlDB_createColumnFamilyWithTtl(JNIEnv* env, jobject, jlong jdb_handle, diff --git a/java/forstjni/write_batch.cc b/java/forstjni/write_batch.cc index d9dc5557a..aa6c5f226 100644 --- a/java/forstjni/write_batch.cc +++ b/java/forstjni/write_batch.cc @@ -639,7 +639,7 @@ void Java_org_forstdb_WriteBatch_markWalTerminationPoint(JNIEnv* /*env*/, /* * Class: org_forstdb_WriteBatch * Method: getWalTerminationPoint - * Signature: (J)Lorg/rocksdb/WriteBatch/SavePoint; + * Signature: (J)Lorg/forstdb/WriteBatch/SavePoint; */ jobject Java_org_forstdb_WriteBatch_getWalTerminationPoint(JNIEnv* env, jobject /*jobj*/, diff --git a/java/forstjni/write_batch_with_index.cc b/java/forstjni/write_batch_with_index.cc index e4ed9a449..e13c750e1 100644 --- a/java/forstjni/write_batch_with_index.cc +++ b/java/forstjni/write_batch_with_index.cc @@ -486,7 +486,7 @@ void Java_org_forstdb_WriteBatchWithIndex_setMaxBytes(JNIEnv* /*env*/, /* * Class: org_forstdb_WriteBatchWithIndex * Method: getWriteBatch - * Signature: (J)Lorg/rocksdb/WriteBatch; + * Signature: (J)Lorg/forstdb/WriteBatch; */ jobject Java_org_forstdb_WriteBatchWithIndex_getWriteBatch(JNIEnv* env, jobject /*jobj*/, @@ -898,7 +898,7 @@ jlongArray Java_org_forstdb_WBWIRocksIterator_entry1(JNIEnv* env, results[0] = ROCKSDB_NAMESPACE::WriteTypeJni::toJavaWriteType(we.type); // NOTE: key_slice and value_slice will be freed by - // org.rocksdb.DirectSlice#close + // org.forstdb.DirectSlice#close auto* key_slice = new ROCKSDB_NAMESPACE::Slice(we.key.data(), we.key.size()); results[1] = GET_CPLUSPLUS_POINTER(key_slice); diff --git a/utilities/flink/flink_compaction_filter_test.cc b/utilities/flink/flink_compaction_filter_test.cc index 26613ae68..192191cd3 100644 --- a/utilities/flink/flink_compaction_filter_test.cc +++ b/utilities/flink/flink_compaction_filter_test.cc @@ -131,8 +131,8 @@ void Deinit() { delete filter; } TEST(FlinkStateTtlTest, CheckStateTypeEnumOrder) { // NOLINT // if the order changes it also needs to be adjusted in Java client: - // in org.rocksdb.FlinkCompactionFilter - // and in org.rocksdb.FlinkCompactionFilterTest + // in org.forstdb.FlinkCompactionFilter + // and in org.forstdb.FlinkCompactionFilterTest EXPECT_EQ(DISABLED, 0); EXPECT_EQ(VALUE, 1); EXPECT_EQ(LIST, 2); From b1015fe746963780b9a53a0d0b10a3918f50b635 Mon Sep 17 00:00:00 2001 From: Zakelly Date: Wed, 23 Oct 2024 15:45:47 +0800 Subject: [PATCH 55/61] [build] Fix packaging error --- HISTORY.md | 0 Makefile | 3 ++- 2 files changed, 2 insertions(+), 1 deletion(-) create mode 100644 HISTORY.md diff --git a/HISTORY.md b/HISTORY.md new file mode 100644 index 000000000..e69de29bb diff --git a/Makefile b/Makefile index b643f96a1..fa6948417 100644 --- a/Makefile +++ b/Makefile @@ -6,7 +6,7 @@ #----------------------------------------------- -FORST_VERSION ?= 0.1.0 +FORST_VERSION ?= 0.1.2-beta BASH_EXISTS := $(shell which bash) SHELL := $(shell which bash) @@ -2117,6 +2117,7 @@ else endif endif ROCKSDB_JAVA_VERSION ?= $(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH) +ROCKSDB_JAVA_VERSION = $(FORST_VERSION) ROCKSDB_JAR = forstjni-$(ROCKSDB_JAVA_VERSION)-linux$(ARCH)$(JNI_LIBC_POSTFIX).jar ROCKSDB_JAR_ALL = forstjni-$(ROCKSDB_JAVA_VERSION).jar ROCKSDB_JAVADOCS_JAR = forstjni-$(ROCKSDB_JAVA_VERSION)-javadoc.jar From 58196552d7d4ca845ec37966fafb0d6c7f7d800f Mon Sep 17 00:00:00 2001 From: Zakelly Date: Fri, 25 Oct 2024 10:28:40 +0800 Subject: [PATCH 56/61] [build] Fixing ci error (#22) --- .github/workflows/pr-jobs.yml | 6 +++--- CMakeLists.txt | 1 - build_tools/format-diff.sh | 2 +- cache/tiered_secondary_cache_test.cc | 12 ++++++++++++ java/forstjni/portal.h | 6 +++--- tools/check_format_compatible.sh | 4 ++-- 6 files changed, 21 insertions(+), 10 deletions(-) diff --git a/.github/workflows/pr-jobs.yml b/.github/workflows/pr-jobs.yml index 385bd2dde..7081020e5 100644 --- a/.github/workflows/pr-jobs.yml +++ b/.github/workflows/pr-jobs.yml @@ -31,7 +31,7 @@ jobs: - uses: "./.github/actions/pre-steps" - uses: "./.github/actions/install-gflags" - run: echo "JAVA_HOME=${JAVA_HOME}" - - run: DISABLE_WARNING_AS_ERROR=1 make V=1 J=8 -j8 check + - run: DISABLE_WARNING_AS_ERROR=1 DISABLE_PERF_CONTEXT=0 make V=1 J=8 -j8 check - uses: "./.github/actions/post-steps" # ======================== Linux No Test Runs ======================= # build-linux-release: @@ -83,7 +83,7 @@ jobs: which java && java -version which javac && javac -version - name: Test RocksDBJava - run: scl enable devtoolset-7 'DISABLE_WARNING_AS_ERROR=1 make V=1 J=8 -j8 jtest' + run: scl enable devtoolset-7 'DISABLE_WARNING_AS_ERROR=1 DISABLE_PERF_CONTEXT=0 make V=1 J=8 -j8 jtest' # NOTE: post-steps skipped because of compatibility issues with docker image build-linux-java-static: runs-on: ubuntu-latest @@ -148,7 +148,7 @@ jobs: which java && java -version which javac && javac -version - name: Test RocksDBJava - run: DISABLE_WARNING_AS_ERROR=1 make V=1 J=16 -j16 jtest + run: DISABLE_WARNING_AS_ERROR=1 DISABLE_PERF_CONTEXT=0 make V=1 J=16 -j16 jtest - uses: "./.github/actions/post-steps" build-macos-java-static: runs-on: macos-13 diff --git a/CMakeLists.txt b/CMakeLists.txt index 9a0ed90c1..31f97bdbc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1465,7 +1465,6 @@ if(WITH_TESTS) utilities/flink/flink_compaction_filter_test.cc utilities/checkpoint/checkpoint_test.cc utilities/env_timed_test.cc - utilities/flink/flink_compaction_filter_test.cc utilities/memory/memory_test.cc utilities/merge_operators/string_append/stringappend_test.cc utilities/object_registry_test.cc diff --git a/build_tools/format-diff.sh b/build_tools/format-diff.sh index 62e8834f7..831714bbd 100755 --- a/build_tools/format-diff.sh +++ b/build_tools/format-diff.sh @@ -127,7 +127,7 @@ uncommitted_code=`git diff HEAD` if [ -z "$uncommitted_code" ] then # Attempt to get name of facebook/rocksdb.git remote. - [ "$FORMAT_REMOTE" ] || FORMAT_REMOTE="$(LC_ALL=POSIX LANG=POSIX git remote -v | grep 'facebook/rocksdb.git' | head -n 1 | cut -f 1)" + [ "$FORMAT_REMOTE" ] || FORMAT_REMOTE="$(LC_ALL=POSIX LANG=POSIX git remote -v | grep 'ververica/ForSt.git' | head -n 1 | cut -f 1)" # Fall back on 'origin' if that fails [ "$FORMAT_REMOTE" ] || FORMAT_REMOTE=origin # Use main branch from that remote diff --git a/cache/tiered_secondary_cache_test.cc b/cache/tiered_secondary_cache_test.cc index 28a393325..0dfe9d929 100644 --- a/cache/tiered_secondary_cache_test.cc +++ b/cache/tiered_secondary_cache_test.cc @@ -234,6 +234,8 @@ class DBTieredSecondaryCacheTest : public DBTestBase { // each data block contains exactly 4 KV pairs. Metadata blocks are not // cached, so we can accurately estimate the cache usage. TEST_F(DBTieredSecondaryCacheTest, BasicTest) { + ROCKSDB_GTEST_SKIP("Temp disable secondary cache."); + return; if (!LZ4_Supported()) { ROCKSDB_GTEST_SKIP("This test requires LZ4 support."); return; @@ -353,6 +355,8 @@ TEST_F(DBTieredSecondaryCacheTest, BasicTest) { // This test is very similar to BasicTest, except it calls MultiGet rather // than Get, in order to exercise the async lookup and WaitAll path. TEST_F(DBTieredSecondaryCacheTest, BasicMultiGetTest) { + ROCKSDB_GTEST_SKIP("Temp disable secondary cache."); + return; if (!LZ4_Supported()) { ROCKSDB_GTEST_SKIP("This test requires LZ4 support."); return; @@ -495,6 +499,8 @@ TEST_F(DBTieredSecondaryCacheTest, BasicMultiGetTest) { } TEST_F(DBTieredSecondaryCacheTest, WaitAllTest) { + ROCKSDB_GTEST_SKIP("Temp disable secondary cache."); + return; if (!LZ4_Supported()) { ROCKSDB_GTEST_SKIP("This test requires LZ4 support."); return; @@ -593,6 +599,8 @@ TEST_F(DBTieredSecondaryCacheTest, WaitAllTest) { } TEST_F(DBTieredSecondaryCacheTest, ReadyBeforeWaitAllTest) { + ROCKSDB_GTEST_SKIP("Temp disable secondary cache."); + return; if (!LZ4_Supported()) { ROCKSDB_GTEST_SKIP("This test requires LZ4 support."); return; @@ -706,6 +714,8 @@ TEST_F(DBTieredSecondaryCacheTest, ReadyBeforeWaitAllTest) { // passes. First pass loads the compressed blocks into the nvm tier, and // the second pass should hit all of those blocks. TEST_F(DBTieredSecondaryCacheTest, IterateTest) { + ROCKSDB_GTEST_SKIP("Temp disable secondary cache."); + return; if (!LZ4_Supported()) { ROCKSDB_GTEST_SKIP("This test requires LZ4 support."); return; @@ -765,6 +775,8 @@ class DBTieredAdmPolicyTest public testing::WithParamInterface {}; TEST_P(DBTieredAdmPolicyTest, CompressedOnlyTest) { + ROCKSDB_GTEST_SKIP("Temp disable secondary cache."); + return; if (!LZ4_Supported()) { ROCKSDB_GTEST_SKIP("This test requires LZ4 support."); return; diff --git a/java/forstjni/portal.h b/java/forstjni/portal.h index 0e67a7691..6d67595e5 100644 --- a/java/forstjni/portal.h +++ b/java/forstjni/portal.h @@ -7743,7 +7743,7 @@ class ExportImportFilesMetaDataJni : public JavaClass { } jmethodID mid = env->GetMethodID(jclazz, "", - "([B[Lorg/rocksdb/LiveFileMetaData;)V"); + "([B[Lorg/forstdb/LiveFileMetaData;)V"); if (mid == nullptr) { // exception thrown: NoSuchMethodException or OutOfMemoryError return nullptr; @@ -7795,7 +7795,7 @@ class ExportImportFilesMetaDataJni : public JavaClass { } static jclass getJClass(JNIEnv* env) { - return JavaClass::getJClass(env, "org/rocksdb/ExportImportFilesMetaData"); + return JavaClass::getJClass(env, "org/forstdb/ExportImportFilesMetaData"); } }; @@ -8651,7 +8651,7 @@ class FlushJobInfoJni : public JavaClass { static jmethodID getConstructorMethodId(JNIEnv* env, jclass clazz) { return env->GetMethodID(clazz, "", "(JLjava/lang/String;Ljava/lang/String;JIZZJJLorg/" - "rocksdb/TableProperties;B)V"); + "forstdb/TableProperties;B)V"); } }; diff --git a/tools/check_format_compatible.sh b/tools/check_format_compatible.sh index 93b51a9b9..a6687b859 100755 --- a/tools/check_format_compatible.sh +++ b/tools/check_format_compatible.sh @@ -39,9 +39,9 @@ tmp_origin=_tmp_origin set -e git remote remove $tmp_origin 2>/dev/null || true if [ "$USE_SSH" ]; then - git remote add $tmp_origin "git@github.com:facebook/rocksdb.git" + git remote add $tmp_origin "git@github.com:ververica/ForSt.git" else - git remote add $tmp_origin "https://github.com/facebook/rocksdb.git" + git remote add $tmp_origin "https://github.com/ververica/ForSt.git" fi git fetch $tmp_origin From 60474f4998552003848d805ea64bec4ca82317af Mon Sep 17 00:00:00 2001 From: Zakelly Date: Mon, 28 Oct 2024 12:46:42 +0800 Subject: [PATCH 57/61] [misc] Correct .gitignore (#24) --- .gitignore | 8 +- .../org_forstdb_AbstractCompactionFilter.h | 21 - ..._forstdb_AbstractCompactionFilterFactory.h | 29 - java/include/org_forstdb_AbstractComparator.h | 29 - .../org_forstdb_AbstractEventListener.h | 29 - java/include/org_forstdb_AbstractSlice.h | 69 - .../include/org_forstdb_AbstractTableFilter.h | 21 - .../include/org_forstdb_AbstractTraceWriter.h | 21 - .../org_forstdb_AbstractTransactionNotifier.h | 29 - java/include/org_forstdb_AbstractWalFilter.h | 21 - java/include/org_forstdb_BackupEngine.h | 101 - .../include/org_forstdb_BackupEngineOptions.h | 213 -- .../org_forstdb_BlockBasedTableConfig.h | 21 - java/include/org_forstdb_BloomFilter.h | 23 - java/include/org_forstdb_Cache.h | 29 - .../org_forstdb_CassandraCompactionFilter.h | 21 - .../org_forstdb_CassandraValueMergeOperator.h | 29 - java/include/org_forstdb_Checkpoint.h | 45 - java/include/org_forstdb_ClockCache.h | 29 - java/include/org_forstdb_ColumnFamilyHandle.h | 45 - .../include/org_forstdb_ColumnFamilyOptions.h | 1141 -------- .../include/org_forstdb_CompactRangeOptions.h | 181 -- java/include/org_forstdb_CompactionJobInfo.h | 125 - java/include/org_forstdb_CompactionJobStats.h | 229 -- java/include/org_forstdb_CompactionOptions.h | 77 - .../org_forstdb_CompactionOptionsFIFO.h | 61 - .../org_forstdb_CompactionOptionsUniversal.h | 141 - java/include/org_forstdb_ComparatorOptions.h | 77 - java/include/org_forstdb_CompressionOptions.h | 125 - .../org_forstdb_ConcurrentTaskLimiterImpl.h | 61 - java/include/org_forstdb_ConfigOptions.h | 69 - java/include/org_forstdb_DBOptions.h | 1343 --------- java/include/org_forstdb_DirectSlice.h | 77 - java/include/org_forstdb_Env.h | 77 - java/include/org_forstdb_EnvFlinkTestSuite.h | 37 - java/include/org_forstdb_EnvOptions.h | 221 -- .../org_forstdb_ExportImportFilesMetaData.h | 21 - java/include/org_forstdb_Filter.h | 21 - .../org_forstdb_FlinkCompactionFilter.h | 45 - java/include/org_forstdb_FlinkEnv.h | 29 - java/include/org_forstdb_FlushOptions.h | 61 - ...org_forstdb_HashLinkedListMemTableConfig.h | 31 - .../org_forstdb_HashSkipListMemTableConfig.h | 27 - java/include/org_forstdb_HyperClockCache.h | 29 - .../org_forstdb_ImportColumnFamilyOptions.h | 45 - .../org_forstdb_IngestExternalFileOptions.h | 133 - java/include/org_forstdb_LRUCache.h | 29 - java/include/org_forstdb_LiveFileMetaData.h | 21 - java/include/org_forstdb_Logger.h | 57 - java/include/org_forstdb_MemoryUtil.h | 21 - .../org_forstdb_NativeComparatorWrapper.h | 21 - ...rapperTest_NativeStringComparatorWrapper.h | 21 - .../org_forstdb_OptimisticTransactionDB.h | 87 - ...org_forstdb_OptimisticTransactionOptions.h | 53 - java/include/org_forstdb_Options.h | 2405 ----------------- java/include/org_forstdb_OptionsUtil.h | 45 - java/include/org_forstdb_PerfContext.h | 805 ------ java/include/org_forstdb_PersistentCache.h | 29 - java/include/org_forstdb_PlainTableConfig.h | 35 - java/include/org_forstdb_RateLimiter.h | 83 - java/include/org_forstdb_ReadOptions.h | 389 --- ...forstdb_RemoveEmptyValueCompactionFilter.h | 21 - java/include/org_forstdb_RestoreOptions.h | 29 - .../include/org_forstdb_RocksCallbackObject.h | 21 - java/include/org_forstdb_RocksDB.h | 935 ------- .../org_forstdb_RocksDBExceptionTest.h | 61 - java/include/org_forstdb_RocksEnv.h | 21 - java/include/org_forstdb_RocksIterator.h | 173 -- java/include/org_forstdb_RocksMemEnv.h | 29 - .../org_forstdb_SkipListMemTableConfig.h | 23 - java/include/org_forstdb_Slice.h | 61 - java/include/org_forstdb_Snapshot.h | 21 - java/include/org_forstdb_SstFileManager.h | 117 - java/include/org_forstdb_SstFileReader.h | 61 - .../org_forstdb_SstFileReaderIterator.h | 173 -- java/include/org_forstdb_SstFileWriter.h | 117 - ...forstdb_SstPartitionerFixedPrefixFactory.h | 29 - java/include/org_forstdb_Statistics.h | 117 - .../org_forstdb_StringAppendOperator.h | 37 - java/include/org_forstdb_ThreadStatus.h | 69 - java/include/org_forstdb_TimedEnv.h | 29 - java/include/org_forstdb_Transaction.h | 613 ----- java/include/org_forstdb_TransactionDB.h | 119 - .../org_forstdb_TransactionDBOptions.h | 109 - .../org_forstdb_TransactionLogIterator.h | 53 - java/include/org_forstdb_TransactionOptions.h | 125 - java/include/org_forstdb_TtlDB.h | 55 - java/include/org_forstdb_UInt64AddOperator.h | 29 - .../org_forstdb_VectorMemTableConfig.h | 23 - java/include/org_forstdb_WBWIRocksIterator.h | 133 - java/include/org_forstdb_WriteBatch.h | 301 --- java/include/org_forstdb_WriteBatchTest.h | 21 - ...org_forstdb_WriteBatchTestInternalHelper.h | 37 - .../include/org_forstdb_WriteBatchWithIndex.h | 261 -- java/include/org_forstdb_WriteBatch_Handler.h | 21 - java/include/org_forstdb_WriteBufferManager.h | 29 - java/include/org_forstdb_WriteOptions.h | 133 - .../org_forstdb_test_TestableEventListener.h | 21 - .../golden-decompression/empty-block.zst | Bin 11 -> 0 bytes .../golden-decompression/rle-first-block.zst | Bin 45 -> 0 bytes 100 files changed, 7 insertions(+), 13638 deletions(-) delete mode 100644 java/include/org_forstdb_AbstractCompactionFilter.h delete mode 100644 java/include/org_forstdb_AbstractCompactionFilterFactory.h delete mode 100644 java/include/org_forstdb_AbstractComparator.h delete mode 100644 java/include/org_forstdb_AbstractEventListener.h delete mode 100644 java/include/org_forstdb_AbstractSlice.h delete mode 100644 java/include/org_forstdb_AbstractTableFilter.h delete mode 100644 java/include/org_forstdb_AbstractTraceWriter.h delete mode 100644 java/include/org_forstdb_AbstractTransactionNotifier.h delete mode 100644 java/include/org_forstdb_AbstractWalFilter.h delete mode 100644 java/include/org_forstdb_BackupEngine.h delete mode 100644 java/include/org_forstdb_BackupEngineOptions.h delete mode 100644 java/include/org_forstdb_BlockBasedTableConfig.h delete mode 100644 java/include/org_forstdb_BloomFilter.h delete mode 100644 java/include/org_forstdb_Cache.h delete mode 100644 java/include/org_forstdb_CassandraCompactionFilter.h delete mode 100644 java/include/org_forstdb_CassandraValueMergeOperator.h delete mode 100644 java/include/org_forstdb_Checkpoint.h delete mode 100644 java/include/org_forstdb_ClockCache.h delete mode 100644 java/include/org_forstdb_ColumnFamilyHandle.h delete mode 100644 java/include/org_forstdb_ColumnFamilyOptions.h delete mode 100644 java/include/org_forstdb_CompactRangeOptions.h delete mode 100644 java/include/org_forstdb_CompactionJobInfo.h delete mode 100644 java/include/org_forstdb_CompactionJobStats.h delete mode 100644 java/include/org_forstdb_CompactionOptions.h delete mode 100644 java/include/org_forstdb_CompactionOptionsFIFO.h delete mode 100644 java/include/org_forstdb_CompactionOptionsUniversal.h delete mode 100644 java/include/org_forstdb_ComparatorOptions.h delete mode 100644 java/include/org_forstdb_CompressionOptions.h delete mode 100644 java/include/org_forstdb_ConcurrentTaskLimiterImpl.h delete mode 100644 java/include/org_forstdb_ConfigOptions.h delete mode 100644 java/include/org_forstdb_DBOptions.h delete mode 100644 java/include/org_forstdb_DirectSlice.h delete mode 100644 java/include/org_forstdb_Env.h delete mode 100644 java/include/org_forstdb_EnvFlinkTestSuite.h delete mode 100644 java/include/org_forstdb_EnvOptions.h delete mode 100644 java/include/org_forstdb_ExportImportFilesMetaData.h delete mode 100644 java/include/org_forstdb_Filter.h delete mode 100644 java/include/org_forstdb_FlinkCompactionFilter.h delete mode 100644 java/include/org_forstdb_FlinkEnv.h delete mode 100644 java/include/org_forstdb_FlushOptions.h delete mode 100644 java/include/org_forstdb_HashLinkedListMemTableConfig.h delete mode 100644 java/include/org_forstdb_HashSkipListMemTableConfig.h delete mode 100644 java/include/org_forstdb_HyperClockCache.h delete mode 100644 java/include/org_forstdb_ImportColumnFamilyOptions.h delete mode 100644 java/include/org_forstdb_IngestExternalFileOptions.h delete mode 100644 java/include/org_forstdb_LRUCache.h delete mode 100644 java/include/org_forstdb_LiveFileMetaData.h delete mode 100644 java/include/org_forstdb_Logger.h delete mode 100644 java/include/org_forstdb_MemoryUtil.h delete mode 100644 java/include/org_forstdb_NativeComparatorWrapper.h delete mode 100644 java/include/org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper.h delete mode 100644 java/include/org_forstdb_OptimisticTransactionDB.h delete mode 100644 java/include/org_forstdb_OptimisticTransactionOptions.h delete mode 100644 java/include/org_forstdb_Options.h delete mode 100644 java/include/org_forstdb_OptionsUtil.h delete mode 100644 java/include/org_forstdb_PerfContext.h delete mode 100644 java/include/org_forstdb_PersistentCache.h delete mode 100644 java/include/org_forstdb_PlainTableConfig.h delete mode 100644 java/include/org_forstdb_RateLimiter.h delete mode 100644 java/include/org_forstdb_ReadOptions.h delete mode 100644 java/include/org_forstdb_RemoveEmptyValueCompactionFilter.h delete mode 100644 java/include/org_forstdb_RestoreOptions.h delete mode 100644 java/include/org_forstdb_RocksCallbackObject.h delete mode 100644 java/include/org_forstdb_RocksDB.h delete mode 100644 java/include/org_forstdb_RocksDBExceptionTest.h delete mode 100644 java/include/org_forstdb_RocksEnv.h delete mode 100644 java/include/org_forstdb_RocksIterator.h delete mode 100644 java/include/org_forstdb_RocksMemEnv.h delete mode 100644 java/include/org_forstdb_SkipListMemTableConfig.h delete mode 100644 java/include/org_forstdb_Slice.h delete mode 100644 java/include/org_forstdb_Snapshot.h delete mode 100644 java/include/org_forstdb_SstFileManager.h delete mode 100644 java/include/org_forstdb_SstFileReader.h delete mode 100644 java/include/org_forstdb_SstFileReaderIterator.h delete mode 100644 java/include/org_forstdb_SstFileWriter.h delete mode 100644 java/include/org_forstdb_SstPartitionerFixedPrefixFactory.h delete mode 100644 java/include/org_forstdb_Statistics.h delete mode 100644 java/include/org_forstdb_StringAppendOperator.h delete mode 100644 java/include/org_forstdb_ThreadStatus.h delete mode 100644 java/include/org_forstdb_TimedEnv.h delete mode 100644 java/include/org_forstdb_Transaction.h delete mode 100644 java/include/org_forstdb_TransactionDB.h delete mode 100644 java/include/org_forstdb_TransactionDBOptions.h delete mode 100644 java/include/org_forstdb_TransactionLogIterator.h delete mode 100644 java/include/org_forstdb_TransactionOptions.h delete mode 100644 java/include/org_forstdb_TtlDB.h delete mode 100644 java/include/org_forstdb_UInt64AddOperator.h delete mode 100644 java/include/org_forstdb_VectorMemTableConfig.h delete mode 100644 java/include/org_forstdb_WBWIRocksIterator.h delete mode 100644 java/include/org_forstdb_WriteBatch.h delete mode 100644 java/include/org_forstdb_WriteBatchTest.h delete mode 100644 java/include/org_forstdb_WriteBatchTestInternalHelper.h delete mode 100644 java/include/org_forstdb_WriteBatchWithIndex.h delete mode 100644 java/include/org_forstdb_WriteBatch_Handler.h delete mode 100644 java/include/org_forstdb_WriteBufferManager.h delete mode 100644 java/include/org_forstdb_WriteOptions.h delete mode 100644 java/include/org_forstdb_test_TestableEventListener.h delete mode 100644 zstd-1.5.5/tests/golden-decompression/empty-block.zst delete mode 100644 zstd-1.5.5/tests/golden-decompression/rle-first-block.zst diff --git a/.gitignore b/.gitignore index 8bd9fea59..f6edad6b5 100644 --- a/.gitignore +++ b/.gitignore @@ -62,7 +62,7 @@ java/out java/target java/test-libs java/*.log -java/include/org_rocksdb_*.h +java/include/org_forstdb_*.h .idea/ *.iml @@ -98,3 +98,9 @@ cmake-build-* third-party/folly/ .cache *.sublime-* + +lz4-* +snappy-* +bzip2-* +zstd-* +zlib-* \ No newline at end of file diff --git a/java/include/org_forstdb_AbstractCompactionFilter.h b/java/include/org_forstdb_AbstractCompactionFilter.h deleted file mode 100644 index 65ae517f7..000000000 --- a/java/include/org_forstdb_AbstractCompactionFilter.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_AbstractCompactionFilter */ - -#ifndef _Included_org_forstdb_AbstractCompactionFilter -#define _Included_org_forstdb_AbstractCompactionFilter -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_AbstractCompactionFilter - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_AbstractCompactionFilter_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_AbstractCompactionFilterFactory.h b/java/include/org_forstdb_AbstractCompactionFilterFactory.h deleted file mode 100644 index 1884a297d..000000000 --- a/java/include/org_forstdb_AbstractCompactionFilterFactory.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_AbstractCompactionFilterFactory */ - -#ifndef _Included_org_forstdb_AbstractCompactionFilterFactory -#define _Included_org_forstdb_AbstractCompactionFilterFactory -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_AbstractCompactionFilterFactory - * Method: createNewCompactionFilterFactory0 - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractCompactionFilterFactory_createNewCompactionFilterFactory0 - (JNIEnv *, jobject); - -/* - * Class: org_forstdb_AbstractCompactionFilterFactory - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_AbstractCompactionFilterFactory_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_AbstractComparator.h b/java/include/org_forstdb_AbstractComparator.h deleted file mode 100644 index d476fdbe7..000000000 --- a/java/include/org_forstdb_AbstractComparator.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_AbstractComparator */ - -#ifndef _Included_org_forstdb_AbstractComparator -#define _Included_org_forstdb_AbstractComparator -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_AbstractComparator - * Method: usingDirectBuffers - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_AbstractComparator_usingDirectBuffers - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_AbstractComparator - * Method: createNewComparator - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractComparator_createNewComparator - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_AbstractEventListener.h b/java/include/org_forstdb_AbstractEventListener.h deleted file mode 100644 index e04648a8e..000000000 --- a/java/include/org_forstdb_AbstractEventListener.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_AbstractEventListener */ - -#ifndef _Included_org_forstdb_AbstractEventListener -#define _Included_org_forstdb_AbstractEventListener -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_AbstractEventListener - * Method: createNewEventListener - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractEventListener_createNewEventListener - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_AbstractEventListener - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_AbstractEventListener_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_AbstractSlice.h b/java/include/org_forstdb_AbstractSlice.h deleted file mode 100644 index 2121b1fe3..000000000 --- a/java/include/org_forstdb_AbstractSlice.h +++ /dev/null @@ -1,69 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_AbstractSlice */ - -#ifndef _Included_org_forstdb_AbstractSlice -#define _Included_org_forstdb_AbstractSlice -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_AbstractSlice - * Method: createNewSliceFromString - * Signature: (Ljava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractSlice_createNewSliceFromString - (JNIEnv *, jclass, jstring); - -/* - * Class: org_forstdb_AbstractSlice - * Method: size0 - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_AbstractSlice_size0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_AbstractSlice - * Method: empty0 - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_AbstractSlice_empty0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_AbstractSlice - * Method: toString0 - * Signature: (JZ)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_AbstractSlice_toString0 - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_AbstractSlice - * Method: compare0 - * Signature: (JJ)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_AbstractSlice_compare0 - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_AbstractSlice - * Method: startsWith0 - * Signature: (JJ)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_AbstractSlice_startsWith0 - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_AbstractSlice - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_AbstractSlice_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_AbstractTableFilter.h b/java/include/org_forstdb_AbstractTableFilter.h deleted file mode 100644 index 35fa3f360..000000000 --- a/java/include/org_forstdb_AbstractTableFilter.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_AbstractTableFilter */ - -#ifndef _Included_org_forstdb_AbstractTableFilter -#define _Included_org_forstdb_AbstractTableFilter -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_AbstractTableFilter - * Method: createNewTableFilter - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractTableFilter_createNewTableFilter - (JNIEnv *, jobject); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_AbstractTraceWriter.h b/java/include/org_forstdb_AbstractTraceWriter.h deleted file mode 100644 index 820d6fe0d..000000000 --- a/java/include/org_forstdb_AbstractTraceWriter.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_AbstractTraceWriter */ - -#ifndef _Included_org_forstdb_AbstractTraceWriter -#define _Included_org_forstdb_AbstractTraceWriter -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_AbstractTraceWriter - * Method: createNewTraceWriter - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractTraceWriter_createNewTraceWriter - (JNIEnv *, jobject); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_AbstractTransactionNotifier.h b/java/include/org_forstdb_AbstractTransactionNotifier.h deleted file mode 100644 index b43bad529..000000000 --- a/java/include/org_forstdb_AbstractTransactionNotifier.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_AbstractTransactionNotifier */ - -#ifndef _Included_org_forstdb_AbstractTransactionNotifier -#define _Included_org_forstdb_AbstractTransactionNotifier -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_AbstractTransactionNotifier - * Method: createNewTransactionNotifier - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractTransactionNotifier_createNewTransactionNotifier - (JNIEnv *, jobject); - -/* - * Class: org_forstdb_AbstractTransactionNotifier - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_AbstractTransactionNotifier_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_AbstractWalFilter.h b/java/include/org_forstdb_AbstractWalFilter.h deleted file mode 100644 index ff7094403..000000000 --- a/java/include/org_forstdb_AbstractWalFilter.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_AbstractWalFilter */ - -#ifndef _Included_org_forstdb_AbstractWalFilter -#define _Included_org_forstdb_AbstractWalFilter -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_AbstractWalFilter - * Method: createNewWalFilter - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_AbstractWalFilter_createNewWalFilter - (JNIEnv *, jobject); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_BackupEngine.h b/java/include/org_forstdb_BackupEngine.h deleted file mode 100644 index a88572dd1..000000000 --- a/java/include/org_forstdb_BackupEngine.h +++ /dev/null @@ -1,101 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_BackupEngine */ - -#ifndef _Included_org_forstdb_BackupEngine -#define _Included_org_forstdb_BackupEngine -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_BackupEngine - * Method: open - * Signature: (JJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_BackupEngine_open - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_BackupEngine - * Method: createNewBackup - * Signature: (JJZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_createNewBackup - (JNIEnv *, jobject, jlong, jlong, jboolean); - -/* - * Class: org_forstdb_BackupEngine - * Method: createNewBackupWithMetadata - * Signature: (JJLjava/lang/String;Z)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_createNewBackupWithMetadata - (JNIEnv *, jobject, jlong, jlong, jstring, jboolean); - -/* - * Class: org_forstdb_BackupEngine - * Method: getBackupInfo - * Signature: (J)Ljava/util/List; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_BackupEngine_getBackupInfo - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngine - * Method: getCorruptedBackups - * Signature: (J)[I - */ -JNIEXPORT jintArray JNICALL Java_org_forstdb_BackupEngine_getCorruptedBackups - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngine - * Method: garbageCollect - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_garbageCollect - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngine - * Method: purgeOldBackups - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_purgeOldBackups - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_BackupEngine - * Method: deleteBackup - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_deleteBackup - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_BackupEngine - * Method: restoreDbFromBackup - * Signature: (JILjava/lang/String;Ljava/lang/String;J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_restoreDbFromBackup - (JNIEnv *, jobject, jlong, jint, jstring, jstring, jlong); - -/* - * Class: org_forstdb_BackupEngine - * Method: restoreDbFromLatestBackup - * Signature: (JLjava/lang/String;Ljava/lang/String;J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_restoreDbFromLatestBackup - (JNIEnv *, jobject, jlong, jstring, jstring, jlong); - -/* - * Class: org_forstdb_BackupEngine - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngine_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_BackupEngineOptions.h b/java/include/org_forstdb_BackupEngineOptions.h deleted file mode 100644 index 2368d6f56..000000000 --- a/java/include/org_forstdb_BackupEngineOptions.h +++ /dev/null @@ -1,213 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_BackupEngineOptions */ - -#ifndef _Included_org_forstdb_BackupEngineOptions -#define _Included_org_forstdb_BackupEngineOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_BackupEngineOptions - * Method: newBackupEngineOptions - * Signature: (Ljava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_BackupEngineOptions_newBackupEngineOptions - (JNIEnv *, jclass, jstring); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: backupDir - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_BackupEngineOptions_backupDir - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setBackupEnv - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setBackupEnv - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setShareTableFiles - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setShareTableFiles - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: shareTableFiles - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_BackupEngineOptions_shareTableFiles - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setInfoLog - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setInfoLog - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setSync - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setSync - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: sync - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_BackupEngineOptions_sync - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setDestroyOldData - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setDestroyOldData - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: destroyOldData - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_BackupEngineOptions_destroyOldData - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setBackupLogFiles - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setBackupLogFiles - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: backupLogFiles - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_BackupEngineOptions_backupLogFiles - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setBackupRateLimit - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setBackupRateLimit - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: backupRateLimit - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_BackupEngineOptions_backupRateLimit - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setBackupRateLimiter - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setBackupRateLimiter - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setRestoreRateLimit - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setRestoreRateLimit - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: restoreRateLimit - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_BackupEngineOptions_restoreRateLimit - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setRestoreRateLimiter - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setRestoreRateLimiter - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setShareFilesWithChecksum - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setShareFilesWithChecksum - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: shareFilesWithChecksum - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_BackupEngineOptions_shareFilesWithChecksum - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setMaxBackgroundOperations - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setMaxBackgroundOperations - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: maxBackgroundOperations - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_BackupEngineOptions_maxBackgroundOperations - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: setCallbackTriggerIntervalSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_setCallbackTriggerIntervalSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: callbackTriggerIntervalSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_BackupEngineOptions_callbackTriggerIntervalSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_BackupEngineOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_BackupEngineOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_BlockBasedTableConfig.h b/java/include/org_forstdb_BlockBasedTableConfig.h deleted file mode 100644 index b83bdf655..000000000 --- a/java/include/org_forstdb_BlockBasedTableConfig.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_BlockBasedTableConfig */ - -#ifndef _Included_org_forstdb_BlockBasedTableConfig -#define _Included_org_forstdb_BlockBasedTableConfig -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_BlockBasedTableConfig - * Method: newTableFactoryHandle - * Signature: (ZZZZBBDBZJJJIIIJZZZJZZIIZZBJI)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_BlockBasedTableConfig_newTableFactoryHandle - (JNIEnv *, jobject, jboolean, jboolean, jboolean, jboolean, jbyte, jbyte, jdouble, jbyte, jboolean, jlong, jlong, jlong, jint, jint, jint, jlong, jboolean, jboolean, jboolean, jlong, jboolean, jboolean, jint, jint, jboolean, jboolean, jbyte, jlong, jint); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_BloomFilter.h b/java/include/org_forstdb_BloomFilter.h deleted file mode 100644 index 95d43d194..000000000 --- a/java/include/org_forstdb_BloomFilter.h +++ /dev/null @@ -1,23 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_BloomFilter */ - -#ifndef _Included_org_forstdb_BloomFilter -#define _Included_org_forstdb_BloomFilter -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_BloomFilter_DEFAULT_BITS_PER_KEY -#define org_forstdb_BloomFilter_DEFAULT_BITS_PER_KEY 10.0 -/* - * Class: org_forstdb_BloomFilter - * Method: createNewBloomFilter - * Signature: (D)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_BloomFilter_createNewBloomFilter - (JNIEnv *, jclass, jdouble); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_Cache.h b/java/include/org_forstdb_Cache.h deleted file mode 100644 index 219d121ad..000000000 --- a/java/include/org_forstdb_Cache.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_Cache */ - -#ifndef _Included_org_forstdb_Cache -#define _Included_org_forstdb_Cache -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_Cache - * Method: getUsage - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Cache_getUsage - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Cache - * Method: getPinnedUsage - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Cache_getPinnedUsage - (JNIEnv *, jclass, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_CassandraCompactionFilter.h b/java/include/org_forstdb_CassandraCompactionFilter.h deleted file mode 100644 index 76c66b9e7..000000000 --- a/java/include/org_forstdb_CassandraCompactionFilter.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_CassandraCompactionFilter */ - -#ifndef _Included_org_forstdb_CassandraCompactionFilter -#define _Included_org_forstdb_CassandraCompactionFilter -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_CassandraCompactionFilter - * Method: createNewCassandraCompactionFilter0 - * Signature: (ZI)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CassandraCompactionFilter_createNewCassandraCompactionFilter0 - (JNIEnv *, jclass, jboolean, jint); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_CassandraValueMergeOperator.h b/java/include/org_forstdb_CassandraValueMergeOperator.h deleted file mode 100644 index a467d52cc..000000000 --- a/java/include/org_forstdb_CassandraValueMergeOperator.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_CassandraValueMergeOperator */ - -#ifndef _Included_org_forstdb_CassandraValueMergeOperator -#define _Included_org_forstdb_CassandraValueMergeOperator -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_CassandraValueMergeOperator - * Method: newSharedCassandraValueMergeOperator - * Signature: (II)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CassandraValueMergeOperator_newSharedCassandraValueMergeOperator - (JNIEnv *, jclass, jint, jint); - -/* - * Class: org_forstdb_CassandraValueMergeOperator - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CassandraValueMergeOperator_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_Checkpoint.h b/java/include/org_forstdb_Checkpoint.h deleted file mode 100644 index 59021737c..000000000 --- a/java/include/org_forstdb_Checkpoint.h +++ /dev/null @@ -1,45 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_Checkpoint */ - -#ifndef _Included_org_forstdb_Checkpoint -#define _Included_org_forstdb_Checkpoint -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_Checkpoint - * Method: newCheckpoint - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Checkpoint_newCheckpoint - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Checkpoint - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Checkpoint_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Checkpoint - * Method: createCheckpoint - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Checkpoint_createCheckpoint - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_Checkpoint - * Method: exportColumnFamily - * Signature: (JJLjava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Checkpoint_exportColumnFamily - (JNIEnv *, jobject, jlong, jlong, jstring); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_ClockCache.h b/java/include/org_forstdb_ClockCache.h deleted file mode 100644 index 24533d053..000000000 --- a/java/include/org_forstdb_ClockCache.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_ClockCache */ - -#ifndef _Included_org_forstdb_ClockCache -#define _Included_org_forstdb_ClockCache -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_ClockCache - * Method: newClockCache - * Signature: (JIZ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ClockCache_newClockCache - (JNIEnv *, jclass, jlong, jint, jboolean); - -/* - * Class: org_forstdb_ClockCache - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ClockCache_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_ColumnFamilyHandle.h b/java/include/org_forstdb_ColumnFamilyHandle.h deleted file mode 100644 index d14687dbe..000000000 --- a/java/include/org_forstdb_ColumnFamilyHandle.h +++ /dev/null @@ -1,45 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_ColumnFamilyHandle */ - -#ifndef _Included_org_forstdb_ColumnFamilyHandle -#define _Included_org_forstdb_ColumnFamilyHandle -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_ColumnFamilyHandle - * Method: getName - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_ColumnFamilyHandle_getName - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyHandle - * Method: getID - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyHandle_getID - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyHandle - * Method: getDescriptor - * Signature: (J)Lorg/forstdb/ColumnFamilyDescriptor; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_ColumnFamilyHandle_getDescriptor - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyHandle - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyHandle_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_ColumnFamilyOptions.h b/java/include/org_forstdb_ColumnFamilyOptions.h deleted file mode 100644 index 0e4e7c3e2..000000000 --- a/java/include/org_forstdb_ColumnFamilyOptions.h +++ /dev/null @@ -1,1141 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_ColumnFamilyOptions */ - -#ifndef _Included_org_forstdb_ColumnFamilyOptions -#define _Included_org_forstdb_ColumnFamilyOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: getColumnFamilyOptionsFromProps - * Signature: (JLjava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__JLjava_lang_String_2 - (JNIEnv *, jclass, jlong, jstring); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: getColumnFamilyOptionsFromProps - * Signature: (Ljava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_getColumnFamilyOptionsFromProps__Ljava_lang_String_2 - (JNIEnv *, jclass, jstring); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: newColumnFamilyOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_newColumnFamilyOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: copyColumnFamilyOptions - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_copyColumnFamilyOptions - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: newColumnFamilyOptionsFromOptions - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_newColumnFamilyOptionsFromOptions - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: oldDefaults - * Signature: (JII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_oldDefaults - (JNIEnv *, jclass, jlong, jint, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: optimizeForSmallDb - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeForSmallDb__J - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: optimizeForSmallDb - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeForSmallDb__JJ - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: optimizeForPointLookup - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeForPointLookup - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: optimizeLevelStyleCompaction - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeLevelStyleCompaction - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: optimizeUniversalStyleCompaction - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeUniversalStyleCompaction - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setComparatorHandle - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setComparatorHandle__JI - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setComparatorHandle - * Signature: (JJB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setComparatorHandle__JJB - (JNIEnv *, jobject, jlong, jlong, jbyte); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMergeOperatorName - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMergeOperatorName - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMergeOperator - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMergeOperator - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setCompactionFilterHandle - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionFilterHandle - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setCompactionFilterFactoryHandle - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionFilterFactoryHandle - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setWriteBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setWriteBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: writeBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_writeBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMaxWriteBufferNumber - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxWriteBufferNumber - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: maxWriteBufferNumber - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_maxWriteBufferNumber - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMinWriteBufferNumberToMerge - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMinWriteBufferNumberToMerge - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: minWriteBufferNumberToMerge - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_minWriteBufferNumberToMerge - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setCompressionType - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompressionType - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: compressionType - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_compressionType - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setCompressionPerLevel - * Signature: (J[B)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompressionPerLevel - (JNIEnv *, jobject, jlong, jbyteArray); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: compressionPerLevel - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_ColumnFamilyOptions_compressionPerLevel - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setBottommostCompressionType - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBottommostCompressionType - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: bottommostCompressionType - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_bottommostCompressionType - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setBottommostCompressionOptions - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBottommostCompressionOptions - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setCompressionOptions - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompressionOptions - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: useFixedLengthPrefixExtractor - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_useFixedLengthPrefixExtractor - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: useCappedPrefixExtractor - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_useCappedPrefixExtractor - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setNumLevels - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setNumLevels - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: numLevels - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_numLevels - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setLevelZeroFileNumCompactionTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevelZeroFileNumCompactionTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: levelZeroFileNumCompactionTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_levelZeroFileNumCompactionTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setLevelZeroSlowdownWritesTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevelZeroSlowdownWritesTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: levelZeroSlowdownWritesTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_levelZeroSlowdownWritesTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setLevelZeroStopWritesTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevelZeroStopWritesTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: levelZeroStopWritesTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_levelZeroStopWritesTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setTargetFileSizeBase - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setTargetFileSizeBase - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: targetFileSizeBase - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_targetFileSizeBase - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setTargetFileSizeMultiplier - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setTargetFileSizeMultiplier - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: targetFileSizeMultiplier - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_targetFileSizeMultiplier - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMaxBytesForLevelBase - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxBytesForLevelBase - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: maxBytesForLevelBase - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_maxBytesForLevelBase - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setLevelCompactionDynamicLevelBytes - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevelCompactionDynamicLevelBytes - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: levelCompactionDynamicLevelBytes - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_levelCompactionDynamicLevelBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMaxBytesForLevelMultiplier - * Signature: (JD)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplier - (JNIEnv *, jobject, jlong, jdouble); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: maxBytesForLevelMultiplier - * Signature: (J)D - */ -JNIEXPORT jdouble JNICALL Java_org_forstdb_ColumnFamilyOptions_maxBytesForLevelMultiplier - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMaxCompactionBytes - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxCompactionBytes - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: maxCompactionBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_maxCompactionBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setArenaBlockSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setArenaBlockSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: arenaBlockSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_arenaBlockSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setDisableAutoCompactions - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setDisableAutoCompactions - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: disableAutoCompactions - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_disableAutoCompactions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setCompactionStyle - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionStyle - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: compactionStyle - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_compactionStyle - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMaxTableFilesSizeFIFO - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxTableFilesSizeFIFO - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: maxTableFilesSizeFIFO - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_maxTableFilesSizeFIFO - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMaxSequentialSkipInIterations - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxSequentialSkipInIterations - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: maxSequentialSkipInIterations - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_maxSequentialSkipInIterations - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMemTableFactory - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMemTableFactory - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: memTableFactoryName - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_ColumnFamilyOptions_memTableFactoryName - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setTableFactory - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setTableFactory - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: tableFactoryName - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_ColumnFamilyOptions_tableFactoryName - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setCfPaths - * Signature: (J[Ljava/lang/String;[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCfPaths - (JNIEnv *, jclass, jlong, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: cfPathsLen - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_cfPathsLen - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: cfPaths - * Signature: (J[Ljava/lang/String;[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_cfPaths - (JNIEnv *, jclass, jlong, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setInplaceUpdateSupport - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setInplaceUpdateSupport - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: inplaceUpdateSupport - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_inplaceUpdateSupport - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setInplaceUpdateNumLocks - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setInplaceUpdateNumLocks - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: inplaceUpdateNumLocks - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_inplaceUpdateNumLocks - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMemtablePrefixBloomSizeRatio - * Signature: (JD)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMemtablePrefixBloomSizeRatio - (JNIEnv *, jobject, jlong, jdouble); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: memtablePrefixBloomSizeRatio - * Signature: (J)D - */ -JNIEXPORT jdouble JNICALL Java_org_forstdb_ColumnFamilyOptions_memtablePrefixBloomSizeRatio - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setExperimentalMempurgeThreshold - * Signature: (JD)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setExperimentalMempurgeThreshold - (JNIEnv *, jobject, jlong, jdouble); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: experimentalMempurgeThreshold - * Signature: (J)D - */ -JNIEXPORT jdouble JNICALL Java_org_forstdb_ColumnFamilyOptions_experimentalMempurgeThreshold - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMemtableWholeKeyFiltering - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMemtableWholeKeyFiltering - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: memtableWholeKeyFiltering - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_memtableWholeKeyFiltering - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setBloomLocality - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBloomLocality - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: bloomLocality - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_bloomLocality - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMaxSuccessiveMerges - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxSuccessiveMerges - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: maxSuccessiveMerges - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_maxSuccessiveMerges - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setOptimizeFiltersForHits - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setOptimizeFiltersForHits - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: optimizeFiltersForHits - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_optimizeFiltersForHits - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMemtableHugePageSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMemtableHugePageSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: memtableHugePageSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_memtableHugePageSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setSoftPendingCompactionBytesLimit - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setSoftPendingCompactionBytesLimit - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: softPendingCompactionBytesLimit - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_softPendingCompactionBytesLimit - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setHardPendingCompactionBytesLimit - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setHardPendingCompactionBytesLimit - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: hardPendingCompactionBytesLimit - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_hardPendingCompactionBytesLimit - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setLevel0FileNumCompactionTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevel0FileNumCompactionTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: level0FileNumCompactionTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_level0FileNumCompactionTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setLevel0SlowdownWritesTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevel0SlowdownWritesTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: level0SlowdownWritesTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_level0SlowdownWritesTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setLevel0StopWritesTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setLevel0StopWritesTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: level0StopWritesTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_level0StopWritesTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMaxBytesForLevelMultiplierAdditional - * Signature: (J[I)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxBytesForLevelMultiplierAdditional - (JNIEnv *, jobject, jlong, jintArray); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: maxBytesForLevelMultiplierAdditional - * Signature: (J)[I - */ -JNIEXPORT jintArray JNICALL Java_org_forstdb_ColumnFamilyOptions_maxBytesForLevelMultiplierAdditional - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setParanoidFileChecks - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setParanoidFileChecks - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: paranoidFileChecks - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_paranoidFileChecks - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMaxWriteBufferNumberToMaintain - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMaxWriteBufferNumberToMaintain - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: maxWriteBufferNumberToMaintain - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_maxWriteBufferNumberToMaintain - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setCompactionPriority - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionPriority - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: compactionPriority - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_compactionPriority - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setReportBgIoStats - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setReportBgIoStats - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: reportBgIoStats - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_reportBgIoStats - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setTtl - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setTtl - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: ttl - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_ttl - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setPeriodicCompactionSeconds - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setPeriodicCompactionSeconds - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: periodicCompactionSeconds - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_periodicCompactionSeconds - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setCompactionOptionsUniversal - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionOptionsUniversal - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setCompactionOptionsFIFO - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionOptionsFIFO - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setForceConsistencyChecks - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setForceConsistencyChecks - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: forceConsistencyChecks - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_forceConsistencyChecks - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setSstPartitionerFactory - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setSstPartitionerFactory - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setCompactionThreadLimiter - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setCompactionThreadLimiter - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMemtableMaxRangeDeletions - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMemtableMaxRangeDeletions - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: memtableMaxRangeDeletions - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_memtableMaxRangeDeletions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setEnableBlobFiles - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setEnableBlobFiles - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: enableBlobFiles - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_enableBlobFiles - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setMinBlobSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setMinBlobSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: minBlobSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_minBlobSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setBlobFileSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobFileSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: blobFileSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_blobFileSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setBlobCompressionType - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobCompressionType - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: blobCompressionType - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_blobCompressionType - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setEnableBlobGarbageCollection - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setEnableBlobGarbageCollection - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: enableBlobGarbageCollection - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ColumnFamilyOptions_enableBlobGarbageCollection - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setBlobGarbageCollectionAgeCutoff - * Signature: (JD)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobGarbageCollectionAgeCutoff - (JNIEnv *, jobject, jlong, jdouble); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: blobGarbageCollectionAgeCutoff - * Signature: (J)D - */ -JNIEXPORT jdouble JNICALL Java_org_forstdb_ColumnFamilyOptions_blobGarbageCollectionAgeCutoff - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setBlobGarbageCollectionForceThreshold - * Signature: (JD)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobGarbageCollectionForceThreshold - (JNIEnv *, jobject, jlong, jdouble); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: blobGarbageCollectionForceThreshold - * Signature: (J)D - */ -JNIEXPORT jdouble JNICALL Java_org_forstdb_ColumnFamilyOptions_blobGarbageCollectionForceThreshold - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setBlobCompactionReadaheadSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobCompactionReadaheadSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: blobCompactionReadaheadSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ColumnFamilyOptions_blobCompactionReadaheadSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setBlobFileStartingLevel - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setBlobFileStartingLevel - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: blobFileStartingLevel - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ColumnFamilyOptions_blobFileStartingLevel - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: setPrepopulateBlobCache - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ColumnFamilyOptions_setPrepopulateBlobCache - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_ColumnFamilyOptions - * Method: prepopulateBlobCache - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_ColumnFamilyOptions_prepopulateBlobCache - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_CompactRangeOptions.h b/java/include/org_forstdb_CompactRangeOptions.h deleted file mode 100644 index 40b48a147..000000000 --- a/java/include/org_forstdb_CompactRangeOptions.h +++ /dev/null @@ -1,181 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_CompactRangeOptions */ - -#ifndef _Included_org_forstdb_CompactRangeOptions -#define _Included_org_forstdb_CompactRangeOptions -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_CompactRangeOptions_VALUE_kSkip -#define org_forstdb_CompactRangeOptions_VALUE_kSkip 0L -#undef org_forstdb_CompactRangeOptions_VALUE_kIfHaveCompactionFilter -#define org_forstdb_CompactRangeOptions_VALUE_kIfHaveCompactionFilter 1L -#undef org_forstdb_CompactRangeOptions_VALUE_kForce -#define org_forstdb_CompactRangeOptions_VALUE_kForce 2L -#undef org_forstdb_CompactRangeOptions_VALUE_kForceOptimized -#define org_forstdb_CompactRangeOptions_VALUE_kForceOptimized 3L -/* - * Class: org_forstdb_CompactRangeOptions - * Method: newCompactRangeOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactRangeOptions_newCompactRangeOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: exclusiveManualCompaction - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactRangeOptions_exclusiveManualCompaction - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: setExclusiveManualCompaction - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setExclusiveManualCompaction - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: changeLevel - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactRangeOptions_changeLevel - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: setChangeLevel - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setChangeLevel - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: targetLevel - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactRangeOptions_targetLevel - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: setTargetLevel - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setTargetLevel - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: targetPathId - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactRangeOptions_targetPathId - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: setTargetPathId - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setTargetPathId - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: bottommostLevelCompaction - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactRangeOptions_bottommostLevelCompaction - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: setBottommostLevelCompaction - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setBottommostLevelCompaction - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: allowWriteStall - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactRangeOptions_allowWriteStall - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: setAllowWriteStall - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setAllowWriteStall - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: setMaxSubcompactions - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setMaxSubcompactions - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: maxSubcompactions - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactRangeOptions_maxSubcompactions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: setFullHistoryTSLow - * Signature: (JJJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setFullHistoryTSLow - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: fullHistoryTSLow - * Signature: (J)Lorg/forstdb/CompactRangeOptions/Timestamp; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_CompactRangeOptions_fullHistoryTSLow - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: setCanceled - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactRangeOptions_setCanceled - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_CompactRangeOptions - * Method: canceled - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactRangeOptions_canceled - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_CompactionJobInfo.h b/java/include/org_forstdb_CompactionJobInfo.h deleted file mode 100644 index 35122098e..000000000 --- a/java/include/org_forstdb_CompactionJobInfo.h +++ /dev/null @@ -1,125 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_CompactionJobInfo */ - -#ifndef _Included_org_forstdb_CompactionJobInfo -#define _Included_org_forstdb_CompactionJobInfo -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_CompactionJobInfo - * Method: newCompactionJobInfo - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobInfo_newCompactionJobInfo - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionJobInfo_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: columnFamilyName - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_CompactionJobInfo_columnFamilyName - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: status - * Signature: (J)Lorg/forstdb/Status; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_CompactionJobInfo_status - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: threadId - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobInfo_threadId - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: jobId - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactionJobInfo_jobId - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: baseInputLevel - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactionJobInfo_baseInputLevel - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: outputLevel - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactionJobInfo_outputLevel - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: inputFiles - * Signature: (J)[Ljava/lang/String; - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_CompactionJobInfo_inputFiles - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: outputFiles - * Signature: (J)[Ljava/lang/String; - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_CompactionJobInfo_outputFiles - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: tableProperties - * Signature: (J)Ljava/util/Map; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_CompactionJobInfo_tableProperties - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: compactionReason - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_CompactionJobInfo_compactionReason - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: compression - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_CompactionJobInfo_compression - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobInfo - * Method: stats - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobInfo_stats - (JNIEnv *, jclass, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_CompactionJobStats.h b/java/include/org_forstdb_CompactionJobStats.h deleted file mode 100644 index 5bdb2ec33..000000000 --- a/java/include/org_forstdb_CompactionJobStats.h +++ /dev/null @@ -1,229 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_CompactionJobStats */ - -#ifndef _Included_org_forstdb_CompactionJobStats -#define _Included_org_forstdb_CompactionJobStats -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_CompactionJobStats - * Method: newCompactionJobStats - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_newCompactionJobStats - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionJobStats_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: reset - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionJobStats_reset - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: add - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionJobStats_add - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: elapsedMicros - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_elapsedMicros - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: numInputRecords - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numInputRecords - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: numInputFiles - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numInputFiles - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: numInputFilesAtOutputLevel - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numInputFilesAtOutputLevel - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: numOutputRecords - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numOutputRecords - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: numOutputFiles - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numOutputFiles - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: isManualCompaction - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactionJobStats_isManualCompaction - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: totalInputBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_totalInputBytes - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: totalOutputBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_totalOutputBytes - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: numRecordsReplaced - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numRecordsReplaced - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: totalInputRawKeyBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_totalInputRawKeyBytes - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: totalInputRawValueBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_totalInputRawValueBytes - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: numInputDeletionRecords - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numInputDeletionRecords - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: numExpiredDeletionRecords - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numExpiredDeletionRecords - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: numCorruptKeys - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numCorruptKeys - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: fileWriteNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_fileWriteNanos - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: fileRangeSyncNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_fileRangeSyncNanos - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: fileFsyncNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_fileFsyncNanos - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: filePrepareWriteNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_filePrepareWriteNanos - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: smallestOutputKeyPrefix - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_CompactionJobStats_smallestOutputKeyPrefix - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: largestOutputKeyPrefix - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_CompactionJobStats_largestOutputKeyPrefix - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: numSingleDelFallthru - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numSingleDelFallthru - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionJobStats - * Method: numSingleDelMismatch - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionJobStats_numSingleDelMismatch - (JNIEnv *, jclass, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_CompactionOptions.h b/java/include/org_forstdb_CompactionOptions.h deleted file mode 100644 index 9de502251..000000000 --- a/java/include/org_forstdb_CompactionOptions.h +++ /dev/null @@ -1,77 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_CompactionOptions */ - -#ifndef _Included_org_forstdb_CompactionOptions -#define _Included_org_forstdb_CompactionOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_CompactionOptions - * Method: newCompactionOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionOptions_newCompactionOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_CompactionOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionOptions - * Method: compression - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_CompactionOptions_compression - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionOptions - * Method: setCompression - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptions_setCompression - (JNIEnv *, jclass, jlong, jbyte); - -/* - * Class: org_forstdb_CompactionOptions - * Method: outputFileSizeLimit - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionOptions_outputFileSizeLimit - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionOptions - * Method: setOutputFileSizeLimit - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptions_setOutputFileSizeLimit - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_CompactionOptions - * Method: maxSubcompactions - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptions_maxSubcompactions - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_CompactionOptions - * Method: setMaxSubcompactions - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptions_setMaxSubcompactions - (JNIEnv *, jclass, jlong, jint); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_CompactionOptionsFIFO.h b/java/include/org_forstdb_CompactionOptionsFIFO.h deleted file mode 100644 index aed1c4b69..000000000 --- a/java/include/org_forstdb_CompactionOptionsFIFO.h +++ /dev/null @@ -1,61 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_CompactionOptionsFIFO */ - -#ifndef _Included_org_forstdb_CompactionOptionsFIFO -#define _Included_org_forstdb_CompactionOptionsFIFO -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_CompactionOptionsFIFO - * Method: newCompactionOptionsFIFO - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionOptionsFIFO_newCompactionOptionsFIFO - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_CompactionOptionsFIFO - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsFIFO_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionOptionsFIFO - * Method: setMaxTableFilesSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsFIFO_setMaxTableFilesSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_CompactionOptionsFIFO - * Method: maxTableFilesSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionOptionsFIFO_maxTableFilesSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionOptionsFIFO - * Method: setAllowCompaction - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsFIFO_setAllowCompaction - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_CompactionOptionsFIFO - * Method: allowCompaction - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactionOptionsFIFO_allowCompaction - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_CompactionOptionsUniversal.h b/java/include/org_forstdb_CompactionOptionsUniversal.h deleted file mode 100644 index 606032f24..000000000 --- a/java/include/org_forstdb_CompactionOptionsUniversal.h +++ /dev/null @@ -1,141 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_CompactionOptionsUniversal */ - -#ifndef _Included_org_forstdb_CompactionOptionsUniversal -#define _Included_org_forstdb_CompactionOptionsUniversal -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: newCompactionOptionsUniversal - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompactionOptionsUniversal_newCompactionOptionsUniversal - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: setSizeRatio - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setSizeRatio - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: sizeRatio - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptionsUniversal_sizeRatio - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: setMinMergeWidth - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setMinMergeWidth - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: minMergeWidth - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptionsUniversal_minMergeWidth - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: setMaxMergeWidth - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setMaxMergeWidth - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: maxMergeWidth - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptionsUniversal_maxMergeWidth - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: setMaxSizeAmplificationPercent - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setMaxSizeAmplificationPercent - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: maxSizeAmplificationPercent - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptionsUniversal_maxSizeAmplificationPercent - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: setCompressionSizePercent - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setCompressionSizePercent - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: compressionSizePercent - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompactionOptionsUniversal_compressionSizePercent - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: setStopStyle - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setStopStyle - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: stopStyle - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_CompactionOptionsUniversal_stopStyle - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: setAllowTrivialMove - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompactionOptionsUniversal_setAllowTrivialMove - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_CompactionOptionsUniversal - * Method: allowTrivialMove - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_CompactionOptionsUniversal_allowTrivialMove - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_ComparatorOptions.h b/java/include/org_forstdb_ComparatorOptions.h deleted file mode 100644 index 68c0846ea..000000000 --- a/java/include/org_forstdb_ComparatorOptions.h +++ /dev/null @@ -1,77 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_ComparatorOptions */ - -#ifndef _Included_org_forstdb_ComparatorOptions -#define _Included_org_forstdb_ComparatorOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_ComparatorOptions - * Method: newComparatorOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ComparatorOptions_newComparatorOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_ComparatorOptions - * Method: reusedSynchronisationType - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_ComparatorOptions_reusedSynchronisationType - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ComparatorOptions - * Method: setReusedSynchronisationType - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ComparatorOptions_setReusedSynchronisationType - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_ComparatorOptions - * Method: useDirectBuffer - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ComparatorOptions_useDirectBuffer - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ComparatorOptions - * Method: setUseDirectBuffer - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ComparatorOptions_setUseDirectBuffer - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ComparatorOptions - * Method: maxReusedBufferSize - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ComparatorOptions_maxReusedBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ComparatorOptions - * Method: setMaxReusedBufferSize - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ComparatorOptions_setMaxReusedBufferSize - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_ComparatorOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ComparatorOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_CompressionOptions.h b/java/include/org_forstdb_CompressionOptions.h deleted file mode 100644 index b5d7fc79b..000000000 --- a/java/include/org_forstdb_CompressionOptions.h +++ /dev/null @@ -1,125 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_CompressionOptions */ - -#ifndef _Included_org_forstdb_CompressionOptions -#define _Included_org_forstdb_CompressionOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_CompressionOptions - * Method: newCompressionOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_CompressionOptions_newCompressionOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_CompressionOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompressionOptions - * Method: setWindowBits - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setWindowBits - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompressionOptions - * Method: windowBits - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompressionOptions_windowBits - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompressionOptions - * Method: setLevel - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setLevel - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompressionOptions - * Method: level - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompressionOptions_level - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompressionOptions - * Method: setStrategy - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setStrategy - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompressionOptions - * Method: strategy - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompressionOptions_strategy - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompressionOptions - * Method: setMaxDictBytes - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setMaxDictBytes - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompressionOptions - * Method: maxDictBytes - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompressionOptions_maxDictBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompressionOptions - * Method: setZstdMaxTrainBytes - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setZstdMaxTrainBytes - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_CompressionOptions - * Method: zstdMaxTrainBytes - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_CompressionOptions_zstdMaxTrainBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_CompressionOptions - * Method: setEnabled - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_CompressionOptions_setEnabled - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_CompressionOptions - * Method: enabled - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_CompressionOptions_enabled - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_ConcurrentTaskLimiterImpl.h b/java/include/org_forstdb_ConcurrentTaskLimiterImpl.h deleted file mode 100644 index e8ae61f40..000000000 --- a/java/include/org_forstdb_ConcurrentTaskLimiterImpl.h +++ /dev/null @@ -1,61 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_ConcurrentTaskLimiterImpl */ - -#ifndef _Included_org_forstdb_ConcurrentTaskLimiterImpl -#define _Included_org_forstdb_ConcurrentTaskLimiterImpl -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_ConcurrentTaskLimiterImpl - * Method: newConcurrentTaskLimiterImpl0 - * Signature: (Ljava/lang/String;I)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_newConcurrentTaskLimiterImpl0 - (JNIEnv *, jclass, jstring, jint); - -/* - * Class: org_forstdb_ConcurrentTaskLimiterImpl - * Method: name - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_name - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_ConcurrentTaskLimiterImpl - * Method: setMaxOutstandingTask - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_setMaxOutstandingTask - (JNIEnv *, jclass, jlong, jint); - -/* - * Class: org_forstdb_ConcurrentTaskLimiterImpl - * Method: resetMaxOutstandingTask - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_resetMaxOutstandingTask - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_ConcurrentTaskLimiterImpl - * Method: outstandingTask - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_outstandingTask - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_ConcurrentTaskLimiterImpl - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ConcurrentTaskLimiterImpl_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_ConfigOptions.h b/java/include/org_forstdb_ConfigOptions.h deleted file mode 100644 index cd3afd215..000000000 --- a/java/include/org_forstdb_ConfigOptions.h +++ /dev/null @@ -1,69 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_ConfigOptions */ - -#ifndef _Included_org_forstdb_ConfigOptions -#define _Included_org_forstdb_ConfigOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_ConfigOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ConfigOptions - * Method: newConfigOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ConfigOptions_newConfigOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_ConfigOptions - * Method: setEnv - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_setEnv - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_ConfigOptions - * Method: setDelimiter - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_setDelimiter - (JNIEnv *, jclass, jlong, jstring); - -/* - * Class: org_forstdb_ConfigOptions - * Method: setIgnoreUnknownOptions - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_setIgnoreUnknownOptions - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_ConfigOptions - * Method: setInputStringsEscaped - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_setInputStringsEscaped - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_ConfigOptions - * Method: setSanityLevel - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ConfigOptions_setSanityLevel - (JNIEnv *, jclass, jlong, jbyte); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_DBOptions.h b/java/include/org_forstdb_DBOptions.h deleted file mode 100644 index 1392c0c3d..000000000 --- a/java/include/org_forstdb_DBOptions.h +++ /dev/null @@ -1,1343 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_DBOptions */ - -#ifndef _Included_org_forstdb_DBOptions -#define _Included_org_forstdb_DBOptions -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_DBOptions_DEFAULT_NUM_SHARD_BITS -#define org_forstdb_DBOptions_DEFAULT_NUM_SHARD_BITS -1L -/* - * Class: org_forstdb_DBOptions - * Method: getDBOptionsFromProps - * Signature: (JLjava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_getDBOptionsFromProps__JLjava_lang_String_2 - (JNIEnv *, jclass, jlong, jstring); - -/* - * Class: org_forstdb_DBOptions - * Method: getDBOptionsFromProps - * Signature: (Ljava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_getDBOptionsFromProps__Ljava_lang_String_2 - (JNIEnv *, jclass, jstring); - -/* - * Class: org_forstdb_DBOptions - * Method: newDBOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_newDBOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_DBOptions - * Method: copyDBOptions - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_copyDBOptions - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: newDBOptionsFromOptions - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_newDBOptionsFromOptions - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: optimizeForSmallDb - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_optimizeForSmallDb - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setIncreaseParallelism - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setIncreaseParallelism - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DBOptions - * Method: setCreateIfMissing - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setCreateIfMissing - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: createIfMissing - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_createIfMissing - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setCreateMissingColumnFamilies - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setCreateMissingColumnFamilies - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: createMissingColumnFamilies - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_createMissingColumnFamilies - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setEnv - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setEnv - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setErrorIfExists - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setErrorIfExists - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: errorIfExists - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_errorIfExists - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setParanoidChecks - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setParanoidChecks - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: paranoidChecks - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_paranoidChecks - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setRateLimiter - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setRateLimiter - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setSstFileManager - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setSstFileManager - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setLogger - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setLogger - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setInfoLogLevel - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setInfoLogLevel - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_DBOptions - * Method: infoLogLevel - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_DBOptions_infoLogLevel - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setMaxOpenFiles - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxOpenFiles - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DBOptions - * Method: maxOpenFiles - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxOpenFiles - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setMaxFileOpeningThreads - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxFileOpeningThreads - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DBOptions - * Method: maxFileOpeningThreads - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxFileOpeningThreads - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setMaxTotalWalSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxTotalWalSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: maxTotalWalSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_maxTotalWalSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setStatistics - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setStatistics - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: statistics - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_statistics - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: useFsync - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_useFsync - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setUseFsync - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setUseFsync - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: setDbPaths - * Signature: (J[Ljava/lang/String;[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDbPaths - (JNIEnv *, jobject, jlong, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_DBOptions - * Method: dbPathsLen - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_dbPathsLen - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: dbPaths - * Signature: (J[Ljava/lang/String;[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_dbPaths - (JNIEnv *, jobject, jlong, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_DBOptions - * Method: setDbLogDir - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDbLogDir - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_DBOptions - * Method: dbLogDir - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_DBOptions_dbLogDir - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setWalDir - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalDir - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_DBOptions - * Method: walDir - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_DBOptions_walDir - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setDeleteObsoleteFilesPeriodMicros - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDeleteObsoleteFilesPeriodMicros - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: deleteObsoleteFilesPeriodMicros - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_deleteObsoleteFilesPeriodMicros - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setMaxBackgroundCompactions - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxBackgroundCompactions - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DBOptions - * Method: maxBackgroundCompactions - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxBackgroundCompactions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setMaxSubcompactions - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxSubcompactions - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DBOptions - * Method: maxSubcompactions - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxSubcompactions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setMaxBackgroundFlushes - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxBackgroundFlushes - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DBOptions - * Method: maxBackgroundFlushes - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxBackgroundFlushes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setMaxBackgroundJobs - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxBackgroundJobs - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DBOptions - * Method: maxBackgroundJobs - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxBackgroundJobs - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setMaxLogFileSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxLogFileSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: maxLogFileSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_maxLogFileSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setLogFileTimeToRoll - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setLogFileTimeToRoll - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: logFileTimeToRoll - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_logFileTimeToRoll - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setKeepLogFileNum - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setKeepLogFileNum - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: keepLogFileNum - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_keepLogFileNum - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setRecycleLogFileNum - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setRecycleLogFileNum - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: recycleLogFileNum - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_recycleLogFileNum - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setMaxManifestFileSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxManifestFileSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: maxManifestFileSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_maxManifestFileSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setTableCacheNumshardbits - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setTableCacheNumshardbits - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DBOptions - * Method: tableCacheNumshardbits - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_tableCacheNumshardbits - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setWalTtlSeconds - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalTtlSeconds - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: walTtlSeconds - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_walTtlSeconds - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setWalSizeLimitMB - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalSizeLimitMB - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: walSizeLimitMB - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_walSizeLimitMB - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setMaxWriteBatchGroupSizeBytes - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxWriteBatchGroupSizeBytes - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: maxWriteBatchGroupSizeBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_maxWriteBatchGroupSizeBytes - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setManifestPreallocationSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setManifestPreallocationSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: manifestPreallocationSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_manifestPreallocationSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setUseDirectReads - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setUseDirectReads - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: useDirectReads - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_useDirectReads - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setUseDirectIoForFlushAndCompaction - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setUseDirectIoForFlushAndCompaction - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: useDirectIoForFlushAndCompaction - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_useDirectIoForFlushAndCompaction - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAllowFAllocate - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllowFAllocate - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: allowFAllocate - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allowFAllocate - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAllowMmapReads - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllowMmapReads - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: allowMmapReads - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allowMmapReads - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAllowMmapWrites - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllowMmapWrites - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: allowMmapWrites - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allowMmapWrites - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setIsFdCloseOnExec - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setIsFdCloseOnExec - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: isFdCloseOnExec - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_isFdCloseOnExec - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setStatsDumpPeriodSec - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setStatsDumpPeriodSec - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DBOptions - * Method: statsDumpPeriodSec - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_statsDumpPeriodSec - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setStatsPersistPeriodSec - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setStatsPersistPeriodSec - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DBOptions - * Method: statsPersistPeriodSec - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_statsPersistPeriodSec - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setStatsHistoryBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setStatsHistoryBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: statsHistoryBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_statsHistoryBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAdviseRandomOnOpen - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAdviseRandomOnOpen - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: adviseRandomOnOpen - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_adviseRandomOnOpen - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setDbWriteBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDbWriteBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setWriteBufferManager - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWriteBufferManager - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: dbWriteBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_dbWriteBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAccessHintOnCompactionStart - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAccessHintOnCompactionStart - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_DBOptions - * Method: accessHintOnCompactionStart - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_DBOptions_accessHintOnCompactionStart - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setCompactionReadaheadSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setCompactionReadaheadSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: compactionReadaheadSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_compactionReadaheadSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setRandomAccessMaxBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setRandomAccessMaxBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: randomAccessMaxBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_randomAccessMaxBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setWritableFileMaxBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWritableFileMaxBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: writableFileMaxBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_writableFileMaxBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setUseAdaptiveMutex - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setUseAdaptiveMutex - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: useAdaptiveMutex - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_useAdaptiveMutex - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setBytesPerSync - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setBytesPerSync - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: bytesPerSync - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_bytesPerSync - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setWalBytesPerSync - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalBytesPerSync - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: walBytesPerSync - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_walBytesPerSync - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setStrictBytesPerSync - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setStrictBytesPerSync - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: strictBytesPerSync - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_strictBytesPerSync - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setEventListeners - * Signature: (J[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setEventListeners - (JNIEnv *, jclass, jlong, jlongArray); - -/* - * Class: org_forstdb_DBOptions - * Method: eventListeners - * Signature: (J)[Lorg/forstdb/AbstractEventListener; - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_DBOptions_eventListeners - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setEnableThreadTracking - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setEnableThreadTracking - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: enableThreadTracking - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_enableThreadTracking - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setDelayedWriteRate - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDelayedWriteRate - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: delayedWriteRate - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_delayedWriteRate - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setEnablePipelinedWrite - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setEnablePipelinedWrite - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: enablePipelinedWrite - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_enablePipelinedWrite - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setUnorderedWrite - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setUnorderedWrite - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: unorderedWrite - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_unorderedWrite - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAllowConcurrentMemtableWrite - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllowConcurrentMemtableWrite - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: allowConcurrentMemtableWrite - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allowConcurrentMemtableWrite - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setEnableWriteThreadAdaptiveYield - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setEnableWriteThreadAdaptiveYield - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: enableWriteThreadAdaptiveYield - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_enableWriteThreadAdaptiveYield - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setWriteThreadMaxYieldUsec - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWriteThreadMaxYieldUsec - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: writeThreadMaxYieldUsec - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_writeThreadMaxYieldUsec - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setWriteThreadSlowYieldUsec - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWriteThreadSlowYieldUsec - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: writeThreadSlowYieldUsec - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_writeThreadSlowYieldUsec - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setSkipStatsUpdateOnDbOpen - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setSkipStatsUpdateOnDbOpen - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: skipStatsUpdateOnDbOpen - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_skipStatsUpdateOnDbOpen - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setSkipCheckingSstFileSizesOnDbOpen - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setSkipCheckingSstFileSizesOnDbOpen - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: skipCheckingSstFileSizesOnDbOpen - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_skipCheckingSstFileSizesOnDbOpen - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setWalRecoveryMode - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalRecoveryMode - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_DBOptions - * Method: walRecoveryMode - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_DBOptions_walRecoveryMode - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAllow2pc - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllow2pc - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: allow2pc - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allow2pc - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setRowCache - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setRowCache - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setWalFilter - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWalFilter - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setFailIfOptionsFileError - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setFailIfOptionsFileError - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: failIfOptionsFileError - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_failIfOptionsFileError - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setDumpMallocStats - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setDumpMallocStats - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: dumpMallocStats - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_dumpMallocStats - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAvoidFlushDuringRecovery - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAvoidFlushDuringRecovery - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: avoidFlushDuringRecovery - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_avoidFlushDuringRecovery - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAvoidFlushDuringShutdown - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAvoidFlushDuringShutdown - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: avoidFlushDuringShutdown - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_avoidFlushDuringShutdown - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAllowIngestBehind - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAllowIngestBehind - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: allowIngestBehind - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_allowIngestBehind - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setTwoWriteQueues - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setTwoWriteQueues - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: twoWriteQueues - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_twoWriteQueues - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setManualWalFlush - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setManualWalFlush - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: manualWalFlush - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_manualWalFlush - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAtomicFlush - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAtomicFlush - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: atomicFlush - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_atomicFlush - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setAvoidUnnecessaryBlockingIO - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setAvoidUnnecessaryBlockingIO - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: avoidUnnecessaryBlockingIO - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_avoidUnnecessaryBlockingIO - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setPersistStatsToDisk - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setPersistStatsToDisk - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: persistStatsToDisk - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_persistStatsToDisk - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setWriteDbidToManifest - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setWriteDbidToManifest - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: writeDbidToManifest - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_writeDbidToManifest - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setLogReadaheadSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setLogReadaheadSize - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: logReadaheadSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_logReadaheadSize - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setBestEffortsRecovery - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setBestEffortsRecovery - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_DBOptions - * Method: bestEffortsRecovery - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_DBOptions_bestEffortsRecovery - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setMaxBgErrorResumeCount - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setMaxBgErrorResumeCount - (JNIEnv *, jclass, jlong, jint); - -/* - * Class: org_forstdb_DBOptions - * Method: maxBgerrorResumeCount - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_DBOptions_maxBgerrorResumeCount - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: setBgerrorResumeRetryInterval - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DBOptions_setBgerrorResumeRetryInterval - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_DBOptions - * Method: bgerrorResumeRetryInterval - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DBOptions_bgerrorResumeRetryInterval - (JNIEnv *, jclass, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_DirectSlice.h b/java/include/org_forstdb_DirectSlice.h deleted file mode 100644 index ea809dcb9..000000000 --- a/java/include/org_forstdb_DirectSlice.h +++ /dev/null @@ -1,77 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_DirectSlice */ - -#ifndef _Included_org_forstdb_DirectSlice -#define _Included_org_forstdb_DirectSlice -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_DirectSlice - * Method: createNewDirectSlice0 - * Signature: (Ljava/nio/ByteBuffer;I)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DirectSlice_createNewDirectSlice0 - (JNIEnv *, jclass, jobject, jint); - -/* - * Class: org_forstdb_DirectSlice - * Method: createNewDirectSlice1 - * Signature: (Ljava/nio/ByteBuffer;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_DirectSlice_createNewDirectSlice1 - (JNIEnv *, jclass, jobject); - -/* - * Class: org_forstdb_DirectSlice - * Method: data0 - * Signature: (J)Ljava/nio/ByteBuffer; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_DirectSlice_data0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_DirectSlice - * Method: get0 - * Signature: (JI)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_DirectSlice_get0 - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DirectSlice - * Method: clear0 - * Signature: (JZJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DirectSlice_clear0 - (JNIEnv *, jobject, jlong, jboolean, jlong); - -/* - * Class: org_forstdb_DirectSlice - * Method: removePrefix0 - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DirectSlice_removePrefix0 - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DirectSlice - * Method: setLength0 - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DirectSlice_setLength0 - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_DirectSlice - * Method: disposeInternalBuf - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_DirectSlice_disposeInternalBuf - (JNIEnv *, jobject, jlong, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_Env.h b/java/include/org_forstdb_Env.h deleted file mode 100644 index 8b9a95d66..000000000 --- a/java/include/org_forstdb_Env.h +++ /dev/null @@ -1,77 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_Env */ - -#ifndef _Included_org_forstdb_Env -#define _Included_org_forstdb_Env -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_Env - * Method: getDefaultEnvInternal - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Env_getDefaultEnvInternal - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_Env - * Method: setBackgroundThreads - * Signature: (JIB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Env_setBackgroundThreads - (JNIEnv *, jobject, jlong, jint, jbyte); - -/* - * Class: org_forstdb_Env - * Method: getBackgroundThreads - * Signature: (JB)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Env_getBackgroundThreads - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Env - * Method: getThreadPoolQueueLen - * Signature: (JB)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Env_getThreadPoolQueueLen - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Env - * Method: incBackgroundThreadsIfNeeded - * Signature: (JIB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Env_incBackgroundThreadsIfNeeded - (JNIEnv *, jobject, jlong, jint, jbyte); - -/* - * Class: org_forstdb_Env - * Method: lowerThreadPoolIOPriority - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Env_lowerThreadPoolIOPriority - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Env - * Method: lowerThreadPoolCPUPriority - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Env_lowerThreadPoolCPUPriority - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Env - * Method: getThreadList - * Signature: (J)[Lorg/forstdb/ThreadStatus; - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Env_getThreadList - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_EnvFlinkTestSuite.h b/java/include/org_forstdb_EnvFlinkTestSuite.h deleted file mode 100644 index 1a880fa27..000000000 --- a/java/include/org_forstdb_EnvFlinkTestSuite.h +++ /dev/null @@ -1,37 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_EnvFlinkTestSuite */ - -#ifndef _Included_org_forstdb_EnvFlinkTestSuite -#define _Included_org_forstdb_EnvFlinkTestSuite -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_EnvFlinkTestSuite - * Method: buildNativeObject - * Signature: (Ljava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_EnvFlinkTestSuite_buildNativeObject - (JNIEnv *, jobject, jstring); - -/* - * Class: org_forstdb_EnvFlinkTestSuite - * Method: runAllTestSuites - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvFlinkTestSuite_runAllTestSuites - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvFlinkTestSuite - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvFlinkTestSuite_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_EnvOptions.h b/java/include/org_forstdb_EnvOptions.h deleted file mode 100644 index 39795651a..000000000 --- a/java/include/org_forstdb_EnvOptions.h +++ /dev/null @@ -1,221 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_EnvOptions */ - -#ifndef _Included_org_forstdb_EnvOptions -#define _Included_org_forstdb_EnvOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_EnvOptions - * Method: newEnvOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_newEnvOptions__ - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_EnvOptions - * Method: newEnvOptions - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_newEnvOptions__J - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setUseMmapReads - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setUseMmapReads - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_EnvOptions - * Method: useMmapReads - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_useMmapReads - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setUseMmapWrites - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setUseMmapWrites - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_EnvOptions - * Method: useMmapWrites - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_useMmapWrites - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setUseDirectReads - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setUseDirectReads - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_EnvOptions - * Method: useDirectReads - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_useDirectReads - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setUseDirectWrites - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setUseDirectWrites - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_EnvOptions - * Method: useDirectWrites - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_useDirectWrites - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setAllowFallocate - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setAllowFallocate - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_EnvOptions - * Method: allowFallocate - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_allowFallocate - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setSetFdCloexec - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setSetFdCloexec - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_EnvOptions - * Method: setFdCloexec - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_setFdCloexec - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setBytesPerSync - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setBytesPerSync - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: bytesPerSync - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_bytesPerSync - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setFallocateWithKeepSize - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setFallocateWithKeepSize - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_EnvOptions - * Method: fallocateWithKeepSize - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_EnvOptions_fallocateWithKeepSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setCompactionReadaheadSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setCompactionReadaheadSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: compactionReadaheadSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_compactionReadaheadSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setRandomAccessMaxBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setRandomAccessMaxBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: randomAccessMaxBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_randomAccessMaxBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setWritableFileMaxBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setWritableFileMaxBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: writableFileMaxBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_EnvOptions_writableFileMaxBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_EnvOptions - * Method: setRateLimiter - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_EnvOptions_setRateLimiter - (JNIEnv *, jobject, jlong, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_ExportImportFilesMetaData.h b/java/include/org_forstdb_ExportImportFilesMetaData.h deleted file mode 100644 index 077daf31a..000000000 --- a/java/include/org_forstdb_ExportImportFilesMetaData.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_ExportImportFilesMetaData */ - -#ifndef _Included_org_forstdb_ExportImportFilesMetaData -#define _Included_org_forstdb_ExportImportFilesMetaData -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_ExportImportFilesMetaData - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ExportImportFilesMetaData_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_Filter.h b/java/include/org_forstdb_Filter.h deleted file mode 100644 index 948c5ecaa..000000000 --- a/java/include/org_forstdb_Filter.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_Filter */ - -#ifndef _Included_org_forstdb_Filter -#define _Included_org_forstdb_Filter -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_Filter - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Filter_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_FlinkCompactionFilter.h b/java/include/org_forstdb_FlinkCompactionFilter.h deleted file mode 100644 index bb9bdb15c..000000000 --- a/java/include/org_forstdb_FlinkCompactionFilter.h +++ /dev/null @@ -1,45 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_FlinkCompactionFilter */ - -#ifndef _Included_org_forstdb_FlinkCompactionFilter -#define _Included_org_forstdb_FlinkCompactionFilter -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_FlinkCompactionFilter - * Method: createNewFlinkCompactionFilter0 - * Signature: (JLorg/forstdb/FlinkCompactionFilter/TimeProvider;J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_FlinkCompactionFilter_createNewFlinkCompactionFilter0 - (JNIEnv *, jclass, jlong, jobject, jlong); - -/* - * Class: org_forstdb_FlinkCompactionFilter - * Method: createNewFlinkCompactionFilterConfigHolder - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_FlinkCompactionFilter_createNewFlinkCompactionFilterConfigHolder - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_FlinkCompactionFilter - * Method: disposeFlinkCompactionFilterConfigHolder - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_FlinkCompactionFilter_disposeFlinkCompactionFilterConfigHolder - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_FlinkCompactionFilter - * Method: configureFlinkCompactionFilter - * Signature: (JIIJJILorg/forstdb/FlinkCompactionFilter/ListElementFilterFactory;)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_FlinkCompactionFilter_configureFlinkCompactionFilter - (JNIEnv *, jclass, jlong, jint, jint, jlong, jlong, jint, jobject); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_FlinkEnv.h b/java/include/org_forstdb_FlinkEnv.h deleted file mode 100644 index 4dfe9e786..000000000 --- a/java/include/org_forstdb_FlinkEnv.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_FlinkEnv */ - -#ifndef _Included_org_forstdb_FlinkEnv -#define _Included_org_forstdb_FlinkEnv -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_FlinkEnv - * Method: createFlinkEnv - * Signature: (Ljava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_FlinkEnv_createFlinkEnv - (JNIEnv *, jclass, jstring); - -/* - * Class: org_forstdb_FlinkEnv - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_FlinkEnv_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_FlushOptions.h b/java/include/org_forstdb_FlushOptions.h deleted file mode 100644 index 97ff71b99..000000000 --- a/java/include/org_forstdb_FlushOptions.h +++ /dev/null @@ -1,61 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_FlushOptions */ - -#ifndef _Included_org_forstdb_FlushOptions -#define _Included_org_forstdb_FlushOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_FlushOptions - * Method: newFlushOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_FlushOptions_newFlushOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_FlushOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_FlushOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_FlushOptions - * Method: setWaitForFlush - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_FlushOptions_setWaitForFlush - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_FlushOptions - * Method: waitForFlush - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_FlushOptions_waitForFlush - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_FlushOptions - * Method: setAllowWriteStall - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_FlushOptions_setAllowWriteStall - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_FlushOptions - * Method: allowWriteStall - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_FlushOptions_allowWriteStall - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_HashLinkedListMemTableConfig.h b/java/include/org_forstdb_HashLinkedListMemTableConfig.h deleted file mode 100644 index bfc29cab3..000000000 --- a/java/include/org_forstdb_HashLinkedListMemTableConfig.h +++ /dev/null @@ -1,31 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_HashLinkedListMemTableConfig */ - -#ifndef _Included_org_forstdb_HashLinkedListMemTableConfig -#define _Included_org_forstdb_HashLinkedListMemTableConfig -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_HashLinkedListMemTableConfig_DEFAULT_BUCKET_COUNT -#define org_forstdb_HashLinkedListMemTableConfig_DEFAULT_BUCKET_COUNT 50000LL -#undef org_forstdb_HashLinkedListMemTableConfig_DEFAULT_HUGE_PAGE_TLB_SIZE -#define org_forstdb_HashLinkedListMemTableConfig_DEFAULT_HUGE_PAGE_TLB_SIZE 0LL -#undef org_forstdb_HashLinkedListMemTableConfig_DEFAULT_BUCKET_ENTRIES_LOG_THRES -#define org_forstdb_HashLinkedListMemTableConfig_DEFAULT_BUCKET_ENTRIES_LOG_THRES 4096L -#undef org_forstdb_HashLinkedListMemTableConfig_DEFAULT_IF_LOG_BUCKET_DIST_WHEN_FLUSH -#define org_forstdb_HashLinkedListMemTableConfig_DEFAULT_IF_LOG_BUCKET_DIST_WHEN_FLUSH 1L -#undef org_forstdb_HashLinkedListMemTableConfig_DEFAUL_THRESHOLD_USE_SKIPLIST -#define org_forstdb_HashLinkedListMemTableConfig_DEFAUL_THRESHOLD_USE_SKIPLIST 256L -/* - * Class: org_forstdb_HashLinkedListMemTableConfig - * Method: newMemTableFactoryHandle - * Signature: (JJIZI)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_HashLinkedListMemTableConfig_newMemTableFactoryHandle - (JNIEnv *, jobject, jlong, jlong, jint, jboolean, jint); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_HashSkipListMemTableConfig.h b/java/include/org_forstdb_HashSkipListMemTableConfig.h deleted file mode 100644 index bc800fe5a..000000000 --- a/java/include/org_forstdb_HashSkipListMemTableConfig.h +++ /dev/null @@ -1,27 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_HashSkipListMemTableConfig */ - -#ifndef _Included_org_forstdb_HashSkipListMemTableConfig -#define _Included_org_forstdb_HashSkipListMemTableConfig -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_HashSkipListMemTableConfig_DEFAULT_BUCKET_COUNT -#define org_forstdb_HashSkipListMemTableConfig_DEFAULT_BUCKET_COUNT 1000000L -#undef org_forstdb_HashSkipListMemTableConfig_DEFAULT_BRANCHING_FACTOR -#define org_forstdb_HashSkipListMemTableConfig_DEFAULT_BRANCHING_FACTOR 4L -#undef org_forstdb_HashSkipListMemTableConfig_DEFAULT_HEIGHT -#define org_forstdb_HashSkipListMemTableConfig_DEFAULT_HEIGHT 4L -/* - * Class: org_forstdb_HashSkipListMemTableConfig - * Method: newMemTableFactoryHandle - * Signature: (JII)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_HashSkipListMemTableConfig_newMemTableFactoryHandle - (JNIEnv *, jobject, jlong, jint, jint); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_HyperClockCache.h b/java/include/org_forstdb_HyperClockCache.h deleted file mode 100644 index c7f5ea634..000000000 --- a/java/include/org_forstdb_HyperClockCache.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_HyperClockCache */ - -#ifndef _Included_org_forstdb_HyperClockCache -#define _Included_org_forstdb_HyperClockCache -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_HyperClockCache - * Method: disposeInternalJni - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_HyperClockCache_disposeInternalJni - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_HyperClockCache - * Method: newHyperClockCache - * Signature: (JJIZ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_HyperClockCache_newHyperClockCache - (JNIEnv *, jclass, jlong, jlong, jint, jboolean); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_ImportColumnFamilyOptions.h b/java/include/org_forstdb_ImportColumnFamilyOptions.h deleted file mode 100644 index d97b72abb..000000000 --- a/java/include/org_forstdb_ImportColumnFamilyOptions.h +++ /dev/null @@ -1,45 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_ImportColumnFamilyOptions */ - -#ifndef _Included_org_forstdb_ImportColumnFamilyOptions -#define _Included_org_forstdb_ImportColumnFamilyOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_ImportColumnFamilyOptions - * Method: newImportColumnFamilyOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ImportColumnFamilyOptions_newImportColumnFamilyOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_ImportColumnFamilyOptions - * Method: moveFiles - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ImportColumnFamilyOptions_moveFiles - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ImportColumnFamilyOptions - * Method: setMoveFiles - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ImportColumnFamilyOptions_setMoveFiles - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ImportColumnFamilyOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ImportColumnFamilyOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_IngestExternalFileOptions.h b/java/include/org_forstdb_IngestExternalFileOptions.h deleted file mode 100644 index 7db0ec878..000000000 --- a/java/include/org_forstdb_IngestExternalFileOptions.h +++ /dev/null @@ -1,133 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_IngestExternalFileOptions */ - -#ifndef _Included_org_forstdb_IngestExternalFileOptions -#define _Included_org_forstdb_IngestExternalFileOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: newIngestExternalFileOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_IngestExternalFileOptions_newIngestExternalFileOptions__ - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: newIngestExternalFileOptions - * Signature: (ZZZZ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_IngestExternalFileOptions_newIngestExternalFileOptions__ZZZZ - (JNIEnv *, jclass, jboolean, jboolean, jboolean, jboolean); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: moveFiles - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_moveFiles - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: setMoveFiles - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setMoveFiles - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: snapshotConsistency - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_snapshotConsistency - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: setSnapshotConsistency - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setSnapshotConsistency - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: allowGlobalSeqNo - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_allowGlobalSeqNo - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: setAllowGlobalSeqNo - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setAllowGlobalSeqNo - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: allowBlockingFlush - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_allowBlockingFlush - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: setAllowBlockingFlush - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setAllowBlockingFlush - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: ingestBehind - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_ingestBehind - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: setIngestBehind - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setIngestBehind - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: writeGlobalSeqno - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_IngestExternalFileOptions_writeGlobalSeqno - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_IngestExternalFileOptions - * Method: setWriteGlobalSeqno - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_IngestExternalFileOptions_setWriteGlobalSeqno - (JNIEnv *, jobject, jlong, jboolean); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_LRUCache.h b/java/include/org_forstdb_LRUCache.h deleted file mode 100644 index 168288330..000000000 --- a/java/include/org_forstdb_LRUCache.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_LRUCache */ - -#ifndef _Included_org_forstdb_LRUCache -#define _Included_org_forstdb_LRUCache -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_LRUCache - * Method: newLRUCache - * Signature: (JIZDD)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_LRUCache_newLRUCache - (JNIEnv *, jclass, jlong, jint, jboolean, jdouble, jdouble); - -/* - * Class: org_forstdb_LRUCache - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_LRUCache_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_LiveFileMetaData.h b/java/include/org_forstdb_LiveFileMetaData.h deleted file mode 100644 index f89568b61..000000000 --- a/java/include/org_forstdb_LiveFileMetaData.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_LiveFileMetaData */ - -#ifndef _Included_org_forstdb_LiveFileMetaData -#define _Included_org_forstdb_LiveFileMetaData -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_LiveFileMetaData - * Method: newLiveFileMetaDataHandle - * Signature: ([BIILjava/lang/String;Ljava/lang/String;JJJ[BI[BIJZJJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_LiveFileMetaData_newLiveFileMetaDataHandle - (JNIEnv *, jobject, jbyteArray, jint, jint, jstring, jstring, jlong, jlong, jlong, jbyteArray, jint, jbyteArray, jint, jlong, jboolean, jlong, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_Logger.h b/java/include/org_forstdb_Logger.h deleted file mode 100644 index d1968a3fd..000000000 --- a/java/include/org_forstdb_Logger.h +++ /dev/null @@ -1,57 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_Logger */ - -#ifndef _Included_org_forstdb_Logger -#define _Included_org_forstdb_Logger -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_Logger_WITH_OPTIONS -#define org_forstdb_Logger_WITH_OPTIONS 0LL -#undef org_forstdb_Logger_WITH_DBOPTIONS -#define org_forstdb_Logger_WITH_DBOPTIONS 1LL -/* - * Class: org_forstdb_Logger - * Method: createNewLoggerOptions - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Logger_createNewLoggerOptions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Logger - * Method: createNewLoggerDbOptions - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Logger_createNewLoggerDbOptions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Logger - * Method: setInfoLogLevel - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Logger_setInfoLogLevel - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Logger - * Method: infoLogLevel - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Logger_infoLogLevel - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Logger - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Logger_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_MemoryUtil.h b/java/include/org_forstdb_MemoryUtil.h deleted file mode 100644 index ed7b3fd3f..000000000 --- a/java/include/org_forstdb_MemoryUtil.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_MemoryUtil */ - -#ifndef _Included_org_forstdb_MemoryUtil -#define _Included_org_forstdb_MemoryUtil -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_MemoryUtil - * Method: getApproximateMemoryUsageByType - * Signature: ([J[J)Ljava/util/Map; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_MemoryUtil_getApproximateMemoryUsageByType - (JNIEnv *, jclass, jlongArray, jlongArray); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_NativeComparatorWrapper.h b/java/include/org_forstdb_NativeComparatorWrapper.h deleted file mode 100644 index 7fb7fb9d1..000000000 --- a/java/include/org_forstdb_NativeComparatorWrapper.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_NativeComparatorWrapper */ - -#ifndef _Included_org_forstdb_NativeComparatorWrapper -#define _Included_org_forstdb_NativeComparatorWrapper -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_NativeComparatorWrapper - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_NativeComparatorWrapper_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper.h b/java/include/org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper.h deleted file mode 100644 index b94d5e91a..000000000 --- a/java/include/org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper */ - -#ifndef _Included_org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper -#define _Included_org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper - * Method: newStringComparator - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_NativeComparatorWrapperTest_00024NativeStringComparatorWrapper_newStringComparator - (JNIEnv *, jobject); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_OptimisticTransactionDB.h b/java/include/org_forstdb_OptimisticTransactionDB.h deleted file mode 100644 index 86f111d7b..000000000 --- a/java/include/org_forstdb_OptimisticTransactionDB.h +++ /dev/null @@ -1,87 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_OptimisticTransactionDB */ - -#ifndef _Included_org_forstdb_OptimisticTransactionDB -#define _Included_org_forstdb_OptimisticTransactionDB -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_OptimisticTransactionDB_NOT_FOUND -#define org_forstdb_OptimisticTransactionDB_NOT_FOUND -1L -/* - * Class: org_forstdb_OptimisticTransactionDB - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_OptimisticTransactionDB_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_OptimisticTransactionDB - * Method: open - * Signature: (JLjava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_open__JLjava_lang_String_2 - (JNIEnv *, jclass, jlong, jstring); - -/* - * Class: org_forstdb_OptimisticTransactionDB - * Method: open - * Signature: (JLjava/lang/String;[[B[J)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_OptimisticTransactionDB_open__JLjava_lang_String_2_3_3B_3J - (JNIEnv *, jclass, jlong, jstring, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_OptimisticTransactionDB - * Method: closeDatabase - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_OptimisticTransactionDB_closeDatabase - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_OptimisticTransactionDB - * Method: beginTransaction - * Signature: (JJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_beginTransaction__JJ - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_OptimisticTransactionDB - * Method: beginTransaction - * Signature: (JJJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_beginTransaction__JJJ - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_OptimisticTransactionDB - * Method: beginTransaction_withOld - * Signature: (JJJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_beginTransaction_1withOld__JJJ - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_OptimisticTransactionDB - * Method: beginTransaction_withOld - * Signature: (JJJJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_beginTransaction_1withOld__JJJJ - (JNIEnv *, jobject, jlong, jlong, jlong, jlong); - -/* - * Class: org_forstdb_OptimisticTransactionDB - * Method: getBaseDB - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionDB_getBaseDB - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_OptimisticTransactionOptions.h b/java/include/org_forstdb_OptimisticTransactionOptions.h deleted file mode 100644 index 9060f1b13..000000000 --- a/java/include/org_forstdb_OptimisticTransactionOptions.h +++ /dev/null @@ -1,53 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_OptimisticTransactionOptions */ - -#ifndef _Included_org_forstdb_OptimisticTransactionOptions -#define _Included_org_forstdb_OptimisticTransactionOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_OptimisticTransactionOptions - * Method: newOptimisticTransactionOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_OptimisticTransactionOptions_newOptimisticTransactionOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_OptimisticTransactionOptions - * Method: isSetSnapshot - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_OptimisticTransactionOptions_isSetSnapshot - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_OptimisticTransactionOptions - * Method: setSetSnapshot - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_OptimisticTransactionOptions_setSetSnapshot - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_OptimisticTransactionOptions - * Method: setComparator - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_OptimisticTransactionOptions_setComparator - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_OptimisticTransactionOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_OptimisticTransactionOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_Options.h b/java/include/org_forstdb_Options.h deleted file mode 100644 index 363a38321..000000000 --- a/java/include/org_forstdb_Options.h +++ /dev/null @@ -1,2405 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_Options */ - -#ifndef _Included_org_forstdb_Options -#define _Included_org_forstdb_Options -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_Options - * Method: newOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_newOptions__ - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_Options - * Method: newOptions - * Signature: (JJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_newOptions__JJ - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: copyOptions - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_copyOptions - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setEnv - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnv - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: prepareForBulkLoad - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_prepareForBulkLoad - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setIncreaseParallelism - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setIncreaseParallelism - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: setCreateIfMissing - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCreateIfMissing - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: createIfMissing - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_createIfMissing - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCreateMissingColumnFamilies - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCreateMissingColumnFamilies - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: createMissingColumnFamilies - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_createMissingColumnFamilies - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setErrorIfExists - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setErrorIfExists - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: errorIfExists - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_errorIfExists - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setParanoidChecks - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setParanoidChecks - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: paranoidChecks - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_paranoidChecks - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setRateLimiter - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setRateLimiter - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setSstFileManager - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setSstFileManager - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setLogger - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setLogger - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setInfoLogLevel - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setInfoLogLevel - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Options - * Method: infoLogLevel - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_infoLogLevel - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxOpenFiles - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxOpenFiles - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: maxOpenFiles - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxOpenFiles - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxTotalWalSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxTotalWalSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxFileOpeningThreads - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxFileOpeningThreads - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: maxFileOpeningThreads - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxFileOpeningThreads - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: maxTotalWalSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxTotalWalSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setStatistics - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setStatistics - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: statistics - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_statistics - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: useFsync - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_useFsync - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setUseFsync - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setUseFsync - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: setDbPaths - * Signature: (J[Ljava/lang/String;[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setDbPaths - (JNIEnv *, jobject, jlong, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_Options - * Method: dbPathsLen - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_dbPathsLen - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: dbPaths - * Signature: (J[Ljava/lang/String;[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_dbPaths - (JNIEnv *, jobject, jlong, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_Options - * Method: setDbLogDir - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setDbLogDir - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_Options - * Method: dbLogDir - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_Options_dbLogDir - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWalDir - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalDir - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_Options - * Method: walDir - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_Options_walDir - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setDeleteObsoleteFilesPeriodMicros - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setDeleteObsoleteFilesPeriodMicros - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: deleteObsoleteFilesPeriodMicros - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_deleteObsoleteFilesPeriodMicros - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxBackgroundCompactions - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBackgroundCompactions - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: maxBackgroundCompactions - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxBackgroundCompactions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxSubcompactions - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxSubcompactions - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: maxSubcompactions - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxSubcompactions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxBackgroundFlushes - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBackgroundFlushes - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: maxBackgroundFlushes - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxBackgroundFlushes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxBackgroundJobs - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBackgroundJobs - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: maxBackgroundJobs - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxBackgroundJobs - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxLogFileSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxLogFileSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: maxLogFileSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxLogFileSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setLogFileTimeToRoll - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setLogFileTimeToRoll - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: logFileTimeToRoll - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_logFileTimeToRoll - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setKeepLogFileNum - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setKeepLogFileNum - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: keepLogFileNum - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_keepLogFileNum - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setRecycleLogFileNum - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setRecycleLogFileNum - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: recycleLogFileNum - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_recycleLogFileNum - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxManifestFileSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxManifestFileSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: maxManifestFileSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxManifestFileSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxTableFilesSizeFIFO - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxTableFilesSizeFIFO - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: maxTableFilesSizeFIFO - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxTableFilesSizeFIFO - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setTableCacheNumshardbits - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setTableCacheNumshardbits - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: tableCacheNumshardbits - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_tableCacheNumshardbits - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWalTtlSeconds - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalTtlSeconds - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: walTtlSeconds - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_walTtlSeconds - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWalSizeLimitMB - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalSizeLimitMB - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: walSizeLimitMB - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_walSizeLimitMB - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxWriteBatchGroupSizeBytes - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxWriteBatchGroupSizeBytes - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: maxWriteBatchGroupSizeBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxWriteBatchGroupSizeBytes - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: setManifestPreallocationSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setManifestPreallocationSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: manifestPreallocationSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_manifestPreallocationSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setUseDirectReads - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setUseDirectReads - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: useDirectReads - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_useDirectReads - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setUseDirectIoForFlushAndCompaction - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setUseDirectIoForFlushAndCompaction - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: useDirectIoForFlushAndCompaction - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_useDirectIoForFlushAndCompaction - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAllowFAllocate - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllowFAllocate - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: allowFAllocate - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allowFAllocate - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAllowMmapReads - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllowMmapReads - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: allowMmapReads - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allowMmapReads - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAllowMmapWrites - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllowMmapWrites - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: allowMmapWrites - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allowMmapWrites - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setIsFdCloseOnExec - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setIsFdCloseOnExec - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: isFdCloseOnExec - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_isFdCloseOnExec - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setStatsDumpPeriodSec - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setStatsDumpPeriodSec - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: statsDumpPeriodSec - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_statsDumpPeriodSec - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setStatsPersistPeriodSec - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setStatsPersistPeriodSec - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: statsPersistPeriodSec - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_statsPersistPeriodSec - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setStatsHistoryBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setStatsHistoryBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: statsHistoryBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_statsHistoryBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAdviseRandomOnOpen - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAdviseRandomOnOpen - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: adviseRandomOnOpen - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_adviseRandomOnOpen - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setDbWriteBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setDbWriteBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWriteBufferManager - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWriteBufferManager - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: dbWriteBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_dbWriteBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAccessHintOnCompactionStart - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAccessHintOnCompactionStart - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Options - * Method: accessHintOnCompactionStart - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_accessHintOnCompactionStart - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCompactionReadaheadSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionReadaheadSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: compactionReadaheadSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_compactionReadaheadSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setRandomAccessMaxBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setRandomAccessMaxBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: randomAccessMaxBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_randomAccessMaxBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWritableFileMaxBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWritableFileMaxBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: writableFileMaxBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_writableFileMaxBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setUseAdaptiveMutex - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setUseAdaptiveMutex - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: useAdaptiveMutex - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_useAdaptiveMutex - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBytesPerSync - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBytesPerSync - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: bytesPerSync - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_bytesPerSync - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWalBytesPerSync - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalBytesPerSync - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: walBytesPerSync - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_walBytesPerSync - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setStrictBytesPerSync - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setStrictBytesPerSync - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: strictBytesPerSync - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_strictBytesPerSync - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setEventListeners - * Signature: (J[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setEventListeners - (JNIEnv *, jclass, jlong, jlongArray); - -/* - * Class: org_forstdb_Options - * Method: eventListeners - * Signature: (J)[Lorg/forstdb/AbstractEventListener; - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Options_eventListeners - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: setEnableThreadTracking - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnableThreadTracking - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: enableThreadTracking - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_enableThreadTracking - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setDelayedWriteRate - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setDelayedWriteRate - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: delayedWriteRate - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_delayedWriteRate - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setEnablePipelinedWrite - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnablePipelinedWrite - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: enablePipelinedWrite - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_enablePipelinedWrite - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setUnorderedWrite - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setUnorderedWrite - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: unorderedWrite - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_unorderedWrite - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAllowConcurrentMemtableWrite - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllowConcurrentMemtableWrite - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: allowConcurrentMemtableWrite - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allowConcurrentMemtableWrite - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setEnableWriteThreadAdaptiveYield - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnableWriteThreadAdaptiveYield - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: enableWriteThreadAdaptiveYield - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_enableWriteThreadAdaptiveYield - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWriteThreadMaxYieldUsec - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWriteThreadMaxYieldUsec - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: writeThreadMaxYieldUsec - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_writeThreadMaxYieldUsec - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWriteThreadSlowYieldUsec - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWriteThreadSlowYieldUsec - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: writeThreadSlowYieldUsec - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_writeThreadSlowYieldUsec - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setSkipStatsUpdateOnDbOpen - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setSkipStatsUpdateOnDbOpen - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: skipStatsUpdateOnDbOpen - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_skipStatsUpdateOnDbOpen - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setSkipCheckingSstFileSizesOnDbOpen - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setSkipCheckingSstFileSizesOnDbOpen - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: skipCheckingSstFileSizesOnDbOpen - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_skipCheckingSstFileSizesOnDbOpen - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWalRecoveryMode - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalRecoveryMode - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Options - * Method: walRecoveryMode - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_walRecoveryMode - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAllow2pc - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllow2pc - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: allow2pc - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allow2pc - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setRowCache - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setRowCache - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWalFilter - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWalFilter - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setFailIfOptionsFileError - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setFailIfOptionsFileError - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: failIfOptionsFileError - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_failIfOptionsFileError - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setDumpMallocStats - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setDumpMallocStats - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: dumpMallocStats - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_dumpMallocStats - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAvoidFlushDuringRecovery - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAvoidFlushDuringRecovery - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: avoidFlushDuringRecovery - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_avoidFlushDuringRecovery - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAvoidFlushDuringShutdown - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAvoidFlushDuringShutdown - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: avoidFlushDuringShutdown - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_avoidFlushDuringShutdown - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAllowIngestBehind - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAllowIngestBehind - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: allowIngestBehind - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_allowIngestBehind - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setTwoWriteQueues - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setTwoWriteQueues - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: twoWriteQueues - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_twoWriteQueues - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setManualWalFlush - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setManualWalFlush - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: manualWalFlush - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_manualWalFlush - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: oldDefaults - * Signature: (JII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_oldDefaults - (JNIEnv *, jclass, jlong, jint, jint); - -/* - * Class: org_forstdb_Options - * Method: optimizeForSmallDb - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_optimizeForSmallDb__J - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: optimizeForSmallDb - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_optimizeForSmallDb__JJ - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: optimizeForPointLookup - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_optimizeForPointLookup - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: optimizeLevelStyleCompaction - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_optimizeLevelStyleCompaction - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: optimizeUniversalStyleCompaction - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_optimizeUniversalStyleCompaction - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setComparatorHandle - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setComparatorHandle__JI - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: setComparatorHandle - * Signature: (JJB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setComparatorHandle__JJB - (JNIEnv *, jobject, jlong, jlong, jbyte); - -/* - * Class: org_forstdb_Options - * Method: setMergeOperatorName - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMergeOperatorName - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_Options - * Method: setMergeOperator - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMergeOperator - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCompactionFilterHandle - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionFilterHandle - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCompactionFilterFactoryHandle - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionFilterFactoryHandle - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWriteBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWriteBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: writeBufferSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_writeBufferSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxWriteBufferNumber - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxWriteBufferNumber - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: maxWriteBufferNumber - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxWriteBufferNumber - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMinWriteBufferNumberToMerge - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMinWriteBufferNumberToMerge - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: minWriteBufferNumberToMerge - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_minWriteBufferNumberToMerge - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCompressionType - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompressionType - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Options - * Method: compressionType - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_compressionType - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCompressionPerLevel - * Signature: (J[B)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompressionPerLevel - (JNIEnv *, jobject, jlong, jbyteArray); - -/* - * Class: org_forstdb_Options - * Method: compressionPerLevel - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_Options_compressionPerLevel - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBottommostCompressionType - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBottommostCompressionType - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Options - * Method: bottommostCompressionType - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_bottommostCompressionType - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBottommostCompressionOptions - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBottommostCompressionOptions - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCompressionOptions - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompressionOptions - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: useFixedLengthPrefixExtractor - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_useFixedLengthPrefixExtractor - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: useCappedPrefixExtractor - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_useCappedPrefixExtractor - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: setNumLevels - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setNumLevels - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: numLevels - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_numLevels - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setLevelZeroFileNumCompactionTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevelZeroFileNumCompactionTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: levelZeroFileNumCompactionTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_levelZeroFileNumCompactionTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setLevelZeroSlowdownWritesTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevelZeroSlowdownWritesTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: levelZeroSlowdownWritesTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_levelZeroSlowdownWritesTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setLevelZeroStopWritesTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevelZeroStopWritesTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: levelZeroStopWritesTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_levelZeroStopWritesTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setTargetFileSizeBase - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setTargetFileSizeBase - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: targetFileSizeBase - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_targetFileSizeBase - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setTargetFileSizeMultiplier - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setTargetFileSizeMultiplier - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: targetFileSizeMultiplier - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_targetFileSizeMultiplier - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxBytesForLevelBase - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBytesForLevelBase - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: maxBytesForLevelBase - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxBytesForLevelBase - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setLevelCompactionDynamicLevelBytes - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevelCompactionDynamicLevelBytes - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: levelCompactionDynamicLevelBytes - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_levelCompactionDynamicLevelBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxBytesForLevelMultiplier - * Signature: (JD)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBytesForLevelMultiplier - (JNIEnv *, jobject, jlong, jdouble); - -/* - * Class: org_forstdb_Options - * Method: maxBytesForLevelMultiplier - * Signature: (J)D - */ -JNIEXPORT jdouble JNICALL Java_org_forstdb_Options_maxBytesForLevelMultiplier - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxCompactionBytes - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxCompactionBytes - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: maxCompactionBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxCompactionBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setArenaBlockSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setArenaBlockSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: arenaBlockSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_arenaBlockSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setDisableAutoCompactions - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setDisableAutoCompactions - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: disableAutoCompactions - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_disableAutoCompactions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCompactionStyle - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionStyle - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Options - * Method: compactionStyle - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_compactionStyle - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxSequentialSkipInIterations - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxSequentialSkipInIterations - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: maxSequentialSkipInIterations - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxSequentialSkipInIterations - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMemTableFactory - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMemTableFactory - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: memTableFactoryName - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_Options_memTableFactoryName - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setTableFactory - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setTableFactory - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: tableFactoryName - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_Options_tableFactoryName - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCfPaths - * Signature: (J[Ljava/lang/String;[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCfPaths - (JNIEnv *, jclass, jlong, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_Options - * Method: cfPathsLen - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_cfPathsLen - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: cfPaths - * Signature: (J[Ljava/lang/String;[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_cfPaths - (JNIEnv *, jclass, jlong, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_Options - * Method: setInplaceUpdateSupport - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setInplaceUpdateSupport - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: inplaceUpdateSupport - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_inplaceUpdateSupport - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setInplaceUpdateNumLocks - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setInplaceUpdateNumLocks - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: inplaceUpdateNumLocks - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_inplaceUpdateNumLocks - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMemtablePrefixBloomSizeRatio - * Signature: (JD)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMemtablePrefixBloomSizeRatio - (JNIEnv *, jobject, jlong, jdouble); - -/* - * Class: org_forstdb_Options - * Method: memtablePrefixBloomSizeRatio - * Signature: (J)D - */ -JNIEXPORT jdouble JNICALL Java_org_forstdb_Options_memtablePrefixBloomSizeRatio - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setExperimentalMempurgeThreshold - * Signature: (JD)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setExperimentalMempurgeThreshold - (JNIEnv *, jobject, jlong, jdouble); - -/* - * Class: org_forstdb_Options - * Method: experimentalMempurgeThreshold - * Signature: (J)D - */ -JNIEXPORT jdouble JNICALL Java_org_forstdb_Options_experimentalMempurgeThreshold - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMemtableWholeKeyFiltering - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMemtableWholeKeyFiltering - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: memtableWholeKeyFiltering - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_memtableWholeKeyFiltering - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBloomLocality - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBloomLocality - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: bloomLocality - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_bloomLocality - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxSuccessiveMerges - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxSuccessiveMerges - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: maxSuccessiveMerges - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_maxSuccessiveMerges - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setOptimizeFiltersForHits - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setOptimizeFiltersForHits - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: optimizeFiltersForHits - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_optimizeFiltersForHits - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMemtableHugePageSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMemtableHugePageSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: memtableHugePageSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_memtableHugePageSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setSoftPendingCompactionBytesLimit - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setSoftPendingCompactionBytesLimit - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: softPendingCompactionBytesLimit - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_softPendingCompactionBytesLimit - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setHardPendingCompactionBytesLimit - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setHardPendingCompactionBytesLimit - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: hardPendingCompactionBytesLimit - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_hardPendingCompactionBytesLimit - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setLevel0FileNumCompactionTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevel0FileNumCompactionTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: level0FileNumCompactionTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_level0FileNumCompactionTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setLevel0SlowdownWritesTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevel0SlowdownWritesTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: level0SlowdownWritesTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_level0SlowdownWritesTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setLevel0StopWritesTrigger - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setLevel0StopWritesTrigger - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: level0StopWritesTrigger - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_level0StopWritesTrigger - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxBytesForLevelMultiplierAdditional - * Signature: (J[I)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBytesForLevelMultiplierAdditional - (JNIEnv *, jobject, jlong, jintArray); - -/* - * Class: org_forstdb_Options - * Method: maxBytesForLevelMultiplierAdditional - * Signature: (J)[I - */ -JNIEXPORT jintArray JNICALL Java_org_forstdb_Options_maxBytesForLevelMultiplierAdditional - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setParanoidFileChecks - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setParanoidFileChecks - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: paranoidFileChecks - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_paranoidFileChecks - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxWriteBufferNumberToMaintain - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxWriteBufferNumberToMaintain - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: maxWriteBufferNumberToMaintain - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxWriteBufferNumberToMaintain - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCompactionPriority - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionPriority - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Options - * Method: compactionPriority - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_compactionPriority - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setReportBgIoStats - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setReportBgIoStats - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: reportBgIoStats - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_reportBgIoStats - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setTtl - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setTtl - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: ttl - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_ttl - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setPeriodicCompactionSeconds - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setPeriodicCompactionSeconds - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: periodicCompactionSeconds - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_periodicCompactionSeconds - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCompactionOptionsUniversal - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionOptionsUniversal - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCompactionOptionsFIFO - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionOptionsFIFO - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setForceConsistencyChecks - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setForceConsistencyChecks - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: forceConsistencyChecks - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_forceConsistencyChecks - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAtomicFlush - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAtomicFlush - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: atomicFlush - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_atomicFlush - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setSstPartitionerFactory - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setSstPartitionerFactory - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMemtableMaxRangeDeletions - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMemtableMaxRangeDeletions - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: memtableMaxRangeDeletions - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_memtableMaxRangeDeletions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setCompactionThreadLimiter - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setCompactionThreadLimiter - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: setAvoidUnnecessaryBlockingIO - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setAvoidUnnecessaryBlockingIO - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: avoidUnnecessaryBlockingIO - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_avoidUnnecessaryBlockingIO - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: setPersistStatsToDisk - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setPersistStatsToDisk - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: persistStatsToDisk - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_persistStatsToDisk - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: setWriteDbidToManifest - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setWriteDbidToManifest - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: writeDbidToManifest - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_writeDbidToManifest - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: setLogReadaheadSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setLogReadaheadSize - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: logReadaheadSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_logReadaheadSize - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBestEffortsRecovery - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBestEffortsRecovery - (JNIEnv *, jclass, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: bestEffortsRecovery - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_bestEffortsRecovery - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMaxBgErrorResumeCount - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMaxBgErrorResumeCount - (JNIEnv *, jclass, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: maxBgerrorResumeCount - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_maxBgerrorResumeCount - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBgerrorResumeRetryInterval - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBgerrorResumeRetryInterval - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: bgerrorResumeRetryInterval - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_bgerrorResumeRetryInterval - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Options - * Method: setEnableBlobFiles - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnableBlobFiles - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: enableBlobFiles - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_enableBlobFiles - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setMinBlobSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setMinBlobSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: minBlobSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_minBlobSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBlobFileSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobFileSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: blobFileSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_blobFileSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBlobCompressionType - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobCompressionType - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Options - * Method: blobCompressionType - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_blobCompressionType - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setEnableBlobGarbageCollection - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setEnableBlobGarbageCollection - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_Options - * Method: enableBlobGarbageCollection - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Options_enableBlobGarbageCollection - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBlobGarbageCollectionAgeCutoff - * Signature: (JD)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobGarbageCollectionAgeCutoff - (JNIEnv *, jobject, jlong, jdouble); - -/* - * Class: org_forstdb_Options - * Method: blobGarbageCollectionAgeCutoff - * Signature: (J)D - */ -JNIEXPORT jdouble JNICALL Java_org_forstdb_Options_blobGarbageCollectionAgeCutoff - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBlobGarbageCollectionForceThreshold - * Signature: (JD)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobGarbageCollectionForceThreshold - (JNIEnv *, jobject, jlong, jdouble); - -/* - * Class: org_forstdb_Options - * Method: blobGarbageCollectionForceThreshold - * Signature: (J)D - */ -JNIEXPORT jdouble JNICALL Java_org_forstdb_Options_blobGarbageCollectionForceThreshold - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBlobCompactionReadaheadSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobCompactionReadaheadSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Options - * Method: blobCompactionReadaheadSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Options_blobCompactionReadaheadSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setBlobFileStartingLevel - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setBlobFileStartingLevel - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Options - * Method: blobFileStartingLevel - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Options_blobFileStartingLevel - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Options - * Method: setPrepopulateBlobCache - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Options_setPrepopulateBlobCache - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Options - * Method: prepopulateBlobCache - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Options_prepopulateBlobCache - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_OptionsUtil.h b/java/include/org_forstdb_OptionsUtil.h deleted file mode 100644 index e4bb85ab0..000000000 --- a/java/include/org_forstdb_OptionsUtil.h +++ /dev/null @@ -1,45 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_OptionsUtil */ - -#ifndef _Included_org_forstdb_OptionsUtil -#define _Included_org_forstdb_OptionsUtil -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_OptionsUtil - * Method: loadLatestOptions - * Signature: (JLjava/lang/String;JLjava/util/List;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_OptionsUtil_loadLatestOptions - (JNIEnv *, jclass, jlong, jstring, jlong, jobject); - -/* - * Class: org_forstdb_OptionsUtil - * Method: loadOptionsFromFile - * Signature: (JLjava/lang/String;JLjava/util/List;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_OptionsUtil_loadOptionsFromFile - (JNIEnv *, jclass, jlong, jstring, jlong, jobject); - -/* - * Class: org_forstdb_OptionsUtil - * Method: getLatestOptionsFileName - * Signature: (Ljava/lang/String;J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_OptionsUtil_getLatestOptionsFileName - (JNIEnv *, jclass, jstring, jlong); - -/* - * Class: org_forstdb_OptionsUtil - * Method: readTableFormatConfig - * Signature: (J)Lorg/forstdb/TableFormatConfig; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_OptionsUtil_readTableFormatConfig - (JNIEnv *, jclass, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_PerfContext.h b/java/include/org_forstdb_PerfContext.h deleted file mode 100644 index 50f9155a9..000000000 --- a/java/include/org_forstdb_PerfContext.h +++ /dev/null @@ -1,805 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_PerfContext */ - -#ifndef _Included_org_forstdb_PerfContext -#define _Included_org_forstdb_PerfContext -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_PerfContext - * Method: reset - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_PerfContext_reset - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getUserKeyComparisonCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getUserKeyComparisonCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockCacheHitCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockCacheHitCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockReadCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockReadCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockReadByte - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockReadByte - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockReadTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockReadTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockReadCpuTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockReadCpuTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockCacheIndexHitCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockCacheIndexHitCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockCacheStandaloneHandleCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockCacheStandaloneHandleCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockCacheRealHandleCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockCacheRealHandleCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getIndexBlockReadCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getIndexBlockReadCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockCacheFilterHitCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockCacheFilterHitCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getFilterBlockReadCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFilterBlockReadCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getCompressionDictBlockReadCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getCompressionDictBlockReadCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getSecondaryCacheHitCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSecondaryCacheHitCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getCompressedSecCacheInsertRealCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getCompressedSecCacheInsertRealCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getCompressedSecCacheInsertDummyCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getCompressedSecCacheInsertDummyCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getCompressedSecCacheUncompressedBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getCompressedSecCacheUncompressedBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getCompressedSecCacheCompressedBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getCompressedSecCacheCompressedBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockChecksumTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockChecksumTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockDecompressTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockDecompressTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getReadBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getReadBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getMultigetReadBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getMultigetReadBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getIterReadBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getIterReadBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlobCacheHitCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobCacheHitCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlobReadCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobReadCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlobReadByte - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobReadByte - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlobReadTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobReadTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlobChecksumTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobChecksumTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlobDecompressTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlobDecompressTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getInternalKeySkippedCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalKeySkippedCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getInternalDeleteSkippedCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalDeleteSkippedCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getInternalRecentSkippedCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalRecentSkippedCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getInternalMergeCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalMergeCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getInternalMergePointLookupCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalMergePointLookupCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getInternalRangeDelReseekCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getInternalRangeDelReseekCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getSnapshotTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSnapshotTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getFromMemtableTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFromMemtableTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getFromMemtableCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFromMemtableCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getPostProcessTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getPostProcessTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getFromOutputFilesTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFromOutputFilesTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getSeekOnMemtableTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekOnMemtableTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getSeekOnMemtableCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekOnMemtableCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getNextOnMemtableCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getNextOnMemtableCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getPrevOnMemtableCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getPrevOnMemtableCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getSeekChildSeekTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekChildSeekTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getSeekChildSeekCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekChildSeekCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getSeekMinHeapTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekMinHeapTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getSeekMaxHeapTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekMaxHeapTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getSeekInternalSeekTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getSeekInternalSeekTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getFindNextUserEntryTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFindNextUserEntryTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getWriteWalTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWriteWalTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getWriteMemtableTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWriteMemtableTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getWriteDelayTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWriteDelayTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getWriteSchedulingFlushesCompactionsTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWriteSchedulingFlushesCompactionsTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getWritePreAndPostProcessTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWritePreAndPostProcessTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getWriteThreadWaitNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getWriteThreadWaitNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getDbMutexLockNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getDbMutexLockNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getDbConditionWaitNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getDbConditionWaitNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getMergeOperatorTimeNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getMergeOperatorTimeNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getReadIndexBlockNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getReadIndexBlockNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getReadFilterBlockNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getReadFilterBlockNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getNewTableBlockIterNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getNewTableBlockIterNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getNewTableIteratorNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getNewTableIteratorNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBlockSeekNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBlockSeekNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getFindTableNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getFindTableNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBloomMemtableHitCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBloomMemtableHitCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBloomMemtableMissCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBloomMemtableMissCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBloomSstHitCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBloomSstHitCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getBloomSstMissCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getBloomSstMissCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getKeyLockWaitTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getKeyLockWaitTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getKeyLockWaitCount - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getKeyLockWaitCount - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvNewSequentialFileNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewSequentialFileNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvNewRandomAccessFileNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewRandomAccessFileNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvNewWritableFileNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewWritableFileNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvReuseWritableFileNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvReuseWritableFileNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvNewRandomRwFileNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewRandomRwFileNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvNewDirectoryNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewDirectoryNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvFileExistsNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvFileExistsNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvGetChildrenNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvGetChildrenNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvGetChildrenFileAttributesNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvGetChildrenFileAttributesNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvDeleteFileNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvDeleteFileNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvCreateDirNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvCreateDirNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvCreateDirIfMissingNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvCreateDirIfMissingNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvDeleteDirNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvDeleteDirNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvGetFileSizeNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvGetFileSizeNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvGetFileModificationTimeNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvGetFileModificationTimeNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvRenameFileNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvRenameFileNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvLinkFileNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvLinkFileNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvLockFileNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvLockFileNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvUnlockFileNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvUnlockFileNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEnvNewLoggerNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEnvNewLoggerNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getGetCpuNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getGetCpuNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getIterNextCpuNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getIterNextCpuNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getIterPrevCpuNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getIterPrevCpuNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getIterSeekCpuNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getIterSeekCpuNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getEncryptDataNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getEncryptDataNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getDecryptDataNanos - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getDecryptDataNanos - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_PerfContext - * Method: getNumberAsyncSeek - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PerfContext_getNumberAsyncSeek - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_PersistentCache.h b/java/include/org_forstdb_PersistentCache.h deleted file mode 100644 index a0358f656..000000000 --- a/java/include/org_forstdb_PersistentCache.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_PersistentCache */ - -#ifndef _Included_org_forstdb_PersistentCache -#define _Included_org_forstdb_PersistentCache -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_PersistentCache - * Method: newPersistentCache - * Signature: (JLjava/lang/String;JJZ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PersistentCache_newPersistentCache - (JNIEnv *, jclass, jlong, jstring, jlong, jlong, jboolean); - -/* - * Class: org_forstdb_PersistentCache - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_PersistentCache_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_PlainTableConfig.h b/java/include/org_forstdb_PlainTableConfig.h deleted file mode 100644 index 5be3e76aa..000000000 --- a/java/include/org_forstdb_PlainTableConfig.h +++ /dev/null @@ -1,35 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_PlainTableConfig */ - -#ifndef _Included_org_forstdb_PlainTableConfig -#define _Included_org_forstdb_PlainTableConfig -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_PlainTableConfig_VARIABLE_LENGTH -#define org_forstdb_PlainTableConfig_VARIABLE_LENGTH 0L -#undef org_forstdb_PlainTableConfig_DEFAULT_BLOOM_BITS_PER_KEY -#define org_forstdb_PlainTableConfig_DEFAULT_BLOOM_BITS_PER_KEY 10L -#undef org_forstdb_PlainTableConfig_DEFAULT_HASH_TABLE_RATIO -#define org_forstdb_PlainTableConfig_DEFAULT_HASH_TABLE_RATIO 0.75 -#undef org_forstdb_PlainTableConfig_DEFAULT_INDEX_SPARSENESS -#define org_forstdb_PlainTableConfig_DEFAULT_INDEX_SPARSENESS 16L -#undef org_forstdb_PlainTableConfig_DEFAULT_HUGE_TLB_SIZE -#define org_forstdb_PlainTableConfig_DEFAULT_HUGE_TLB_SIZE 0L -#undef org_forstdb_PlainTableConfig_DEFAULT_FULL_SCAN_MODE -#define org_forstdb_PlainTableConfig_DEFAULT_FULL_SCAN_MODE 0L -#undef org_forstdb_PlainTableConfig_DEFAULT_STORE_INDEX_IN_FILE -#define org_forstdb_PlainTableConfig_DEFAULT_STORE_INDEX_IN_FILE 0L -/* - * Class: org_forstdb_PlainTableConfig - * Method: newTableFactoryHandle - * Signature: (IIDIIBZZ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_PlainTableConfig_newTableFactoryHandle - (JNIEnv *, jobject, jint, jint, jdouble, jint, jint, jbyte, jboolean, jboolean); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_RateLimiter.h b/java/include/org_forstdb_RateLimiter.h deleted file mode 100644 index 8cdab2a11..000000000 --- a/java/include/org_forstdb_RateLimiter.h +++ /dev/null @@ -1,83 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_RateLimiter */ - -#ifndef _Included_org_forstdb_RateLimiter -#define _Included_org_forstdb_RateLimiter -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_RateLimiter_DEFAULT_REFILL_PERIOD_MICROS -#define org_forstdb_RateLimiter_DEFAULT_REFILL_PERIOD_MICROS 100000LL -#undef org_forstdb_RateLimiter_DEFAULT_FAIRNESS -#define org_forstdb_RateLimiter_DEFAULT_FAIRNESS 10L -#undef org_forstdb_RateLimiter_DEFAULT_AUTOTUNE -#define org_forstdb_RateLimiter_DEFAULT_AUTOTUNE 0L -/* - * Class: org_forstdb_RateLimiter - * Method: newRateLimiterHandle - * Signature: (JJIBZ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RateLimiter_newRateLimiterHandle - (JNIEnv *, jclass, jlong, jlong, jint, jbyte, jboolean); - -/* - * Class: org_forstdb_RateLimiter - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RateLimiter_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RateLimiter - * Method: setBytesPerSecond - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RateLimiter_setBytesPerSecond - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RateLimiter - * Method: getBytesPerSecond - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RateLimiter_getBytesPerSecond - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RateLimiter - * Method: request - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RateLimiter_request - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RateLimiter - * Method: getSingleBurstBytes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RateLimiter_getSingleBurstBytes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RateLimiter - * Method: getTotalBytesThrough - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RateLimiter_getTotalBytesThrough - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RateLimiter - * Method: getTotalRequests - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RateLimiter_getTotalRequests - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_ReadOptions.h b/java/include/org_forstdb_ReadOptions.h deleted file mode 100644 index 7082dc8c1..000000000 --- a/java/include/org_forstdb_ReadOptions.h +++ /dev/null @@ -1,389 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_ReadOptions */ - -#ifndef _Included_org_forstdb_ReadOptions -#define _Included_org_forstdb_ReadOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_ReadOptions - * Method: newReadOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_newReadOptions__ - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_ReadOptions - * Method: newReadOptions - * Signature: (ZZ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_newReadOptions__ZZ - (JNIEnv *, jclass, jboolean, jboolean); - -/* - * Class: org_forstdb_ReadOptions - * Method: copyReadOptions - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_copyReadOptions - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: verifyChecksums - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_verifyChecksums - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setVerifyChecksums - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setVerifyChecksums - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ReadOptions - * Method: fillCache - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_fillCache - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setFillCache - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setFillCache - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ReadOptions - * Method: snapshot - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_snapshot - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setSnapshot - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setSnapshot - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: readTier - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_ReadOptions_readTier - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setReadTier - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setReadTier - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_ReadOptions - * Method: tailing - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_tailing - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setTailing - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setTailing - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ReadOptions - * Method: managed - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_managed - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setManaged - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setManaged - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ReadOptions - * Method: totalOrderSeek - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_totalOrderSeek - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setTotalOrderSeek - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setTotalOrderSeek - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ReadOptions - * Method: prefixSameAsStart - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_prefixSameAsStart - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setPrefixSameAsStart - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setPrefixSameAsStart - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ReadOptions - * Method: pinData - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_pinData - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setPinData - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setPinData - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ReadOptions - * Method: backgroundPurgeOnIteratorCleanup - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_backgroundPurgeOnIteratorCleanup - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setBackgroundPurgeOnIteratorCleanup - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setBackgroundPurgeOnIteratorCleanup - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ReadOptions - * Method: readaheadSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_readaheadSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setReadaheadSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setReadaheadSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: maxSkippableInternalKeys - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_maxSkippableInternalKeys - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setMaxSkippableInternalKeys - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setMaxSkippableInternalKeys - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: ignoreRangeDeletions - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_ignoreRangeDeletions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setIgnoreRangeDeletions - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setIgnoreRangeDeletions - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ReadOptions - * Method: setIterateUpperBound - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setIterateUpperBound - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: iterateUpperBound - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_iterateUpperBound - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setIterateLowerBound - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setIterateLowerBound - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: iterateLowerBound - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_iterateLowerBound - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setTableFilter - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setTableFilter - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: autoPrefixMode - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_ReadOptions_autoPrefixMode - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setAutoPrefixMode - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setAutoPrefixMode - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_ReadOptions - * Method: timestamp - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_timestamp - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setTimestamp - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setTimestamp - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: iterStartTs - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_iterStartTs - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setIterStartTs - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setIterStartTs - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: deadline - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_deadline - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setDeadline - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setDeadline - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: ioTimeout - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_ioTimeout - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setIoTimeout - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setIoTimeout - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: valueSizeSoftLimit - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_ReadOptions_valueSizeSoftLimit - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_ReadOptions - * Method: setValueSizeSoftLimit - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_ReadOptions_setValueSizeSoftLimit - (JNIEnv *, jobject, jlong, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_RemoveEmptyValueCompactionFilter.h b/java/include/org_forstdb_RemoveEmptyValueCompactionFilter.h deleted file mode 100644 index 0fdf0786d..000000000 --- a/java/include/org_forstdb_RemoveEmptyValueCompactionFilter.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_RemoveEmptyValueCompactionFilter */ - -#ifndef _Included_org_forstdb_RemoveEmptyValueCompactionFilter -#define _Included_org_forstdb_RemoveEmptyValueCompactionFilter -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_RemoveEmptyValueCompactionFilter - * Method: createNewRemoveEmptyValueCompactionFilter0 - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RemoveEmptyValueCompactionFilter_createNewRemoveEmptyValueCompactionFilter0 - (JNIEnv *, jclass); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_RestoreOptions.h b/java/include/org_forstdb_RestoreOptions.h deleted file mode 100644 index cb0cfaa96..000000000 --- a/java/include/org_forstdb_RestoreOptions.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_RestoreOptions */ - -#ifndef _Included_org_forstdb_RestoreOptions -#define _Included_org_forstdb_RestoreOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_RestoreOptions - * Method: newRestoreOptions - * Signature: (Z)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RestoreOptions_newRestoreOptions - (JNIEnv *, jclass, jboolean); - -/* - * Class: org_forstdb_RestoreOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RestoreOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_RocksCallbackObject.h b/java/include/org_forstdb_RocksCallbackObject.h deleted file mode 100644 index edd63d253..000000000 --- a/java/include/org_forstdb_RocksCallbackObject.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_RocksCallbackObject */ - -#ifndef _Included_org_forstdb_RocksCallbackObject -#define _Included_org_forstdb_RocksCallbackObject -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_RocksCallbackObject - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksCallbackObject_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_RocksDB.h b/java/include/org_forstdb_RocksDB.h deleted file mode 100644 index 43248af59..000000000 --- a/java/include/org_forstdb_RocksDB.h +++ /dev/null @@ -1,935 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_RocksDB */ - -#ifndef _Included_org_forstdb_RocksDB -#define _Included_org_forstdb_RocksDB -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_RocksDB_NOT_FOUND -#define org_forstdb_RocksDB_NOT_FOUND -1L -/* - * Class: org_forstdb_RocksDB - * Method: open - * Signature: (JLjava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_open__JLjava_lang_String_2 - (JNIEnv *, jclass, jlong, jstring); - -/* - * Class: org_forstdb_RocksDB - * Method: open - * Signature: (JLjava/lang/String;[[B[J)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_open__JLjava_lang_String_2_3_3B_3J - (JNIEnv *, jclass, jlong, jstring, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_RocksDB - * Method: openROnly - * Signature: (JLjava/lang/String;Z)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_openROnly__JLjava_lang_String_2Z - (JNIEnv *, jclass, jlong, jstring, jboolean); - -/* - * Class: org_forstdb_RocksDB - * Method: openROnly - * Signature: (JLjava/lang/String;[[B[JZ)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_openROnly__JLjava_lang_String_2_3_3B_3JZ - (JNIEnv *, jclass, jlong, jstring, jobjectArray, jlongArray, jboolean); - -/* - * Class: org_forstdb_RocksDB - * Method: openAsSecondary - * Signature: (JLjava/lang/String;Ljava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_openAsSecondary__JLjava_lang_String_2Ljava_lang_String_2 - (JNIEnv *, jclass, jlong, jstring, jstring); - -/* - * Class: org_forstdb_RocksDB - * Method: openAsSecondary - * Signature: (JLjava/lang/String;Ljava/lang/String;[[B[J)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_openAsSecondary__JLjava_lang_String_2Ljava_lang_String_2_3_3B_3J - (JNIEnv *, jclass, jlong, jstring, jstring, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_RocksDB - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: closeDatabase - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_closeDatabase - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: listColumnFamilies - * Signature: (JLjava/lang/String;)[[B - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_listColumnFamilies - (JNIEnv *, jclass, jlong, jstring); - -/* - * Class: org_forstdb_RocksDB - * Method: createColumnFamily - * Signature: (J[BIJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_createColumnFamily - (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: createColumnFamilies - * Signature: (JJ[[B)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_createColumnFamilies__JJ_3_3B - (JNIEnv *, jobject, jlong, jlong, jobjectArray); - -/* - * Class: org_forstdb_RocksDB - * Method: createColumnFamilies - * Signature: (J[J[[B)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_createColumnFamilies__J_3J_3_3B - (JNIEnv *, jobject, jlong, jlongArray, jobjectArray); - -/* - * Class: org_forstdb_RocksDB - * Method: createColumnFamilyWithImport - * Signature: (J[BIJJ[J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_createColumnFamilyWithImport - (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong, jlong, jlongArray); - -/* - * Class: org_forstdb_RocksDB - * Method: dropColumnFamily - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_dropColumnFamily - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: dropColumnFamilies - * Signature: (J[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_dropColumnFamilies - (JNIEnv *, jobject, jlong, jlongArray); - -/* - * Class: org_forstdb_RocksDB - * Method: put - * Signature: (J[BII[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_put__J_3BII_3BII - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: put - * Signature: (J[BII[BIIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_put__J_3BII_3BIIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: put - * Signature: (JJ[BII[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_put__JJ_3BII_3BII - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: put - * Signature: (JJ[BII[BIIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_put__JJ_3BII_3BIIJ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: delete - * Signature: (J[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_delete__J_3BII - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: delete - * Signature: (J[BIIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_delete__J_3BIIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: delete - * Signature: (JJ[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_delete__JJ_3BII - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: delete - * Signature: (JJ[BIIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_delete__JJ_3BIIJ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: singleDelete - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_singleDelete__J_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: singleDelete - * Signature: (J[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_singleDelete__J_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: singleDelete - * Signature: (JJ[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_singleDelete__JJ_3BI - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: singleDelete - * Signature: (JJ[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_singleDelete__JJ_3BIJ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: deleteRange - * Signature: (J[BII[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteRange__J_3BII_3BII - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: deleteRange - * Signature: (J[BII[BIIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteRange__J_3BII_3BIIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: deleteRange - * Signature: (JJ[BII[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteRange__JJ_3BII_3BII - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: deleteRange - * Signature: (JJ[BII[BIIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteRange__JJ_3BII_3BIIJ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: clipColumnFamily - * Signature: (JJ[BII[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_clipColumnFamily - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: merge - * Signature: (J[BII[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_merge__J_3BII_3BII - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: merge - * Signature: (J[BII[BIIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_merge__J_3BII_3BIIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: merge - * Signature: (JJ[BII[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_merge__JJ_3BII_3BII - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: merge - * Signature: (JJ[BII[BIIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_merge__JJ_3BII_3BIIJ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: mergeDirect - * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_mergeDirect - (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jobject, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: write0 - * Signature: (JJJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_write0 - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: write1 - * Signature: (JJJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_write1 - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: get - * Signature: (J[BII[BII)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_get__J_3BII_3BII - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: get - * Signature: (J[BII[BIIJ)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_get__J_3BII_3BIIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: get - * Signature: (JJ[BII[BII)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_get__JJ_3BII_3BII - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: get - * Signature: (JJ[BII[BIIJ)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_get__JJ_3BII_3BIIJ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: get - * Signature: (J[BII)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksDB_get__J_3BII - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: get - * Signature: (J[BIIJ)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksDB_get__J_3BIIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: get - * Signature: (JJ[BII)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksDB_get__JJ_3BII - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: get - * Signature: (JJ[BIIJ)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksDB_get__JJ_3BIIJ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: multiGet - * Signature: (J[[B[I[I)[[B - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_multiGet__J_3_3B_3I_3I - (JNIEnv *, jobject, jlong, jobjectArray, jintArray, jintArray); - -/* - * Class: org_forstdb_RocksDB - * Method: multiGet - * Signature: (J[[B[I[I[J)[[B - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_multiGet__J_3_3B_3I_3I_3J - (JNIEnv *, jobject, jlong, jobjectArray, jintArray, jintArray, jlongArray); - -/* - * Class: org_forstdb_RocksDB - * Method: multiGet - * Signature: (JJ[[B[I[I)[[B - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_multiGet__JJ_3_3B_3I_3I - (JNIEnv *, jobject, jlong, jlong, jobjectArray, jintArray, jintArray); - -/* - * Class: org_forstdb_RocksDB - * Method: multiGet - * Signature: (JJ[[B[I[I[J)[[B - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_multiGet__JJ_3_3B_3I_3I_3J - (JNIEnv *, jobject, jlong, jlong, jobjectArray, jintArray, jintArray, jlongArray); - -/* - * Class: org_forstdb_RocksDB - * Method: multiGet - * Signature: (JJ[J[Ljava/nio/ByteBuffer;[I[I[Ljava/nio/ByteBuffer;[I[Lorg/forstdb/Status;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_multiGet__JJ_3J_3Ljava_nio_ByteBuffer_2_3I_3I_3Ljava_nio_ByteBuffer_2_3I_3Lorg_forstdb_Status_2 - (JNIEnv *, jobject, jlong, jlong, jlongArray, jobjectArray, jintArray, jintArray, jobjectArray, jintArray, jobjectArray); - -/* - * Class: org_forstdb_RocksDB - * Method: keyExists - * Signature: (JJJ[BII)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_RocksDB_keyExists - (JNIEnv *, jobject, jlong, jlong, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: keyExistsDirect - * Signature: (JJJLjava/nio/ByteBuffer;II)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_RocksDB_keyExistsDirect - (JNIEnv *, jobject, jlong, jlong, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: keyMayExist - * Signature: (JJJ[BII)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_RocksDB_keyMayExist - (JNIEnv *, jobject, jlong, jlong, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: keyMayExistFoundValue - * Signature: (JJJ[BII)[[B - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_keyMayExistFoundValue - (JNIEnv *, jobject, jlong, jlong, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: putDirect - * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_putDirect - (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jobject, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: iterator - * Signature: (JJJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_iterator - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: iterators - * Signature: (J[JJ)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_iterators - (JNIEnv *, jobject, jlong, jlongArray, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getSnapshot - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getSnapshot - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: releaseSnapshot - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_releaseSnapshot - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getProperty - * Signature: (JJLjava/lang/String;I)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_RocksDB_getProperty - (JNIEnv *, jobject, jlong, jlong, jstring, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: getMapProperty - * Signature: (JJLjava/lang/String;I)Ljava/util/Map; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_RocksDB_getMapProperty - (JNIEnv *, jobject, jlong, jlong, jstring, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: getDirect - * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_getDirect - (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jobject, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: keyMayExistDirect - * Signature: (JJJLjava/nio/ByteBuffer;II)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_RocksDB_keyMayExistDirect - (JNIEnv *, jobject, jlong, jlong, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: keyMayExistDirectFoundValue - * Signature: (JJJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)[I - */ -JNIEXPORT jintArray JNICALL Java_org_forstdb_RocksDB_keyMayExistDirectFoundValue - (JNIEnv *, jobject, jlong, jlong, jlong, jobject, jint, jint, jobject, jint, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: deleteDirect - * Signature: (JJLjava/nio/ByteBuffer;IIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteDirect - (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getLongProperty - * Signature: (JJLjava/lang/String;I)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getLongProperty - (JNIEnv *, jobject, jlong, jlong, jstring, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: resetStats - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_resetStats - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getAggregatedLongProperty - * Signature: (JLjava/lang/String;I)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getAggregatedLongProperty - (JNIEnv *, jobject, jlong, jstring, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: getApproximateSizes - * Signature: (JJ[JB)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_getApproximateSizes - (JNIEnv *, jobject, jlong, jlong, jlongArray, jbyte); - -/* - * Class: org_forstdb_RocksDB - * Method: getApproximateMemTableStats - * Signature: (JJJJ)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_getApproximateMemTableStats - (JNIEnv *, jobject, jlong, jlong, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: compactRange - * Signature: (J[BI[BIJJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_compactRange - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: setOptions - * Signature: (JJ[Ljava/lang/String;[Ljava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_setOptions - (JNIEnv *, jobject, jlong, jlong, jobjectArray, jobjectArray); - -/* - * Class: org_forstdb_RocksDB - * Method: getOptions - * Signature: (JJ)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_RocksDB_getOptions - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: setDBOptions - * Signature: (J[Ljava/lang/String;[Ljava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_setDBOptions - (JNIEnv *, jobject, jlong, jobjectArray, jobjectArray); - -/* - * Class: org_forstdb_RocksDB - * Method: getDBOptions - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_RocksDB_getDBOptions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: setPerfLevel - * Signature: (B)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_setPerfLevel - (JNIEnv *, jobject, jbyte); - -/* - * Class: org_forstdb_RocksDB - * Method: getPerfLevelNative - * Signature: ()B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_RocksDB_getPerfLevelNative - (JNIEnv *, jobject); - -/* - * Class: org_forstdb_RocksDB - * Method: getPerfContextNative - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getPerfContextNative - (JNIEnv *, jobject); - -/* - * Class: org_forstdb_RocksDB - * Method: compactFiles - * Signature: (JJJ[Ljava/lang/String;IIJ)[Ljava/lang/String; - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_compactFiles - (JNIEnv *, jobject, jlong, jlong, jlong, jobjectArray, jint, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: cancelAllBackgroundWork - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_cancelAllBackgroundWork - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_RocksDB - * Method: pauseBackgroundWork - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_pauseBackgroundWork - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: continueBackgroundWork - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_continueBackgroundWork - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: enableAutoCompaction - * Signature: (J[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_enableAutoCompaction - (JNIEnv *, jobject, jlong, jlongArray); - -/* - * Class: org_forstdb_RocksDB - * Method: numberLevels - * Signature: (JJ)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_numberLevels - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: maxMemCompactionLevel - * Signature: (JJ)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_maxMemCompactionLevel - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: level0StopWriteTrigger - * Signature: (JJ)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_level0StopWriteTrigger - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getName - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_RocksDB_getName - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getEnv - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getEnv - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: flush - * Signature: (JJ[J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_flush - (JNIEnv *, jobject, jlong, jlong, jlongArray); - -/* - * Class: org_forstdb_RocksDB - * Method: flushWal - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_flushWal - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_RocksDB - * Method: syncWal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_syncWal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getLatestSequenceNumber - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getLatestSequenceNumber - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: disableFileDeletions - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_disableFileDeletions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: enableFileDeletions - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_enableFileDeletions - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_RocksDB - * Method: getLiveFiles - * Signature: (JZ)[Ljava/lang/String; - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_getLiveFiles - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_RocksDB - * Method: getSortedWalFiles - * Signature: (J)[Lorg/forstdb/LogFile; - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_getSortedWalFiles - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getUpdatesSince - * Signature: (JJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getUpdatesSince - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: deleteFile - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteFile - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_RocksDB - * Method: getLiveFilesMetaData - * Signature: (J)[Lorg/forstdb/LiveFileMetaData; - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_RocksDB_getLiveFilesMetaData - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getColumnFamilyMetaData - * Signature: (JJ)Lorg/forstdb/ColumnFamilyMetaData; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_RocksDB_getColumnFamilyMetaData - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: ingestExternalFile - * Signature: (JJ[Ljava/lang/String;IJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_ingestExternalFile - (JNIEnv *, jobject, jlong, jlong, jobjectArray, jint, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: verifyChecksum - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_verifyChecksum - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getDefaultColumnFamily - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksDB_getDefaultColumnFamily - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getPropertiesOfAllTables - * Signature: (JJ)Ljava/util/Map; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_RocksDB_getPropertiesOfAllTables - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: getPropertiesOfTablesInRange - * Signature: (JJ[J)Ljava/util/Map; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_RocksDB_getPropertiesOfTablesInRange - (JNIEnv *, jobject, jlong, jlong, jlongArray); - -/* - * Class: org_forstdb_RocksDB - * Method: suggestCompactRange - * Signature: (JJ)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_RocksDB_suggestCompactRange - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: promoteL0 - * Signature: (JJI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_promoteL0 - (JNIEnv *, jobject, jlong, jlong, jint); - -/* - * Class: org_forstdb_RocksDB - * Method: startTrace - * Signature: (JJJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_startTrace - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: endTrace - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_endTrace - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: tryCatchUpWithPrimary - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_tryCatchUpWithPrimary - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: deleteFilesInRanges - * Signature: (JJ[[BZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_deleteFilesInRanges - (JNIEnv *, jobject, jlong, jlong, jobjectArray, jboolean); - -/* - * Class: org_forstdb_RocksDB - * Method: destroyDB - * Signature: (Ljava/lang/String;J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDB_destroyDB - (JNIEnv *, jclass, jstring, jlong); - -/* - * Class: org_forstdb_RocksDB - * Method: version - * Signature: ()I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksDB_version - (JNIEnv *, jclass); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_RocksDBExceptionTest.h b/java/include/org_forstdb_RocksDBExceptionTest.h deleted file mode 100644 index 0b707eff1..000000000 --- a/java/include/org_forstdb_RocksDBExceptionTest.h +++ /dev/null @@ -1,61 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_RocksDBExceptionTest */ - -#ifndef _Included_org_forstdb_RocksDBExceptionTest -#define _Included_org_forstdb_RocksDBExceptionTest -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_RocksDBExceptionTest - * Method: raiseException - * Signature: ()V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseException - (JNIEnv *, jobject); - -/* - * Class: org_forstdb_RocksDBExceptionTest - * Method: raiseExceptionWithStatusCode - * Signature: ()V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseExceptionWithStatusCode - (JNIEnv *, jobject); - -/* - * Class: org_forstdb_RocksDBExceptionTest - * Method: raiseExceptionNoMsgWithStatusCode - * Signature: ()V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseExceptionNoMsgWithStatusCode - (JNIEnv *, jobject); - -/* - * Class: org_forstdb_RocksDBExceptionTest - * Method: raiseExceptionWithStatusCodeSubCode - * Signature: ()V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseExceptionWithStatusCodeSubCode - (JNIEnv *, jobject); - -/* - * Class: org_forstdb_RocksDBExceptionTest - * Method: raiseExceptionNoMsgWithStatusCodeSubCode - * Signature: ()V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseExceptionNoMsgWithStatusCodeSubCode - (JNIEnv *, jobject); - -/* - * Class: org_forstdb_RocksDBExceptionTest - * Method: raiseExceptionWithStatusCodeState - * Signature: ()V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksDBExceptionTest_raiseExceptionWithStatusCodeState - (JNIEnv *, jobject); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_RocksEnv.h b/java/include/org_forstdb_RocksEnv.h deleted file mode 100644 index 6c9bc74c3..000000000 --- a/java/include/org_forstdb_RocksEnv.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_RocksEnv */ - -#ifndef _Included_org_forstdb_RocksEnv -#define _Included_org_forstdb_RocksEnv -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_RocksEnv - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksEnv_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_RocksIterator.h b/java/include/org_forstdb_RocksIterator.h deleted file mode 100644 index f89e51591..000000000 --- a/java/include/org_forstdb_RocksIterator.h +++ /dev/null @@ -1,173 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_RocksIterator */ - -#ifndef _Included_org_forstdb_RocksIterator -#define _Included_org_forstdb_RocksIterator -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_RocksIterator - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksIterator - * Method: isValid0 - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_RocksIterator_isValid0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksIterator - * Method: seekToFirst0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekToFirst0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksIterator - * Method: seekToLast0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekToLast0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksIterator - * Method: next0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_next0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksIterator - * Method: prev0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_prev0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksIterator - * Method: refresh0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_refresh0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksIterator - * Method: seek0 - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seek0 - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_RocksIterator - * Method: seekForPrev0 - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekForPrev0 - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_RocksIterator - * Method: seekDirect0 - * Signature: (JLjava/nio/ByteBuffer;II)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekDirect0 - (JNIEnv *, jobject, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_RocksIterator - * Method: seekByteArray0 - * Signature: (J[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekByteArray0 - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksIterator - * Method: seekForPrevDirect0 - * Signature: (JLjava/nio/ByteBuffer;II)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekForPrevDirect0 - (JNIEnv *, jobject, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_RocksIterator - * Method: seekForPrevByteArray0 - * Signature: (J[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_seekForPrevByteArray0 - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksIterator - * Method: status0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksIterator_status0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksIterator - * Method: key0 - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksIterator_key0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksIterator - * Method: value0 - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_RocksIterator_value0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_RocksIterator - * Method: keyDirect0 - * Signature: (JLjava/nio/ByteBuffer;II)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksIterator_keyDirect0 - (JNIEnv *, jobject, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_RocksIterator - * Method: keyByteArray0 - * Signature: (J[BII)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksIterator_keyByteArray0 - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_RocksIterator - * Method: valueDirect0 - * Signature: (JLjava/nio/ByteBuffer;II)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksIterator_valueDirect0 - (JNIEnv *, jobject, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_RocksIterator - * Method: valueByteArray0 - * Signature: (J[BII)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_RocksIterator_valueByteArray0 - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_RocksMemEnv.h b/java/include/org_forstdb_RocksMemEnv.h deleted file mode 100644 index b4a080847..000000000 --- a/java/include/org_forstdb_RocksMemEnv.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_RocksMemEnv */ - -#ifndef _Included_org_forstdb_RocksMemEnv -#define _Included_org_forstdb_RocksMemEnv -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_RocksMemEnv - * Method: createMemEnv - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_RocksMemEnv_createMemEnv - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_RocksMemEnv - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_RocksMemEnv_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_SkipListMemTableConfig.h b/java/include/org_forstdb_SkipListMemTableConfig.h deleted file mode 100644 index 43a6f1946..000000000 --- a/java/include/org_forstdb_SkipListMemTableConfig.h +++ /dev/null @@ -1,23 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_SkipListMemTableConfig */ - -#ifndef _Included_org_forstdb_SkipListMemTableConfig -#define _Included_org_forstdb_SkipListMemTableConfig -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_SkipListMemTableConfig_DEFAULT_LOOKAHEAD -#define org_forstdb_SkipListMemTableConfig_DEFAULT_LOOKAHEAD 0LL -/* - * Class: org_forstdb_SkipListMemTableConfig - * Method: newMemTableFactoryHandle0 - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_SkipListMemTableConfig_newMemTableFactoryHandle0 - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_Slice.h b/java/include/org_forstdb_Slice.h deleted file mode 100644 index 45fae672a..000000000 --- a/java/include/org_forstdb_Slice.h +++ /dev/null @@ -1,61 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_Slice */ - -#ifndef _Included_org_forstdb_Slice -#define _Included_org_forstdb_Slice -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_Slice - * Method: data0 - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_Slice_data0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Slice - * Method: createNewSlice0 - * Signature: ([BI)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Slice_createNewSlice0 - (JNIEnv *, jclass, jbyteArray, jint); - -/* - * Class: org_forstdb_Slice - * Method: createNewSlice1 - * Signature: ([B)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Slice_createNewSlice1 - (JNIEnv *, jclass, jbyteArray); - -/* - * Class: org_forstdb_Slice - * Method: clear0 - * Signature: (JZJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Slice_clear0 - (JNIEnv *, jobject, jlong, jboolean, jlong); - -/* - * Class: org_forstdb_Slice - * Method: removePrefix0 - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Slice_removePrefix0 - (JNIEnv *, jobject, jlong, jint); - -/* - * Class: org_forstdb_Slice - * Method: disposeInternalBuf - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Slice_disposeInternalBuf - (JNIEnv *, jobject, jlong, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_Snapshot.h b/java/include/org_forstdb_Snapshot.h deleted file mode 100644 index 595a18e68..000000000 --- a/java/include/org_forstdb_Snapshot.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_Snapshot */ - -#ifndef _Included_org_forstdb_Snapshot -#define _Included_org_forstdb_Snapshot -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_Snapshot - * Method: getSequenceNumber - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Snapshot_getSequenceNumber - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_SstFileManager.h b/java/include/org_forstdb_SstFileManager.h deleted file mode 100644 index 25fe9e0db..000000000 --- a/java/include/org_forstdb_SstFileManager.h +++ /dev/null @@ -1,117 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_SstFileManager */ - -#ifndef _Included_org_forstdb_SstFileManager -#define _Included_org_forstdb_SstFileManager -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_SstFileManager_RATE_BYTES_PER_SEC_DEFAULT -#define org_forstdb_SstFileManager_RATE_BYTES_PER_SEC_DEFAULT 0LL -#undef org_forstdb_SstFileManager_DELETE_EXISTING_TRASH_DEFAULT -#define org_forstdb_SstFileManager_DELETE_EXISTING_TRASH_DEFAULT 1L -#undef org_forstdb_SstFileManager_MAX_TRASH_DB_RATION_DEFAULT -#define org_forstdb_SstFileManager_MAX_TRASH_DB_RATION_DEFAULT 0.25 -#undef org_forstdb_SstFileManager_BYTES_MAX_DELETE_CHUNK_DEFAULT -#define org_forstdb_SstFileManager_BYTES_MAX_DELETE_CHUNK_DEFAULT 67108864LL -/* - * Class: org_forstdb_SstFileManager - * Method: newSstFileManager - * Signature: (JJJDJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileManager_newSstFileManager - (JNIEnv *, jclass, jlong, jlong, jlong, jdouble, jlong); - -/* - * Class: org_forstdb_SstFileManager - * Method: setMaxAllowedSpaceUsage - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileManager_setMaxAllowedSpaceUsage - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_SstFileManager - * Method: setCompactionBufferSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileManager_setCompactionBufferSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_SstFileManager - * Method: isMaxAllowedSpaceReached - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_SstFileManager_isMaxAllowedSpaceReached - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileManager - * Method: isMaxAllowedSpaceReachedIncludingCompactions - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_SstFileManager_isMaxAllowedSpaceReachedIncludingCompactions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileManager - * Method: getTotalSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileManager_getTotalSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileManager - * Method: getTrackedFiles - * Signature: (J)Ljava/util/Map; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_SstFileManager_getTrackedFiles - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileManager - * Method: getDeleteRateBytesPerSecond - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileManager_getDeleteRateBytesPerSecond - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileManager - * Method: setDeleteRateBytesPerSecond - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileManager_setDeleteRateBytesPerSecond - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_SstFileManager - * Method: getMaxTrashDBRatio - * Signature: (J)D - */ -JNIEXPORT jdouble JNICALL Java_org_forstdb_SstFileManager_getMaxTrashDBRatio - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileManager - * Method: setMaxTrashDBRatio - * Signature: (JD)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileManager_setMaxTrashDBRatio - (JNIEnv *, jobject, jlong, jdouble); - -/* - * Class: org_forstdb_SstFileManager - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileManager_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_SstFileReader.h b/java/include/org_forstdb_SstFileReader.h deleted file mode 100644 index 688f87a4e..000000000 --- a/java/include/org_forstdb_SstFileReader.h +++ /dev/null @@ -1,61 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_SstFileReader */ - -#ifndef _Included_org_forstdb_SstFileReader -#define _Included_org_forstdb_SstFileReader -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_SstFileReader - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReader_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReader - * Method: newIterator - * Signature: (JJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileReader_newIterator - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_SstFileReader - * Method: open - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReader_open - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_SstFileReader - * Method: newSstFileReader - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileReader_newSstFileReader - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_SstFileReader - * Method: verifyChecksum - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReader_verifyChecksum - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReader - * Method: getTableProperties - * Signature: (J)Lorg/forstdb/TableProperties; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_SstFileReader_getTableProperties - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_SstFileReaderIterator.h b/java/include/org_forstdb_SstFileReaderIterator.h deleted file mode 100644 index e8fde1efb..000000000 --- a/java/include/org_forstdb_SstFileReaderIterator.h +++ /dev/null @@ -1,173 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_SstFileReaderIterator */ - -#ifndef _Included_org_forstdb_SstFileReaderIterator -#define _Included_org_forstdb_SstFileReaderIterator -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: isValid0 - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_SstFileReaderIterator_isValid0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: seekToFirst0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekToFirst0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: seekToLast0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekToLast0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: next0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_next0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: prev0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_prev0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: refresh0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_refresh0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: seek0 - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seek0 - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: seekForPrev0 - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekForPrev0 - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: status0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_status0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: seekDirect0 - * Signature: (JLjava/nio/ByteBuffer;II)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekDirect0 - (JNIEnv *, jobject, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: seekForPrevDirect0 - * Signature: (JLjava/nio/ByteBuffer;II)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekForPrevDirect0 - (JNIEnv *, jobject, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: seekByteArray0 - * Signature: (J[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekByteArray0 - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: seekForPrevByteArray0 - * Signature: (J[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileReaderIterator_seekForPrevByteArray0 - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: key0 - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_SstFileReaderIterator_key0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: value0 - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_SstFileReaderIterator_value0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: keyDirect0 - * Signature: (JLjava/nio/ByteBuffer;II)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_SstFileReaderIterator_keyDirect0 - (JNIEnv *, jobject, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: keyByteArray0 - * Signature: (J[BII)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_SstFileReaderIterator_keyByteArray0 - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: valueDirect0 - * Signature: (JLjava/nio/ByteBuffer;II)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_SstFileReaderIterator_valueDirect0 - (JNIEnv *, jobject, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_SstFileReaderIterator - * Method: valueByteArray0 - * Signature: (J[BII)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_SstFileReaderIterator_valueByteArray0 - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_SstFileWriter.h b/java/include/org_forstdb_SstFileWriter.h deleted file mode 100644 index 58af1dd58..000000000 --- a/java/include/org_forstdb_SstFileWriter.h +++ /dev/null @@ -1,117 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_SstFileWriter */ - -#ifndef _Included_org_forstdb_SstFileWriter -#define _Included_org_forstdb_SstFileWriter -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_SstFileWriter - * Method: newSstFileWriter - * Signature: (JJJB)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileWriter_newSstFileWriter__JJJB - (JNIEnv *, jclass, jlong, jlong, jlong, jbyte); - -/* - * Class: org_forstdb_SstFileWriter - * Method: newSstFileWriter - * Signature: (JJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileWriter_newSstFileWriter__JJ - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_SstFileWriter - * Method: open - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_open - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_SstFileWriter - * Method: put - * Signature: (JJJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_put__JJJ - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_SstFileWriter - * Method: put - * Signature: (J[B[B)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_put__J_3B_3B - (JNIEnv *, jobject, jlong, jbyteArray, jbyteArray); - -/* - * Class: org_forstdb_SstFileWriter - * Method: putDirect - * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_putDirect - (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint); - -/* - * Class: org_forstdb_SstFileWriter - * Method: fileSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_SstFileWriter_fileSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileWriter - * Method: merge - * Signature: (JJJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_merge__JJJ - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_SstFileWriter - * Method: merge - * Signature: (J[B[B)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_merge__J_3B_3B - (JNIEnv *, jobject, jlong, jbyteArray, jbyteArray); - -/* - * Class: org_forstdb_SstFileWriter - * Method: delete - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_delete__JJ - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_SstFileWriter - * Method: delete - * Signature: (J[B)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_delete__J_3B - (JNIEnv *, jobject, jlong, jbyteArray); - -/* - * Class: org_forstdb_SstFileWriter - * Method: finish - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_finish - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_SstFileWriter - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstFileWriter_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_SstPartitionerFixedPrefixFactory.h b/java/include/org_forstdb_SstPartitionerFixedPrefixFactory.h deleted file mode 100644 index 13b7db72e..000000000 --- a/java/include/org_forstdb_SstPartitionerFixedPrefixFactory.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_SstPartitionerFixedPrefixFactory */ - -#ifndef _Included_org_forstdb_SstPartitionerFixedPrefixFactory -#define _Included_org_forstdb_SstPartitionerFixedPrefixFactory -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_SstPartitionerFixedPrefixFactory - * Method: newSstPartitionerFixedPrefixFactory0 - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_SstPartitionerFixedPrefixFactory_newSstPartitionerFixedPrefixFactory0 - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_SstPartitionerFixedPrefixFactory - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_SstPartitionerFixedPrefixFactory_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_Statistics.h b/java/include/org_forstdb_Statistics.h deleted file mode 100644 index de20acdc6..000000000 --- a/java/include/org_forstdb_Statistics.h +++ /dev/null @@ -1,117 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_Statistics */ - -#ifndef _Included_org_forstdb_Statistics -#define _Included_org_forstdb_Statistics -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_Statistics - * Method: newStatistics - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_newStatistics__ - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_Statistics - * Method: newStatistics - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_newStatistics__J - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_Statistics - * Method: newStatistics - * Signature: ([B)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_newStatistics___3B - (JNIEnv *, jclass, jbyteArray); - -/* - * Class: org_forstdb_Statistics - * Method: newStatistics - * Signature: ([BJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_newStatistics___3BJ - (JNIEnv *, jclass, jbyteArray, jlong); - -/* - * Class: org_forstdb_Statistics - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Statistics_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Statistics - * Method: statsLevel - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Statistics_statsLevel - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Statistics - * Method: setStatsLevel - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Statistics_setStatsLevel - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Statistics - * Method: getTickerCount - * Signature: (JB)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_getTickerCount - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Statistics - * Method: getAndResetTickerCount - * Signature: (JB)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Statistics_getAndResetTickerCount - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Statistics - * Method: getHistogramData - * Signature: (JB)Lorg/forstdb/HistogramData; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_Statistics_getHistogramData - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Statistics - * Method: getHistogramString - * Signature: (JB)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_Statistics_getHistogramString - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_Statistics - * Method: reset - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Statistics_reset - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Statistics - * Method: toString - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_Statistics_toString - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_StringAppendOperator.h b/java/include/org_forstdb_StringAppendOperator.h deleted file mode 100644 index b4a7fa77c..000000000 --- a/java/include/org_forstdb_StringAppendOperator.h +++ /dev/null @@ -1,37 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_StringAppendOperator */ - -#ifndef _Included_org_forstdb_StringAppendOperator -#define _Included_org_forstdb_StringAppendOperator -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_StringAppendOperator - * Method: newSharedStringAppendOperator - * Signature: (C)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_StringAppendOperator_newSharedStringAppendOperator__C - (JNIEnv *, jclass, jchar); - -/* - * Class: org_forstdb_StringAppendOperator - * Method: newSharedStringAppendOperator - * Signature: (Ljava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_StringAppendOperator_newSharedStringAppendOperator__Ljava_lang_String_2 - (JNIEnv *, jclass, jstring); - -/* - * Class: org_forstdb_StringAppendOperator - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_StringAppendOperator_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_ThreadStatus.h b/java/include/org_forstdb_ThreadStatus.h deleted file mode 100644 index 6c358e4e2..000000000 --- a/java/include/org_forstdb_ThreadStatus.h +++ /dev/null @@ -1,69 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_ThreadStatus */ - -#ifndef _Included_org_forstdb_ThreadStatus -#define _Included_org_forstdb_ThreadStatus -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_ThreadStatus - * Method: getThreadTypeName - * Signature: (B)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_getThreadTypeName - (JNIEnv *, jclass, jbyte); - -/* - * Class: org_forstdb_ThreadStatus - * Method: getOperationName - * Signature: (B)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_getOperationName - (JNIEnv *, jclass, jbyte); - -/* - * Class: org_forstdb_ThreadStatus - * Method: microsToStringNative - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_microsToStringNative - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_ThreadStatus - * Method: getOperationStageName - * Signature: (B)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_getOperationStageName - (JNIEnv *, jclass, jbyte); - -/* - * Class: org_forstdb_ThreadStatus - * Method: getOperationPropertyName - * Signature: (BI)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_getOperationPropertyName - (JNIEnv *, jclass, jbyte, jint); - -/* - * Class: org_forstdb_ThreadStatus - * Method: interpretOperationProperties - * Signature: (B[J)Ljava/util/Map; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_ThreadStatus_interpretOperationProperties - (JNIEnv *, jclass, jbyte, jlongArray); - -/* - * Class: org_forstdb_ThreadStatus - * Method: getStateName - * Signature: (B)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_ThreadStatus_getStateName - (JNIEnv *, jclass, jbyte); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_TimedEnv.h b/java/include/org_forstdb_TimedEnv.h deleted file mode 100644 index 9fbc7ae94..000000000 --- a/java/include/org_forstdb_TimedEnv.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_TimedEnv */ - -#ifndef _Included_org_forstdb_TimedEnv -#define _Included_org_forstdb_TimedEnv -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_TimedEnv - * Method: createTimedEnv - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TimedEnv_createTimedEnv - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_TimedEnv - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TimedEnv_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_Transaction.h b/java/include/org_forstdb_Transaction.h deleted file mode 100644 index eeb9dc73e..000000000 --- a/java/include/org_forstdb_Transaction.h +++ /dev/null @@ -1,613 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_Transaction */ - -#ifndef _Included_org_forstdb_Transaction -#define _Included_org_forstdb_Transaction -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_Transaction - * Method: setSnapshot - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setSnapshot - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: setSnapshotOnNextOperation - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setSnapshotOnNextOperation__J - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: setSnapshotOnNextOperation - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setSnapshotOnNextOperation__JJ - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getSnapshot - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getSnapshot - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: clearSnapshot - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_clearSnapshot - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: prepare - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_prepare - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: commit - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_commit - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: rollback - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_rollback - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: setSavePoint - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setSavePoint - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: rollbackToSavePoint - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_rollbackToSavePoint - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: get - * Signature: (JJ[BIIJ)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_Transaction_get__JJ_3BIIJ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: get - * Signature: (JJ[BII[BIIJ)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Transaction_get__JJ_3BII_3BIIJ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getDirect - * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Transaction_getDirect - (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jobject, jint, jint, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: multiGet - * Signature: (JJ[[B[J)[[B - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Transaction_multiGet__JJ_3_3B_3J - (JNIEnv *, jobject, jlong, jlong, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_Transaction - * Method: multiGet - * Signature: (JJ[[B)[[B - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Transaction_multiGet__JJ_3_3B - (JNIEnv *, jobject, jlong, jlong, jobjectArray); - -/* - * Class: org_forstdb_Transaction - * Method: getForUpdate - * Signature: (JJ[BIIJZZ)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_Transaction_getForUpdate__JJ_3BIIJZZ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jlong, jboolean, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: getForUpdate - * Signature: (JJ[BII[BIIJZZ)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Transaction_getForUpdate__JJ_3BII_3BIIJZZ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong, jboolean, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: getDirectForUpdate - * Signature: (JJLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJZZ)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_Transaction_getDirectForUpdate - (JNIEnv *, jobject, jlong, jlong, jobject, jint, jint, jobject, jint, jint, jlong, jboolean, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: multiGetForUpdate - * Signature: (JJ[[B[J)[[B - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Transaction_multiGetForUpdate__JJ_3_3B_3J - (JNIEnv *, jobject, jlong, jlong, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_Transaction - * Method: multiGetForUpdate - * Signature: (JJ[[B)[[B - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_Transaction_multiGetForUpdate__JJ_3_3B - (JNIEnv *, jobject, jlong, jlong, jobjectArray); - -/* - * Class: org_forstdb_Transaction - * Method: getIterator - * Signature: (JJJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getIterator - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: put - * Signature: (J[BII[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_put__J_3BII_3BII - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_Transaction - * Method: put - * Signature: (J[BII[BIIJZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_put__J_3BII_3BIIJZ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: put - * Signature: (J[[BI[[BIJZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_put__J_3_3BI_3_3BIJZ - (JNIEnv *, jobject, jlong, jobjectArray, jint, jobjectArray, jint, jlong, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: put - * Signature: (J[[BI[[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_put__J_3_3BI_3_3BI - (JNIEnv *, jobject, jlong, jobjectArray, jint, jobjectArray, jint); - -/* - * Class: org_forstdb_Transaction - * Method: putDirect - * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2IIJZ - (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint, jlong, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: putDirect - * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2II - (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint); - -/* - * Class: org_forstdb_Transaction - * Method: merge - * Signature: (J[BII[BIIJZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_merge__J_3BII_3BIIJZ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: mergeDirect - * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_mergeDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2IIJZ - (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint, jlong, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: mergeDirect - * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;II)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_mergeDirect__JLjava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2II - (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint); - -/* - * Class: org_forstdb_Transaction - * Method: merge - * Signature: (J[BII[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_merge__J_3BII_3BII - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_Transaction - * Method: delete - * Signature: (J[BIJZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_delete__J_3BIJZ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: delete - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_delete__J_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_Transaction - * Method: delete - * Signature: (J[[BIJZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_delete__J_3_3BIJZ - (JNIEnv *, jobject, jlong, jobjectArray, jint, jlong, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: delete - * Signature: (J[[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_delete__J_3_3BI - (JNIEnv *, jobject, jlong, jobjectArray, jint); - -/* - * Class: org_forstdb_Transaction - * Method: singleDelete - * Signature: (J[BIJZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_singleDelete__J_3BIJZ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: singleDelete - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_singleDelete__J_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_Transaction - * Method: singleDelete - * Signature: (J[[BIJZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_singleDelete__J_3_3BIJZ - (JNIEnv *, jobject, jlong, jobjectArray, jint, jlong, jboolean); - -/* - * Class: org_forstdb_Transaction - * Method: singleDelete - * Signature: (J[[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_singleDelete__J_3_3BI - (JNIEnv *, jobject, jlong, jobjectArray, jint); - -/* - * Class: org_forstdb_Transaction - * Method: putUntracked - * Signature: (J[BI[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putUntracked__J_3BI_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: putUntracked - * Signature: (J[BI[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putUntracked__J_3BI_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); - -/* - * Class: org_forstdb_Transaction - * Method: putUntracked - * Signature: (J[[BI[[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putUntracked__J_3_3BI_3_3BIJ - (JNIEnv *, jobject, jlong, jobjectArray, jint, jobjectArray, jint, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: putUntracked - * Signature: (J[[BI[[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putUntracked__J_3_3BI_3_3BI - (JNIEnv *, jobject, jlong, jobjectArray, jint, jobjectArray, jint); - -/* - * Class: org_forstdb_Transaction - * Method: mergeUntracked - * Signature: (J[BII[BIIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_mergeUntracked - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jbyteArray, jint, jint, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: mergeUntrackedDirect - * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_mergeUntrackedDirect - (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: deleteUntracked - * Signature: (J[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_deleteUntracked__J_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: deleteUntracked - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_deleteUntracked__J_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_Transaction - * Method: deleteUntracked - * Signature: (J[[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_deleteUntracked__J_3_3BIJ - (JNIEnv *, jobject, jlong, jobjectArray, jint, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: deleteUntracked - * Signature: (J[[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_deleteUntracked__J_3_3BI - (JNIEnv *, jobject, jlong, jobjectArray, jint); - -/* - * Class: org_forstdb_Transaction - * Method: putLogData - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_putLogData - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_Transaction - * Method: disableIndexing - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_disableIndexing - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: enableIndexing - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_enableIndexing - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getNumKeys - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getNumKeys - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getNumPuts - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getNumPuts - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getNumDeletes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getNumDeletes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getNumMerges - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getNumMerges - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getElapsedTime - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getElapsedTime - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getWriteBatch - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getWriteBatch - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: setLockTimeout - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setLockTimeout - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getWriteOptions - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getWriteOptions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: setWriteOptions - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setWriteOptions - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: undoGetForUpdate - * Signature: (J[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_undoGetForUpdate__J_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: undoGetForUpdate - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_undoGetForUpdate__J_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_Transaction - * Method: rebuildFromWriteBatch - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_rebuildFromWriteBatch - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getCommitTimeWriteBatch - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getCommitTimeWriteBatch - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: setLogNumber - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setLogNumber - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getLogNumber - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getLogNumber - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: setName - * Signature: (JLjava/lang/String;)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_setName - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_Transaction - * Method: getName - * Signature: (J)Ljava/lang/String; - */ -JNIEXPORT jstring JNICALL Java_org_forstdb_Transaction_getName - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getID - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getID - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: isDeadlockDetect - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_Transaction_isDeadlockDetect - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getWaitingTxns - * Signature: (J)Lorg/forstdb/Transaction/WaitingTransactions; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_Transaction_getWaitingTxns - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getState - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_Transaction_getState - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: getId - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_Transaction_getId - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_Transaction - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_Transaction_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_TransactionDB.h b/java/include/org_forstdb_TransactionDB.h deleted file mode 100644 index 6e71740dd..000000000 --- a/java/include/org_forstdb_TransactionDB.h +++ /dev/null @@ -1,119 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_TransactionDB */ - -#ifndef _Included_org_forstdb_TransactionDB -#define _Included_org_forstdb_TransactionDB -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_TransactionDB_NOT_FOUND -#define org_forstdb_TransactionDB_NOT_FOUND -1L -/* - * Class: org_forstdb_TransactionDB - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionDB_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionDB - * Method: open - * Signature: (JJLjava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_open__JJLjava_lang_String_2 - (JNIEnv *, jclass, jlong, jlong, jstring); - -/* - * Class: org_forstdb_TransactionDB - * Method: open - * Signature: (JJLjava/lang/String;[[B[J)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_TransactionDB_open__JJLjava_lang_String_2_3_3B_3J - (JNIEnv *, jclass, jlong, jlong, jstring, jobjectArray, jlongArray); - -/* - * Class: org_forstdb_TransactionDB - * Method: closeDatabase - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionDB_closeDatabase - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_TransactionDB - * Method: beginTransaction - * Signature: (JJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_beginTransaction__JJ - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_TransactionDB - * Method: beginTransaction - * Signature: (JJJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_beginTransaction__JJJ - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_TransactionDB - * Method: beginTransaction_withOld - * Signature: (JJJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_beginTransaction_1withOld__JJJ - (JNIEnv *, jobject, jlong, jlong, jlong); - -/* - * Class: org_forstdb_TransactionDB - * Method: beginTransaction_withOld - * Signature: (JJJJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_beginTransaction_1withOld__JJJJ - (JNIEnv *, jobject, jlong, jlong, jlong, jlong); - -/* - * Class: org_forstdb_TransactionDB - * Method: getTransactionByName - * Signature: (JLjava/lang/String;)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDB_getTransactionByName - (JNIEnv *, jobject, jlong, jstring); - -/* - * Class: org_forstdb_TransactionDB - * Method: getAllPreparedTransactions - * Signature: (J)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_TransactionDB_getAllPreparedTransactions - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionDB - * Method: getLockStatusData - * Signature: (J)Ljava/util/Map; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_TransactionDB_getLockStatusData - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionDB - * Method: getDeadlockInfoBuffer - * Signature: (J)[Lorg/forstdb/TransactionDB/DeadlockPath; - */ -JNIEXPORT jobjectArray JNICALL Java_org_forstdb_TransactionDB_getDeadlockInfoBuffer - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionDB - * Method: setDeadlockInfoBufferSize - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionDB_setDeadlockInfoBufferSize - (JNIEnv *, jobject, jlong, jint); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_TransactionDBOptions.h b/java/include/org_forstdb_TransactionDBOptions.h deleted file mode 100644 index 2fd6def68..000000000 --- a/java/include/org_forstdb_TransactionDBOptions.h +++ /dev/null @@ -1,109 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_TransactionDBOptions */ - -#ifndef _Included_org_forstdb_TransactionDBOptions -#define _Included_org_forstdb_TransactionDBOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_TransactionDBOptions - * Method: newTransactionDBOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDBOptions_newTransactionDBOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_TransactionDBOptions - * Method: getMaxNumLocks - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDBOptions_getMaxNumLocks - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionDBOptions - * Method: setMaxNumLocks - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_setMaxNumLocks - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_TransactionDBOptions - * Method: getNumStripes - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDBOptions_getNumStripes - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionDBOptions - * Method: setNumStripes - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_setNumStripes - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_TransactionDBOptions - * Method: getTransactionLockTimeout - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDBOptions_getTransactionLockTimeout - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionDBOptions - * Method: setTransactionLockTimeout - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_setTransactionLockTimeout - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_TransactionDBOptions - * Method: getDefaultLockTimeout - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionDBOptions_getDefaultLockTimeout - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionDBOptions - * Method: setDefaultLockTimeout - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_setDefaultLockTimeout - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_TransactionDBOptions - * Method: getWritePolicy - * Signature: (J)B - */ -JNIEXPORT jbyte JNICALL Java_org_forstdb_TransactionDBOptions_getWritePolicy - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionDBOptions - * Method: setWritePolicy - * Signature: (JB)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_setWritePolicy - (JNIEnv *, jobject, jlong, jbyte); - -/* - * Class: org_forstdb_TransactionDBOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionDBOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_TransactionLogIterator.h b/java/include/org_forstdb_TransactionLogIterator.h deleted file mode 100644 index ee8c79d99..000000000 --- a/java/include/org_forstdb_TransactionLogIterator.h +++ /dev/null @@ -1,53 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_TransactionLogIterator */ - -#ifndef _Included_org_forstdb_TransactionLogIterator -#define _Included_org_forstdb_TransactionLogIterator -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_TransactionLogIterator - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionLogIterator_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionLogIterator - * Method: isValid - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_TransactionLogIterator_isValid - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionLogIterator - * Method: next - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionLogIterator_next - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionLogIterator - * Method: status - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionLogIterator_status - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionLogIterator - * Method: getBatch - * Signature: (J)Lorg/forstdb/TransactionLogIterator/BatchResult; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_TransactionLogIterator_getBatch - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_TransactionOptions.h b/java/include/org_forstdb_TransactionOptions.h deleted file mode 100644 index 673a41c5f..000000000 --- a/java/include/org_forstdb_TransactionOptions.h +++ /dev/null @@ -1,125 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_TransactionOptions */ - -#ifndef _Included_org_forstdb_TransactionOptions -#define _Included_org_forstdb_TransactionOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_TransactionOptions - * Method: newTransactionOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionOptions_newTransactionOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_TransactionOptions - * Method: isSetSnapshot - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_TransactionOptions_isSetSnapshot - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionOptions - * Method: setSetSnapshot - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setSetSnapshot - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_TransactionOptions - * Method: isDeadlockDetect - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_TransactionOptions_isDeadlockDetect - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionOptions - * Method: setDeadlockDetect - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setDeadlockDetect - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_TransactionOptions - * Method: getLockTimeout - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionOptions_getLockTimeout - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionOptions - * Method: setLockTimeout - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setLockTimeout - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_TransactionOptions - * Method: getExpiration - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionOptions_getExpiration - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionOptions - * Method: setExpiration - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setExpiration - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_TransactionOptions - * Method: getDeadlockDetectDepth - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionOptions_getDeadlockDetectDepth - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionOptions - * Method: setDeadlockDetectDepth - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setDeadlockDetectDepth - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_TransactionOptions - * Method: getMaxWriteBatchSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TransactionOptions_getMaxWriteBatchSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TransactionOptions - * Method: setMaxWriteBatchSize - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_setMaxWriteBatchSize - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_TransactionOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TransactionOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_TtlDB.h b/java/include/org_forstdb_TtlDB.h deleted file mode 100644 index 9f77960ed..000000000 --- a/java/include/org_forstdb_TtlDB.h +++ /dev/null @@ -1,55 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_TtlDB */ - -#ifndef _Included_org_forstdb_TtlDB -#define _Included_org_forstdb_TtlDB -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_TtlDB_NOT_FOUND -#define org_forstdb_TtlDB_NOT_FOUND -1L -/* - * Class: org_forstdb_TtlDB - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TtlDB_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_TtlDB - * Method: open - * Signature: (JLjava/lang/String;IZ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TtlDB_open - (JNIEnv *, jclass, jlong, jstring, jint, jboolean); - -/* - * Class: org_forstdb_TtlDB - * Method: openCF - * Signature: (JLjava/lang/String;[[B[J[IZ)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_TtlDB_openCF - (JNIEnv *, jclass, jlong, jstring, jobjectArray, jlongArray, jintArray, jboolean); - -/* - * Class: org_forstdb_TtlDB - * Method: createColumnFamilyWithTtl - * Signature: (J[BJI)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_TtlDB_createColumnFamilyWithTtl - (JNIEnv *, jobject, jlong, jbyteArray, jlong, jint); - -/* - * Class: org_forstdb_TtlDB - * Method: closeDatabase - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_TtlDB_closeDatabase - (JNIEnv *, jclass, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_UInt64AddOperator.h b/java/include/org_forstdb_UInt64AddOperator.h deleted file mode 100644 index 930b61362..000000000 --- a/java/include/org_forstdb_UInt64AddOperator.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_UInt64AddOperator */ - -#ifndef _Included_org_forstdb_UInt64AddOperator -#define _Included_org_forstdb_UInt64AddOperator -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_UInt64AddOperator - * Method: newSharedUInt64AddOperator - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_UInt64AddOperator_newSharedUInt64AddOperator - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_UInt64AddOperator - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_UInt64AddOperator_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_VectorMemTableConfig.h b/java/include/org_forstdb_VectorMemTableConfig.h deleted file mode 100644 index b25ed0fbb..000000000 --- a/java/include/org_forstdb_VectorMemTableConfig.h +++ /dev/null @@ -1,23 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_VectorMemTableConfig */ - -#ifndef _Included_org_forstdb_VectorMemTableConfig -#define _Included_org_forstdb_VectorMemTableConfig -#ifdef __cplusplus -extern "C" { -#endif -#undef org_forstdb_VectorMemTableConfig_DEFAULT_RESERVED_SIZE -#define org_forstdb_VectorMemTableConfig_DEFAULT_RESERVED_SIZE 0L -/* - * Class: org_forstdb_VectorMemTableConfig - * Method: newMemTableFactoryHandle - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_VectorMemTableConfig_newMemTableFactoryHandle - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_WBWIRocksIterator.h b/java/include/org_forstdb_WBWIRocksIterator.h deleted file mode 100644 index d42e5b6b8..000000000 --- a/java/include/org_forstdb_WBWIRocksIterator.h +++ /dev/null @@ -1,133 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_WBWIRocksIterator */ - -#ifndef _Included_org_forstdb_WBWIRocksIterator -#define _Included_org_forstdb_WBWIRocksIterator -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: isValid0 - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WBWIRocksIterator_isValid0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: seekToFirst0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekToFirst0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: seekToLast0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekToLast0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: next0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_next0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: prev0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_prev0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: refresh0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_refresh0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: seek0 - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seek0 - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: seekForPrev0 - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekForPrev0 - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: status0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_status0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: seekDirect0 - * Signature: (JLjava/nio/ByteBuffer;II)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekDirect0 - (JNIEnv *, jobject, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: seekForPrevDirect0 - * Signature: (JLjava/nio/ByteBuffer;II)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekForPrevDirect0 - (JNIEnv *, jobject, jlong, jobject, jint, jint); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: seekByteArray0 - * Signature: (J[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekByteArray0 - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: seekForPrevByteArray0 - * Signature: (J[BII)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WBWIRocksIterator_seekForPrevByteArray0 - (JNIEnv *, jobject, jlong, jbyteArray, jint, jint); - -/* - * Class: org_forstdb_WBWIRocksIterator - * Method: entry1 - * Signature: (J)[J - */ -JNIEXPORT jlongArray JNICALL Java_org_forstdb_WBWIRocksIterator_entry1 - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_WriteBatch.h b/java/include/org_forstdb_WriteBatch.h deleted file mode 100644 index b485ce83a..000000000 --- a/java/include/org_forstdb_WriteBatch.h +++ /dev/null @@ -1,301 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_WriteBatch */ - -#ifndef _Included_org_forstdb_WriteBatch -#define _Included_org_forstdb_WriteBatch -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_WriteBatch - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: count0 - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_WriteBatch_count0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: put - * Signature: (J[BI[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_put__J_3BI_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatch - * Method: put - * Signature: (J[BI[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_put__J_3BI_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: putDirect - * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_putDirect - (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: merge - * Signature: (J[BI[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_merge__J_3BI_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatch - * Method: merge - * Signature: (J[BI[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_merge__J_3BI_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: delete - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_delete__J_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatch - * Method: delete - * Signature: (J[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_delete__J_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: singleDelete - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_singleDelete__J_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatch - * Method: singleDelete - * Signature: (J[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_singleDelete__J_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: deleteDirect - * Signature: (JLjava/nio/ByteBuffer;IIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_deleteDirect - (JNIEnv *, jobject, jlong, jobject, jint, jint, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: deleteRange - * Signature: (J[BI[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_deleteRange__J_3BI_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatch - * Method: deleteRange - * Signature: (J[BI[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_deleteRange__J_3BI_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: putLogData - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_putLogData - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatch - * Method: clear0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_clear0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: setSavePoint0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_setSavePoint0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: rollbackToSavePoint0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_rollbackToSavePoint0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: popSavePoint - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_popSavePoint - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: setMaxBytes - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_setMaxBytes - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: newWriteBatch - * Signature: (I)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatch_newWriteBatch__I - (JNIEnv *, jclass, jint); - -/* - * Class: org_forstdb_WriteBatch - * Method: newWriteBatch - * Signature: ([BI)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatch_newWriteBatch___3BI - (JNIEnv *, jclass, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatch - * Method: iterate - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_iterate - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: data - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatch_data - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: getDataSize - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatch_getDataSize - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: hasPut - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasPut - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: hasDelete - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasDelete - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: hasSingleDelete - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasSingleDelete - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: hasDeleteRange - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasDeleteRange - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: hasMerge - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasMerge - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: hasBeginPrepare - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasBeginPrepare - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: hasEndPrepare - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasEndPrepare - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: hasCommit - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasCommit - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: hasRollback - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteBatch_hasRollback - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: markWalTerminationPoint - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatch_markWalTerminationPoint - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatch - * Method: getWalTerminationPoint - * Signature: (J)Lorg/forstdb/WriteBatch/SavePoint; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_WriteBatch_getWalTerminationPoint - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_WriteBatchTest.h b/java/include/org_forstdb_WriteBatchTest.h deleted file mode 100644 index 2bb6651d4..000000000 --- a/java/include/org_forstdb_WriteBatchTest.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_WriteBatchTest */ - -#ifndef _Included_org_forstdb_WriteBatchTest -#define _Included_org_forstdb_WriteBatchTest -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_WriteBatchTest - * Method: getContents - * Signature: (J)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatchTest_getContents - (JNIEnv *, jclass, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_WriteBatchTestInternalHelper.h b/java/include/org_forstdb_WriteBatchTestInternalHelper.h deleted file mode 100644 index 15d6e041f..000000000 --- a/java/include/org_forstdb_WriteBatchTestInternalHelper.h +++ /dev/null @@ -1,37 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_WriteBatchTestInternalHelper */ - -#ifndef _Included_org_forstdb_WriteBatchTestInternalHelper -#define _Included_org_forstdb_WriteBatchTestInternalHelper -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_WriteBatchTestInternalHelper - * Method: setSequence - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchTestInternalHelper_setSequence - (JNIEnv *, jclass, jlong, jlong); - -/* - * Class: org_forstdb_WriteBatchTestInternalHelper - * Method: sequence - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchTestInternalHelper_sequence - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_WriteBatchTestInternalHelper - * Method: append - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchTestInternalHelper_append - (JNIEnv *, jclass, jlong, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_WriteBatchWithIndex.h b/java/include/org_forstdb_WriteBatchWithIndex.h deleted file mode 100644 index a39427580..000000000 --- a/java/include/org_forstdb_WriteBatchWithIndex.h +++ /dev/null @@ -1,261 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_WriteBatchWithIndex */ - -#ifndef _Included_org_forstdb_WriteBatchWithIndex -#define _Included_org_forstdb_WriteBatchWithIndex -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: count0 - * Signature: (J)I - */ -JNIEXPORT jint JNICALL Java_org_forstdb_WriteBatchWithIndex_count0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: put - * Signature: (J[BI[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_put__J_3BI_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: put - * Signature: (J[BI[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_put__J_3BI_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: putDirect - * Signature: (JLjava/nio/ByteBuffer;IILjava/nio/ByteBuffer;IIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_putDirect - (JNIEnv *, jobject, jlong, jobject, jint, jint, jobject, jint, jint, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: merge - * Signature: (J[BI[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_merge__J_3BI_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: merge - * Signature: (J[BI[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_merge__J_3BI_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: delete - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_delete__J_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: delete - * Signature: (J[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_delete__J_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: singleDelete - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_singleDelete__J_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: singleDelete - * Signature: (J[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_singleDelete__J_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: deleteDirect - * Signature: (JLjava/nio/ByteBuffer;IIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_deleteDirect - (JNIEnv *, jobject, jlong, jobject, jint, jint, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: deleteRange - * Signature: (J[BI[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_deleteRange__J_3BI_3BI - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: deleteRange - * Signature: (J[BI[BIJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_deleteRange__J_3BI_3BIJ - (JNIEnv *, jobject, jlong, jbyteArray, jint, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: putLogData - * Signature: (J[BI)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_putLogData - (JNIEnv *, jobject, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: clear0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_clear0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: setSavePoint0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_setSavePoint0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: rollbackToSavePoint0 - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_rollbackToSavePoint0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: popSavePoint - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_popSavePoint - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: setMaxBytes - * Signature: (JJ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBatchWithIndex_setMaxBytes - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: getWriteBatch - * Signature: (J)Lorg/forstdb/WriteBatch; - */ -JNIEXPORT jobject JNICALL Java_org_forstdb_WriteBatchWithIndex_getWriteBatch - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: newWriteBatchWithIndex - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_newWriteBatchWithIndex__ - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: newWriteBatchWithIndex - * Signature: (Z)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_newWriteBatchWithIndex__Z - (JNIEnv *, jclass, jboolean); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: newWriteBatchWithIndex - * Signature: (JBIZ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_newWriteBatchWithIndex__JBIZ - (JNIEnv *, jclass, jlong, jbyte, jint, jboolean); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: iterator0 - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_iterator0 - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: iterator1 - * Signature: (JJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_iterator1 - (JNIEnv *, jobject, jlong, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: iteratorWithBase - * Signature: (JJJJ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatchWithIndex_iteratorWithBase - (JNIEnv *, jobject, jlong, jlong, jlong, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: getFromBatch - * Signature: (JJ[BI)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatchWithIndex_getFromBatch__JJ_3BI - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: getFromBatch - * Signature: (JJ[BIJ)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatchWithIndex_getFromBatch__JJ_3BIJ - (JNIEnv *, jobject, jlong, jlong, jbyteArray, jint, jlong); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: getFromBatchAndDB - * Signature: (JJJ[BI)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BI - (JNIEnv *, jobject, jlong, jlong, jlong, jbyteArray, jint); - -/* - * Class: org_forstdb_WriteBatchWithIndex - * Method: getFromBatchAndDB - * Signature: (JJJ[BIJ)[B - */ -JNIEXPORT jbyteArray JNICALL Java_org_forstdb_WriteBatchWithIndex_getFromBatchAndDB__JJJ_3BIJ - (JNIEnv *, jobject, jlong, jlong, jlong, jbyteArray, jint, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_WriteBatch_Handler.h b/java/include/org_forstdb_WriteBatch_Handler.h deleted file mode 100644 index 1015031f2..000000000 --- a/java/include/org_forstdb_WriteBatch_Handler.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_WriteBatch_Handler */ - -#ifndef _Included_org_forstdb_WriteBatch_Handler -#define _Included_org_forstdb_WriteBatch_Handler -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_WriteBatch_Handler - * Method: createNewHandler0 - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBatch_00024Handler_createNewHandler0 - (JNIEnv *, jobject); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_WriteBufferManager.h b/java/include/org_forstdb_WriteBufferManager.h deleted file mode 100644 index 0af6a74bd..000000000 --- a/java/include/org_forstdb_WriteBufferManager.h +++ /dev/null @@ -1,29 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_WriteBufferManager */ - -#ifndef _Included_org_forstdb_WriteBufferManager -#define _Included_org_forstdb_WriteBufferManager -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_WriteBufferManager - * Method: newWriteBufferManager - * Signature: (JJZ)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteBufferManager_newWriteBufferManager - (JNIEnv *, jclass, jlong, jlong, jboolean); - -/* - * Class: org_forstdb_WriteBufferManager - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteBufferManager_disposeInternal - (JNIEnv *, jobject, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_WriteOptions.h b/java/include/org_forstdb_WriteOptions.h deleted file mode 100644 index 01ecfa9df..000000000 --- a/java/include/org_forstdb_WriteOptions.h +++ /dev/null @@ -1,133 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_WriteOptions */ - -#ifndef _Included_org_forstdb_WriteOptions -#define _Included_org_forstdb_WriteOptions -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_WriteOptions - * Method: newWriteOptions - * Signature: ()J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteOptions_newWriteOptions - (JNIEnv *, jclass); - -/* - * Class: org_forstdb_WriteOptions - * Method: copyWriteOptions - * Signature: (J)J - */ -JNIEXPORT jlong JNICALL Java_org_forstdb_WriteOptions_copyWriteOptions - (JNIEnv *, jclass, jlong); - -/* - * Class: org_forstdb_WriteOptions - * Method: disposeInternal - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_disposeInternal - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteOptions - * Method: setSync - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setSync - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_WriteOptions - * Method: sync - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_sync - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteOptions - * Method: setDisableWAL - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setDisableWAL - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_WriteOptions - * Method: disableWAL - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_disableWAL - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteOptions - * Method: setIgnoreMissingColumnFamilies - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setIgnoreMissingColumnFamilies - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_WriteOptions - * Method: ignoreMissingColumnFamilies - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_ignoreMissingColumnFamilies - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteOptions - * Method: setNoSlowdown - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setNoSlowdown - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_WriteOptions - * Method: noSlowdown - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_noSlowdown - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteOptions - * Method: setLowPri - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setLowPri - (JNIEnv *, jobject, jlong, jboolean); - -/* - * Class: org_forstdb_WriteOptions - * Method: lowPri - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_lowPri - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteOptions - * Method: memtableInsertHintPerBatch - * Signature: (J)Z - */ -JNIEXPORT jboolean JNICALL Java_org_forstdb_WriteOptions_memtableInsertHintPerBatch - (JNIEnv *, jobject, jlong); - -/* - * Class: org_forstdb_WriteOptions - * Method: setMemtableInsertHintPerBatch - * Signature: (JZ)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_WriteOptions_setMemtableInsertHintPerBatch - (JNIEnv *, jobject, jlong, jboolean); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/java/include/org_forstdb_test_TestableEventListener.h b/java/include/org_forstdb_test_TestableEventListener.h deleted file mode 100644 index 4e9d36df5..000000000 --- a/java/include/org_forstdb_test_TestableEventListener.h +++ /dev/null @@ -1,21 +0,0 @@ -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include -/* Header for class org_forstdb_test_TestableEventListener */ - -#ifndef _Included_org_forstdb_test_TestableEventListener -#define _Included_org_forstdb_test_TestableEventListener -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_forstdb_test_TestableEventListener - * Method: invokeAllCallbacks - * Signature: (J)V - */ -JNIEXPORT void JNICALL Java_org_forstdb_test_TestableEventListener_invokeAllCallbacks - (JNIEnv *, jclass, jlong); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/zstd-1.5.5/tests/golden-decompression/empty-block.zst b/zstd-1.5.5/tests/golden-decompression/empty-block.zst deleted file mode 100644 index fbfb893e11eb677f1e6444ead8a5829a3a23e53e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 11 QcmdPcs{faPL6iXq020jt9{>OV diff --git a/zstd-1.5.5/tests/golden-decompression/rle-first-block.zst b/zstd-1.5.5/tests/golden-decompression/rle-first-block.zst deleted file mode 100644 index fd067edd74ef9bab1dcf9af83baa7fee24f73287..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 45 acmdPcs{eNh1A_nq6CTVAl>2BW_7DJtPX%=V From 0d346d4a3c021332f48e60c0b576cacea969edbf Mon Sep 17 00:00:00 2001 From: Zakelly Date: Mon, 28 Oct 2024 13:36:15 +0800 Subject: [PATCH 58/61] [FLINK-36598] Provide FileSystem instance in intialization --- env/flink/env_flink.cc | 125 +++++++++++-------- env/flink/env_flink.h | 12 +- env/flink/env_flink_test_suite.cc | 3 +- env/flink/jni_helper.cc | 7 ++ env/flink/jni_helper.h | 1 + java/forstjni/env_flink.cc | 8 +- java/src/main/java/org/forstdb/FlinkEnv.java | 6 +- 7 files changed, 102 insertions(+), 60 deletions(-) diff --git a/env/flink/env_flink.cc b/env/flink/env_flink.cc index eae1773cf..3c7579c34 100644 --- a/env/flink/env_flink.cc +++ b/env/flink/env_flink.cc @@ -174,6 +174,10 @@ class FlinkReadableFile : virtual public FSSequentialFile, ~FlinkReadableFile() override { JNIEnv* jniEnv = getJNIEnv(); if (fs_data_input_stream_instance_ != nullptr) { + JavaClassCache::JavaMethodContext closeMethod = class_cache_->GetJMethod( + JavaClassCache::JM_FLINK_FS_INPUT_STREAM_CLOSE); + jniEnv->CallVoidMethod(fs_data_input_stream_instance_, + closeMethod.javaMethod); jniEnv->DeleteGlobalRef(fs_data_input_stream_instance_); } } @@ -305,8 +309,16 @@ class FlinkDirectory : public FSDirectory { }; FlinkFileSystem::FlinkFileSystem(const std::shared_ptr& base_fs, - const std::string& base_path) - : FileSystemWrapper(base_fs), base_path_(TrimTrailingSlash(base_path)) {} + const std::string& base_path, + jobject file_system_instance) + : FileSystemWrapper(base_fs), base_path_(TrimTrailingSlash(base_path)) { + if (file_system_instance != nullptr) { + JNIEnv* env = getJNIEnv(); + file_system_instance_ = env->NewGlobalRef(file_system_instance); + } else { + file_system_instance_ = nullptr; + } +} FlinkFileSystem::~FlinkFileSystem() { if (file_system_instance_ != nullptr) { @@ -325,48 +337,60 @@ Status FlinkFileSystem::Init() { } class_cache_ = javaClassCache.release(); - // Delegate Flink to load real FileSystem (e.g. - // S3FileSystem/OSSFileSystem/...) - JavaClassCache::JavaClassContext fileSystemClass = - class_cache_->GetJClass(JavaClassCache::JC_FLINK_FILE_SYSTEM); - JavaClassCache::JavaMethodContext fileSystemGetMethod = - class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_GET); - - JavaClassCache::JavaClassContext uriClass = - class_cache_->GetJClass(JavaClassCache::JC_URI); - JavaClassCache::JavaMethodContext uriConstructor = - class_cache_->GetJMethod(JavaClassCache::JM_FLINK_URI_CONSTRUCTOR); - - // Construct URI - jstring uriStringArg = jniEnv->NewStringUTF(base_path_.c_str()); - jobject uriInstance = jniEnv->NewObject( - uriClass.javaClass, uriConstructor.javaMethod, uriStringArg); - jniEnv->DeleteLocalRef(uriStringArg); - if (uriInstance == nullptr) { - return CheckThenError( - std::string("NewObject Exception when Init FlinkFileSystem, ") - .append(uriClass.ToString()) - .append(uriConstructor.ToString()) - .append(", args: ") - .append(base_path_)); - } - - // Construct FileSystem - jobject fileSystemInstance = jniEnv->CallStaticObjectMethod( - fileSystemClass.javaClass, fileSystemGetMethod.javaMethod, uriInstance); - jniEnv->DeleteLocalRef(uriInstance); - if (fileSystemInstance == nullptr || jniEnv->ExceptionCheck()) { + if (file_system_instance_ == nullptr) { + // Delegate Flink to load real FileSystem (e.g. + // S3FileSystem/OSSFileSystem/...) + JavaClassCache::JavaClassContext fileSystemClass = + class_cache_->GetJClass(JavaClassCache::JC_FLINK_FILE_SYSTEM); + JavaClassCache::JavaMethodContext fileSystemGetMethod = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_FILE_SYSTEM_GET); + + JavaClassCache::JavaClassContext uriClass = + class_cache_->GetJClass(JavaClassCache::JC_URI); + JavaClassCache::JavaMethodContext uriConstructor = + class_cache_->GetJMethod(JavaClassCache::JM_FLINK_URI_CONSTRUCTOR); + + // Construct URI + jstring uriStringArg = jniEnv->NewStringUTF(base_path_.c_str()); + jobject uriInstance = jniEnv->NewObject( + uriClass.javaClass, uriConstructor.javaMethod, uriStringArg); + jniEnv->DeleteLocalRef(uriStringArg); + if (uriInstance == nullptr) { + return CheckThenError( + std::string("NewObject Exception when Init FlinkFileSystem, ") + .append(uriClass.ToString()) + .append(uriConstructor.ToString()) + .append(", args: ") + .append(base_path_)); + } + + // Construct FileSystem + jobject fileSystemInstance = jniEnv->CallStaticObjectMethod( + fileSystemClass.javaClass, fileSystemGetMethod.javaMethod, uriInstance); + jniEnv->DeleteLocalRef(uriInstance); + if (fileSystemInstance == nullptr || jniEnv->ExceptionCheck()) { + return CheckThenError( + std::string( + "CallStaticObjectMethod Exception when Init FlinkFileSystem, ") + .append(fileSystemClass.ToString()) + .append(fileSystemGetMethod.ToString()) + .append(", args: URI(") + .append(base_path_) + .append(")")); + } + file_system_instance_ = jniEnv->NewGlobalRef(fileSystemInstance); + jniEnv->DeleteLocalRef(fileSystemInstance); + } + + if (file_system_instance_ == nullptr) { + return CheckThenError(std::string( + "Error when init flink env, the file system provided is null")); + } + + if (jniEnv->ExceptionCheck()) { return CheckThenError( - std::string( - "CallStaticObjectMethod Exception when Init FlinkFileSystem, ") - .append(fileSystemClass.ToString()) - .append(fileSystemGetMethod.ToString()) - .append(", args: URI(") - .append(base_path_) - .append(")")); + std::string("Error when init flink env, JNI throws exception.")); } - file_system_instance_ = jniEnv->NewGlobalRef(fileSystemInstance); - jniEnv->DeleteLocalRef(fileSystemInstance); return Status::OK(); } @@ -856,17 +880,19 @@ IOStatus FlinkFileSystem::UnlockFile(FileLock* /*lock*/, Status FlinkFileSystem::Create(const std::shared_ptr& base, const std::string& uri, - std::unique_ptr* result) { - auto* fileSystem = new FlinkFileSystem(base, uri); + std::unique_ptr* result, + jobject file_system_instance) { + auto* fileSystem = new FlinkFileSystem(base, uri, file_system_instance); Status status = fileSystem->Init(); result->reset(fileSystem); return status; } Status NewFlinkEnv(const std::string& uri, - std::unique_ptr* flinkFileSystem) { + std::unique_ptr* flinkFileSystem, + jobject file_system_instance) { std::shared_ptr fs; - Status s = NewFlinkFileSystem(uri, &fs); + Status s = NewFlinkFileSystem(uri, &fs, file_system_instance); if (s.ok()) { *flinkFileSystem = NewCompositeEnv(fs); } @@ -874,10 +900,11 @@ Status NewFlinkEnv(const std::string& uri, } Status NewFlinkFileSystem(const std::string& uri, - std::shared_ptr* fs) { + std::shared_ptr* fs, + jobject file_system_instance) { std::unique_ptr flinkFileSystem; - Status s = - FlinkFileSystem::Create(FileSystem::Default(), uri, &flinkFileSystem); + Status s = FlinkFileSystem::Create(FileSystem::Default(), uri, + &flinkFileSystem, file_system_instance); if (s.ok()) { fs->reset(flinkFileSystem.release()); } diff --git a/env/flink/env_flink.h b/env/flink/env_flink.h index 04295815f..2ed2f8859 100644 --- a/env/flink/env_flink.h +++ b/env/flink/env_flink.h @@ -34,7 +34,8 @@ class FlinkFileSystem : public FileSystemWrapper { // base_path static Status Create(const std::shared_ptr& /*base_fs*/, const std::string& /*base_path*/, - std::unique_ptr* /*fs*/); + std::unique_ptr* /*fs*/, + jobject file_system_instance); // Define some names static const char* kClassName() { return "FlinkFileSystem"; } @@ -103,7 +104,8 @@ class FlinkFileSystem : public FileSystemWrapper { jobject file_system_instance_; explicit FlinkFileSystem(const std::shared_ptr& base, - const std::string& fsname); + const std::string& fsname, + jobject file_system_instance); // Init FileSystem Status Init(); @@ -126,8 +128,10 @@ class FlinkFileSystem : public FileSystemWrapper { }; // Returns a `FlinkEnv` with base_path -Status NewFlinkEnv(const std::string& base_path, std::unique_ptr* env); +Status NewFlinkEnv(const std::string& base_path, std::unique_ptr* env, + jobject file_system_instance); // Returns a `FlinkFileSystem` with base_path Status NewFlinkFileSystem(const std::string& base_path, - std::shared_ptr* fs); + std::shared_ptr* fs, + jobject file_system_instance); } // namespace ROCKSDB_NAMESPACE diff --git a/env/flink/env_flink_test_suite.cc b/env/flink/env_flink_test_suite.cc index 4db7f6968..7b50cb443 100644 --- a/env/flink/env_flink_test_suite.cc +++ b/env/flink/env_flink_test_suite.cc @@ -52,7 +52,8 @@ void EnvFlinkTestSuites::runAllTestSuites() { } void EnvFlinkTestSuites::setUp() { - auto status = ROCKSDB_NAMESPACE::NewFlinkEnv(base_path_, &flink_env_); + auto status = + ROCKSDB_NAMESPACE::NewFlinkEnv(base_path_, &flink_env_, nullptr); if (!status.ok()) { throw std::runtime_error("New FlinkEnv failed"); } diff --git a/env/flink/jni_helper.cc b/env/flink/jni_helper.cc index 9be816c39..0f87ac385 100644 --- a/env/flink/jni_helper.cc +++ b/env/flink/jni_helper.cc @@ -180,6 +180,13 @@ IOStatus JavaClassCache::Init() { cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_SKIP] .signature = "(J)J"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_CLOSE] + .javaClassAndName = cached_java_classes_[JC_FLINK_FS_INPUT_STREAM]; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_CLOSE] + .methodName = "close"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_INPUT_STREAM_CLOSE] + .signature = "()V"; + cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_WRITE] .javaClassAndName = cached_java_classes_[JC_FLINK_FS_OUTPUT_STREAM]; cached_java_methods_[CachedJavaMethod::JM_FLINK_FS_OUTPUT_STREAM_WRITE] diff --git a/env/flink/jni_helper.h b/env/flink/jni_helper.h index 54a6da85b..b98cd0eff 100644 --- a/env/flink/jni_helper.h +++ b/env/flink/jni_helper.h @@ -56,6 +56,7 @@ class JavaClassCache { JM_FLINK_FS_INPUT_STREAM_SEQ_READ, JM_FLINK_FS_INPUT_STREAM_RANDOM_READ, JM_FLINK_FS_INPUT_STREAM_SKIP, + JM_FLINK_FS_INPUT_STREAM_CLOSE, JM_FLINK_FS_OUTPUT_STREAM_WRITE, JM_FLINK_FS_OUTPUT_STREAM_FLUSH, JM_FLINK_FS_OUTPUT_STREAM_SYNC, diff --git a/java/forstjni/env_flink.cc b/java/forstjni/env_flink.cc index c3fee7690..abfdcaa03 100644 --- a/java/forstjni/env_flink.cc +++ b/java/forstjni/env_flink.cc @@ -28,10 +28,11 @@ /* * Class: org_forstdb_FlinkEnv * Method: createFlinkEnv - * Signature: (Ljava/lang/String;)J + * Signature: (Ljava/lang/String;Ljava/lang/Object;)J */ jlong Java_org_forstdb_FlinkEnv_createFlinkEnv(JNIEnv* env, jclass, - jstring base_path) { + jstring base_path, + jobject file_system_instance_) { jboolean has_exception = JNI_FALSE; auto path = ROCKSDB_NAMESPACE::JniUtil::copyStdString(env, base_path, &has_exception); @@ -41,7 +42,8 @@ jlong Java_org_forstdb_FlinkEnv_createFlinkEnv(JNIEnv* env, jclass, return 0; } std::unique_ptr flink_env; - auto status = ROCKSDB_NAMESPACE::NewFlinkEnv(path, &flink_env); + auto status = + ROCKSDB_NAMESPACE::NewFlinkEnv(path, &flink_env, file_system_instance_); if (!status.ok()) { ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, status); return 0; diff --git a/java/src/main/java/org/forstdb/FlinkEnv.java b/java/src/main/java/org/forstdb/FlinkEnv.java index 758e72952..3fdb2be1c 100644 --- a/java/src/main/java/org/forstdb/FlinkEnv.java +++ b/java/src/main/java/org/forstdb/FlinkEnv.java @@ -31,11 +31,11 @@ public class FlinkEnv extends Env { * @param basePath the base path string for the given Flink file system, * formatted as "{fs-schema-supported-by-flink}://xxx" */ - public FlinkEnv(final String basePath) { - super(createFlinkEnv(basePath)); + public FlinkEnv(final String basePath, final Object fileSystem) { + super(createFlinkEnv(basePath, fileSystem)); } - private static native long createFlinkEnv(final String basePath); + private static native long createFlinkEnv(final String basePath, final Object fileSystem); @Override protected final native void disposeInternal(final long handle); } \ No newline at end of file From d6a941b4a4caa1cf95b0b7762f696e9623b5e0d6 Mon Sep 17 00:00:00 2001 From: Hangxiang Yu Date: Sun, 7 Apr 2024 18:05:18 +0800 Subject: [PATCH 59/61] [build] Trigger CI to build --- .circleci/config.yml | 121 +++++++++++++++++++++++++++++++++++-------- Makefile | 6 +-- 2 files changed, 103 insertions(+), 24 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 23466cf48..095425dc8 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -45,7 +45,7 @@ commands: echo "export SNAPPY_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/snappy" >> $BASH_ENV echo "export LZ4_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/lz4" >> $BASH_ENV echo "export ZSTD_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/zstd" >> $BASH_ENV - echo "export DISABLE_PERF_CONTEXT=0" >> $BASH_ENV + echo "export DISABLE_PERF_CONTEXT=1" >> $BASH_ENV windows-build-steps: steps: @@ -65,27 +65,19 @@ commands: mkdir build cd build & $Env:CMAKE_BIN -G "$Env:CMAKE_GENERATOR" .. - msbuild.exe Snappy.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64 + msbuild.exe Snappy.sln -maxCpuCount -property:Configuration=Release -property:Platform=x64 - run: name: "Build RocksDB" command: | $env:Path = $env:JAVA_HOME + ";" + $env:Path mkdir build cd build - & $Env:CMAKE_BIN -G "$Env:CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=Debug -DOPTDBG=1 -DPORTABLE="$Env:CMAKE_PORTABLE" -DSNAPPY=1 -DJNI=1 .. + & $Env:CMAKE_BIN -G "$Env:CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=RELEASE -DOPTDBG=1 -DPORTABLE="$Env:CMAKE_PORTABLE" -DSNAPPY=1 -DJNI=1 .. cd .. echo "Building with VS version: $Env:CMAKE_GENERATOR" - msbuild.exe build/rocksdb.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64 - - run: - name: "Test RocksDB" - shell: powershell.exe - command: | - build_tools\run_ci_db_test.ps1 -SuiteRun arena_test,db_basic_test,db_test,db_test2,db_merge_operand_test,bloom_test,c_test,coding_test,crc32c_test,dynamic_bloom_test,env_basic_test,env_test,hash_test,random_test -Concurrency 16 - - run: - name: "Test RocksJava" - command: | - cd build\java - & $Env:CTEST_BIN -C Debug -j 16 + msbuild.exe build/rocksdb.sln -maxCpuCount -property:Configuration=Release -property:Platform=x64 + - store_artifacts: + path: build\java pre-steps-macos: steps: - pre-steps @@ -362,7 +354,7 @@ jobs: resource_class: xlarge steps: - checkout # check out the code in the project directory - - run: CC=clang CXX=clang++ USE_CLANG=1 PORTABLE=1 DISABLE_PERF_CONTEXT=0 make V=1 -j16 all + - run: CC=clang CXX=clang++ USE_CLANG=1 PORTABLE=1 DISABLE_PERF_CONTEXT=1 make V=1 -j16 all - post-steps build-linux-clang10-asan: @@ -475,7 +467,7 @@ jobs: - run: apt-get update -y && apt-get install -y libgflags-dev - run: name: "Unity build" - command: DISABLE_PERF_CONTEXT=0 make V=1 -j8 unity_test + command: DISABLE_PERF_CONTEXT=1 make V=1 -j8 unity_test no_output_timeout: 20m - run: make V=1 -j8 -k check-headers # could be moved to a different build - post-steps @@ -612,7 +604,7 @@ jobs: JAVA_HOME: C:/Program Files/BellSoft/LibericaJDK-8 SNAPPY_HOME: C:/Users/circleci/thirdparty/snappy-1.1.8 SNAPPY_INCLUDE: C:/Users/circleci/thirdparty/snappy-1.1.8;C:/Users/circleci/thirdparty/snappy-1.1.8/build - SNAPPY_LIB_DEBUG: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Debug/snappy.lib + SNAPPY_LIB_RELEASE: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Release/snappy.lib CMAKE_GENERATOR: Visual Studio 17 2022 CMAKE_PORTABLE: AVX2 steps: @@ -630,7 +622,7 @@ jobs: JAVA_HOME: C:/Program Files/BellSoft/LibericaJDK-8 SNAPPY_HOME: C:/Users/circleci/thirdparty/snappy-1.1.8 SNAPPY_INCLUDE: C:/Users/circleci/thirdparty/snappy-1.1.8;C:/Users/circleci/thirdparty/snappy-1.1.8/build - SNAPPY_LIB_DEBUG: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Debug/snappy.lib + SNAPPY_LIB_RELEASE: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Release/snappy.lib CMAKE_GENERATOR: Visual Studio 17 2022 CMAKE_PORTABLE: 1 steps: @@ -648,7 +640,7 @@ jobs: JAVA_HOME: C:/Program Files/BellSoft/LibericaJDK-8 SNAPPY_HOME: C:/Users/circleci/thirdparty/snappy-1.1.8 SNAPPY_INCLUDE: C:/Users/circleci/thirdparty/snappy-1.1.8;C:/Users/circleci/thirdparty/snappy-1.1.8/build - SNAPPY_LIB_DEBUG: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Debug/snappy.lib + SNAPPY_LIB_RELEASE: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Release/snappy.lib CMAKE_GENERATOR: Visual Studio 16 2019 CMAKE_PORTABLE: 1 steps: @@ -808,8 +800,10 @@ jobs: echo "JAVA_HOME=${JAVA_HOME}" which java && java -version which javac && javac -version - mkdir build && cd build && cmake -DJNI=1 -DWITH_GFLAGS=OFF .. -DCMAKE_C_COMPILER=x86_64-w64-mingw32-gcc -DCMAKE_CXX_COMPILER=x86_64-w64-mingw32-g++ -DCMAKE_SYSTEM_NAME=Windows && make -j4 rocksdb rocksdbjni - - post-steps + mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=RELEASE -DJNI=1 -DWITH_GFLAGS=OFF .. -DCMAKE_C_COMPILER=x86_64-w64-mingw32-gcc -DCMAKE_CXX_COMPILER=x86_64-w64-mingw32-g++ -DCMAKE_SYSTEM_NAME=Windows && make -j4 rocksdb rocksdbjni + - store_artifacts: + path: build + - post-steps build-linux-non-shm: executor: linux-docker @@ -841,6 +835,86 @@ jobs: - run: ROCKSDBTESTS_PLATFORM_DEPENDENT=only make V=1 J=4 -j4 all_but_some_tests check_some - post-steps + build-linux-arm-docker-musl: + machine: + image: ubuntu-2004:202111-02 + resource_class: arm.xlarge + steps: + - pre-steps + - run: + name: "Set Java Environment" + command: | + echo "JAVA_HOME=${JAVA_HOME}" + echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $BASH_ENV + which java && java -version + which javac && javac -version + - run: + name: "Build rocksdbjavastaticdockerarm64v8musl" + command: DEBUG_LEVEL=0 ROCKSDB_DISABLE_JEMALLOC=true PORTABLE=1 CXXFLAGS="-I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux -Wno-error=shadow -Wno-error-defaulted-function-deleted -Wno-unknown-warning-option -Wno-error=unused-parameter -Wno-error=unused-variable" make V=1 J=8 -j8 rocksdbjavastaticdockerarm64v8musl + - store_artifacts: + path: java/target + - post-steps + + build-linux-arm-docker: + machine: + image: ubuntu-2004:202111-02 + resource_class: arm.xlarge + steps: + - pre-steps + - run: + name: "Set Java Environment" + command: | + echo "JAVA_HOME=${JAVA_HOME}" + echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $BASH_ENV + which java && java -version + which javac && javac -version + - run: + name: "Build rocksdbjavastaticdockerarm64v8" + command: DEBUG_LEVEL=0 ROCKSDB_DISABLE_JEMALLOC=true PORTABLE=1 CXXFLAGS="-I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux -Wno-error=shadow -Wno-error-defaulted-function-deleted -Wno-unknown-warning-option -Wno-error=unused-parameter -Wno-error=unused-variable" make V=1 J=8 -j8 rocksdbjavastaticdockerarm64v8 + - store_artifacts: + path: java/target + - post-steps + + build-linux-ppc64le-docker-musl: + machine: + image: ubuntu-2004:202111-02 + resource_class: arm.xlarge + steps: + - pre-steps + - run: + name: "Set Java Environment" + command: | + echo "JAVA_HOME=${JAVA_HOME}" + echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $BASH_ENV + which java && java -version + which javac && javac -version + - run: + name: "Build rocksdbjavastaticdockerppc64lemusl" + command: DEBUG_LEVEL=0 ROCKSDB_DISABLE_JEMALLOC=true PORTABLE=1 CXXFLAGS="-I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux -Wno-error=shadow -Wno-error-defaulted-function-deleted -Wno-unknown-warning-option -Wno-error=unused-parameter -Wno-error=unused-variable" make V=1 J=8 -j8 rocksdbjavastaticdockerppc64lemusl + - store_artifacts: + path: java/target + - post-steps + + build-linux-ppc64le-docker: + machine: + image: ubuntu-2004:202111-02 + resource_class: arm.xlarge + steps: + - pre-steps + - run: + name: "Set Java Environment" + command: | + echo "JAVA_HOME=${JAVA_HOME}" + echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $BASH_ENV + which java && java -version + which javac && javac -version + - run: + name: "Build rocksdbjavastaticdockerppc64le" + command: DEBUG_LEVEL=0 ROCKSDB_DISABLE_JEMALLOC=true PORTABLE=1 CXXFLAGS="-I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux -Wno-error=shadow -Wno-error-defaulted-function-deleted -Wno-unknown-warning-option -Wno-error=unused-parameter -Wno-error=unused-variable" make V=1 J=8 -j8 rocksdbjavastaticdockerppc64le + - store_artifacts: + path: java/target + - post-steps + build-linux-arm-cmake-no_test_run: machine: image: ubuntu-2004:202111-02 @@ -946,6 +1020,7 @@ workflows: - build-linux-mini-crashtest jobs-windows: jobs: + - build-windows-vs2022 - build-windows-vs2019 - build-cmake-mingw jobs-java: @@ -969,6 +1044,10 @@ workflows: build-fuzzers: jobs: - build-fuzzers + - build-linux-arm-docker-musl + - build-linux-arm-docker + - build-linux-ppc64le-docker-musl + - build-linux-ppc64le-docker benchmark-linux: triggers: - schedule: diff --git a/Makefile b/Makefile index fa6948417..c36ceace2 100644 --- a/Makefile +++ b/Makefile @@ -572,9 +572,9 @@ ifeq ($(PLATFORM), OS_OPENBSD) WARNING_FLAGS += -Wno-unused-lambda-capture endif -ifndef DISABLE_WARNING_AS_ERROR - WARNING_FLAGS += -Werror -endif +# ifndef DISABLE_WARNING_AS_ERROR +# WARNING_FLAGS += -Werror +# endif ifdef LUA_PATH From 01a3c1eeca15676b7695d7c60ce0d07ebda03003 Mon Sep 17 00:00:00 2001 From: Zakelly Date: Fri, 27 Sep 2024 21:59:26 +0800 Subject: [PATCH 60/61] [build] Win debug --- .circleci/config.yml | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 095425dc8..95f505204 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -65,17 +65,27 @@ commands: mkdir build cd build & $Env:CMAKE_BIN -G "$Env:CMAKE_GENERATOR" .. - msbuild.exe Snappy.sln -maxCpuCount -property:Configuration=Release -property:Platform=x64 + msbuild.exe Snappy.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64 - run: name: "Build RocksDB" command: | $env:Path = $env:JAVA_HOME + ";" + $env:Path mkdir build cd build - & $Env:CMAKE_BIN -G "$Env:CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=RELEASE -DOPTDBG=1 -DPORTABLE="$Env:CMAKE_PORTABLE" -DSNAPPY=1 -DJNI=1 .. + & $Env:CMAKE_BIN -G "$Env:CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=DEBUG -DOPTDBG=1 -DPORTABLE="$Env:CMAKE_PORTABLE" -DSNAPPY=1 -DJNI=1 .. cd .. echo "Building with VS version: $Env:CMAKE_GENERATOR" - msbuild.exe build/rocksdb.sln -maxCpuCount -property:Configuration=Release -property:Platform=x64 + msbuild.exe build/rocksdb.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64 + - run: + name: "Test RocksDB" + shell: powershell.exe + command: | + build_tools\run_ci_db_test.ps1 -SuiteRun arena_test,db_basic_test,db_test,db_test2,db_merge_operand_test,bloom_test,c_test,coding_test,crc32c_test,dynamic_bloom_test,env_basic_test,env_test,hash_test,random_test -Concurrency 16 + - run: + name: "Test RocksJava" + command: | + cd build\java + & $Env:CTEST_BIN -C Debug -j 16 - store_artifacts: path: build\java pre-steps-macos: @@ -604,6 +614,7 @@ jobs: JAVA_HOME: C:/Program Files/BellSoft/LibericaJDK-8 SNAPPY_HOME: C:/Users/circleci/thirdparty/snappy-1.1.8 SNAPPY_INCLUDE: C:/Users/circleci/thirdparty/snappy-1.1.8;C:/Users/circleci/thirdparty/snappy-1.1.8/build + SNAPPY_LIB_DEBUG: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Debug/snappy.lib SNAPPY_LIB_RELEASE: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Release/snappy.lib CMAKE_GENERATOR: Visual Studio 17 2022 CMAKE_PORTABLE: AVX2 @@ -622,6 +633,7 @@ jobs: JAVA_HOME: C:/Program Files/BellSoft/LibericaJDK-8 SNAPPY_HOME: C:/Users/circleci/thirdparty/snappy-1.1.8 SNAPPY_INCLUDE: C:/Users/circleci/thirdparty/snappy-1.1.8;C:/Users/circleci/thirdparty/snappy-1.1.8/build + SNAPPY_LIB_DEBUG: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Debug/snappy.lib SNAPPY_LIB_RELEASE: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Release/snappy.lib CMAKE_GENERATOR: Visual Studio 17 2022 CMAKE_PORTABLE: 1 @@ -640,6 +652,7 @@ jobs: JAVA_HOME: C:/Program Files/BellSoft/LibericaJDK-8 SNAPPY_HOME: C:/Users/circleci/thirdparty/snappy-1.1.8 SNAPPY_INCLUDE: C:/Users/circleci/thirdparty/snappy-1.1.8;C:/Users/circleci/thirdparty/snappy-1.1.8/build + SNAPPY_LIB_DEBUG: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Debug/snappy.lib SNAPPY_LIB_RELEASE: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Release/snappy.lib CMAKE_GENERATOR: Visual Studio 16 2019 CMAKE_PORTABLE: 1 From 06e667ec8ab3e204c266b659f8a2d64ed3d0a8eb Mon Sep 17 00:00:00 2001 From: Zakelly Date: Thu, 31 Oct 2024 18:07:01 +0800 Subject: [PATCH 61/61] 0.1.3 --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index c36ceace2..a5083c129 100644 --- a/Makefile +++ b/Makefile @@ -6,7 +6,7 @@ #----------------------------------------------- -FORST_VERSION ?= 0.1.2-beta +FORST_VERSION ?= 0.1.3-beta BASH_EXISTS := $(shell which bash) SHELL := $(shell which bash)